Libev源码分析08：Libev中的信号监视器

         Libev中的信号监视器，用于监控信号的发生，因信号是异步的，所以Libev的处理方式是尽量的将异步信号同步化。异步信号的同步化方法主要有：signalfd、eventfd、pipe、sigwaitinfo等。这里Libev采用的是前三种方法，最终都是将对异步信号的处理，转化成对文件描述符的处理，也就是将ev_signal转化为处理ev_io。

 

一：数据结构

1：ev_signal

typedef struct ev_signal
{
    int active;
    int pending;
    int priority;
    void *data;
    void (*cb)(EV_P_ struct ev_signal *w, int revents);
    struct ev_watcher_list *next;

    int signum;
} ev_signal;

         ev_signal的结构跟ev_io的结构十分类似，前6个成员是完全一样的，最后一个signum记录信号值。前六个成员构成了一个ev_watcher_list结构，因此信号监视器也是按照链表组织的。

 

2：ANSIG

typedef struct
{
    sig_atomic_t volatile pending;
#if EV_MULTIPLICITY
    struct ev_loop *loop;
#endif
    ev_watcher_list *head;
} ANSIG;

static ANSIG signals [EV_NSIG - 1];

         ANSIG就是Libev内部用来组织ev_signal的结构体，它的成员包括：pending表明该信号是否处于未决状态（触发但尚未处理），head表明该信号对应的监视器链表的头指针，另外，Libev不允许同一个信号出现在多个ev_loop结构中，因此，如果支持多个ev_loop的话，还有一个loop成员记录该信号对应的ev_loop。

 

         signals是ANSIG类型的数组，它的下标就是相应的信号值-1，因此，每个信号都有对应的ANSIG结构。

 

二：初始化ev_signal

#define ev_signal_set(ev,signum_)  do {\
  (ev)->signum = (signum_); \
} while (0)

#define ev_signal_init(ev,cb,signum)  do {\
   ev_init ((ev), (cb)); \
   ev_signal_set ((ev), (signum)); \
} while (0)

三：使用signalfd处理信号

         各个系统支持的信号同步机制各有不同，针对多种信号同步机制，Libev采用下面的优先级循序：signalfd、eventfd、pipe。

         signalfd是最简单方便的信号同步机制，可以很容易的将异步的信号的监听转化成对文件描述符的监听。下面首先看一下使用signalfd时的信号处理流程。

 

1：ev_signal_start

void ev_signal_start (struct ev_loop *loop, ev_signal *w)
{
    if (expect_false (ev_is_active (w)))
        return;
        
    assert (("libev: ev_signal_start called with illegal signal number", 
            w->signum > 0 && w->signum < EV_NSIG));

#if EV_MULTIPLICITY
    assert (("libev: a signal must not be attached to two different loops",
            !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));

    signals [w->signum - 1].loop = loop;
#endif

#if EV_USE_SIGNALFD
    if (sigfd == -2)
    {
        sigfd = signalfd (-1, &sigfd_set, SFD_NONBLOCK | SFD_CLOEXEC);
        if (sigfd < 0 && errno == EINVAL)
            sigfd = signalfd (-1, &sigfd_set, 0); /* retry without flags */

        if (sigfd >= 0)
        {
            fd_intern (sigfd); /* doing it twice will not hurt */

            sigemptyset (&sigfd_set);

            ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ);
            ev_set_priority (&sigfd_w, EV_MAXPRI);
            ev_io_start (EV_A_ &sigfd_w);
            ev_unref (EV_A); /* signalfd watcher should not keep loop alive */
        }
    }

    if (sigfd >= 0)
    {
        sigaddset (&sigfd_set, w->signum);
        sigprocmask (SIG_BLOCK, &sigfd_set, 0);

        signalfd (sigfd, &sigfd_set, 0);
    }
#endif

    ev_start (EV_A_ (W)w, 1);
    wlist_add (&signals [w->signum - 1].head, (WL)w);

    ...

}

         在ev_signal_start中，首先对信号监视器w进行验证：

如果它已经被激活，也就是w->active不为0，直接返回；

信号监视器中的信号值应该处于合法范围(0, EV_NSIG)内，否则进程退出；

该信号对应的ANSIG结构中记录的ev_loop，应该就是参数loop，否则进程退出；

 

         验证完成后，首先记录一下该信号所在的ev_loop：

signals [w->signum - 1].loop = loop;

         然后，根据宏EV_USE_SIGNALFD判断系统是否支持signalfd函数，根据loop->sigfd的值判断用户是否使用signalfd函数，在初始化ev_loop的函数loop_init (struct ev_loop *loop, unsigned intflags)中有：

sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;

         因此，用户如果想使用signalfd函数，flags参数中必须有EVFLAG_SIGNALFD，也就是在使用ev_default_loop或者ev_loop_new初始化ev_loop时，必须指明EVFLAG_SIGNALFD标志。

 

         如果系统支持signalfd，并且loop->sigfd为-2的话，则开始调用signalfd函数（这是第一次调用signalfd），创建signalfd文件描述符。如果signalfd支持SFD_NONBLOCK和SFD_CLOEXEC标志的话，则直接在signalfd中设置，否则调用fd_intern，使用fcntl设置（即使signalfd支持这俩标志，也会调用该函数重新设置一遍，无伤大雅）。注意，第一次调用signalfd时，信号集（sigset_t）sigfd_set尚未初始化，在下面初始化。

         第一次调用signalfd成功之后，首先清空信号集sigfd_set，然后将signalfd文件描述符加入到Libev内部的IO监视器（ev_io）sigfd_w中，并且启动sigfd_w，注意这里设置sigfd_w的优先级为最高优先级，回调函数为sigfdcb：

sigemptyset (&sigfd_set);

ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ);
ev_set_priority (&sigfd_w, EV_MAXPRI);
ev_io_start (EV_A_ &sigfd_w);
ev_unref (EV_A); /* signalfd watcher should not keep loop alive */

         接下来，将信号w->signum加入到信号集sigfd_set中，阻塞该信号，重新关联signalfd和sigfd_set：

sigaddset (&sigfd_set, w->signum);
sigprocmask (SIG_BLOCK, &sigfd_set, 0);
signalfd (sigfd, &sigfd_set, 0);

         之所以不在调用signalfd的时候阻塞该信号并关联signalfd描述符，是因为所有信号仅使用一个signalfd描述符sigfd，一个IO监视器sigfd_w。当有多个信号监视器时，需要多次调用ev_signal_start，在第一次调用ev_signal_start成功之后，sigfd的值便已是大于等于0的整数了，这样只需要将信号阻塞，然后重新关联sigfd即可，而无需重新创建一个signalfd描述符并加入到IO监视器sigfd_w中。

 

         最后，激活该信号监视器w，并且将其加入到相应的ANSIG结构中：

ev_start (EV_A_ (W)w, 1);
wlist_add (&signals [w->signum - 1].head, (WL)w);

         这样，如果使用signalfd监控信号，ev_signal_start函数的流程就结束了。接下来，就是监控IO监视器sigfd_w了。当sigfd_set中的一个或多个信号发生时，sigfd变成可读状态，IO监视器sigfd_w触发，在ev_run中，调用ev_invoke_pending时，就会调用它的回调函数sigfdcb。ev_invoke_pending的代码如下：

void ev_invoke_pending (struct ev_loop *loop)
{
  pendingpri = NUMPRI;

  while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
    {
      --pendingpri;

      while (pendingcnt [pendingpri])
        {
          ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];

          p->w->pending = 0;
          EV_CB_INVOKE (p->w, p->events);
          EV_FREQUENT_CHECK;
        }
    }
}

         该函数中，首先从最高优先级的pendings开始轮训，依次调用其中监视器的回调函数。因IO监视器sigfd_w具有最高优先级，因此如果信号触发了，则sigfd_w的回调函数sigfdcb会首先被调用到。

 

2：sigfdcb

static void sigfdcb (struct ev_loop *loop, ev_io *iow, int revents)
{
    struct signalfd_siginfo si[2], *sip; /* these structs are big */

    for (;;)
    {
        ssize_t res = read (sigfd, si, sizeof (si));

        /* not ISO-C, as res might be -1, but works with SuS */
        for (sip = si; (char *)sip < (char *)si + res; ++sip)
            ev_feed_signal_event (EV_A_ sip->ssi_signo);

        if (res < (ssize_t)sizeof (si))
            break;
    }
}

         该回调函数中，主要是读取sigfd中的信号信息。因struct  signalfd_siginfo结构比较大(128字节)，这里采用的技巧是每次read时最多只读取2个。

         针对读取到的信号值，调用ev_feed_signal_event函数。

 

3：ev_feed_signal_event

