libevent源码分析之信号处理

新看看官方demo的libevent如何使用信号

    

  1. int called = 0;
    2. 

  2. static void
    3. 

  3. signal_cb(int fd, short event, void *arg)
    4. 

  4. {
    5. 

  5. 	struct event *signal = arg;
    6. 

    7. 

  7. 	printf("%s: got signal %d\n", __func__, EVENT_SIGNAL(signal));
    8. 

    9. 

  9. 	if (called >= 2)
    10. 

  10. 		event_del(signal);
    11. 

    12. 

  12. 	called++;
    13. 

  13. }
    14. 

    15. 

  15. int
    16. 

  16. main (int argc, char **argv)
    17. 

  17. {
    18. 

  18. 	struct event signal_int;//这里我们把它称为事件2
    19. 

  19.  
    20. 

  20. 	/* Initalize the event library */
    21. 

  21. 	event_init();
    22. 

    23. 

  23. 	/* 初始化事件2，设置相关信号，回调函数 */
    24. 

  24. 	event_set(&signal_int, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb,
    25. 

  25. 	    &signal_int);
    26. 

    27. 

  27. 	event_add(&signal_int, NULL);//激活信号
    28. 

    29. 

  29. 	event_dispatch();//等待事件的触发
    30. 

    31. 

  31. 	return (0);
    32. 

  32. }
    33.

这里只提信号相关操作~~~

event_init()有关信号操作将跳转到epoll.c中的epoll_init->evsignal_init

    

  1. evsignal_init(base);
    2.

接下来分析evsignal_init函数，event_base结构体中有信号管理结构evsignal_info（注意不是指针）

而evsignal_info结构本身有一个event事件，这里称为事件1(这里很关键)

    

    2. 

  2. struct evsignal_info {
    3. 

  3. 	struct event ev_signal;//向event_base注册读事件使用的event结构体,这里我们称为事件1
    4. 

  4. 	int ev_signal_pair[2];//sock pair对，也就是clientfd跟servfd
    5. 

  5. 	int ev_signal_added;//记录ev_signal信号是否已经注册
    6. 

  6. 	volatile sig_atomic_t evsignal_caught;//是否有信号发生
    7. 

  7. 	struct event_list evsigevents[NSIG];//注册到信号的事件链表的一个标志
    8. 

  8. 	sig_atomic_t evsigcaught[NSIG];//记录每个信号的触发的次数
    9. 

  9. #ifdef HAVE_SIGACTION
    10. 

  10. 	struct sigaction **sh_old;//记录旧的信号处理函数
    11. 

  11. #else
    12. 

  12. 	ev_sighandler_t **sh_old;
    13. 

  13. #endif
    14. 

  14. 	int sh_old_max;
    15. 

  15. };
    16.

evsignal_init具体流程：event_init中最终会使用evsignal_init(base),来看看做了什么事

创建了一对Socketpair（作用:信号来临时，通过信号处理函数socketpair写端发送字节，事件1监听socketpair的读fd，触发事件1），并且将读的fd与事件1相关联，并且将事件1与event_base结构体的指针相关联

    

    2. 

  2. int
    3. 

  3. evsignal_init(struct event_base *base)
    4. 

  4. {
    5. 

  5. 	int i;
    6. 

    7. 

  7. 	/* 
    8. 

  8. 	 * Our signal handler is going to write to one end of the socket
    9. 

  9. 	 * pair to wake up our event loop.  The event loop then scans for
    10. 

  10. 	 * signals that got delivered.
    11. 

  11. 	 *///创建一个socketpair
    12. 

  12. 	if (evutil_socketpair(
    13. 

  13. 		    AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {
    14. 

  14. #ifdef WIN32
    15. 

  15. 		/* Make this nonfatal on win32, where sometimes people
    16. 

  16. 		   have localhost firewalled. */
    17. 

  17. 		event_warn("%s: socketpair", __func__);
    18. 

  18. #else
    19. 

  19. 		event_err(1, "%s: socketpair", __func__);
    20. 

  20. #endif
    21. 

  21. 		return -1;
    22. 

  22. 	}
    23. 

  23.    ////子进程不能访问该socketpair
    24. 

  24. 	FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]);
    25. 

  25. 	FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]);
    26. 

  26. 	base->sig.sh_old = NULL;
    27. 

  27. 	base->sig.sh_old_max = 0;
    28. 

  28. 	base->sig.evsignal_caught = 0;
    29. 

  29. 	memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG);
    30. 

  30. 	/* initialize the queues for all events */
    31. 

  31. 	for (i = 0; i < NSIG; ++i)
    32. 

  32. 		TAILQ_INIT(&base->sig.evsigevents[i]);
    33. 

  33.         //设置为非阻塞
    34. 

  34.         evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);
    35. 

  35.    //可读事件设置与fd相关(但还缺乏注册到base注册链表中，需要在event_add中才会被注册到链表中去)
    36. 

  36. 	event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1],
    37. 

  37. 		EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal);
    38. 

  38. 	base->sig.ev_signal.ev_base = base;//把信号对应的事件跟base相关联
    39. 

  39. 	base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
    40. 

    41. 

  41. 	return 0;
    42. 

  42. }
    43.

