![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_epoll_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event / modules|
Return to ngx_epoll_module.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event / modules |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10: #include <ngx_event.h>
11:
12:
13: #if (NGX_TEST_BUILD_EPOLL)
14:
15: /* epoll declarations */
16:
17: #define EPOLLIN 0x001
18: #define EPOLLPRI 0x002
19: #define EPOLLOUT 0x004
20: #define EPOLLRDNORM 0x040
21: #define EPOLLRDBAND 0x080
22: #define EPOLLWRNORM 0x100
23: #define EPOLLWRBAND 0x200
24: #define EPOLLMSG 0x400
25: #define EPOLLERR 0x008
26: #define EPOLLHUP 0x010
27:
28: #define EPOLLET 0x80000000
29: #define EPOLLONESHOT 0x40000000
30:
31: #define EPOLL_CTL_ADD 1
32: #define EPOLL_CTL_DEL 2
33: #define EPOLL_CTL_MOD 3
34:
35: typedef union epoll_data {
36: void *ptr;
37: int fd;
38: uint32_t u32;
39: uint64_t u64;
40: } epoll_data_t;
41:
42: struct epoll_event {
43: uint32_t events;
44: epoll_data_t data;
45: };
46:
47:
48: int epoll_create(int size);
49:
50: int epoll_create(int size)
51: {
52: return -1;
53: }
54:
55:
56: int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
57:
58: int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
59: {
60: return -1;
61: }
62:
63:
64: int epoll_wait(int epfd, struct epoll_event *events, int nevents, int timeout);
65:
66: int epoll_wait(int epfd, struct epoll_event *events, int nevents, int timeout)
67: {
68: return -1;
69: }
70:
71: #if (NGX_HAVE_FILE_AIO)
72:
73: #define SYS_io_setup 245
74: #define SYS_io_destroy 246
75: #define SYS_io_getevents 247
76: #define SYS_eventfd 323
77:
78: typedef u_int aio_context_t;
79:
80: struct io_event {
81: uint64_t data; /* the data field from the iocb */
82: uint64_t obj; /* what iocb this event came from */
83: int64_t res; /* result code for this event */
84: int64_t res2; /* secondary result */
85: };
86:
87:
88: #endif
89: #endif
90:
91:
92: typedef struct {
93: ngx_uint_t events;
94: ngx_uint_t aio_requests;
95: } ngx_epoll_conf_t;
96:
97:
98: static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
99: static void ngx_epoll_done(ngx_cycle_t *cycle);
100: static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event,
101: ngx_uint_t flags);
102: static ngx_int_t ngx_epoll_del_event(ngx_event_t *ev, ngx_int_t event,
103: ngx_uint_t flags);
104: static ngx_int_t ngx_epoll_add_connection(ngx_connection_t *c);
105: static ngx_int_t ngx_epoll_del_connection(ngx_connection_t *c,
106: ngx_uint_t flags);
107: static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
108: ngx_uint_t flags);
109:
110: #if (NGX_HAVE_FILE_AIO)
111: static void ngx_epoll_eventfd_handler(ngx_event_t *ev);
112: #endif
113:
114: static void *ngx_epoll_create_conf(ngx_cycle_t *cycle);
115: static char *ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf);
116:
117: static int ep = -1;
118: static struct epoll_event *event_list;
119: static ngx_uint_t nevents;
120:
121: #if (NGX_HAVE_FILE_AIO)
122:
123: int ngx_eventfd = -1;
124: aio_context_t ngx_aio_ctx = 0;
125:
126: static ngx_event_t ngx_eventfd_event;
127: static ngx_connection_t ngx_eventfd_conn;
128:
129: #endif
130:
131: static ngx_str_t epoll_name = ngx_string("epoll");
132:
133: static ngx_command_t ngx_epoll_commands[] = {
134:
135: { ngx_string("epoll_events"),
136: NGX_EVENT_CONF|NGX_CONF_TAKE1,
137: ngx_conf_set_num_slot,
138: 0,
139: offsetof(ngx_epoll_conf_t, events),
140: NULL },
141:
142: { ngx_string("worker_aio_requests"),
143: NGX_EVENT_CONF|NGX_CONF_TAKE1,
144: ngx_conf_set_num_slot,
145: 0,
146: offsetof(ngx_epoll_conf_t, aio_requests),
147: NULL },
148:
149: ngx_null_command
150: };
151:
152:
153: ngx_event_module_t ngx_epoll_module_ctx = {
154: &epoll_name,
155: ngx_epoll_create_conf, /* create configuration */
156: ngx_epoll_init_conf, /* init configuration */
157:
158: {
159: ngx_epoll_add_event, /* add an event */
160: ngx_epoll_del_event, /* delete an event */
161: ngx_epoll_add_event, /* enable an event */
162: ngx_epoll_del_event, /* disable an event */
163: ngx_epoll_add_connection, /* add an connection */
164: ngx_epoll_del_connection, /* delete an connection */
165: NULL, /* process the changes */
166: ngx_epoll_process_events, /* process the events */
167: ngx_epoll_init, /* init the events */
168: ngx_epoll_done, /* done the events */
169: }
170: };
171:
172: ngx_module_t ngx_epoll_module = {
173: NGX_MODULE_V1,
174: &ngx_epoll_module_ctx, /* module context */
175: ngx_epoll_commands, /* module directives */
176: NGX_EVENT_MODULE, /* module type */
177: NULL, /* init master */
178: NULL, /* init module */
179: NULL, /* init process */
180: NULL, /* init thread */
181: NULL, /* exit thread */
182: NULL, /* exit process */
183: NULL, /* exit master */
184: NGX_MODULE_V1_PADDING
185: };
186:
187:
188: #if (NGX_HAVE_FILE_AIO)
189:
190: /*
191: * We call io_setup(), io_destroy() io_submit(), and io_getevents() directly
192: * as syscalls instead of libaio usage, because the library header file
193: * supports eventfd() since 0.3.107 version only.
194: *
195: * Also we do not use eventfd() in glibc, because glibc supports it
196: * since 2.8 version and glibc maps two syscalls eventfd() and eventfd2()
197: * into single eventfd() function with different number of parameters.
198: */
199:
200: static int
201: io_setup(u_int nr_reqs, aio_context_t *ctx)
202: {
203: return syscall(SYS_io_setup, nr_reqs, ctx);
204: }
205:
206:
207: static int
208: io_destroy(aio_context_t ctx)
209: {
210: return syscall(SYS_io_destroy, ctx);
211: }
212:
213:
214: static int
215: io_getevents(aio_context_t ctx, long min_nr, long nr, struct io_event *events,
216: struct timespec *tmo)
217: {
218: return syscall(SYS_io_getevents, ctx, min_nr, nr, events, tmo);
219: }
220:
221:
222: static void
223: ngx_epoll_aio_init(ngx_cycle_t *cycle, ngx_epoll_conf_t *epcf)
224: {
225: int n;
226: struct epoll_event ee;
227:
228: ngx_eventfd = syscall(SYS_eventfd, 0);
229:
230: if (ngx_eventfd == -1) {
231: ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
232: "eventfd() failed");
233: ngx_file_aio = 0;
234: return;
235: }
236:
237: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
238: "eventfd: %d", ngx_eventfd);
239:
240: n = 1;
241:
242: if (ioctl(ngx_eventfd, FIONBIO, &n) == -1) {
243: ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
244: "ioctl(eventfd, FIONBIO) failed");
245: goto failed;
246: }
247:
248: if (io_setup(epcf->aio_requests, &ngx_aio_ctx) == -1) {
249: ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
250: "io_setup() failed");
251: goto failed;
252: }
253:
254: ngx_eventfd_event.data = &ngx_eventfd_conn;
255: ngx_eventfd_event.handler = ngx_epoll_eventfd_handler;
256: ngx_eventfd_event.log = cycle->log;
257: ngx_eventfd_event.active = 1;
258: ngx_eventfd_conn.fd = ngx_eventfd;
259: ngx_eventfd_conn.read = &ngx_eventfd_event;
260: ngx_eventfd_conn.log = cycle->log;
261:
262: ee.events = EPOLLIN|EPOLLET;
263: ee.data.ptr = &ngx_eventfd_conn;
264:
265: if (epoll_ctl(ep, EPOLL_CTL_ADD, ngx_eventfd, &ee) != -1) {
266: return;
267: }
268:
269: ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
270: "epoll_ctl(EPOLL_CTL_ADD, eventfd) failed");
271:
272: if (io_destroy(ngx_aio_ctx) == -1) {
273: ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
274: "io_destroy() failed");
275: }
276:
277: failed:
278:
279: if (close(ngx_eventfd) == -1) {
280: ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
281: "eventfd close() failed");
282: }
283:
284: ngx_eventfd = -1;
285: ngx_aio_ctx = 0;
286: ngx_file_aio = 0;
287: }
288:
289: #endif
290:
291:
292: static ngx_int_t
293: ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
294: {
295: ngx_epoll_conf_t *epcf;
296:
297: epcf = ngx_event_get_conf(cycle->conf_ctx, ngx_epoll_module);
298:
299: if (ep == -1) {
300: ep = epoll_create(cycle->connection_n / 2);
301:
302: if (ep == -1) {
303: ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
304: "epoll_create() failed");
305: return NGX_ERROR;
306: }
307:
308: #if (NGX_HAVE_FILE_AIO)
309:
310: ngx_epoll_aio_init(cycle, epcf);
311:
312: #endif
313: }
314:
315: if (nevents < epcf->events) {
316: if (event_list) {
317: ngx_free(event_list);
318: }
319:
320: event_list = ngx_alloc(sizeof(struct epoll_event) * epcf->events,
321: cycle->log);
322: if (event_list == NULL) {
323: return NGX_ERROR;
324: }
325: }
326:
327: nevents = epcf->events;
328:
329: ngx_io = ngx_os_io;
330:
331: ngx_event_actions = ngx_epoll_module_ctx.actions;
332:
333: #if (NGX_HAVE_CLEAR_EVENT)
334: ngx_event_flags = NGX_USE_CLEAR_EVENT
335: #else
336: ngx_event_flags = NGX_USE_LEVEL_EVENT
337: #endif
338: |NGX_USE_GREEDY_EVENT
339: |NGX_USE_EPOLL_EVENT;
340:
341: return NGX_OK;
342: }
343:
344:
345: static void
346: ngx_epoll_done(ngx_cycle_t *cycle)
347: {
348: if (close(ep) == -1) {
349: ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
350: "epoll close() failed");
351: }
352:
353: ep = -1;
354:
355: #if (NGX_HAVE_FILE_AIO)
356:
357: if (ngx_eventfd != -1) {
358:
359: if (io_destroy(ngx_aio_ctx) == -1) {
360: ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
361: "io_destroy() failed");
362: }
363:
364: if (close(ngx_eventfd) == -1) {
365: ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
366: "eventfd close() failed");
367: }
368:
369: ngx_eventfd = -1;
370: }
371:
372: ngx_aio_ctx = 0;
373:
374: #endif
375:
376: ngx_free(event_list);
377:
378: event_list = NULL;
379: nevents = 0;
380: }
381:
382:
383: static ngx_int_t
384: ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
385: {
386: int op;
387: uint32_t events, prev;
388: ngx_event_t *e;
389: ngx_connection_t *c;
390: struct epoll_event ee;
391:
392: c = ev->data;
393:
394: events = (uint32_t) event;
395:
396: if (event == NGX_READ_EVENT) {
397: e = c->write;
398: prev = EPOLLOUT;
399: #if (NGX_READ_EVENT != EPOLLIN)
400: events = EPOLLIN;
401: #endif
402:
403: } else {
404: e = c->read;
405: prev = EPOLLIN;
406: #if (NGX_WRITE_EVENT != EPOLLOUT)
407: events = EPOLLOUT;
408: #endif
409: }
410:
411: if (e->active) {
412: op = EPOLL_CTL_MOD;
413: events |= prev;
414:
415: } else {
416: op = EPOLL_CTL_ADD;
417: }
418:
419: ee.events = events | (uint32_t) flags;
420: ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);
421:
422: ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
423: "epoll add event: fd:%d op:%d ev:%08XD",
424: c->fd, op, ee.events);
425:
426: if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
427: ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
428: "epoll_ctl(%d, %d) failed", op, c->fd);
429: return NGX_ERROR;
430: }
431:
432: ev->active = 1;
433: #if 0
434: ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
435: #endif
436:
437: return NGX_OK;
438: }
439:
440:
441: static ngx_int_t
442: ngx_epoll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
443: {
444: int op;
445: uint32_t prev;
446: ngx_event_t *e;
447: ngx_connection_t *c;
448: struct epoll_event ee;
449:
450: /*
451: * when the file descriptor is closed, the epoll automatically deletes
452: * it from its queue, so we do not need to delete explicitly the event
453: * before the closing the file descriptor
454: */
455:
456: if (flags & NGX_CLOSE_EVENT) {
457: ev->active = 0;
458: return NGX_OK;
459: }
460:
461: c = ev->data;
462:
463: if (event == NGX_READ_EVENT) {
464: e = c->write;
465: prev = EPOLLOUT;
466:
467: } else {
468: e = c->read;
469: prev = EPOLLIN;
470: }
471:
472: if (e->active) {
473: op = EPOLL_CTL_MOD;
474: ee.events = prev | (uint32_t) flags;
475: ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);
476:
477: } else {
478: op = EPOLL_CTL_DEL;
479: ee.events = 0;
480: ee.data.ptr = NULL;
481: }
482:
483: ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
484: "epoll del event: fd:%d op:%d ev:%08XD",
485: c->fd, op, ee.events);
486:
487: if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
488: ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
489: "epoll_ctl(%d, %d) failed", op, c->fd);
490: return NGX_ERROR;
491: }
492:
493: ev->active = 0;
494:
495: return NGX_OK;
496: }
497:
498:
499: static ngx_int_t
500: ngx_epoll_add_connection(ngx_connection_t *c)
501: {
502: struct epoll_event ee;
503:
504: ee.events = EPOLLIN|EPOLLOUT|EPOLLET;
505: ee.data.ptr = (void *) ((uintptr_t) c | c->read->instance);
506:
507: ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
508: "epoll add connection: fd:%d ev:%08XD", c->fd, ee.events);
509:
510: if (epoll_ctl(ep, EPOLL_CTL_ADD, c->fd, &ee) == -1) {
511: ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
512: "epoll_ctl(EPOLL_CTL_ADD, %d) failed", c->fd);
513: return NGX_ERROR;
514: }
515:
516: c->read->active = 1;
517: c->write->active = 1;
518:
519: return NGX_OK;
520: }
521:
522:
523: static ngx_int_t
524: ngx_epoll_del_connection(ngx_connection_t *c, ngx_uint_t flags)
525: {
526: int op;
527: struct epoll_event ee;
528:
529: /*
530: * when the file descriptor is closed the epoll automatically deletes
531: * it from its queue so we do not need to delete explicitly the event
532: * before the closing the file descriptor
533: */
534:
535: if (flags & NGX_CLOSE_EVENT) {
536: c->read->active = 0;
537: c->write->active = 0;
538: return NGX_OK;
539: }
540:
541: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
542: "epoll del connection: fd:%d", c->fd);
543:
544: op = EPOLL_CTL_DEL;
545: ee.events = 0;
546: ee.data.ptr = NULL;
547:
548: if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
549: ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
550: "epoll_ctl(%d, %d) failed", op, c->fd);
551: return NGX_ERROR;
552: }
553:
554: c->read->active = 0;
555: c->write->active = 0;
556:
557: return NGX_OK;
558: }
559:
560:
561: static ngx_int_t
562: ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
563: {
564: int events;
565: uint32_t revents;
566: ngx_int_t instance, i;
567: ngx_uint_t level;
568: ngx_err_t err;
569: ngx_event_t *rev, *wev, **queue;
570: ngx_connection_t *c;
571:
572: /* NGX_TIMER_INFINITE == INFTIM */
573:
574: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
575: "epoll timer: %M", timer);
576:
577: events = epoll_wait(ep, event_list, (int) nevents, timer);
578:
579: err = (events == -1) ? ngx_errno : 0;
580:
581: if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
582: ngx_time_update();
583: }
584:
585: if (err) {
586: if (err == NGX_EINTR) {
587:
588: if (ngx_event_timer_alarm) {
589: ngx_event_timer_alarm = 0;
590: return NGX_OK;
591: }
592:
593: level = NGX_LOG_INFO;
594:
595: } else {
596: level = NGX_LOG_ALERT;
597: }
598:
599: ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
600: return NGX_ERROR;
601: }
602:
603: if (events == 0) {
604: if (timer != NGX_TIMER_INFINITE) {
605: return NGX_OK;
606: }
607:
608: ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
609: "epoll_wait() returned no events without timeout");
610: return NGX_ERROR;
611: }
612:
613: ngx_mutex_lock(ngx_posted_events_mutex);
614:
615: for (i = 0; i < events; i++) {
616: c = event_list[i].data.ptr;
617:
618: instance = (uintptr_t) c & 1;
619: c = (ngx_connection_t *) ((uintptr_t) c & (uintptr_t) ~1);
620:
621: rev = c->read;
622:
623: if (c->fd == -1 || rev->instance != instance) {
624:
625: /*
626: * the stale event from a file descriptor
627: * that was just closed in this iteration
628: */
629:
630: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
631: "epoll: stale event %p", c);
632: continue;
633: }
634:
635: revents = event_list[i].events;
636:
637: ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
638: "epoll: fd:%d ev:%04XD d:%p",
639: c->fd, revents, event_list[i].data.ptr);
640:
641: if (revents & (EPOLLERR|EPOLLHUP)) {
642: ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
643: "epoll_wait() error on fd:%d ev:%04XD",
644: c->fd, revents);
645: }
646:
647: #if 0
648: if (revents & ~(EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP)) {
649: ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
650: "strange epoll_wait() events fd:%d ev:%04XD",
651: c->fd, revents);
652: }
653: #endif
654:
655: if ((revents & (EPOLLERR|EPOLLHUP))
656: && (revents & (EPOLLIN|EPOLLOUT)) == 0)
657: {
658: /*
659: * if the error events were returned without EPOLLIN or EPOLLOUT,
660: * then add these flags to handle the events at least in one
661: * active handler
662: */
663:
664: revents |= EPOLLIN|EPOLLOUT;
665: }
666:
667: if ((revents & EPOLLIN) && rev->active) {
668:
669: if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
670: rev->posted_ready = 1;
671:
672: } else {
673: rev->ready = 1;
674: }
675:
676: if (flags & NGX_POST_EVENTS) {
677: queue = (ngx_event_t **) (rev->accept ?
678: &ngx_posted_accept_events : &ngx_posted_events);
679:
680: ngx_locked_post_event(rev, queue);
681:
682: } else {
683: rev->handler(rev);
684: }
685: }
686:
687: wev = c->write;
688:
689: if ((revents & EPOLLOUT) && wev->active) {
690:
691: if (c->fd == -1 || wev->instance != instance) {
692:
693: /*
694: * the stale event from a file descriptor
695: * that was just closed in this iteration
696: */
697:
698: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
699: "epoll: stale event %p", c);
700: continue;
701: }
702:
703: if (flags & NGX_POST_THREAD_EVENTS) {
704: wev->posted_ready = 1;
705:
706: } else {
707: wev->ready = 1;
708: }
709:
710: if (flags & NGX_POST_EVENTS) {
711: ngx_locked_post_event(wev, &ngx_posted_events);
712:
713: } else {
714: wev->handler(wev);
715: }
716: }
717: }
718:
719: ngx_mutex_unlock(ngx_posted_events_mutex);
720:
721: return NGX_OK;
722: }
723:
724:
725: #if (NGX_HAVE_FILE_AIO)
726:
727: static void
728: ngx_epoll_eventfd_handler(ngx_event_t *ev)
729: {
730: int n, events;
731: long i;
732: uint64_t ready;
733: ngx_err_t err;
734: ngx_event_t *e;
735: ngx_event_aio_t *aio;
736: struct io_event event[64];
737: struct timespec ts;
738:
739: ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "eventfd handler");
740:
741: n = read(ngx_eventfd, &ready, 8);
742:
743: err = ngx_errno;
744:
745: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0, "eventfd: %d", n);
746:
747: if (n != 8) {
748: if (n == -1) {
749: if (err == NGX_EAGAIN) {
750: return;
751: }
752:
753: ngx_log_error(NGX_LOG_ALERT, ev->log, err, "read(eventfd) failed");
754: return;
755: }
756:
757: ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
758: "read(eventfd) returned only %d bytes", n);
759: return;
760: }
761:
762: ts.tv_sec = 0;
763: ts.tv_nsec = 0;
764:
765: while (ready) {
766:
767: events = io_getevents(ngx_aio_ctx, 1, 64, event, &ts);
768:
769: ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
770: "io_getevents: %l", events);
771:
772: if (events > 0) {
773: ready -= events;
774:
775: for (i = 0; i < events; i++) {
776:
777: ngx_log_debug4(NGX_LOG_DEBUG_EVENT, ev->log, 0,
778: "io_event: %uXL %uXL %L %L",
779: event[i].data, event[i].obj,
780: event[i].res, event[i].res2);
781:
782: e = (ngx_event_t *) (uintptr_t) event[i].data;
783:
784: e->complete = 1;
785: e->active = 0;
786: e->ready = 1;
787:
788: aio = e->data;
789: aio->res = event[i].res;
790:
791: ngx_post_event(e, &ngx_posted_events);
792: }
793:
794: continue;
795: }
796:
797: if (events == 0) {
798: return;
799: }
800:
801: /* events == -1 */
802: ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
803: "io_getevents() failed");
804: return;
805: }
806: }
807:
808: #endif
809:
810:
811: static void *
812: ngx_epoll_create_conf(ngx_cycle_t *cycle)
813: {
814: ngx_epoll_conf_t *epcf;
815:
816: epcf = ngx_palloc(cycle->pool, sizeof(ngx_epoll_conf_t));
817: if (epcf == NULL) {
818: return NULL;
819: }
820:
821: epcf->events = NGX_CONF_UNSET;
822: epcf->aio_requests = NGX_CONF_UNSET;
823:
824: return epcf;
825: }
826:
827:
828: static char *
829: ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf)
830: {
831: ngx_epoll_conf_t *epcf = conf;
832:
833: ngx_conf_init_uint_value(epcf->events, 512);
834: ngx_conf_init_uint_value(epcf->aio_requests, 32);
835:
836: return NGX_CONF_OK;
837: }