Nuttx相关的历史文章

• Nuttx Task Schedule

介绍

信号是在软件层次上对中断机制的模拟，在原理上说，一个任务接收到一个信号，与CPU接收到中断请求是一致的。信号是异步的，任务不必通过任何操作来等待信号的到达，它甚至不知道信号何时会到达。
信号的来源包括：

• 硬件来源，比如按键触发
• 软件来源，比如kill，raise等系统函数，比如一些非法运算操作等

任务和信号

Nuttx为进程和线程提供了信号接口，可以在任务上下文中或在任务上下文之间，通过信号这种异步通信机制，来改变任务的控制流。在任何一个任务中或中断处理函数中，可以给指定TASK ID的其他任务发送信号。接收到信号的任务将在具有优先级时执行任务指定的信号处理函数。信号处理程序是一个用户提供的函数，它绑定到一个特定的信号，并在接收到信号时执行任何必要的操作。默认情况下，没有对任何信号设置预定义动作，所有信号的默认操作都是忽略（如果用户没有提供信号处理函数），从这个意义上说，所有Nuttx默认情况下都是实时信号。

任务组

Nuttx既支持任务task，又支持线程pthreads。task和pthreads的主要区别在于task之间的独立性要高得多。task可以创建pthreads，这些pthreads将共享task的资源。主task线程和它所包含的pthreads，一起被称为任务组，在Nuttx中使用任务组来模拟POSIX的进程。

发送信号给多线程任务组

多线程任务组中的信号行为是复杂的。Nuttx使用任务组模拟进程，并遵循POSIX规则进行信号发送。通常，当向一个任务组发送信号时，需要向创建该任务组的主task线程的ID号发送（实际上，其他任务不应该知道该任务组中创建的内部线程ID）。任务组会记住该ID（即使主任务线程退出）。

当向一个多线程任务组发送信号时，会出现以下情况：

• 当任务组接收到一个信号，那么任务组中只有一个不阻塞该信号的不确定线程会接收到信号。
• 当任务组接收到一个信号，并且有多个线程在等待该信号，有且只有一个不确定的线程将接收该信号。

可以使用sigprocmask()或pthread_sigmask()接口来屏蔽信号。信号被屏蔽后，将不会在具有屏蔽该信号的线程中接收到。在创建新的线程时，新线程将会继承父线程的信号掩码，因此如果在一个线程上阻塞某个信号，那么在它所创建的线程中也会阻塞该信号。

可以通过信号掩码来控制哪个线程接收信号，例如，创建一个线程，该线程的唯一目的是捕获某个特定的信号并且做出响应：在主任务中阻塞信号；这时该信号会在任务组中被所有的线程阻塞。在一个“信号处理线程”中，使能了信号，这个线程将是唯一接收信号的线程。

API接口

本来想一上来就分析数据结构，看了一圈源代码，发现还是先从应用层的API入手，有个全面的认识后，再逐层去分析底层的原理。

API如下：

int sigemptyset(sigset_t *set) ;    /* 清空set信号集， 排除所有信号 */
int sigfillset(sigset_t *set);    /* 置位set信号集，包含所有信号 */
int sigaddset(sigset_t *set, int signo);    /* 将信号signo添加进set信号集 */
int sigdelset(sigset_t *set, int signo);    /* 将signo信号从set信号集中删除 */
int  sigismember(const sigset_t *set, int signo);    /* 判断signo信号是否属于set信号集 */
int sigaction(int signo, const struct sigaction *act,
                  struct sigaction *oact);    /* 信号安装函数，将sigaction与一个特定的信号进行绑定，sigaction结构体在下文会介绍 */
int sigignore(int signo);    /* 忽略signo信号 */
void (*sigset(int signo, void (*disp)(int)))(int);    /* 改变signo信号的配置， disp可以是SIG_DFL、SIG_IGN，或者信号处理Handler */
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);    /* 根据how的策略，来改变当前阻塞的信号集 */
int sighold(int signo);    /* 将signo信号添加进进程的阻塞信号集 */
int sigrelse(int signo);    /* 将sigo信号从进程的阻塞信号集中移除 */
int sigpending(sigset_t *set);    /* 返回在阻塞期间收到的阻塞信号的集合 */
int sigsuspend(const sigset_t *set);    /* 在接收到某个信号之前，临时用set替换进程的信号掩码,并暂停进程执行，直到收到信号为止 */
int sigpause(int signo);    /* 将signo信号从信号掩码中移除，暂停进程，直到收到信号为止 */
int sigwaitinfo(const sigset_t *set, struct siginfo *info);    /* 调用的sigtimedwait */
int sigtimedwait(const sigset_t *set, struct siginfo *info,
                     const struct timespec *timeout);    /* 将set作为阻塞信号集，当多个信号到达时，返回最小的返回，如果没有信号到达，在timeout时间内，进程会暂停，直到收到信号或者时间到期 */
int sigqueue (int tid, int signo, union sigval value);    /* 向tid Task发送signo信号，信号携带value数据 */
int kill(pid_t pid, int sig);    /* 向pid Task发送sig信号 */
int pause(void);    /* 暂停当前调用线程，直到收到一个non-blocked信号 */

从上述接口中可以看出，大致可以分为以下几类：

• 对信号集/信号本身的操作：比如信号集的清空与置位、将信号从信号集中删除、增加信号到信号集中、判断信号是否属于信号集等
• 对信号的行为响应：比如首先需要信号安装、设置信号的Handler、忽略某个信号、阻塞某些信号、在接收到某些信号前暂停当前进程（会涉及到任务的切换）等
• 发送信号：向某个特定的task发送信号，信号中还能携带数据

