libevent1.4 阅读记录三

前面我们对I/O模型有了一些了解,现在再来说signal。signal事件的出现对于进程来说是随机的,libevent当信号事件发生时,不是用信号的回调函数直接处理信号,而是在回调函数中设法通知I/O模型有信号事件发生让I/O返回,将信号与I/O事件、计时器事件一起处理。

首先,看一下event_base中的(evsignal_info)sig的结构体

//evsignal.h
struct
evsignal_info { struct event ev_signal;    //这不是信号事件,这是socket pair的读监听事件,所有关注的信号间接关联到这个事件。 int ev_signal_pair[2];    //socket pair对,一对通过本地环回连接的socket,ev_signal_pair[0]为收到信号后回调函数发送I/O的socket,ev_signal_pair[1]为接收I/O的socket。 int ev_signal_added;      //一个标记,表明这个event被注册过 volatile sig_atomic_t evsignal_caught;  //一个标记,如果收到至少一个信号,置为1。sig_atomic_t意思是对这个变量的初始化、赋值都是原子的。 struct event_list evsigevents[NSIG];  //注册到signal的事件链表的数组,数组下标为对应的signal sig_atomic_t evsigcaught[NSIG];  //记录signal事件发生次数的数组,数组下标为对应的signal #ifdef HAVE_SIGACTION struct sigaction **sh_old;  //记录被修改的signal回调函数及信号屏蔽状态。这是一个signal回调函数指针数组,下标对应的signal的值(例如:信号SIGINT的回调函数指针为sh_old[2])。
                    我们注册信号时信号回调函数被改为了向socket pair的一端发送数据,当我们注销某个信号时,需要把该信号的回调函数改回去。
#else ev_sighandler_t **sh_old; #endif int sh_old_max;  //sh_old数组长度 };

 

接下里,从源码看一下signal流程,还是以epoll为例

1.在epoll_init中调用evsignal_init完成socekt pair的初始化并连接,并将其中的读socket注册成epoll监听事件

 1 int
 2 evsignal_init(struct event_base *base)
 3 {
 4     int i;
 5 
 6     /* 
 7      * Our signal handler is going to write to one end of the socket
 8      * pair to wake up our event loop.  The event loop then scans for
 9      * signals that got delivered.
10      */                                        //这段注释说的很清楚了,就是signal回调函数发送消息给这个socket pair的一端来唤醒event loop,然后event loop检查signal并处理
11     if (evutil_socketpair(
12             AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {  //在evutil.c中初始化socket pair对,并连接,发送消息的socket存在base->sig.ev_signal_pair[0],
                                              接收消息的socket存在base->sig.ev_signal_pair[1]
13 #ifdef WIN32 14 /* Make this nonfatal on win32, where sometimes people 15 have localhost firewalled. */ 16 event_warn("%s: socketpair", __func__); 17 #else 18 event_err(1, "%s: socketpair", __func__); 19 #endif 20 return -1; 21 } 22 23 FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]);    //从定义来看是说在子进程中不能使用这个句柄,也就是子进程不能用这个socket 24 FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]);    //从定义来看是说在子进程中不能使用这个句柄,也就是子进程不能用这个socket 25 base->sig.sh_old = NULL; 26 base->sig.sh_old_max = 0; 27 base->sig.evsignal_caught = 0; 28 memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG); 29 /* initialize the queues for all events */ 30 for (i = 0; i < NSIG; ++i) 31 TAILQ_INIT(&base->sig.evsigevents[i]); 32 33 evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]); 34 evutil_make_socket_nonblocking(base->sig.ev_signal_pair[1]); 35 36 event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1], 37 EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal);  //初始化socket pair持久化的读事件,用于接收signal回调发送I/O的消息。注意这里还没有注册,只是初始化了这个事件。 38 base->sig.ev_signal.ev_base = base; 39 base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL; 40 41 return 0; 42 }

2.接下来在epoll_add中调用了evsignal_add注册了前面socket pair初始化后的读事件,在epoll_add完成后,还会将这个事件添加到已注册链表中

  1 /* Helper: set the signal handler for evsignal to handler in base, so that
  2  * we can restore the original handler when we clear the current one. */
  3 int
  4 _evsignal_set_handler(struct event_base *base,
  5               int evsignal, void (*handler)(int))
  6 {
  7 #ifdef HAVE_SIGACTION
  8     struct sigaction sa;
  9 #else
 10     ev_sighandler_t sh;
 11 #endif
 12     struct evsignal_info *sig = &base->sig;
 13     void *p;
 14 
 15     /*
 16      * resize saved signal handler array up to the highest signal number.
 17      * a dynamic array is used to keep footprint on the low side.
 18      */
 19     if (evsignal >= sig->sh_old_max) {  //扩充保存原来信号回调函数数组的内存,这里还没有为数组元素分配内存
 20         int new_max = evsignal + 1;
 21         event_debug(("%s: evsignal (%d) >= sh_old_max (%d), resizing",
 22                 __func__, evsignal, sig->sh_old_max));
 23         p = realloc(sig->sh_old, new_max * sizeof(*sig->sh_old));
 24         if (p == NULL) {
 25             event_warn("realloc");
 26             return (-1);
 27         }
 28 
 29         memset((char *)p + sig->sh_old_max * sizeof(*sig->sh_old),
 30             0, (new_max - sig->sh_old_max) * sizeof(*sig->sh_old));
 31 
 32         sig->sh_old_max = new_max;
 33         sig->sh_old = p;
 34     }
 35 
 36     /* allocate space for previous handler out of dynamic array */
 37     sig->sh_old[evsignal] = malloc(sizeof *sig->sh_old[evsignal]);  //为数组中的下标为该信号的元素分配内存,在调用_evsignal_set_handler前已经判断过目标为NULL
 38     if (sig->sh_old[evsignal] == NULL) {
 39         event_warn("malloc");
 40         return (-1);
 41     }
 42 
 43     /* save previous handler and setup new handler */
 44 #ifdef HAVE_SIGACTION
 45     memset(&sa, 0, sizeof(sa));
 46     sa.sa_handler = handler;    //这是该信号的回调函数,它已经被定义为通过socket pair发送数据。
 47     sa.sa_flags |= SA_RESTART;   //用于指定信号的处理行为。(SA_RESTART:使被信号打断的系统调用自动重新发起)
 48     sigfillset(&sa.sa_mask);    //获取之前信号屏蔽情况
 49 
 50     if (sigaction(evsignal, &sa, sig->sh_old[evsignal]) == -1) {   //设置新的回调函数及行为,并记录之前的回调函数及行为
 51         event_warn("sigaction");
 52         free(sig->sh_old[evsignal]);
 53         sig->sh_old[evsignal] = NULL;
 54         return (-1);
 55     }
 56 #else
 57     if ((sh = signal(evsignal, handler)) == SIG_ERR) {
 58         event_warn("signal");
 59         free(sig->sh_old[evsignal]);
 60         sig->sh_old[evsignal] = NULL;
 61         return (-1);
 62     }
 63     *sig->sh_old[evsignal] = sh;
 64 #endif
 65 
 66     return (0);
 67 }
 68 
 69 int
 70 evsignal_add(struct event *ev)
 71 {
 72     int evsignal;
 73     struct event_base *base = ev->ev_base;
 74     struct evsignal_info *sig = &ev->ev_base->sig;
 75 
 76     if (ev->ev_events & (EV_READ|EV_WRITE))
 77         event_errx(1, "%s: EV_SIGNAL incompatible use", __func__);
 78     evsignal = EVENT_SIGNAL(ev);    //这个希望被注册信号的值
 79     assert(evsignal >= 0 && evsignal < NSIG);
 80     if (TAILQ_EMPTY(&sig->evsigevents[evsignal])) {  //如果我们还没有注册过该信号,注册它,如果已经注册过,忽略这次注册
 81         event_debug(("%s: %p: changing signal handler", __func__, ev));
 82         if (_evsignal_set_handler(
 83                 base, evsignal, evsignal_handler) == -1)
 84             return (-1);
 85 
 86         /* catch signals if they happen quickly */
 87         evsignal_base = base;    //evsignal_base是一个全局变量,它指向的是我们的信号注册在哪个event_base实例。因此多线程用信号可能冲突,如果2个以上的线程执行到这里,但evsignal_base缺只能指向一个线程中libevent实例.
 88 
 89         if (!sig->ev_signal_added) {    //如果socket pair的读事件没有被注册就注册它,如果已注册不要重复注册(与我们正在注册的信号事件不是同一个)
 90             if (event_add(&sig->ev_signal, NULL))
 91                 return (-1);
 92             sig->ev_signal_added = 1;
 93         }
 94     }
 95 
 96     /* multiple events may listen to the same signal */
 97     TAILQ_INSERT_TAIL(&sig->evsigevents[evsignal], ev, ev_signal_next);  //将这个信号事件插入到信号事件链表末尾,即使因为已注册过而没有注册成功
 98 
 99     return (0);
100 }
 1 static void
 2 evsignal_handler(int sig)
 3 {
 4     int save_errno = errno;
 5 
 6     if (evsignal_base == NULL) {
 7         event_warn(
 8             "%s: received signal %d, but have no base configured",
 9             __func__, sig);
10         return;
11     }
12 
13     evsignal_base->sig.evsigcaught[sig]++;    //该信号发生次数加1
14     evsignal_base->sig.evsignal_caught = 1;    //标记有信号事件发生
15 
16 #ifndef HAVE_SIGACTION
17     signal(sig, evsignal_handler);
18 #endif
19 
20     /* Wake up our notification mechanism */
21     send(evsignal_base->sig.ev_signal_pair[0], "a", 1, 0);  //socket pair 发送端发送数据
22     errno = save_errno;
23 }

3.当我们event loop过程中收到信号,信号回调函数通过socket pair发送端发送消息,因为我们将socket pair 接收端注册到了epoll监听事件中,epoll_wait将会返回。然后event loop将会调用evsignal_process来调用我们设置信号事件时给定的回调函数

 1 void
 2 evsignal_process(struct event_base *base)
 3 {
 4     struct evsignal_info *sig = &base->sig;
 5     struct event *ev, *next_ev;
 6     sig_atomic_t ncalls;
 7     int i;
 8     
 9     base->sig.evsignal_caught = 0;  //是否有信号事件发生的标记重置为0
10     for (i = 1; i < NSIG; ++i) {
11         ncalls = sig->evsigcaught[i];  
12         if (ncalls == 0)  //如果发生该信号i的次数为0,跳过该信号
13             continue;
14         sig->evsigcaught[i] -= ncalls;  //重置该信号发生次数为0
15 
16         for (ev = TAILQ_FIRST(&sig->evsigevents[i]);
17             ev != NULL; ev = next_ev) {    //这里看上去在一个信号上可以注册多个事件,当发生时所有回调都执行一次,但事实上在我们注册的时候每个信号只能注册一个回调
18             next_ev = TAILQ_NEXT(ev, ev_signal_next);
19             if (!(ev->ev_events & EV_PERSIST))  //如果不是持久化事件,注销这个事件
20                 event_del(ev);
21             event_active(ev, EV_SIGNAL, ncalls);  //插入到已激活列表中,执行次数为信号发生次数
22         }
23 
24     }
25 }

4.最后,我们再来看看如何注销信号事件的

 1 int
 2 evsignal_del(struct event *ev)
 3 {
 4     struct event_base *base = ev->ev_base;
 5     struct evsignal_info *sig = &base->sig;
 6     int evsignal = EVENT_SIGNAL(ev);   //先取得要注销信号事件的信号
 7 
 8     assert(evsignal >= 0 && evsignal < NSIG);
 9 
10     /* multiple events may listen to the same signal */
11     TAILQ_REMOVE(&sig->evsigevents[evsignal], ev, ev_signal_next);  
12 
13     if (!TAILQ_EMPTY(&sig->evsigevents[evsignal]))
14         return (0);
15 
16     event_debug(("%s: %p: restoring signal handler", __func__, ev));
17 
18     return (_evsignal_restore_handler(ev->ev_base, EVENT_SIGNAL(ev)));  //注销信号事件后将信号的回调函数及处理行为等恢复
19 }

 

posted @ 2018-11-22 20:00  dyan1024  阅读(198)  评论(0编辑  收藏  举报