void ev_feed_signal_event (struct ev_loop *loop, int signum)
{
    WL w;

    if (expect_false (signum <= 0 || signum >= EV_NSIG))
        return;

    --signum;

#if EV_MULTIPLICITY
  /* it is permissible to try to feed a signal to the wrong loop */
  /* or, likely more useful, feeding a signal nobody is waiting for*/

    if (expect_false (signals [signum].loop != EV_A))
        return;
#endif

    signals [signum].pending = 0;

    for (w = signals [signum].head; w; w = w->next)
        ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
}

         在ev_feed_signal_event中，首先检查信号值是否处于合法范围(0, EV_NSIG)内，然后检查该信号对应的ev_loop是否就是当前的loop，如果不是则直接返回。

         然后置signals [signum].pending为0，在signals中找到该信号的监视器列表，针对该列表中的所有监视器，调用ev_feed_event，将监视器加入到loop->pendings中。

         注意，此时添加信号监视器到loop->pendings的流程，还是处于ev_invoke_pending函数的流程中的，因此，在ev_invoke_pending中，处理完sigfd_w监视器后，接着就会处理到刚刚加到loop->pendings的信号监视器。从而信号自己的回调函数就会被调用到。

        

        这样使用signalfd监控信号的完整流程就结束了。

 

四：使用eventfd、pipe处理信号

         使用eventfd和pipe处理信号的基本思路是一样的，首先创建eventfd描述符或者管道pipe，使用IO监视器监听eventfd描述符或者pipe[0]，当信号发生时时，在信号处理程序中，写入eventfd描述符或者pipe[1]，从而触发IO监视器，调用回调函数pipecb处理信号。

 

1：ev_signal_start

         首先看下，当不使用signalfd，或者调用signalfd失败时，ev_signal_start的流程：

void ev_signal_start (struct ev_loop *loop, ev_signal *w) EV_THROW
{
    if (expect_false (ev_is_active (w)))
        return;

    assert (("libev: ev_signal_start called with illegal signal number", 
            w->signum > 0 && w->signum < EV_NSIG));

#if EV_MULTIPLICITY
    assert (("libev: a signal must not be attached to two different loops",
           !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));

    signals [w->signum - 1].loop = EV_A;
#endif

...

    ev_start (EV_A_ (W)w, 1);
    wlist_add (&signals [w->signum - 1].head, (WL)w);

    if (!((WL)w)->next)
# if EV_USE_SIGNALFD
        if (sigfd < 0) /*TODO*/
# endif
        {
            struct sigaction sa;

            evpipe_init (EV_A);

            sa.sa_handler = ev_sighandler;
            sigfillset (&sa.sa_mask);
            sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration*/
            sigaction (w->signum, &sa, 0);

            if (origflags & EVFLAG_NOSIGMASK)
            {
                sigemptyset (&sa.sa_mask);
                sigaddset (&sa.sa_mask, w->signum);
                sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
            }
      }
}

        首先对信号监视器w进行验证，然后激活该信号监视器w，并且将其加入到相应的ANSIG结构中，该过程与使用signalfd的流程一样，不再赘述。

        接下来，如果该监视器是当前信号的第一个监视器（((WL)w)->next == NULL），说明这是第一次监听该信号，需要创建该信号的信号处理函数，并且创建eventfd或pipe结构。

        首先调用evpipe_init初始化eventfd或pipe结构，暂且不表，下面详述。

        然后调用sigaction建立该信号的处理函数为ev_sighandler，并且在调用信号处理函数时，阻塞所有信号，且被信号中断的低速系统调用会被重启

sa.sa_handler = ev_sighandler;
sigfillset (&sa.sa_mask);
sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
sigaction (w->signum, &sa, 0);

        如果在初始化ev_loop时指定了EVFLAG_NOSIGMASK标志的话，还需要明确将监听的信号解除阻塞。

if (origflags & EVFLAG_NOSIGMASK)
{
sigemptyset (&sa.sa_mask);
sigaddset (&sa.sa_mask, w->signum);
sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
}

 

2：evpipe_init

         该函数用来创建eventfd描述符或者pipe，并将信号监视器转换为IO监视器pipe_w。代码如下：

