信号内部机制实现的疑问

发布于 2024-07-09 09:45:20 浏览：374 订阅该版

我的问题是：下面的第3种情况，为什么不采用和第一种情况一样的处理信号的方式去处理，而是要采用构建栈，在_signal_entry函数中去处理

在信号（signal）的_signal_deliver函数中，信号的处理分位3种情况，如下：

1. 如果目标线程是挂起状态时，恢复成就绪状态，设置信号标志，最终信号的处理函数rt_thread_handle_sig(RT_TRUE);会在rt_schedule();中执行
   ```c
   #ifdef RT_USING_SIGNALS
                       /* check stat of thread for signal */
                       level = rt_hw_interrupt_disable();
                       if (RT_SCHED_CTX(rt_current_thread).stat & RT_THREAD_STAT_SIGNAL_PENDING)
                       {
                           extern void rt_thread_handle_sig(rt_bool_t clean_state);

RT_SCHED_CTX(rt_current_thread).stat &= ~RT_THREAD_STAT_SIGNAL_PENDING;

rt_hw_interrupt_enable(level);

/* check signal status */
                           rt_thread_handle_sig(RT_TRUE);
                       }
                       else
                       {
                           rt_hw_interrupt_enable(level);
                       }
   ```
2. 如果目标线程就是当前线程，会在_signal_deliver(rt_thread_ttid)函数直接执行信号的处理函数rt_thread_handle_sig(RT_TRUE);

```c
if (tid == rt_thread_self())
        {
            /* add signal state */
            RT_SCHED_CTX(tid).stat |= RT_THREAD_STAT_SIGNAL;

rt_spin_unlock_irqrestore(&_thread_signal_lock, level);

/* do signal action in self thread context */
            if (rt_interrupt_get_nest() == 0)
            {
                rt_thread_handle_sig(RT_TRUE);
            }
        }
```

3.如果目标线程处于就绪态，则在目标线程的栈上构建新的栈，且通过rt_hw_stack_init把线程entry改为_signal_entry，然后在_signal_entry函数中去执行信号的处理函数rt_thread_handle_sig(RT_TRUE);，执行完后再去切换到之前的栈

```c
            /* point to the signal handle entry */
            RT_SCHED_CTX(tid).stat   &= ~RT_THREAD_STAT_SIGNAL_PENDING;
            tid->sig_ret = tid->sp;
            tid->sp = rt_hw_stack_init((void *)_signal_entry, RT_NULL,
                                       (void *)((char *)tid->sig_ret - 32), RT_NULL);
```

```c
static void _signal_entry(void *parameter)
{
    RT_UNUSED(parameter);

rt_thread_t tid = rt_thread_self();

/* handle signal */
    rt_thread_handle_sig(RT_FALSE);

#ifdef RT_USING_SMP
#else
    /* return to thread */
    tid->sp = tid->sig_ret;
    tid->sig_ret = RT_NULL;
#endif /* RT_USING_SMP */

LOG_D("switch back to: 0x%08x\n", tid->sp);
    RT_SCHED_CTX(tid).stat &= ~RT_THREAD_STAT_SIGNAL;

#ifdef RT_USING_SMP
    rt_hw_context_switch_to((rt_base_t)¶meter, tid);
#else
    rt_hw_context_switch_to((rt_ubase_t)&(tid->sp));
#endif /* RT_USING_SMP */
}
```

static void _signal_deliver(rt_thread_ttid)函数

```c
static void _signal_deliver(rt_thread_t tid)
{
    rt_base_t level;

level = rt_spin_lock_irqsave(&_thread_signal_lock);

/* thread is not interested in pended signals */
    if (!(tid->sig_pending & tid->sig_mask))
    {
        rt_spin_unlock_irqrestore(&_thread_signal_lock, level);
        return;
    }

if ((RT_SCHED_CTX(tid).stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK)
    {
        /* resume thread to handle signal */
#ifdef RT_USING_SMART
        rt_thread_wakeup(tid);
#else
        rt_thread_resume(tid);
#endif
        /* add signal state */
        RT_SCHED_CTX(tid).stat |= (RT_THREAD_STAT_SIGNAL | RT_THREAD_STAT_SIGNAL_PENDING);

rt_spin_unlock_irqrestore(&_thread_signal_lock, level);

/* re-schedule */
        rt_schedule();
    }
    else
    {
        if (tid == rt_thread_self())
        {
            /* add signal state */
            RT_SCHED_CTX(tid).stat |= RT_THREAD_STAT_SIGNAL;

rt_spin_unlock_irqrestore(&_thread_signal_lock, level);

/* do signal action in self thread context */
            if (rt_interrupt_get_nest() == 0)
            {
                rt_thread_handle_sig(RT_TRUE);
            }
        }
        else if (!((RT_SCHED_CTX(tid).stat & RT_THREAD_STAT_SIGNAL_MASK) & RT_THREAD_STAT_SIGNAL))
        {
            /* add signal state */
            RT_SCHED_CTX(tid).stat |= (RT_THREAD_STAT_SIGNAL | RT_THREAD_STAT_SIGNAL_PENDING);

#ifdef RT_USING_SMP
            {
                int cpu_id;

cpu_id = RT_SCHED_CTX(tid).oncpu;
                if ((cpu_id != RT_CPU_DETACHED) && (cpu_id != rt_cpu_get_id()))
                {
                    rt_uint32_t cpu_mask;

cpu_mask = RT_CPU_MASK ^ (1 << cpu_id);
                    rt_hw_ipi_send(RT_SCHEDULE_IPI, cpu_mask);
                }
            }
#else
            /* point to the signal handle entry */
            RT_SCHED_CTX(tid).stat   &= ~RT_THREAD_STAT_SIGNAL_PENDING;
            tid->sig_ret = tid->sp;
            tid->sp = rt_hw_stack_init((void *)_signal_entry, RT_NULL,
                                       (void *)((char *)tid->sig_ret - 32), RT_NULL);
#endif /* RT_USING_SMP */

rt_spin_unlock_irqrestore(&_thread_signal_lock, level);
            LOG_D("signal stack pointer @ 0x%08x", tid->sp);

/* re-schedule */
            rt_schedule();
        }
        else
        {
            rt_spin_unlock_irqrestore(&_thread_signal_lock, level);
        }
    }
}
```