数据结构

数据结构又分为两部分：Kernel部分和User部分，其中Kernel部分也需要用到User部分的定义。

User部分，定义在include/signal.h中，主要描述信号的基本数据结构以及API接口

• 信号集的定义，总共包含32中信号，Nuttx提供了部分信号，其余的用户可以自定义

/* This defines a set of 32 signals (numbered 0 through 31).
 * REVISIT: Signal 0 is, however, not generally usable since that value has
 * special meaning in some circumstances (e.g., kill()).
 */

typedef uint32_t sigset_t;   /* Bit set of 32 signals */
#define __SIGSET_T_DEFINED 1

/* Signal set management definitions and macros. */

#define NULL_SIGNAL_SET ((sigset_t)0x00000000)
#define ALL_SIGNAL_SET  ((sigset_t)0xffffffff)
#define MIN_SIGNO       0
#define MAX_SIGNO       31
#define GOOD_SIGNO(s)   ((((unsigned)(s))<=MAX_SIGNO))
#define SIGNO2SET(s)    ((sigset_t)1 << (s))

/* A few of the real time signals are used within the OS.  They have
 * default values that can be overridden from the configuration file. The
 * rest are all user signals.
 *
 * The signal number zero is wasted for the most part.  It is a valid
 * signal number, but has special meaning at many interfaces (e.g., Kill()).
 *
 * These are the semi-standard signal definitions:
 */
#define SIGUSR1       1  /* User signal 1 */
#define SIGUSR2       2  /* User signal 2 */
#define SIGALRM       3  /* Default signal used with POSIX timers (used only */
                           /* no other signal is provided) */
#define SIGCHLD     4  /* Used by child threads to signal parent thread */
#define SIGPOLL     5  /* Sent when an asynchronous I/O event occurs */

/* The following are non-standard signal definitions */
#define SIGCONDTIMEDOUT 16  /* Used in the implementation of pthread_cond_timedwait */
#define SIGWORK     17  /* Used to wake up the work queue */

• 信号事件的定义，主要用于向消息队列发送信号，通知某个task队列中已经有消息了

/* Values for the sigev_notify field of struct sigevent */

#define SIGEV_NONE      0 /* No asynchronous notification is delivered */
#define SIGEV_SIGNAL    1 /* Notify via signal,with an application-defined value */
#ifdef CONFIG_SIG_EVTHREAD
#define SIGEV_THREAD    3 /* A notification function is called */
#endif

/* This defines the type of the siginfo si_value field */

union sigval
{
  int       sival_int;       /* Integer value */
  FAR void *sival_ptr;       /* Pointer value */
};

/* This structure contains elements that define a queue signal. The following is
 * used to attach a signal to a message queue to notify a task when a message is
 * available on a queue
 */

#ifdef CONFIG_CAN_PASS_STRUCTS
typedef CODE void (*sigev_notify_function_t)(union sigval value);
#else
typedef CODE void (*sigev_notify_function_t)(FAR void *sival_ptr);
#endif

struct sigevent
{
  uint8_t      sigev_notify; /* Notification method: SIGEV_SIGNAL, SIGEV_NONE, or SIGEV_THREAD */
  uint8_t      sigev_signo;  /* Notification signal */
  union sigval sigev_value;  /* Data passed with notification */

#ifdef CONFIG_SIG_EVTHREAD
  sigev_notify_function_t sigev_notify_function; /* Notification function */
  FAR pthread_attr_t *sigev_notify_attributes;   /* Notification attributes (not used) */
#endif
};

• 信号的定义，描述信号的内部细节信息，用于在信号Handler中的参数传递

/* These are the possible values of the signfo si_code field */

#define SI_USER         0  /* Signal sent from kill, raise, or abort */
#define SI_QUEUE        1  /* Signal sent from sigqueue */
#define SI_TIMER        2  /* Signal is result of timer expiration */
#define SI_ASYNCIO      3  /* Signal is the result of asynch IO completion */
#define SI_MESGQ        4  /* Signal generated by arrival of a message on an */
                           /* empty message queue */
#define CLD_EXITED      5  /* Child has exited (SIGCHLD only) */
#define CLD_KILLED      6  /* Child was killed (SIGCHLD only) */
#define CLD_DUMPED      7  /* Child terminated abnormally (SIGCHLD only) */
#define CLD_TRAPPED     8  /* Traced child has trapped (SIGCHLD only) */
#define CLD_STOPPED     9  /* Child has stopped (SIGCHLD only) */
#define CLD_CONTINUED   10 /* Stopped child had continued (SIGCHLD only) */

/* The following types is used to pass parameters to/from signal handlers */

struct siginfo
{
  uint8_t      si_signo;     /* Identifies signal */
  uint8_t      si_code;      /* Source: SI_USER, SI_QUEUE, SI_TIMER, SI_ASYNCIO, or SI_MESGQ */
  uint8_t      si_errno;     /* Zero or errno value associated with signal */
  union sigval si_value;     /* Data passed with signal */
#ifdef CONFIG_SCHED_HAVE_PARENT
  pid_t        si_pid;       /* Sending task ID */
  int          si_status;    /* Exit value or signal (SIGCHLD only). */
#endif
};

typedef struct siginfo siginfo_t;
#define __SIGINFO_T_DEFINED 1

• 信号action的定义，当信号deliver的时候，Task所采取的行动，其中sigaction中sa_mask位域，表示的是当Handler在执行期间，需要阻塞的信号

/* struct sigaction flag values */

#define SA_NOCLDSTOP    (1 << 0) /* Do not generate SIGCHILD when
                                  * children stop (ignored) */