接着分析event_add函数，实际对应epoll_add函数(以epoll举例）

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

    

    2. 

  2. //添加事件
    3. 

  3. static int
    4. 

  4. epoll_add(void *arg, struct event *ev)
    5. 

  5. {
    6. 

  6. 	struct epollop *epollop = arg;//获取epoll管理结构体
    7. 

  7. 	struct epoll_event epev = {0, {0}};//epoll事件
    8. 

  8. 	struct evepoll *evep;//读写事件指针
    9. 

  9. 	int fd, op, events;
    10. 

    11. 

  11. 	if (ev->ev_events & EV_SIGNAL)//是否注册了信号
    12. 

  12. 		return (evsignal_add(ev));//是的话，添加信号到此事件
    13. 

    14. 

  14. 	fd = ev->ev_fd;//获取对应的描述符
    15. 

  15. 	if (fd >= epollop->nfds) {//判断描述符是否大于最大值，是的话，扩充
    16. 

  16. 		/* Extent the file descriptor array as necessary */
    17. 

  17. 		if (epoll_recalc(ev->ev_base, epollop, fd) == -1)
    18. 

  18. 			return (-1);
    19. 

  19. 	}
    20. 

  20. 	evep = &epollop->fds[fd];//获取事件指针
    21. 

  21. 	op = EPOLL_CTL_ADD;//默认是添加，其实还有修改等
    22. 

  22. 	events = 0;
    23. 

  23. 	if (evep->evread != NULL) {//这里epoll的修改与添加设置到一起了，如果不为空，说明本身已有事件了,那就只是修改器读写而已
    24. 

  24. 		events |= EPOLLIN;//修改
    25. 

  25. 		op = EPOLL_CTL_MOD;//设置为默认
    26. 

  26. 	}
    27. 

  27. 	if (evep->evwrite != NULL) {//为空
    28. 

  28. 		events |= EPOLLOUT;
    29. 

  29. 		op = EPOLL_CTL_MOD;
    30. 

  30. 	}
    31. 

    32. 

  32. 	if (ev->ev_events & EV_READ)//是否可读
    33. 

  33. 		events |= EPOLLIN;//events设置为可读
    34. 

  34. 	if (ev->ev_events & EV_WRITE)//是否可写
    35. 

  35. 		events |= EPOLLOUT;//设置为可写，注意events只是int类型
    36. 

    37. 

  37. 	epev.data.fd = fd;//epoll事件设置fd
    38. 

  38. 	epev.events = events;//epoll事件设置为是否可读可写
    39. 

  39. 	if (epoll_ctl(epollop->epfd, op, ev->ev_fd, &epev) == -1)
    40. 

  40. 			return (-1);
    41. 

    42. 

  42. 	/* Update events responsible */
    43. 

  43. 	if (ev->ev_events & EV_READ)//更新ev_events是否可读可写，如果是，那就更新evep读写事件指针，表示此事件可读可写
    44. 

  44. 		evep->evread = ev;
    45. 

  45. 	if (ev->ev_events & EV_WRITE)
    46. 

  46. 		evep->evwrite = ev;
    47. 

    48. 

  48. 	return (0);
    49. 

  49. }
    50.

evsignal_add函数分析

设置信号处理函数evsignal_handler，将事件1注册到base中(这样就可以响应了),并且将ev_signal_added标志设置为1，表示因事件1注册而表示有信号加入。

同时将事件2挂载到信号链表(通过信号值为索引)的末端。

    

    2. 

  2. int
    3. 

  3. evsignal_add(struct event *ev)
    4. 

  4. {
    5. 

  5. 	int evsignal;
    6. 

  6. 	struct event_base *base = ev->ev_base;
    7. 

  7. 	struct evsignal_info *sig = &ev->ev_base->sig;//获取信号事件结构体
    8. 

    9. 

  9. 	if (ev->ev_events & (EV_READ|EV_WRITE))//信号事件不可以是读写
    10. 

  10. 		event_errx(1, "%s: EV_SIGNAL incompatible use", __func__);
    11. 

  11. 	evsignal = EVENT_SIGNAL(ev);//信号的fd就是信号的number
    12. 

  12. 	assert(evsignal >= 0 && evsignal < NSIG); // //信号不能超过NSIG这个数
    13. 

  13. 	if (TAILQ_EMPTY(&sig->evsigevents[evsignal])) {////如果说该信号链表为空
    14. 

  14. 		event_debug(("%s: %p: changing signal handler", __func__, ev));
    15. 

  15. 		if (_evsignal_set_handler(  //设置信号处理函数，同时，保存原来的信号处理函数到ev_base->sh_old中去
    16. 

  16. 			    base, evsignal, evsignal_handler) == -1)
    17. 

  17. 			return (-1);
    18. 

    19. 

  19. 		/* catch signals if they happen quickly */
    20. 

  20. 		evsignal_base = base;
    21. 

    22. 

  22. 		if (!sig->ev_signal_added) {//判断是否已加入
    23. 

  23. 			if (event_add(&sig->ev_signal, NULL))//正式注册,添加到epoll_wait中去
    24. 

  24. 				return (-1);
    25. 

  25. 			sig->ev_signal_added = 1;//表示已经添加了
    26. 

  26. 		}
    27. 

  27. 	}
    28. 

  28.  //把ev->ev_signal_next加入到sig->evsigevents[evsignal]的链表末端
    29. 

  29. 	/* multiple events may listen to the same signal */
    30. 

  30. 	TAILQ_INSERT_TAIL(&sig->evsigevents[evsignal], ev, ev_signal_next);
    31. 

    32. 

  32. 	return (0);
    33. 

  33. }
    34.

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

    

    2. 

  2. static int
    3. 

  3. epoll_dispatch(struct event_base *base, void *arg, struct timeval *tv)
    4. 

  4. {
    5. 

  5. 	struct epollop *epollop = arg; //获取管理epoll的结构
    6. 

  6. 	struct epoll_event *events = epollop->events;//epoll的事件数组
    7. 

  7. 	struct evepoll *evep;
    8. 

  8. 	int i, res, timeout = -1;
    9. 

    10. 

  10. 	if (tv != NULL)
    11. 

  11. 		timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;//设置超时事件
    12. 

    13. 

  13. 	if (timeout > MAX_EPOLL_TIMEOUT_MSEC) {//不可以大于最大超时事件
    14. 

  14. 		/* Linux kernels can wait forever if the timeout is too big;
    15. 

  15. 		 * see comment on MAX_EPOLL_TIMEOUT_MSEC. */
    16. 

  16. 		timeout = MAX_EPOLL_TIMEOUT_MSEC;
    17. 

  17. 	}
    18. 

    19. 

  19. 	res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout);
    20. 

    21. 

  21. 	if (res == -1) {
    22. 

  22. 		if (errno != EINTR) {
    23. 

  23. 			event_warn("epoll_wait");
    24. 

  24. 			return (-1);
    25. 

  25. 		}
    26. 

    27. 

  27. 		evsignal_process(base);//处理信号事件
    28. 

  28. 		return (0);
    29. 

  29. 	} else if (base->sig.evsignal_caught) {
    30. 

  30. 		evsignal_process(base);//处理信号事件
    31. 

  31. 	}
    32. 

    33. 

  33. 	event_debug(("%s: epoll_wait reports %d", __func__, res));
    34. 

    35. 

  35. 	for (i = 0; i < res; i++) {
    36. 

  36. 		int what = events[i].events;
    37. 

  37. 		struct event *evread = NULL, *evwrite = NULL;
    38. 

  38. 		int fd = events[i].data.fd;
    39. 

    40. 

  40. 		if (fd < 0 || fd >= epollop->nfds)
    41. 

  41. 			continue;
    42. 

  42. 		evep = &epollop->fds[fd];
    43. 

    44. 

  44. 		if (what & (EPOLLHUP|EPOLLERR)) {
    45. 

  45. 			evread = evep->evread;
    46. 

  46. 			evwrite = evep->evwrite;
    47. 

  47. 		} else {
    48. 

  48. 			if (what & EPOLLIN) {//可读
    49. 

  49. 				evread = evep->evread;
    50. 

  50. 			}
    51. 

    52. 

  52. 			if (what & EPOLLOUT) {//可写
    53. 

  53. 				evwrite = evep->evwrite;
    54. 

  54. 			}
    55. 

  55. 		}
    56. 

    57. 

  57. 		if (!(evread||evwrite))
    58. 

  58. 			continue;
    59. 

    60. 

  60. 		if (evread != NULL)//插入就绪链表
    61. 

  61. 			event_active(evread, EV_READ, 1);
    62. 

  62. 		if (evwrite != NULL)//插入就绪链表
    63. 

  63. 			event_active(evwrite, EV_WRITE, 1);
    64. 

  64. 	}
    65. 

    66. 

  66. 	if (res == epollop->nevents && epollop->nevents < MAX_NEVENTS) {
    67. 

  67. 		/* We used all of the event space this time.  We should
    68. 

  68. 		   be ready for more events next time. */
    69. 

  69. 		int new_nevents = epollop->nevents * 2;
    70. 

  70. 		struct epoll_event *new_events;
    71. 

    72. 

  72. 		new_events = realloc(epollop->events,
    73. 

  73. 		    new_nevents * sizeof(struct epoll_event));
    74. 

  74. 		if (new_events) {
    75. 

  75. 			epollop->events = new_events;
    76. 

  76. 			epollop->nevents = new_nevents;
    77. 

  77. 		}
    78. 

  78. 	}
    79. 

    80. 

  80. 	return (0);
    81. 

  81. }
    82.

