libevent源码分析之信号处理

新看看官方demo的libevent如何使用信号
  1. int called = 0;
  2. static void
  3. signal_cb(int fd, short event, void *arg)
  4. {
  5. 	struct event *signal = arg;
  7. 	printf("%s: got signal %d\n", __func__, EVENT_SIGNAL(signal));
  9. 	if (called >= 2)
  10. 		event_del(signal);

  12. 	called++;
  13. }
  15. int
  16. main (int argc, char **argv)
  17. {
  18. 	struct event signal_int;//这里我们把它称为事件2
  19.  
  20. 	/* Initalize the event library */
  21. 	event_init();
  23. 	/* 初始化事件2，设置相关信号，回调函数 */
  24. 	event_set(&signal_int, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb,
  25. 	    &signal_int);
  27. 	event_add(&signal_int, NULL);//激活信号
  29. 	event_dispatch();//等待事件的触发
  31. 	return (0);
  32. }
这里只提信号相关操作~~~
event_init()有关信号操作将跳转到epoll.c中的epoll_init->evsignal_init
  1. evsignal_init(base);

接下来分析evsignal_init函数，event_base结构体中有信号管理结构evsignal_info（注意不是指针）
而evsignal_info结构本身有一个event事件，这里称为事件1(这里很关键)
  2. struct evsignal_info {
  3. 	struct event ev_signal;//向event_base注册读事件使用的event结构体,这里我们称为事件1
  4. 	int ev_signal_pair[2];//sock pair对，也就是clientfd跟servfd
  5. 	int ev_signal_added;//记录ev_signal信号是否已经注册
  6. 	volatile sig_atomic_t evsignal_caught;//是否有信号发生
  7. 	struct event_list evsigevents[NSIG];//注册到信号的事件链表的一个标志
  8. 	sig_atomic_t evsigcaught[NSIG];//记录每个信号的触发的次数
  9. #ifdef HAVE_SIGACTION
  10. 	struct sigaction **sh_old;//记录旧的信号处理函数
  11. #else
  12. 	ev_sighandler_t **sh_old;
  13. #endif
  14. 	int sh_old_max;
  15. };
evsignal_init具体流程：event_init中最终会使用evsignal_init(base),来看看做了什么事
创建了一对Socketpair（作用:信号来临时，通过信号处理函数socketpair写端发送字节，事件1监听socketpair的读fd，触发事件1），并且将读的fd与事件1相关联，并且将事件1与event_base结构体的指针相关联   
  2. int
  3. evsignal_init(struct event_base *base)
  4. {
  5. 	int i;
  7. 	/* 
  8. 	 * Our signal handler is going to write to one end of the socket
  9. 	 * pair to wake up our event loop.  The event loop then scans for
  10. 	 * signals that got delivered.
  11. 	 *///创建一个socketpair
  12. 	if (evutil_socketpair(
  13. 		    AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {
  14. #ifdef WIN32
  15. 		/* Make this nonfatal on win32, where sometimes people
  16. 		   have localhost firewalled. */
  17. 		event_warn("%s: socketpair", __func__);
  18. #else
  19. 		event_err(1, "%s: socketpair", __func__);
  20. #endif
  21. 		return -1;
  22. 	}
  23.    ////子进程不能访问该socketpair
  24. 	FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]);
  25. 	FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]);
  26. 	base->sig.sh_old = NULL;
  27. 	base->sig.sh_old_max = 0;
  28. 	base->sig.evsignal_caught = 0;
  29. 	memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG);
  30. 	/* initialize the queues for all events */
  31. 	for (i = 0; i < NSIG; ++i)
  32. 		TAILQ_INIT(&base->sig.evsigevents[i]);
  33.         //设置为非阻塞
  34.         evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
  35.    //可读事件设置与fd相关(但还缺乏注册到base注册链表中，需要在event_add中才会被注册到链表中去)
  36. 	event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1],
  37. 		EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal);
  38. 	base->sig.ev_signal.ev_base = base;//把信号对应的事件跟base相关联
  39. 	base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
  41. 	return 0;
  42. }