static void evpipe_init (struct ev_loop *loop)
{
    if (!ev_is_active (&pipe_w))
    {
        int fds [2];

# if EV_USE_EVENTFD
        fds [0] = -1;
        fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
        if (fds [1] < 0 && errno == EINVAL)
            fds [1] = eventfd (0, 0);

        if (fds [1] < 0)
# endif
        {
            while (pipe (fds))
                ev_syserr ("(libev) error creating signal/async pipe");

            fd_intern (fds [0]);
        }

        evpipe [0] = fds [0];

        if (evpipe [1] < 0)
            evpipe [1] = fds [1]; /* first call, set write fd */
        else
        {
            /* on subsequent calls, do not change evpipe [1] */
            /* so that evpipe_write can always rely on its value. */
            /* this branch does not do anything sensible on windows, */
            /* so must not be executed on windows */

            dup2 (fds [1], evpipe [1]);
            close (fds [1]);
        }

        fd_intern (evpipe [1]);

        ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
        ev_io_start (EV_A_ &pipe_w);
        ev_unref (EV_A); /* watcher should not keep loop alive */
    }
}

        所有信号使用一个IO监视器pipe_w，如果pipe_w已经处于激活状态，则说明相应的结构已经创建好了，直接返回即可。

        然后根据宏EV_USE_EVENTFD判断系统是否支持eventfd，如果支持，则调用eventfd创建eventfd描述符，如果不支持，或者调用eventfd失败，则调用pipe创建管道，并设置管道读端描述符的FD_CLOEXEC和O_NONBLOCK标志。

        使用evpipe[0]记录读描述符，evpipe[1]记录写描述符，如果使用eventfd，则evpipe[0]为-1，evpipe[1]为eventfd描述符，读写描述符都是eventfd。

        调用fd_intern，使用fcntl设置写描述符evpipe[1]的FD_CLOEXEC和O_NONBLOCK标志。

        最后启动内部IO监视器pipe_w，监听读描述符：

ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
ev_io_start (EV_A_ &pipe_w);
ev_unref (EV_A); /* watcher should not keep loop alive */

        注意，pipe_w监视器的初始化，在loop_init中就已经做了：

#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
    ev_init (&pipe_w, pipecb);
    ev_set_priority (&pipe_w, EV_MAXPRI);
#endif

        这里设置pipe_w的回调函数为pipecb，优先级为最高优先级EV_MAXPRI。

 

        当信号产生时，就会调用到信号处理函数ev_sighandler，改处理函数仅仅就是调用函数ev_feed_signal而已。

 

3：ev_feed_signal

void ev_feed_signal (int signum)
{
#if EV_MULTIPLICITY
    struct ev_loop *loop;
    loop = signals [signum - 1].loop;

    if (!loop)
        return;
#endif
    signals [signum - 1].pending = 1;
    evpipe_write (loop, &sig_pending);
}

         该函数首先根据信号值得到该信号所在的ev_loop，然后置该信号对应的ANSIG的pending为1，最后调用evpipe_write函数。

 

4：evpipe_write

void evpipe_write (struct ev_loop *loop, sig_atomic_t volatile *flag)
{
    if (expect_true (*flag))
        return;

    *flag = 1;

    pipe_write_skipped = 1;

    if (pipe_write_wanted)
    {
        int old_errno;

        pipe_write_skipped = 0;

        old_errno = errno; /* save errno because write will clobber it*/

#if EV_USE_EVENTFD
        if (evpipe [0] < 0)
        {
            uint64_t counter = 1;
            write (evpipe [1], &counter, sizeof (uint64_t));
        }
        else
#endif
        {
            write (evpipe [1], &(evpipe [1]), 1);
        }

        errno = old_errno;
    }
}

         注意，当在一个loop中有多个信号发生时，也仅需要产生一个事件而已。本函数主要作用就是当信号发生时向写描述符写入一个事件，即可触发pipe_w中的读事件，表明有一个或者多个信号触发了。但是因为信号处理函数的调用时机是完全随机的，因此，需要有一定的手段保证代码的安全性。

         a：sig_pending

         该值表示是否有信号处于未决状态（触发但尚未处理）。该值在初始化ev_loop时置为0，调用evpipe_write时，会首先判断该值是否为1。如果该值已经为1，表示已经有监听的信号处于未决状态了，无需再向写描述符写入事件了。该值直到调用pipe_w的回调函数pipecb时，消费掉该事件之后才重置为0，表明从此刻起，若有监听信号触发，才能继续向写描述符写入事件。

         b：pipe_write_wanted和pipe_write_skipped

         pipe_write_wanted表明是否允许向写描述符写入事件，pipe_write_skipped表明是否信号发生了，却因pipe_write_wanted的关系被暂时忽略了。这两个值在初始化ev_loop时置为0。

         在evpipe_write中，首先置pipe_write_skipped为1，如果pipe_write_wanted此时为0，evpipe_write直接返回，这就表明触发信号暂时被忽略掉了（仅仅是暂时的）。否则，重置pipe_write_skipped为0，向写描述符写入事件。

         在ev_run中，调用backend_poll之前，会将pipe_write_wanted置为1，表明此刻起写描述符才能接受写入事件，如果此刻之前有监听信号发生的话，则会在信号处理函数调用的evpipe_write中，置pipe_write_skipped为1表示信号暂时忽略掉。

         在ev_run中调用backend_poll后立即置pipe_write_wanted为0。如果pipe_write_skipped为1，表明有信号被忽略了，调用ev_feed_event，直接将pipe_w标记为pending状态，将pipe_w加入到loop->pendings中：