evsignal_process

假设有信号发生了~将调用信号处理函数设置信号发生标志位同时发送一个字节数据到socketpair的读端，

而事件1恰好是监听此读端，所以epoll_wait返回然后看信号触发位是否设置为1了，设置了将调用evsignal_process()

而evsignal_process函数内容是遍历信号链表看是否有挂载的事件，有的话，将该事件2插入已就绪链表中，另外也将事件1插入就绪链表

    

    2. 

  2. void
    3. 

  3. evsignal_process(struct event_base *base)//遍历信号链表，是否有事件2挂载
    4. 

  4. {
    5. 

  5. 	struct evsignal_info *sig = &base->sig;//获取信号管理结构体
    6. 

  6. 	struct event *ev, *next_ev;
    7. 

  7. 	sig_atomic_t ncalls;
    8. 

  8. 	int i;
    9. 

  9. 	
    10. 

  10. 	base->sig.evsignal_caught = 0;
    11. 

  11. 	for (i = 1; i < NSIG; ++i) {
    12. 

  12. 		ncalls = sig->evsigcaught[i];//是否有触发
    13. 

  13. 		if (ncalls == 0)//没有就可以滚了
    14. 

  14. 			continue;
    15. 

  15. 		sig->evsigcaught[i] -= ncalls;//有的话。。。清空
    16. 

    17. 

  17. 		for (ev = TAILQ_FIRST(&sig->evsigevents[i]);
    18. 

  18. 		    ev != NULL; ev = next_ev) {
    19. 

  19. 			next_ev = TAILQ_NEXT(ev, ev_signal_next);
    20. 

  20. 			if (!(ev->ev_events & EV_PERSIST))//没设置这个位，就只使用一次了
    21. 

  21. 				event_del(ev);
    22. 

  22. 			event_active(ev, EV_SIGNAL, ncalls);//插入就绪链表
    23. 

  23. 		}
    24. 

    25. 

  25. 	}
    26. 

  26. }
    27.