#define SA_SIGINFO      (1 << 1) /* Invoke the signal-catching function
                                  * with 3 args instead of 1
                                  * (always assumed) */
#define SA_NOCLDWAIT    (1 << 2) /* If signo=SIGCHLD, exit status of child
                                  * processes will be discarded */

/* Special values of of sa_handler used by sigaction and sigset.  They are all
 * treated like NULL for now.  This is okay for SIG_DFL and SIG_IGN because
 * in NuttX, the default action for all signals is to ignore them.
 */

#define SIG_ERR         ((_sa_handler_t)-1)  /* And error occurred */
#define SIG_DFL         ((_sa_handler_t)0)   /* Default is SIG_IGN for all signals */
#define SIG_IGN         ((_sa_handler_t)0)   /* Ignore the signal */
#define SIG_HOLD        ((_sa_handler_t)1)   /* Used only with sigset() */

/* Non-standard convenience definition of signal handling function types.
 * These should be used only internally within the NuttX signal logic.
 */

typedef CODE void (*_sa_handler_t)(int signo);
typedef CODE void (*_sa_sigaction_t)(int signo, FAR siginfo_t *siginfo,
                                     FAR void *context);

/* The following structure defines the action to take for given signal */

struct sigaction
{
  union
  {
    _sa_handler_t   _sa_handler;
    _sa_sigaction_t _sa_sigaction;
  } sa_u;
  sigset_t          sa_mask;
  int               sa_flags;
};

/* Definitions that adjust the non-standard naming */

#define sa_handler   sa_u._sa_handler
#define sa_sigaction sa_u._sa_sigaction

Kernle部分，定义在include/sched/signal/signal.h中，主要描述了Kernel中是如何实现信号机制的

• 描述一个信号的action的结构，指针flink将sigactq链接起来管理，系统注册一个信号，底层将用一个sigactq结构体来对应

/* The following defines the sigaction queue entry */

struct sigactq
{
  FAR struct sigactq *flink;     /* Forward link */
  struct sigaction act;          /* Sigaction data */
  uint8_t   signo;               /* Signal associated with action */
};
typedef struct sigactq  sigactq_t;

• 描述pending信号（未决信号）的结构，其中info中包括信号的详细信息，该信号会通过flink链接管理

/* The following defines the queue structure within each TCB to hold pending
 * signals received by the task.  These are signals that cannot be processed
 * because:  (1) the task is not waiting for them, or (2) the task has no
 * action associated with the signal.
 */

struct sigpendq
{
  FAR struct sigpendq *flink;    /* Forward link */
  siginfo_t info;                /* Signal information */
  uint8_t   type;                /* (Used to manage allocations) */
};
typedef struct sigpendq sigpendq_t;

• 描述需要被执行的信号节队列点结构，当任务注册了信号并接收到信号后，会分配一个信号队列节点，将该节点挂载到任务tcb->sigpendactionq链表上等待运行信号服务函数。其中action指向信号处理函数，mask用于当信号处理函数运行时阻塞其他信号，info是信号的详细信息

/* The following defines the queue structure within each TCB to hold queued
 * signal actions that need action by the task
 */

struct sigq_s
{
  FAR struct sigq_s *flink;      /* Forward link */
  union
  {
    void (*sighandler)(int signo, siginfo_t *info, void *context);
  } action;                      /* Signal action */
  sigset_t  mask;                /* Additional signals to mask while the
                                  * the signal-catching function executes */
  siginfo_t info;                /* Signal information */
  uint8_t   type;                /* (Used to manage allocations) */
};
typedef struct sigq_s sigq_t;

上述三种结构，struct sigactq描述信号的action， struct sigpendq描述未决的信号， struct sigq_s描述的是信号与action的对应关系，可以认为是一个纽带，将信号和Action绑定到一起。这几个结构的名字让我懵逼了好久。还有更懵逼的在下边。

基于上述的三个结构体，系统维护了5个全局队列，用于最终信号的处理，信号处理过程中，这三个结构体的节点，将在这5个全局队列中进行流动，有点类似于任务调度中任务队列的意思。

1. 存放action的队列，存放sigactq_t，用于Action资源的分配

/* The g_sigfreeaction data structure is a list of available signal action
 * structures.
 */

extern sq_queue_t  g_sigfreeaction;

2. 存放信号队列节点的队列，存放sigq_t，此时Action和信号已经完成了绑定，用于sigq_t资源的分配。存放信号队列节点的队有两种：用于普通分配的队列和用于中断中分配的队列。

/* The g_sigpendingaction data structure is a list of available pending
 * signal action structures.
 */

extern sq_queue_t  g_sigpendingaction;

/* The g_sigpendingirqaction is a list of available pending signal actions
 * that are reserved for use by interrupt handlers.
 */

extern sq_queue_t  g_sigpendingirqaction;

3. 存放未决信号的队列，存放sigpendq_t，用于未决信号资源的分配。同2相似，它也存在两种队列：用于普通分配的队列和用于中断中分配的队列。

/* The g_sigpendingsignal data structure is a list of available pending
 * signal structures.
 */

extern sq_queue_t  g_sigpendingsignal;

/* The g_sigpendingirqsignal data structure is a list of available pending
 * signal structures that are reserved for use by interrupt handlers.
 */

extern sq_queue_t  g_sigpendingirqsignal;

那么这三种数据结构以及几个全局队列又是怎么对应到Task数据结构中的呢，先看看Task中与信号相关的位域吧，有两部分：

第一部分：