接着分析event_add函数，实际对应epoll_add函数(以epoll举例）
实际调用的是evsignal_add函数：这里唯一注意的是（事件2并不是注册到base而是挂载到信号链表，因为信号对应的fd为-1，并没有什么卵用）

  2. //添加事件
  3. static int
  4. epoll_add(void *arg, struct event *ev)
  5. {
  6. 	struct epollop *epollop = arg;//获取epoll管理结构体
  7. 	struct epoll_event epev = {0, {0}};//epoll事件
  8. 	struct evepoll *evep;//读写事件指针
  9. 	int fd, op, events;
  11. 	if (ev->ev_events & EV_SIGNAL)//是否注册了信号
  12. 		return (evsignal_add(ev));//是的话，添加信号到此事件
  14. 	fd = ev->ev_fd;//获取对应的描述符
  15. 	if (fd >= epollop->nfds) {//判断描述符是否大于最大值，是的话，扩充
  16. 		/* Extent the file descriptor array as necessary */
  17. 		if (epoll_recalc(ev->ev_base, epollop, fd) == -1)
  18. 			return (-1);
  19. 	}
  20. 	evep = &epollop->fds[fd];//获取事件指针
  21. 	op = EPOLL_CTL_ADD;//默认是添加，其实还有修改等
  22. 	events = 0;
  23. 	if (evep->evread != NULL) {//这里epoll的修改与添加设置到一起了，如果不为空，说明本身已有事件了,那就只是修改器读写而已
  24. 		events |= EPOLLIN;//修改
  25. 		op = EPOLL_CTL_MOD;//设置为默认
  26. 	}
  27. 	if (evep->evwrite != NULL) {//为空
  28. 		events |= EPOLLOUT;
  29. 		op = EPOLL_CTL_MOD;
  30. 	}
  32. 	if (ev->ev_events & EV_READ)//是否可读
  33. 		events |= EPOLLIN;//events设置为可读
  34. 	if (ev->ev_events & EV_WRITE)//是否可写
  35. 		events |= EPOLLOUT;//设置为可写，注意events只是int类型
  37. 	epev.data.fd = fd;//epoll事件设置fd
  38. 	epev.events = events;//epoll事件设置为是否可读可写
  39. 	if (epoll_ctl(epollop->epfd, op, ev->ev_fd, &epev) == -1)
  40. 			return (-1);
  42. 	/* Update events responsible */
  43. 	if (ev->ev_events & EV_READ)//更新ev_events是否可读可写，如果是，那就更新evep读写事件指针，表示此事件可读可写
  44. 		evep->evread = ev;
  45. 	if (ev->ev_events & EV_WRITE)
  46. 		evep->evwrite = ev;
  48. 	return (0);
  49. }
evsignal_add函数分析
设置信号处理函数evsignal_handler，将事件1注册到base中(这样就可以响应了),并且将ev_signal_added标志设置为1，表示因事件1注册而表示有信号加入。
同时将事件2挂载到信号链表(通过信号值为索引)的末端。
  2. int
  3. evsignal_add(struct event *ev)
  4. {
  5. 	int evsignal;
  6. 	struct event_base *base = ev->ev_base;
  7. 	struct evsignal_info *sig = &ev->ev_base->sig;//获取信号事件结构体
  9. 	if (ev->ev_events & (EV_READ|EV_WRITE))//信号事件不可以是读写
  10. 		event_errx(1, "%s: EV_SIGNAL incompatible use", __func__);
  11. 	evsignal = EVENT_SIGNAL(ev);//信号的fd就是信号的number
  12. 	assert(evsignal >= 0 && evsignal < NSIG); // //信号不能超过NSIG这个数
  13. 	if (TAILQ_EMPTY(&sig->evsigevents[evsignal])) {////如果说该信号链表为空
  14. 		event_debug(("%s: %p: changing signal handler", __func__, ev));
  15. 		if (_evsignal_set_handler(  //设置信号处理函数，同时，保存原来的信号处理函数到ev_base->sh_old中去
  16. 			    base, evsignal, evsignal_handler) == -1)
  17. 			return (-1);
  19. 		/* catch signals if they happen quickly */
  20. 		evsignal_base = base;
  22. 		if (!sig->ev_signal_added) {//判断是否已加入
  23. 			if (event_add(&sig->ev_signal, NULL))//正式注册,添加到epoll_wait中去
  24. 				return (-1);
  25. 			sig->ev_signal_added = 1;//表示已经添加了
  26. 		}
  27. 	}
  28.  //把ev->ev_signal_next加入到sig->evsigevents[evsignal]的链表末端
  29. 	/* multiple events may listen to the same signal */
  30. 	TAILQ_INSERT_TAIL(&sig->evsigevents[evsignal], ev, ev_signal_next);
  32. 	return (0);
  33. }

event_dispatch()分析，实际调用epoll_dispatch，而epoll_dispatch实际调用evsignal_process。

  2. static int
  3. epoll_dispatch(struct event_base *base, void *arg, struct timeval *tv)
  4. {
  5. 	struct epollop *epollop = arg; //获取管理epoll的结构
  6. 	struct epoll_event *events = epollop->events;//epoll的事件数组
  7. 	struct evepoll *evep;
  8. 	int i, res, timeout = -1;
  10. 	if (tv != NULL)
  11. 		timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;//设置超时事件
  13. 	if (timeout > MAX_EPOLL_TIMEOUT_MSEC) {//不可以大于最大超时事件
  14. 		/* Linux kernels can wait forever if the timeout is too big;
  15. 		 * see comment on MAX_EPOLL_TIMEOUT_MSEC. */
  16. 		timeout = MAX_EPOLL_TIMEOUT_MSEC;
  17. 	}
  19. 	res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout);
  21. 	if (res == -1) {
  22. 		if (errno != EINTR) {
  23. 			event_warn("epoll_wait");
  24. 			return (-1);
  25. 		}
  27. 		evsignal_process(base);//处理信号事件
  28. 		return (0);
  29. 	} else if (base->sig.evsignal_caught) {
  30. 		evsignal_process(base);//处理信号事件
  31. 	}
  33. 	event_debug(("%s: epoll_wait reports %d", __func__, res));
  35. 	for (i = 0; i < res; i++) {
  36. 		int what = events[i].events;
  37. 		struct event *evread = NULL, *evwrite = NULL;
  38. 		int fd = events[i].data.fd;
  40. 		if (fd < 0 || fd >= epollop->nfds)
  41. 			continue;
  42. 		evep = &epollop->fds[fd];
  44. 		if (what & (EPOLLHUP|EPOLLERR)) {
  45. 			evread = evep->evread;
  46. 			evwrite = evep->evwrite;
  47. 		} else {
  48. 			if (what & EPOLLIN) {//可读
  49. 				evread = evep->evread;
  50. 			}
  52. 			if (what & EPOLLOUT) {//可写
  53. 				evwrite = evep->evwrite;
  54. 			}
  55. 		}
  57. 		if (!(evread||evwrite))
  58. 			continue;
  60. 		if (evread != NULL)//插入就绪链表
  61. 			event_active(evread, EV_READ, 1);
  62. 		if (evwrite != NULL)//插入就绪链表
  63. 			event_active(evwrite, EV_WRITE, 1);
  64. 	}
  66. 	if (res == epollop->nevents && epollop->nevents < MAX_NEVENTS) {
  67. 		/* We used all of the event space this time.  We should
  68. 		   be ready for more events next time. */
  69. 		int new_nevents = epollop->nevents * 2;
  70. 		struct epoll_event *new_events;
  72. 		new_events = realloc(epollop->events,
  73. 		    new_nevents * sizeof(struct epoll_event));
  74. 		if (new_events) {
  75. 			epollop->events = new_events;
  76. 			epollop->nevents = new_nevents;
  77. 		}
  78. 	}
  80. 	return (0);
  81. }