总流程：

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)

时间： 2024-11-10 08:16:49

libevent源码分析之信号处理的相关文章

【转】libevent源码分析

libevent源码分析 转自:http://www.cnblogs.com/hustcat/archive/2010/08/31/1814022.html 这两天没事,看了一下Memcached和libevent的源码,做个小总结. 1.入门 1.1.概述Libevent是一个用于开发可扩展性网络服务器的基于事件驱动(event-driven)模型的网络库.Libevent有几个显著的亮点: (1)事件驱动(event-driven),高性能:(2)轻量级,专注于网络,不如 ACE 那么臃肿庞

Libevent源码分析-timer和signal处理

timer处理 Signal处理 timerfd和signalfd timerfd signalfd timer处理 在Libevent源码分析-event处理流程中,使用了定时器,来看一下源码: evtimer_set(&ev, time_cb, NULL);//设置定时器事件 其中evtimer_set是个宏定义 #define evtimer_set(ev, cb, arg) event_set((ev), -1, 0, (cb), (arg)) //event_set原型 void ev

Libevent源码分析 (1) hello-world

Libevent源码分析 (1) hello-world ⑨月份接触了久闻大名的libevent,当时想读读源码,可是由于事情比较多一直没有时间,现在手头的东西基本告一段落了,我准备读读libevent的源码,凡是我觉得有必要的内容均一一记录,与君共勉. 首先要说说什么是libevent: libevent是一个事件通知库,libevent API提供一种机制使得我们可以在一个文件描述符(file descriptor)发生特定事件时或者timeout发生时执行指定的回调函数.libevent意