struct tcb_s 
{
...
#ifndef CONFIG_DISABLE_SIGNALS
  sigset_t   sigprocmask;                /* Signals that are blocked            */
  sigset_t   sigwaitmask;                /* Waiting for pending signals         */
  sq_queue_t sigpendactionq;             /* List of pending signal actions      */
  sq_queue_t sigpostedq;                 /* List of posted signals              */
  siginfo_t  sigunbinfo;                 /* Signal info when task unblocked     */
#endif
...
}

上述代码中位域介绍如下：

• sigprocmask：任务Tcb的阻塞信号集，如果某个信号属于这个阻塞信号集，那么发送该信号到Tcb时，信号被阻塞。除非该信号是等待的信号，或者Tcb任务取消了对该信号的阻塞，信号才会被deliver。
• sigwaitmask：该任务等待的信号集。
• sigpendactionq：用于挂载该任务需要服务的信号节点sigq_t，任务开始执行时，sigpendactionq中的节点所代表的信号处理函数将被运行。在信号处理函数运行前，该信号的sigq_t节点将从sigpendactionq队列中转移到sigpostedq队列中。
• sigpostedq：用于挂载该任务正在执行信号处理函数的信号节点sigq_t，当信号处理函数执行完毕后，信号节点sigq_t将被从队列中移除，然后被释放。
• sigunbinfo：用于记录信号信息

从上可以看出，上述结构中的sigpendactionq会存放sigq_t资源，也就是已经完成了信号和Action绑定后的节点。显然，sigq_t资源会在tcb->sigpendactionq字段指向的队列和g_sigpendingaction/g_sigpendingirqaction之间流动。

第二部分，在struct task_group_s中，如果定义了TASK_GROUP的话就会包含。

struct task_group_s
{
...
#ifndef CONFIG_DISABLE_SIGNALS
  /* POSIX Signal Control Fields ************************************************/

  sq_queue_t tg_sigactionq;         /* List of actions for signals              */
  sq_queue_t tg_sigpendingq;        /* List of pending signals                  */
#endif
...
}

上述两个位域含义很清晰，一个用于放置Action，一个用于放置信号。对应到前边的五个全局队列，可以知道：sigactq_t资源在task_group->tg_sigactionq指向的队列和g_sigfreeaction队列中流动；sigpendq_t资源在task_group->tg_sigpendingq指向的队列和g_sigpendingsignal/g_sigpendingirqsignal队列中流动。

到这里为止，基本上将所有的数据结构及资源捋清了。注册信号就是关联一个Task和某个信号处理函数，当Task接收到信号后，对应信号的信号处理函数被运行。而涉及到这个处理流程的所有资源（上述结构体描述），就是在这些资源队列中进行流转。
来一张图吧

信号机制

注册信号

通过int sigaction(int signo, FAR const struct sigaction *act, FAR struct sigaction *oact)接口可以查询和设置信号关联的处理方式。在该函数中，完成了以下几个功能：

• 将act对应的sigaction设置进本task中，并将之前的sigaction以oact的形式传递出来。
• 根据signo查询task_group->tg_sigactionq中是否有对应的sigactq_t，没有的话从系统g_sigfreeaction链表中分配一个。
• 根据act对应的sigaction中Handler的处理方式(忽略信号，还是提供处理函数)，更新sigactq_t结构，最终将sigactq_t的结构插入到task_group->tg_sigactionq中。

整个过程，就是将sigaction注册进Task中的链表中，还是直接看源代码来得更清晰，代码里有详尽的注释，理解起来比较容易。

/****************************************************************************
 * Name: sigaction
 *
 * Description:
 *   This function allows the calling process to examine and/or specify the
 *   action to be associated with a specific signal.
 *
 *   The structure sigaction, used to describe an action to be taken, is
 *   defined to include the following members:
 *
 *   - sa_u.sa_handler:  Pointer to a signal-catching function
 *   - sa_u.sa_sigaction:  Alternative form of the signal-catching function
 *   - sa_mask: An additional set of signals to be blocked during execution
 *       of a signal catching function
 *   - sa_flags.  Special flags to affect the behavior of a signal.
 *
 *   If the argument 'act' is not NULL, it points to a structure specifying
 *   the action to be associated with the specified signal.  If the argument
 *   'oact' is not NULL, the action previously associated with the signal
 *   is stored in the location pointed to by the argument 'oact.'
 *
 *   When a signal is caught by a signal-catching function installed by
 *   sigaction() function, a new signal mask is calculated and installed for
 *   the duration of the signal-catching function.  This mask is formed by
 *   taking the union of the current signal mask and the value of the
 *   sa_mask for the signal being delivered and then including the signal
 *   being delivered.  If and when the user's signal handler returns, the
 *   original signal mask is restored.
 *
 *   Once an action is installed for a specific signal, it remains installed
 *   until another action is explicitly requested by another call to sigaction().
 *
 * Parameters:
 *   sig - Signal of interest
 *   act - Location of new handler
 *   oact - Location to store only handler
 *
 * Return Value:
 *   0 (OK), or -1 (ERROR) if the signal number is invalid.
 *   (errno is not set)
 *
 * Assumptions:
 *
 * POSIX Compatibility:
 * - There are no default actions so the special value SIG_DFL is treated
 *   like SIG_IGN.
 * - All sa_flags in struct sigaction of act input are ignored (all
 *   treated like SA_SIGINFO). The one exception is if CONFIG_SCHED_CHILD_STATUS
 *   is defined; then SA_NOCLDWAIT is supported but only for SIGCHLD
 *
 ****************************************************************************/

