One Level Up Top Level

src/event/modules/ngx_epoll_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. #if (NGX_TEST_BUILD_EPOLL)

  15. /* epoll declarations */

  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

  28. ‌#define EPOLLRDHUP     0x2000

  30. ‌#define EPOLLET        0x80000000
  31. ‌#define EPOLLONESHOT   0x40000000

  33. ‌#define EPOLL_CTL_ADD  1
  34. ‌#define EPOLL_CTL_DEL  2
  35. ‌#define EPOLL_CTL_MOD  3

  37. ‌typedef union epoll_data {
  38.     void         *ptr;
  39.     int           fd;
  40.     uint32_t      u32;
  41.     uint64_t      u64;
  42. ‌} epoll_data_t;

  44. ‌struct epoll_event {
  45.     uint32_t      events;
  46.     epoll_data_t  data;
  47. };


  50. int epoll_create(int size);

  52. ‌int epoll_create(int size)
  53. {
  54.     return -1;
  55. }


  58. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

  60. ‌int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
  61. {
  62.     return -1;
  63. }


  66. int epoll_wait(int epfd, struct epoll_event *events, int nevents, int timeout);

  68. ‌int epoll_wait(int epfd, struct epoll_event *events, int nevents, int timeout)
  69. {
  70.     return -1;
  71. }

  73. #if (NGX_HAVE_FILE_AIO)

  75. ‌#define SYS_io_setup      245
  76. ‌#define SYS_io_destroy    246
  77. ‌#define SYS_io_getevents  247
  78. ‌#define SYS_eventfd       323

  80. ‌typedef u_int  aio_context_t;

  82. ‌struct io_event {
  83.     uint64_t  data;  /* the data field from the iocb */
  84.     uint64_t  obj;   /* what iocb this event came from */
  85.     int64_t   res;   /* result code for this event */
  86.     int64_t   res2;  /* secondary result */
  87. };


  90. #endif
  91. #endif


  94. typedef struct {
  95.     ngx_uint_t  events;
  96.     ngx_uint_t  aio_requests;
  97. ‌} ngx_epoll_conf_t;


  100. static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  101. static void ngx_epoll_done(ngx_cycle_t *cycle);
  102. static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event,
  103.     ngx_uint_t flags);
  104. static ngx_int_t ngx_epoll_del_event(ngx_event_t *ev, ngx_int_t event,
  105.     ngx_uint_t flags);
  106. static ngx_int_t ngx_epoll_add_connection(ngx_connection_t *c);
  107. static ngx_int_t ngx_epoll_del_connection(ngx_connection_t *c,
  108.     ngx_uint_t flags);
  109. static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  110.     ngx_uint_t flags);

  112. #if (NGX_HAVE_FILE_AIO)
  113. static void ngx_epoll_eventfd_handler(ngx_event_t *ev);
  114. #endif

  116. static void *ngx_epoll_create_conf(ngx_cycle_t *cycle);
  117. static char *ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf);

  119. ‌static int                  ep = -1;
  120. ‌static struct epoll_event  *event_list;
  121. ‌static ngx_uint_t           nevents;

  123. #if (NGX_HAVE_FILE_AIO)

  125. ‌int                         ngx_eventfd = -1;
  126. ‌aio_context_t               ngx_aio_ctx = 0;

  128. ‌static ngx_event_t          ngx_eventfd_event;
  129. ‌static ngx_connection_t     ngx_eventfd_conn;

  131. #endif

  133. ‌static ngx_str_t      epoll_name = ngx_string("epoll");

  135. ‌static ngx_command_t  ngx_epoll_commands[] = {

  137.     { ngx_string("epoll_events"),
  138.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  139.       ngx_conf_set_num_slot,
  140.       0,
  141.       offsetof(ngx_epoll_conf_t, events),
  142.       NULL },

  144.     { ngx_string("worker_aio_requests"),
  145.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  146.       ngx_conf_set_num_slot,
  147.       0,
  148.       offsetof(ngx_epoll_conf_t, aio_requests),
  149.       NULL },

  151.       ngx_null_command
  152. };


  155. ‌ngx_event_module_t  ngx_epoll_module_ctx = {
  156.     &epoll_name,
  157.     ngx_epoll_create_conf,               /* create configuration */
  158.     ngx_epoll_init_conf,                 /* init configuration */

  160.     {
  161.         ngx_epoll_add_event,             /* add an event */
  162.         ngx_epoll_del_event,             /* delete an event */
  163.         ngx_epoll_add_event,             /* enable an event */
  164.         ngx_epoll_del_event,             /* disable an event */
  165.         ngx_epoll_add_connection,        /* add an connection */
  166.         ngx_epoll_del_connection,        /* delete an connection */
  167.         NULL,                            /* process the changes */
  168.         ngx_epoll_process_events,        /* process the events */
  169.         ngx_epoll_init,                  /* init the events */
  170.         ngx_epoll_done,                  /* done the events */
  171.     }
  172. };

  174. ‌ngx_module_t  ngx_epoll_module = {
  175.     NGX_MODULE_V1,
  176.     &ngx_epoll_module_ctx,               /* module context */
  177.     ngx_epoll_commands,                  /* module directives */
  178.     NGX_EVENT_MODULE,                    /* module type */
  179.     NULL,                                /* init master */
  180.     NULL,                                /* init module */
  181.     NULL,                                /* init process */
  182.     NULL,                                /* init thread */
  183.     NULL,                                /* exit thread */
  184.     NULL,                                /* exit process */
  185.     NULL,                                /* exit master */
  186.     NGX_MODULE_V1_PADDING
  187. };


  190. #if (NGX_HAVE_FILE_AIO)

  192. /*
  193. * We call io_setup(), io_destroy() io_submit(), and io_getevents() directly
  194. * as syscalls instead of libaio usage, because the library header file
  195. * supports eventfd() since 0.3.107 version only.
  196. */

  198. static int
  199. ‌io_setup(u_int nr_reqs, aio_context_t *ctx)
  200. {
  201.     return syscall(SYS_io_setup, nr_reqs, ctx);
  202. }


  205. static int
  206. ‌io_destroy(aio_context_t ctx)
  207. {
  208.     return syscall(SYS_io_destroy, ctx);
  209. }


  212. static int
  213. ‌io_getevents(aio_context_t ctx, long min_nr, long nr, struct io_event *events,
  214.     struct timespec *tmo)
  215. {
  216.     return syscall(SYS_io_getevents, ctx, min_nr, nr, events, tmo);
  217. }


  220. static void
  221. ‌ngx_epoll_aio_init(ngx_cycle_t *cycle, ngx_epoll_conf_t *epcf)
  222. {
  223.     int                 n;
  224.     struct epoll_event  ee;

  226. #if (NGX_HAVE_SYS_EVENTFD_H)
  227.     ngx_eventfd = eventfd(0, 0);
  228. #else
  229.     ngx_eventfd = syscall(SYS_eventfd, 0);
  230. #endif

  232.     if (ngx_eventfd == -1) {
  233.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  234.                       "eventfd() failed");
  235.         ngx_file_aio = 0;
  236.         return;
  237.     }

  239.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  240.                    "eventfd: %d", ngx_eventfd);

  242.     n = 1;

  244.     if (ioctl(ngx_eventfd, FIONBIO, &n) == -1) {
  245.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  246.                       "ioctl(eventfd, FIONBIO) failed");
  247.         goto failed;
  248.     }

  250.     if (io_setup(epcf->aio_requests, &ngx_aio_ctx) == -1) {
  251.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  252.                       "io_setup() failed");
  253.         goto failed;
  254.     }

  256.     ngx_eventfd_event.data = &ngx_eventfd_conn;
  257.     ngx_eventfd_event.handler = ngx_epoll_eventfd_handler;
  258.     ngx_eventfd_event.log = cycle->log;
  259.     ngx_eventfd_event.active = 1;
  260.     ngx_eventfd_conn.fd = ngx_eventfd;
  261.     ngx_eventfd_conn.read = &ngx_eventfd_event;
  262.     ngx_eventfd_conn.log = cycle->log;

  264.     ee.events = EPOLLIN|EPOLLET;
  265.     ee.data.ptr = &ngx_eventfd_conn;

  267.     if (epoll_ctl(ep, EPOLL_CTL_ADD, ngx_eventfd, &ee) != -1) {
  268.         return;
  269.     }

  271.     ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  272.                   "epoll_ctl(EPOLL_CTL_ADD, eventfd) failed");

  274.     if (io_destroy(ngx_aio_ctx) == -1) {
  275.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  276.                       "io_destroy() failed");
  277.     }

  279. failed:

  281.     if (close(ngx_eventfd) == -1) {
  282.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  283.                       "eventfd close() failed");
  284.     }

  286.     ngx_eventfd = -1;
  287.     ngx_aio_ctx = 0;
  288.     ngx_file_aio = 0;
  289. }

  291. #endif


  294. static ngx_int_t
  295. ‌ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  296. {
  297.     ngx_epoll_conf_t  *epcf;

  299.     epcf = ngx_event_get_conf(cycle->conf_ctx, ngx_epoll_module);

  301.     if (ep == -1) {
  302.         ep = epoll_create(cycle->connection_n / 2);

  304.         if (ep == -1) {
  305.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  306.                           "epoll_create() failed");
  307.             return NGX_ERROR;
  308.         }

  310. #if (NGX_HAVE_FILE_AIO)

  312.         ngx_epoll_aio_init(cycle, epcf);

  314. #endif
  315.     }

  317.     if (nevents < epcf->events) {
  318.         if (event_list) {
  319.             ngx_free(event_list);
  320.         }

  322.         event_list = ngx_alloc(sizeof(struct epoll_event) * epcf->events,
  323.                                cycle->log);
  324.         if (event_list == NULL) {
  325.             return NGX_ERROR;
  326.         }
  327.     }

  329.     nevents = epcf->events;

  331.     ngx_io = ngx_os_io;

  333.     ngx_event_actions = ngx_epoll_module_ctx.actions;

  335. #if (NGX_HAVE_CLEAR_EVENT)
  336.     ngx_event_flags = NGX_USE_CLEAR_EVENT
  337. #else
  338.     ngx_event_flags = NGX_USE_LEVEL_EVENT
  339. #endif
  340.                       |NGX_USE_GREEDY_EVENT
  341.                       |NGX_USE_EPOLL_EVENT;

  343.     return NGX_OK;
  344. }


  347. static void
  348. ‌ngx_epoll_done(ngx_cycle_t *cycle)
  349. {
  350.     if (close(ep) == -1) {
  351.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  352.                       "epoll close() failed");
  353.     }

  355.     ep = -1;

  357. #if (NGX_HAVE_FILE_AIO)

  359.     if (ngx_eventfd != -1) {

  361.         if (io_destroy(ngx_aio_ctx) == -1) {
  362.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  363.                           "io_destroy() failed");
  364.         }

  366.         if (close(ngx_eventfd) == -1) {
  367.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  368.                           "eventfd close() failed");
  369.         }

  371.         ngx_eventfd = -1;
  372.     }

  374.     ngx_aio_ctx = 0;

  376. #endif

  378.     ngx_free(event_list);

  380.     event_list = NULL;
  381.     nevents = 0;
  382. }


  385. static ngx_int_t
  386. ‌ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  387. {
  388.     int                  op;
  389.     uint32_t             events, prev;
  390.     ngx_event_t         *e;
  391.     ngx_connection_t    *c;
  392.     struct epoll_event   ee;

  394.     c = ev->data;

  396.     events = (uint32_t) event;

  398.     if (event == NGX_READ_EVENT) {
  399.         e = c->write;
  400.         prev = EPOLLOUT;
  401. #if (NGX_READ_EVENT != EPOLLIN|EPOLLRDHUP)
  402.         events = EPOLLIN|EPOLLRDHUP;
  403. #endif

  405.     } else {
  406.         e = c->read;
  407.         prev = EPOLLIN|EPOLLRDHUP;
  408. #if (NGX_WRITE_EVENT != EPOLLOUT)
  409.         events = EPOLLOUT;
  410. #endif
  411.     }

  413.     if (e->active) {
  414.         op = EPOLL_CTL_MOD;
  415.         events |= prev;

  417.     } else {
  418.         op = EPOLL_CTL_ADD;
  419.     }

  421.     ee.events = events | (uint32_t) flags;
  422.     ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);

  424.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  425.                    "epoll add event: fd:%d op:%d ev:%08XD",
  426.                    c->fd, op, ee.events);

  428.     if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
  429.         ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  430.                       "epoll_ctl(%d, %d) failed", op, c->fd);
  431.         return NGX_ERROR;
  432.     }

  434.     ev->active = 1;
  435. #if 0
  436.     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
  437. #endif

  439.     return NGX_OK;
  440. }


  443. static ngx_int_t
  444. ‌ngx_epoll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  445. {
  446.     int                  op;
  447.     uint32_t             prev;
  448.     ngx_event_t         *e;
  449.     ngx_connection_t    *c;
  450.     struct epoll_event   ee;

  452.     /*
  453.      * when the file descriptor is closed, the epoll automatically deletes
  454.      * it from its queue, so we do not need to delete explicitly the event
  455.      * before the closing the file descriptor
  456.      */

  458.     if (flags & NGX_CLOSE_EVENT) {
  459.         ev->active = 0;
  460.         return NGX_OK;
  461.     }

  463.     c = ev->data;

  465.     if (event == NGX_READ_EVENT) {
  466.         e = c->write;
  467.         prev = EPOLLOUT;

  469.     } else {
  470.         e = c->read;
  471.         prev = EPOLLIN|EPOLLRDHUP;
  472.     }

  474.     if (e->active) {
  475.         op = EPOLL_CTL_MOD;
  476.         ee.events = prev | (uint32_t) flags;
  477.         ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);

  479.     } else {
  480.         op = EPOLL_CTL_DEL;
  481.         ee.events = 0;
  482.         ee.data.ptr = NULL;
  483.     }

  485.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  486.                    "epoll del event: fd:%d op:%d ev:%08XD",
  487.                    c->fd, op, ee.events);

  489.     if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
  490.         ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  491.                       "epoll_ctl(%d, %d) failed", op, c->fd);
  492.         return NGX_ERROR;
  493.     }

  495.     ev->active = 0;

  497.     return NGX_OK;
  498. }


  501. static ngx_int_t
  502. ‌ngx_epoll_add_connection(ngx_connection_t *c)
  503. {
  504.     struct epoll_event  ee;

  506.     ee.events = EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP;
  507.     ee.data.ptr = (void *) ((uintptr_t) c | c->read->instance);

  509.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  510.                    "epoll add connection: fd:%d ev:%08XD", c->fd, ee.events);

  512.     if (epoll_ctl(ep, EPOLL_CTL_ADD, c->fd, &ee) == -1) {
  513.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  514.                       "epoll_ctl(EPOLL_CTL_ADD, %d) failed", c->fd);
  515.         return NGX_ERROR;
  516.     }

  518.     c->read->active = 1;
  519.     c->write->active = 1;

  521.     return NGX_OK;
  522. }


  525. static ngx_int_t
  526. ‌ngx_epoll_del_connection(ngx_connection_t *c, ngx_uint_t flags)
  527. {
  528.     int                 op;
  529.     struct epoll_event  ee;

  531.     /*
  532.      * when the file descriptor is closed the epoll automatically deletes
  533.      * it from its queue so we do not need to delete explicitly the event
  534.      * before the closing the file descriptor
  535.      */

  537.     if (flags & NGX_CLOSE_EVENT) {
  538.         c->read->active = 0;
  539.         c->write->active = 0;
  540.         return NGX_OK;
  541.     }

  543.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  544.                    "epoll del connection: fd:%d", c->fd);

  546.     op = EPOLL_CTL_DEL;
  547.     ee.events = 0;
  548.     ee.data.ptr = NULL;

  550.     if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
  551.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  552.                       "epoll_ctl(%d, %d) failed", op, c->fd);
  553.         return NGX_ERROR;
  554.     }

  556.     c->read->active = 0;
  557.     c->write->active = 0;

  559.     return NGX_OK;
  560. }


  563. static ngx_int_t
  564. ‌ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
  565. {
  566.     int                events;
  567.     uint32_t           revents;
  568.     ngx_int_t          instance, i;
  569.     ngx_uint_t         level;
  570.     ngx_err_t          err;
  571.     ngx_event_t       *rev, *wev;
  572.     ngx_queue_t       *queue;
  573.     ngx_connection_t  *c;

  575.     /* NGX_TIMER_INFINITE == INFTIM */

  577.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  578.                    "epoll timer: %M", timer);

  580.     events = epoll_wait(ep, event_list, (int) nevents, timer);

  582.     err = (events == -1) ? ngx_errno : 0;

  584.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  585.         ngx_time_update();
  586.     }

  588.     if (err) {
  589.         if (err == NGX_EINTR) {

  591.             if (ngx_event_timer_alarm) {
  592.                 ngx_event_timer_alarm = 0;
  593.                 return NGX_OK;
  594.             }

  596.             level = NGX_LOG_INFO;

  598.         } else {
  599.             level = NGX_LOG_ALERT;
  600.         }

  602.         ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
  603.         return NGX_ERROR;
  604.     }

  606.     if (events == 0) {
  607.         if (timer != NGX_TIMER_INFINITE) {
  608.             return NGX_OK;
  609.         }

  611.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  612.                       "epoll_wait() returned no events without timeout");
  613.         return NGX_ERROR;
  614.     }

  616.     for (i = 0; i < events; i++) {
  617.         c = event_list[i].data.ptr;

  619.         instance = (uintptr_t) c & 1;
  620.         c = (ngx_connection_t *) ((uintptr_t) c & (uintptr_t) ~1);

  622.         rev = c->read;

  624.         if (c->fd == -1 || rev->instance != instance) {

  626.             /*
  627.              * the stale event from a file descriptor
  628.              * that was just closed in this iteration
  629.              */

  631.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  632.                            "epoll: stale event %p", c);
  633.             continue;
  634.         }

  636.         revents = event_list[i].events;

  638.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  639.                        "epoll: fd:%d ev:%04XD d:%p",
  640.                        c->fd, revents, event_list[i].data.ptr);

  642.         if (revents & (EPOLLERR|EPOLLHUP)) {
  643.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  644.                            "epoll_wait() error on fd:%d ev:%04XD",
  645.                            c->fd, revents);
  646.         }

  648. #if 0
  649.         if (revents & ~(EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP)) {
  650.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  651.                           "strange epoll_wait() events fd:%d ev:%04XD",
  652.                           c->fd, revents);
  653.         }
  654. #endif

  656.         if ((revents & (EPOLLERR|EPOLLHUP))
  657.              && (revents & (EPOLLIN|EPOLLOUT)) == 0)
  658.         {
  659.             /*
  660.              * if the error events were returned without EPOLLIN or EPOLLOUT,
  661.              * then add these flags to handle the events at least in one
  662.              * active handler
  663.              */

  665.             revents |= EPOLLIN|EPOLLOUT;
  666.         }

  668.         if ((revents & EPOLLIN) && rev->active) {

  670. #if (NGX_HAVE_EPOLLRDHUP)
  671.             if (revents & EPOLLRDHUP) {
  672.                 rev->pending_eof = 1;
  673.             }
  674. #endif

  676.             rev->ready = 1;

  678.             if (flags & NGX_POST_EVENTS) {
  679.                 queue = rev->accept ? &ngx_posted_accept_events
  680.                                     : &ngx_posted_events;

  682.                 ngx_post_event(rev, queue);

  684.             } else {
  685.                 rev->handler(rev);
  686.             }
  687.         }

  689.         wev = c->write;

  691.         if ((revents & EPOLLOUT) && wev->active) {

  693.             if (c->fd == -1 || wev->instance != instance) {

  695.                 /*
  696.                  * the stale event from a file descriptor
  697.                  * that was just closed in this iteration
  698.                  */

  700.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  701.                                "epoll: stale event %p", c);
  702.                 continue;
  703.             }

  705.             wev->ready = 1;

  707.             if (flags & NGX_POST_EVENTS) {
  708.                 ngx_post_event(wev, &ngx_posted_events);

  710.             } else {
  711.                 wev->handler(wev);
  712.             }
  713.         }
  714.     }

  716.     return NGX_OK;
  717. }


  720. #if (NGX_HAVE_FILE_AIO)

  722. static void
  723. ‌ngx_epoll_eventfd_handler(ngx_event_t *ev)
  724. {
  725.     int               n, events;
  726.     long              i;
  727.     uint64_t          ready;
  728.     ngx_err_t         err;
  729.     ngx_event_t      *e;
  730.     ngx_event_aio_t  *aio;
  731.     struct io_event   event[64];
  732.     struct timespec   ts;

  734.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "eventfd handler");

  736.     n = read(ngx_eventfd, &ready, 8);

  738.     err = ngx_errno;

  740.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0, "eventfd: %d", n);

  742.     if (n != 8) {
  743.         if (n == -1) {
  744.             if (err == NGX_EAGAIN) {
  745.                 return;
  746.             }

  748.             ngx_log_error(NGX_LOG_ALERT, ev->log, err, "read(eventfd) failed");
  749.             return;
  750.         }

  752.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  753.                       "read(eventfd) returned only %d bytes", n);
  754.         return;
  755.     }

  757.     ts.tv_sec = 0;
  758.     ts.tv_nsec = 0;

  760.     while (ready) {

  762.         events = io_getevents(ngx_aio_ctx, 1, 64, event, &ts);

  764.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  765.                        "io_getevents: %l", events);

  767.         if (events > 0) {
  768.             ready -= events;

  770.             for (i = 0; i < events; i++) {

  772.                 ngx_log_debug4(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  773.                                "io_event: %uXL %uXL %L %L",
  774.                                 event[i].data, event[i].obj,
  775.                                 event[i].res, event[i].res2);

  777.                 e = (ngx_event_t *) (uintptr_t) event[i].data;

  779.                 e->complete = 1;
  780.                 e->active = 0;
  781.                 e->ready = 1;

  783.                 aio = e->data;
  784.                 aio->res = event[i].res;

  786.                 ngx_post_event(e, &ngx_posted_events);
  787.             }

  789.             continue;
  790.         }

  792.         if (events == 0) {
  793.             return;
  794.         }

  796.         /* events == -1 */
  797.         ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  798.                       "io_getevents() failed");
  799.         return;
  800.     }
  801. }

  803. #endif


  806. static void *
  807. ‌ngx_epoll_create_conf(ngx_cycle_t *cycle)
  808. {
  809.     ngx_epoll_conf_t  *epcf;

  811.     epcf = ngx_palloc(cycle->pool, sizeof(ngx_epoll_conf_t));
  812.     if (epcf == NULL) {
  813.         return NULL;
  814.     }

  816.     epcf->events = NGX_CONF_UNSET;
  817.     epcf->aio_requests = NGX_CONF_UNSET;

  819.     return epcf;
  820. }


  823. static char *
  824. ‌ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf)
  825. {
  826.     ngx_epoll_conf_t *epcf = conf;

  828.     ngx_conf_init_uint_value(epcf->events, 512);
  829.     ngx_conf_init_uint_value(epcf->aio_requests, 32);

  831.     return NGX_CONF_OK;
  832. }

One Level Up Top Level