[libevent源码分析] event_add

event_add 把event往当前event中的ev_base追加,如果需要定时,那么tv不能为空 int event_add(struct event *ev, const struct timeval *tv) { struct event_base *base = ev->ev_base; //event_add 会把event加入到他的ev_base成员里 const struct eventop *evsel = base->evsel; //对应linux的epoll相关函数

libevent源码分析-event

event结构 event相关接口 Libevent对event的管理 event结构 event是Reactor模式中的最重要的组件.它包含了了一个句柄fd,并设置监听这个句柄上的哪些事件(读/写等),设置了对应的函数指针,在事件到来时,回调函数指针来处理事件. 先看一下event的结构.它位于include/event2/event_struct.h中 struct event { TAILQ_ENTRY(event) ev_active_next; TAILQ_ENTRY(event) e

[libevent源码分析] event_init

libevent采用的是经典的reactor网络框架,集成了信号.定时.网络事件于一体 首先对event_init进行源码剖析 event_init 主要创建event_base对象, struct event_base { const struct eventop *evsel; //lievent支持select epoll kequeue..等网络api,包括init.add.del.dispatch的接口,每种网络框架都支持 void *evbase; //支持相应网络api的 结构对象

[libevent源码分析] event_set

libevent使用event来封装网络事件回调,参数.fd...等一些信息,函数很简单 void event_set(struct event *ev, int fd, short events, void (*callback)(int, short, void *), void *arg) { /* Take the current base - caller needs to set the real base later */ ev->ev_base = current_base; /

[libevent源码分析] event_base_dispatch

分析下事件循环 event_base_dispatch int event_base_dispatch(struct event_base *event_base) { return (event_base_loop(event_base, 0)); } int event_base_loop(struct event_base *base, int flags) { const struct eventop *evsel = base->evsel; void *evbase = base->

Libevent源码分析—event_base_dispatch()

我们知道libevent是一个Reactor模式的事件驱动的网络库. 到目前为止,我们已经看了核心的event和event_base结构体的源码,看了初始化这两个结构体的源码,看了注册event的源码,也将event注册到I/O多路复用监听的事件上了.现在准备工作都做好了,下面就是看运行时的主循环了,在这个主循环中,是如何检测事件.分发事件.调用事件的回调函数的.这一步就是libevent的核心框架流程了. Reactor模式中的Event.Event Handler.Reactor目前都完成了