int sigaction(int signo, FAR const struct sigaction *act, FAR struct sigaction *oact)
{
  FAR struct tcb_s *rtcb = this_task();
  FAR struct task_group_s *group;
  FAR sigactq_t *sigact;

  /* Since sigactions can only be installed from the running thread of
   * execution, no special precautions should be necessary.
   */

  DEBUGASSERT(rtcb != NULL && rtcb->group != NULL);
  group = rtcb->group;

  /* Verify the signal number */

  if (!GOOD_SIGNO(signo))
    {
      set_errno(EINVAL);
      return ERROR;
    }

  /* Find the signal in the signal action queue */

  sigact = sig_findaction(group, signo);

  /* Return the old sigaction value if so requested */

  if (oact)
    {
      if (sigact)
        {
          COPY_SIGACTION(oact, &sigact->act);
        }
      else
        {
          /* There isn't an old value */

          oact->sa_u._sa_handler = NULL;
          oact->sa_mask = NULL_SIGNAL_SET;
          oact->sa_flags = 0;
        }
    }

  /* If the argument act is a null pointer, signal handling is unchanged;
   * thus, the call can be used to enquire about the current handling of
   * a given signal.
   */

  if (!act)
    {
      return OK;
    }

#if defined(CONFIG_SCHED_HAVE_PARENT) && defined(CONFIG_SCHED_CHILD_STATUS)

  /* Handle a special case.  Retention of child status can be suppressed
   * if signo == SIGCHLD and sa_flags == SA_NOCLDWAIT.
   *
   * POSIX.1 leaves it unspecified whether a SIGCHLD signal is generated
   * when a child process terminates.  In NuttX, a SIGCHLD signal is
   * generated in this case; but in some other implementations, it may not
   * be.
   */

  if (signo == SIGCHLD && (act->sa_flags & SA_NOCLDWAIT) != 0)
    {
      irqstate_t flags;

      /* We do require a critical section to muck with the TCB values that
       * can be modified by the child thread.
       */

      flags = enter_critical_section();

      /* Mark that status should be not be retained */

      rtcb->group->tg_flags |= GROUP_FLAG_NOCLDWAIT;

      /* Free all pending exit status */

      group_removechildren(rtcb->group);
      leave_critical_section(flags);
    }
#endif

  /* Handle the case where no sigaction is supplied (SIG_IGN) */

  if (act->sa_u._sa_handler == SIG_IGN)
    {
      /* Do we still have a sigaction container from the previous setting? */

      if (sigact)
        {
          /* Yes.. Remove it from signal action queue */

          sq_rem((FAR sq_entry_t *)sigact, &group->tg_sigactionq);

          /* And deallocate it */

          sig_releaseaction(sigact);
        }
    }

  /* A sigaction has been supplied */

  else
    {
      /* Do we still have a sigaction container from the previous setting?
       * If so, then re-use for the new signal action.
       */

      if (!sigact)
        {
          /* No.. Then we need to allocate one for the new action. */

          sigact = sig_allocateaction();

          /* An error has occurred if we could not allocate the sigaction */

          if (!sigact)
            {
              set_errno(ENOMEM);
              return ERROR;
            }

          /* Put the signal number in the queue entry */

          sigact->signo = (uint8_t)signo;

          /* Add the new sigaction to signal action queue */

          sq_addlast((FAR sq_entry_t *)sigact, &group->tg_sigactionq);
        }

      /* Set the new sigaction */

      COPY_SIGACTION(&sigact->act, act);
    }

  return OK;
}

发送信号

发送信号以kill()函数来解释是再合适不过了。
在kill()函数中，根据传进来的PID号，找到对应的Task，并向该Task发送信号，关键代码如下：

int kill(pid_t pid, int signo)
{
...
  /* Keep things stationary through the following */

  sched_lock();

  /* Create the siginfo structure */

  info.si_signo           = signo;
  info.si_code            = SI_USER;
  info.si_errno           = EINTR;
  info.si_value.sival_ptr = NULL;
#ifdef CONFIG_SCHED_HAVE_PARENT
  info.si_pid             = rtcb->pid;
  info.si_status          = OK;
#endif

  /* Send the signal */

  ret = sig_dispatch(pid, &info);
  sched_unlock();
...
}

调用到sig_dispatch()接口，完成信号的分发，而在sig_dispatch()接口中，又将调用sig_tcbdispatch()接口，最核心的部分在于sig_tcbdispatch()，事实上上层信号最终的分发都在这个接口中实现。

sig_tcbdispatch()函数，主要完成以下几点功能：

• 如果分发的信号在目标Task中是是masked，而且Task的状态没有变成等待该信号的话，就将信号添加进pending队列中，也就是task_group->tg_sigpendingq队列中；而如果Task的状态变成了需要等待这个之前mask掉的信号，这时候就调用up_unblock_task()接口，完成任务的切换。
• 如果分发的信号在目标Task中是unmask，此时需要调用sig_queueaction()接口，将一个sigq_t结构添加进tcb->sigpendactionq队列中。当然，在sig_queueaction()接口中，会去从上文中提到过的全局队列中获取sigq_t结构资源。加入到tcb->sigpendactionq队列后，调用up_schedule_sigaction()接口，该接口主要是更新Task对应的Tcb中的内容，最终调用up_unblock_task()进行任务切换的时候，能去处理信号。

最终信号发送成功，有两件事完成了：1）在目标Task的tcb->sigpendactionq队列中，成功的添加了sigq_t结构，该结构完成了信号和Action的匹配；2）更新了目标Task的tcb->xcp中的内容，更新完这个后，当完成任务切换的时候，Context Restore的时候会将tcb->xcp中的内容恢复到寄存器中，因此也就能跳转到信号处理函数中执行。