do{
    ev_tstamp waittime  = 0.;

    pipe_write_wanted = 1;

    if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
    {
        waittime = MAX_BLOCKTIME;
        ...      
    }

    backend_poll (EV_A_ waittime);
            
    pipe_write_wanted = 0; /* just an optimisation, no fence needed */

    if (pipe_write_skipped)
    {
        assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
        ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
    }
    
    EV_INVOKE_PENDING;
}while(expect_true (
    activecnt
    && !loop_done
    && !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
))

         上面就是ev_run中的相关逻辑，注意：调用backend_poll之后，如果在检测pipe_write_skipped之后才有信号发生的话，此时在evpipe_write中仅设置pipe_write_skipped为1后就返回。然后进入下次循环，因pipe_write_skipped为1，所以waittime为0，backend_poll会立即返回，处理pipe_w的激活事件。

         PS：现在还没有想明白，为什么需要pipe_write_wanted和pipe_write_skipped这两个标志，感觉sig_pending已经足够了。

         在向写描述符写入事件之后，pipe_w监视器触发，调用回调函数pipecb。

 

5：pipecb

static void pipecb (struct ev_loop *loop, ev_io *iow, int revents)
{
    int i;

    if (revents & EV_READ)
    {
#if EV_USE_EVENTFD
        if (evpipe [0] < 0)
        {
            uint64_t counter;
            read (evpipe [1], &counter, sizeof (uint64_t));
        }
        else
#endif
        {
            char dummy[4];
            read (evpipe [0], &dummy, sizeof (dummy));
        }
    }

    pipe_write_skipped = 0;

#if EV_SIGNAL_ENABLE
    if (sig_pending)
    {
        sig_pending = 0;

        for (i = EV_NSIG - 1; i--; )
            if (expect_false (signals [i].pending))
                ev_feed_signal_event (EV_A_ i + 1);
    }
#endif
...
}

         在pipecb中，首先从eventfd描述符或者pipe[0]中消费掉事件。然后轮训signals数组中每个ANSIG结构的pending字段，只要是信号触发了，则该字段一定为1，从而可以调用ev_feed_signal_event处理该信号。剩下的流程就与使用signalfd时一样了，不再赘述。

 

四：ev_signal_stop

void ev_signal_stop (struct ev_loop *loop, ev_signal *w)
{
    clear_pending (EV_A_ (W)w);
    if (expect_false (!ev_is_active (w)))
        return;

    wlist_del (&signals [w->signum - 1].head, (WL)w);
    ev_stop (EV_A_ (W)w);

    if (!signals [w->signum - 1].head)
    {
#if EV_MULTIPLICITY
        signals [w->signum - 1].loop = 0; /* unattach from signal */
#endif
#if EV_USE_SIGNALFD
        if (sigfd >= 0)
        {
            sigset_t ss;

            sigemptyset (&ss);
            sigaddset (&ss, w->signum);
            sigdelset (&sigfd_set, w->signum);

            signalfd (sigfd, &sigfd_set, 0);
            sigprocmask (SIG_UNBLOCK, &ss, 0);
        }
        else
#endif
            signal (w->signum, SIG_DFL);
    }
}

         在ev_signal_stop中，首先调用clear_pending清除监视器w在loop->pendings中的状态，置w->pending = 0。这里有个技巧是将loop->pendings中，原w所在位置直接赋值为内部伪监视器pending_w，pending_w的回调函数为空函数，会直接返回。

         调用wlist_del，将w从该信号的监视器列表中删除，调用ev_stop注销改监视器；

         如果相应信号的监视器列表空了，则首先signals [w->signum - 1].loop =0，然后恢复该信号的处理方式：若使用signalfd，则取消阻塞该信号，将该信号从sigfd描述符关联的信号集中删除；若不使用signalfd，则直接恢复该信号的处理方式为默认方式。

 

五：总结

六：例子

ev_signal signal_w;

void signal_action(struct ev_loop *main_loop,ev_signal *signal_w,int e)
{
    puts("\nin signal cb \n");
}

int main()
{
    struct ev_loop *main_loop = ev_default_loop(EVFLAG_SIGNALFD);
      
    ev_init(&signal_w,signal_action);
    ev_signal_set(&signal_w,SIGINT); 

    ev_signal_start(main_loop,&signal_w);

    ev_run(main_loop,0);
    return 0;
}

         结果：

#./a.out
^C
in signal cb 

^C
in signal cb 

^\Quit (core dumped)