evsignal_process
假设有信号发生了~将调用信号处理函数设置信号发生标志位同时发送一个字节数据到socketpair的读端，
而事件1恰好是监听此读端，所以epoll_wait返回然后看信号触发位是否设置为1了，设置了将调用evsignal_process()
而evsignal_process函数内容是遍历信号链表看是否有挂载的事件，有的话，将该事件2插入已就绪链表中，另外也将事件1插入就绪链表
  2. void
  3. evsignal_process(struct event_base *base)//遍历信号链表，是否有事件2挂载
  4. {
  5. 	struct evsignal_info *sig = &base->sig;//获取信号管理结构体
  6. 	struct event *ev, *next_ev;
  7. 	sig_atomic_t ncalls;
  8. 	int i;
  9. 	
  10. 	base->sig.evsignal_caught = 0;
  11. 	for (i = 1; i < NSIG; ++i) {
  12. 		ncalls = sig->evsigcaught[i];//是否有触发
  13. 		if (ncalls == 0)//没有就可以滚了
  14. 			continue;
  15. 		sig->evsigcaught[i] -= ncalls;//有的话。。。清空
  17. 		for (ev = TAILQ_FIRST(&sig->evsigevents[i]);
  18. 		    ev != NULL; ev = next_ev) {
  19. 			next_ev = TAILQ_NEXT(ev, ev_signal_next);
  20. 			if (!(ev->ev_events & EV_PERSIST))//没设置这个位，就只使用一次了
  21. 				event_del(ev);
  22. 			event_active(ev, EV_SIGNAL, ncalls);//插入就绪链表
  23. 		}
  25. 	}
  26. }