关键代码如下：

/****************************************************************************
 * Name: sig_tcbdispatch
 *
 * Description:
 *   All signals received the task (whatever the source) go through this
 *   function to be processed.  This function is responsible for:
 *
 *   - Determining if the signal is blocked.
 *   - Queuing and dispatching signal actions
 *   - Unblocking tasks that are waiting for signals
 *   - Queuing pending signals.
 *
 *   This function will deliver the signal to the task associated with
 *   the specified TCB.  This function should *not* typically be used
 *   to dispatch signals since it will *not* follow the group signal
 *   deliver algorithms.
 *
 * Returned Value:
 *   Returns 0 (OK) on success or a negated errno value on failure.
 *
 ****************************************************************************/

int sig_tcbdispatch(FAR struct tcb_s *stcb, siginfo_t *info)
{
...
  /************************* MASKED SIGNAL HANDLING ************************/

  /* Check if the signal is masked -- if it is, it will be added to the list
   * of pending signals.
   */

  if (sigismember(&stcb->sigprocmask, info->si_signo))
    {
      /* Check if the task is waiting for this pending signal.  If so, then unblock it.
       * This must be performed in a critical section because signals can be queued
       * from the interrupt level.
       */

      flags = enter_critical_section();
      if (stcb->task_state == TSTATE_WAIT_SIG &&
          sigismember(&stcb->sigwaitmask, info->si_signo))
        {
          memcpy(&stcb->sigunbinfo, info, sizeof(siginfo_t));
          stcb->sigwaitmask = NULL_SIGNAL_SET;
          up_unblock_task(stcb);
          leave_critical_section(flags);
        }

      /* Its not one we are waiting for... Add it to the list of pending
       * signals.
       */

      else
        {
          leave_critical_section(flags);
          ASSERT(sig_addpendingsignal(stcb, info));
        }
    }

  /************************ UNMASKED SIGNAL HANDLING ***********************/

  else
    {
#ifdef CONFIG_SMP
      int cpu;
#endif
      /* Queue any sigaction's requested by this task. */

      ret = sig_queueaction(stcb, info);

      /* Deliver of the signal must be performed in a critical section */

      flags = enter_critical_section();

#ifdef CONFIG_SMP
      /* If the thread is running on another CPU, then pause that CPU.  We can
       * then setup the for signal delivery on the running thread.  When the
       * CPU is resumed, the signal handler will then execute.
       */

      cpu = sched_cpu_pause(stcb);
#endif /* CONFIG_SMP */

      /* Then schedule execution of the signal handling action on the
       * recipient's thread.
       */

      up_schedule_sigaction(stcb, sig_deliver);

#ifdef CONFIG_SMP
      /* Resume the paused CPU (if any) */

      if (cpu >= 0)
        {
          /* I am not yet sure how to handle a failure here. */

          DEBUGVERIFY(up_cpu_resume(cpu));
        }
#endif /* CONFIG_SMP */

      /* Check if the task is waiting for an unmasked signal.  If so, then
       * unblock it. This must be performed in a critical section because
       * signals can be queued from the interrupt level.
       */

      if (stcb->task_state == TSTATE_WAIT_SIG)
        {
          memcpy(&stcb->sigunbinfo, info, sizeof(siginfo_t));
          stcb->sigwaitmask = NULL_SIGNAL_SET;
          up_unblock_task(stcb);
        }

      leave_critical_section(flags);

      /* If the task neither was waiting for the signal nor had a signal
       * handler attached to the signal, then the default action is
       * simply to ignore the signal
       */

      /*********************** OTHER SIGNAL HANDLING ***********************/

      /* If the task is blocked waiting for a semaphore, then that task must
       * be unblocked when a signal is received.
       */
...
}

传递信号

信号最终的deliver，需要理解两个函数，以及一个过程。两个函数指的是up_schedule_sigaction()和up_sigdeliver()，在arch/arm/src/arm下实现，一个过程指的是Context切换的过程，参考我之前的一篇文章：Nuttx Task Schedule

先来看看up_schedule_sigaction()函数，在函数中又分为几种情况：1）发送的信号是给当前任务的，且当前任务不在中断上下文中；2）发送的信号是给当前任务的，且当前任务在中断上下文中；3）发送的信号是给其他任务的。

• 发送给当前任务，且不在中断中，直接调用sig_deliver()函数，完成信号的deliver。
• 发送给当前任务，且在中断中，需要先将中断上下文中保存的PC和CPSR值保存到tcb->xcp.saved_pc和tcb->xcp.saved_cpsr中，然后再将up_sigdeliver()函数指针值及新设置的CPSR覆盖中断上下文中的PC和CPSR值，因此当中断返回的时候，中断上下文将恢复到寄存器中，此时便会去执行up_sigdeliver()函数，在up_sigdeliver()中调用sig_deliver()完成信号处理。这时候可能会有疑问，那之前的中断上下文被破坏了，怎么恢复呢？别忘了tcb->xcp.saved_pc和tcb->xcp.saved_cpsr，这个结构保存了最开始的中断上下文，因此在up_sigdeliver()执行中，会去恢复原来的中断上下文。
• 发送给其他任务，处理的方式与在中断中发送给当前任务的情况类似。

/****************************************************************************
 * Name: up_schedule_sigaction
 *
 * Description:
 *   This function is called by the OS when one or more
 *   signal handling actions have been queued for execution.
 *   The architecture specific code must configure things so
 *   that the 'igdeliver' callback is executed on the thread
 *   specified by 'tcb' as soon as possible.
 *
 *   This function may be called from interrupt handling logic.
 *
 *   This operation should not cause the task to be unblocked
 *   nor should it cause any immediate execution of sigdeliver.
 *   Typically, a few cases need to be considered:
 *
 *   (1) This function may be called from an interrupt handler
 *       During interrupt processing, all xcptcontext structures
 *       should be valid for all tasks.  That structure should
 *       be modified to invoke sigdeliver() either on return
 *       from (this) interrupt or on some subsequent context
 *       switch to the recipient task.
 *   (2) If not in an interrupt handler and the tcb is NOT
 *       the currently executing task, then again just modify
 *       the saved xcptcontext structure for the recipient
 *       task so it will invoke sigdeliver when that task is
 *       later resumed.
 *   (3) If not in an interrupt handler and the tcb IS the
 *       currently executing task -- just call the signal
 *       handler now.
 *
 ****************************************************************************/

void up_schedule_sigaction(struct tcb_s *tcb, sig_deliver_t sigdeliver)
{
  irqstate_t flags;

  sinfo("tcb=0x%p sigdeliver=0x%p\n", tcb, sigdeliver);

  /* Make sure that interrupts are disabled */

  flags = enter_critical_section();

  /* Refuse to handle nested signal actions */

  if (!tcb->xcp.sigdeliver)
    {
      /* First, handle some special cases when the signal is
       * being delivered to the currently executing task.
       */

      sinfo("rtcb=0x%p CURRENT_REGS=0x%p\n", this_task(), CURRENT_REGS);

      if (tcb == this_task())
        {
          /* CASE 1:  We are not in an interrupt handler and
           * a task is signalling itself for some reason.
           */

          if (!CURRENT_REGS)
            {
              /* In this case just deliver the signal now. */

              sigdeliver(tcb);
            }

          /* CASE 2:  We are in an interrupt handler AND the
           * interrupted task is the same as the one that
           * must receive the signal, then we will have to modify
           * the return state as well as the state in the TCB.
           *
           * Hmmm... there looks like a latent bug here: The following
           * logic would fail in the strange case where we are in an
           * interrupt handler, the thread is signalling itself, but
           * a context switch to another task has occurred so that
           * CURRENT_REGS does not refer to the thread of this_task()!
           */

          else
            {
              /* Save the return lr and cpsr and one scratch register
               * These will be restored by the signal trampoline after
               * the signals have been delivered.
               */

              tcb->xcp.sigdeliver       = sigdeliver;
              tcb->xcp.saved_pc         = CURRENT_REGS[REG_PC];
              tcb->xcp.saved_cpsr       = CURRENT_REGS[REG_CPSR];

              /* Then set up to vector to the trampoline with interrupts
               * disabled
               */

              CURRENT_REGS[REG_PC]      = (uint32_t)up_sigdeliver;
              CURRENT_REGS[REG_CPSR]    = SVC_MODE | PSR_I_BIT | PSR_F_BIT;

              /* And make sure that the saved context in the TCB
               * is the same as the interrupt return context.
               */

              up_savestate(tcb->xcp.regs);
            }
        }

      /* Otherwise, we are (1) signaling a task is not running
       * from an interrupt handler or (2) we are not in an
       * interrupt handler and the running task is signalling
       * some non-running task.
       */

      else
        {
          /* Save the return lr and cpsr and one scratch register
           * These will be restored by the signal trampoline after
           * the signals have been delivered.
           */

          tcb->xcp.sigdeliver       = sigdeliver;
          tcb->xcp.saved_pc         = tcb->xcp.regs[REG_PC];
          tcb->xcp.saved_cpsr       = tcb->xcp.regs[REG_CPSR];

          /* Then set up to vector to the trampoline with interrupts
           * disabled
           */

          tcb->xcp.regs[REG_PC]      = (uint32_t)up_sigdeliver;
          tcb->xcp.regs[REG_CPSR]    = SVC_MODE | PSR_I_BIT | PSR_F_BIT;
        }
    }

  leave_critical_section(flags);
}

当调用up_schedule_sigaction()接口，更新了tcb->xcp的值后，当遇到任务切换点的时候，比如up_unblock_task()，就有可能去执行信号处理函数了，这个就是up_sigdeliver()函数的作用了。
up_sigdeliver()函数主要完成以下几个功能：

• 在栈上边regs中将现场保存好，并且将之前tcb->xcp.saved_pc和tcb->xcp.saved_cpsr中的值恢复到regs栈上边对应位置。
• 恢复中断状态
• 调用信号处理Handler进行处理
• 调用up_fullcontextrestore(regs)，进行任务的恢复。

可以看出，这个过程很像中断处理的过程，因此信号的处理机制，有的地方称为软中断处理机制

还是放上代码吧：

/****************************************************************************
 * Name: up_sigdeliver
 *
 * Description:
 *   This is the a signal handling trampoline.  When a signal action was
 *   posted.  The task context was mucked with and forced to branch to this
 *   location with interrupts disabled.
 *
 ****************************************************************************/

void up_sigdeliver(void)
{
  struct tcb_s  *rtcb = this_task();
  uint32_t regs[XCPTCONTEXT_REGS];
  sig_deliver_t sigdeliver;

  /* Save the errno.  This must be preserved throughout the signal handling
   * so that the user code final gets the correct errno value (probably
   * EINTR).
   */

  int saved_errno = rtcb->pterrno;

  board_autoled_on(LED_SIGNAL);

  sinfo("rtcb=%p sigdeliver=%p sigpendactionq.head=%p\n",
        rtcb, rtcb->xcp.sigdeliver, rtcb->sigpendactionq.head);
  ASSERT(rtcb->xcp.sigdeliver != NULL);

  /* Save the real return state on the stack. */

  up_copyfullstate(regs, rtcb->xcp.regs);
  regs[REG_PC]         = rtcb->xcp.saved_pc;
  regs[REG_CPSR]       = rtcb->xcp.saved_cpsr;

  /* Get a local copy of the sigdeliver function pointer. we do this so that
   * we can nullify the sigdeliver function pointer in the TCB and accept
   * more signal deliveries while processing the current pending signals.
   */

  sigdeliver           = rtcb->xcp.sigdeliver;
  rtcb->xcp.sigdeliver = NULL;

  /* Then restore the task interrupt state */

  up_irq_restore(regs[REG_CPSR]);

  /* Deliver the signals */

  sigdeliver(rtcb);

  /* Output any debug messages BEFORE restoring errno (because they may
   * alter errno), then disable interrupts again and restore the original
   * errno that is needed by the user logic (it is probably EINTR).
   */

  sinfo("Resuming\n");
  (void)up_irq_save();
  rtcb->pterrno = saved_errno;

  /* Then restore the correct state for this thread of execution. */

  board_autoled_off(LED_SIGNAL);
  up_fullcontextrestore(regs);
}

上面讨论的两个函数，都会最终调用到sig_deliver()函数，完成最终实际上的Handler处理，sig_deliver()函数处理那些被链接到tcb->sigpendactionq中的sigq_t，将sigq_t结构转移到tcb->sigpostedq队列中，紧接着执行信号处理函数。处理完当前的信号后，紧接着调用sig_unmaskpendingsignal()函数，查询tcb_group->tg_sigpendingq中是否还有pending的信号需要去处理，并调用sig_tcbdispatch()继续进行分发。最终处理完本次任务后，将sigq_t结构体从任务tcb->sigpostedq中移除，并释放该结构。
代码如下：

/****************************************************************************
 * Name: sig_deliver
 *
 * Description:
 *   This function is called on the thread of execution of the signal
 *   receiving task.  It processes all queued signals then returns.
 *
 ****************************************************************************/

void sig_deliver(FAR struct tcb_s *stcb)
{
  FAR sigq_t *sigq;
  FAR sigq_t *next;
  sigset_t    savesigprocmask;
  irqstate_t  flags;
  int         saved_errno;

  sched_lock();

  /* Save the thread errno.  When we finished dispatching the
   * signal actions and resume the task, the errno value must
   * be unchanged by the operation of the signal handling.  In
   * particular, the EINTR indication that says that the task
   * was reawakened by a signal must be retained.
   */

  saved_errno = stcb->pterrno;
  for (sigq = (FAR sigq_t *)stcb->sigpendactionq.head; (sigq); sigq = next)
    {
      next = sigq->flink;
      sinfo("Sending signal sigq=0x%x\n", sigq);

      /* Remove the signal structure from the sigpendactionq and place it
       * in the sigpostedq.  NOTE:  Since signals are processed one at a
       * time, there should never be more than one signal in the sigpostedq
       */

      flags = enter_critical_section();
      sq_rem((FAR sq_entry_t *)sigq, &(stcb->sigpendactionq));
      sq_addlast((FAR sq_entry_t *)sigq, &(stcb->sigpostedq));
      leave_critical_section(flags);

      /* Call the signal handler (unless the signal was cancelled)
       *
       * Save a copy of the old sigprocmask and install the new
       * (temporary) sigprocmask.  The new sigprocmask is the union
       * of the current sigprocmask and the sa_mask for the signal being
       * delivered plus the signal being delivered.
       */

      savesigprocmask = stcb->sigprocmask;
      stcb->sigprocmask = savesigprocmask | sigq->mask | SIGNO2SET(sigq->info.si_signo);

      /* Deliver the signal.  In the kernel build this has to be handled
       * differently if we are dispatching to a signal handler in a user-
       * space task or thread; we have to switch to user-mode before
       * calling the task.
       */

#if defined(CONFIG_BUILD_PROTECTED) || defined(CONFIG_BUILD_KERNEL)
      if ((stcb->flags & TCB_FLAG_TTYPE_MASK) != TCB_FLAG_TTYPE_KERNEL)
        {
          /* The sigq_t pointed to by sigq resides in kernel space.  So we
           * cannot pass a reference to sigq->info to the user application.
           * Instead, we will copy the siginfo_t structure onto the stack.
           * We are currently executing on the stack of the user thread
           * (albeit temporarily in kernel mode), so the copy of the
           * siginfo_t structure will be accessible by the user thread.
           */

          siginfo_t info;
          memcpy(&info, &sigq->info, sizeof(siginfo_t));

          up_signal_dispatch(sigq->action.sighandler, sigq->info.si_signo,
                             &info, NULL);
        }
      else
#endif
        {
          /* The kernel thread signal handler is much simpler. */

          (*sigq->action.sighandler)(sigq->info.si_signo, &sigq->info,
                                     NULL);
        }

      /* Restore the original sigprocmask */

      stcb->sigprocmask = savesigprocmask;

      /* Now, handle the (rare?) case where (a) a blocked signal was
       * received while the signal handling executed but (b) restoring the
       * original sigprocmask will unblock the signal.
       */

      sig_unmaskpendingsignal();

      /* Remove the signal from the sigpostedq */

      flags = enter_critical_section();
      sq_rem((FAR sq_entry_t *)sigq, &(stcb->sigpostedq));
      leave_critical_section(flags);

      /* Then deallocate it */

      sig_releasependingsigaction(sigq);
    }

  stcb->pterrno = saved_errno;
  sched_unlock();
}

Nuttx OS的学习和相关文档更新持续中...