总流程：
event_base结构体中有信号管理结构evsignal_info（注意不是指针）
而evsignal_info结构本身有一个event事件，这里称为事件1(这里很关键)

event_init中最终会使用evsignal_init(base),来看看做了什么事
创建了一对Socketpair（作用:通过信号处理函数发送字节，事件1监听读fd，触发事件1发生），并且将读的fd与事件1相关联，并且将事件1与event_base结构体的指针相关联


然后我们在main函数中，创建一个事件2，通过初始化信号2
event_set(&signal_int, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb,
   &signal_int);

然后event_add实际使用的是epoll_add然后把事件插入到已注册链表
看看epoll_add实际是evsignal_add
设置信号处理函数evsignal_handler，将事件1注册到base中(这样就可以响应了),并且将ev_signal_added设置为1，表示因事件1注册而表示有信号加入。
同时将事件2挂载到信号链表(通过信号值查找)的末端（貌似事件2并不是注册到base而是挂载到链表，因为信号对应的fd为-1，并没有什么卵用）

evsignal_handler信号处理函数的内容如下
设置信号已经触发位为1，触发次数+1
同时发送1个字节数据到socketpair的读端



当当当~接下来开始dispatch了

~~~假设有信号发生了~将调用信号处理函数设置信号发生标志位同时发送一个字节数据到socketpair的读端，
而事件1恰好是监听此读端，所以epoll_wait返回然后看信号触发位是否设置为1了，设置了将调用evsignal_process()
而evsignal_process函数内容是遍历信号链表看是否有挂载的事件，有的话，将该事件2插入已就绪链表中，另外也将事件1插入就绪链表

接着发现有就绪事件，就调用event_process_active(),实际也就是调用其事件对应的回调函数完成处理~~End



来自为知笔记(Wiz)


posted on 2016-11-17 12:26  笨拙的菜鸟  阅读(1152)  评论(0)  编辑  收藏  举报

导航