One Level Up Top Level

src/event/modules/ngx_eventport_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_EVENTPORT)

  15. ‌#define ushort_t  u_short
  16. ‌#define uint_t    u_int

  18. #ifndef CLOCK_REALTIME
  19. ‌#define CLOCK_REALTIME          0
  20. ‌typedef int     clockid_t;
  21. ‌typedef void *  timer_t;
  22. #endif

  24. /* Solaris declarations */

  26. ‌#define PORT_SOURCE_AIO         1
  27. ‌#define PORT_SOURCE_TIMER       2
  28. ‌#define PORT_SOURCE_USER        3
  29. ‌#define PORT_SOURCE_FD          4
  30. ‌#define PORT_SOURCE_ALERT       5
  31. ‌#define PORT_SOURCE_MQ          6

  33. #ifndef ETIME
  34. ‌#define ETIME                   64
  35. #endif

  37. ‌#define SIGEV_PORT              4

  39. typedef struct {
  40.     int         portev_events;  /* event data is source specific */
  41.     ushort_t    portev_source;  /* event source */
  42.     ushort_t    portev_pad;     /* port internal use */
  43.     uintptr_t   portev_object;  /* source specific object */
  44.     void       *portev_user;    /* user cookie */
  45. ‌} port_event_t;

  47. ‌typedef struct  port_notify {
  48.     int         portnfy_port;   /* bind request(s) to port */
  49.     void       *portnfy_user;   /* user defined */
  50. ‌} port_notify_t;

  52. #if (__FreeBSD_version < 700005)

  54. ‌typedef struct itimerspec {     /* definition per POSIX.4 */
  55.     struct timespec it_interval;/* timer period */
  56.     struct timespec it_value;   /* timer expiration */
  57. ‌} itimerspec_t;

  59. #endif

  61. int port_create(void);

  63. ‌int port_create(void)
  64. {
  65.     return -1;
  66. }


  69. int port_associate(int port, int source, uintptr_t object, int events,
  70.     void *user);

  72. ‌int port_associate(int port, int source, uintptr_t object, int events,
  73.     void *user)
  74. {
  75.     return -1;
  76. }


  79. int port_dissociate(int port, int source, uintptr_t object);

  81. ‌int port_dissociate(int port, int source, uintptr_t object)
  82. {
  83.     return -1;
  84. }


  87. int port_getn(int port, port_event_t list[], uint_t max, uint_t *nget,
  88.     struct timespec *timeout);

  90. ‌int port_getn(int port, port_event_t list[], uint_t max, uint_t *nget,
  91.     struct timespec *timeout)
  92. {
  93.     return -1;
  94. }


  97. int timer_create(clockid_t clock_id, struct sigevent *evp, timer_t *timerid);

  99. ‌int timer_create(clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
  100. {
  101.     return -1;
  102. }


  105. int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
  106.     struct itimerspec *ovalue);

  108. ‌int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
  109.     struct itimerspec *ovalue)
  110. {
  111.     return -1;
  112. }


  115. int timer_delete(timer_t timerid);

  117. ‌int timer_delete(timer_t timerid)
  118. {
  119.     return -1;
  120. }

  122. #endif


  125. typedef struct {
  126.     ngx_uint_t  events;
  127. ‌} ngx_eventport_conf_t;


  130. static ngx_int_t ngx_eventport_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  131. static void ngx_eventport_done(ngx_cycle_t *cycle);
  132. static ngx_int_t ngx_eventport_add_event(ngx_event_t *ev, ngx_int_t event,
  133.     ngx_uint_t flags);
  134. static ngx_int_t ngx_eventport_del_event(ngx_event_t *ev, ngx_int_t event,
  135.     ngx_uint_t flags);
  136. static ngx_int_t ngx_eventport_process_events(ngx_cycle_t *cycle,
  137.     ngx_msec_t timer, ngx_uint_t flags);

  139. static void *ngx_eventport_create_conf(ngx_cycle_t *cycle);
  140. static char *ngx_eventport_init_conf(ngx_cycle_t *cycle, void *conf);

  142. ‌static int            ep = -1;
  143. ‌static port_event_t  *event_list;
  144. ‌static ngx_uint_t     nevents;
  145. ‌static timer_t        event_timer = (timer_t) -1;

  147. ‌static ngx_str_t      eventport_name = ngx_string("eventport");


  150. ‌static ngx_command_t  ngx_eventport_commands[] = {

  152.     { ngx_string("eventport_events"),
  153.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  154.       ngx_conf_set_num_slot,
  155.       0,
  156.       offsetof(ngx_eventport_conf_t, events),
  157.       NULL },

  159.       ngx_null_command
  160. };


  163. ‌ngx_event_module_t  ngx_eventport_module_ctx = {
  164.     &eventport_name,
  165.     ngx_eventport_create_conf,             /* create configuration */
  166.     ngx_eventport_init_conf,               /* init configuration */

  168.     {
  169.         ngx_eventport_add_event,           /* add an event */
  170.         ngx_eventport_del_event,           /* delete an event */
  171.         ngx_eventport_add_event,           /* enable an event */
  172.         ngx_eventport_del_event,           /* disable an event */
  173.         NULL,                              /* add an connection */
  174.         NULL,                              /* delete an connection */
  175.         NULL,                              /* process the changes */
  176.         ngx_eventport_process_events,      /* process the events */
  177.         ngx_eventport_init,                /* init the events */
  178.         ngx_eventport_done,                /* done the events */
  179.     }

  181. };

  183. ‌ngx_module_t  ngx_eventport_module = {
  184.     NGX_MODULE_V1,
  185.     &ngx_eventport_module_ctx,             /* module context */
  186.     ngx_eventport_commands,                /* module directives */
  187.     NGX_EVENT_MODULE,                      /* module type */
  188.     NULL,                                  /* init master */
  189.     NULL,                                  /* init module */
  190.     NULL,                                  /* init process */
  191.     NULL,                                  /* init thread */
  192.     NULL,                                  /* exit thread */
  193.     NULL,                                  /* exit process */
  194.     NULL,                                  /* exit master */
  195.     NGX_MODULE_V1_PADDING
  196. };


  199. static ngx_int_t
  200. ‌ngx_eventport_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  201. {
  202.     port_notify_t          pn;
  203.     struct itimerspec      its;
  204.     struct sigevent        sev;
  205.     ngx_eventport_conf_t  *epcf;

  207.     epcf = ngx_event_get_conf(cycle->conf_ctx, ngx_eventport_module);

  209.     if (ep == -1) {
  210.         ep = port_create();

  212.         if (ep == -1) {
  213.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  214.                           "port_create() failed");
  215.             return NGX_ERROR;
  216.         }
  217.     }

  219.     if (nevents < epcf->events) {
  220.         if (event_list) {
  221.             ngx_free(event_list);
  222.         }

  224.         event_list = ngx_alloc(sizeof(port_event_t) * epcf->events,
  225.                                cycle->log);
  226.         if (event_list == NULL) {
  227.             return NGX_ERROR;
  228.         }
  229.     }

  231.     ngx_event_flags = NGX_USE_EVENTPORT_EVENT;

  233.     if (timer) {
  234.         ngx_memzero(&pn, sizeof(port_notify_t));
  235.         pn.portnfy_port = ep;

  237.         ngx_memzero(&sev, sizeof(struct sigevent));
  238.         sev.sigev_notify = SIGEV_PORT;
  239. #if !(NGX_TEST_BUILD_EVENTPORT)
  240.         sev.sigev_value.sival_ptr = &pn;
  241. #endif

  243.         if (timer_create(CLOCK_REALTIME, &sev, &event_timer) == -1) {
  244.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  245.                           "timer_create() failed");
  246.             return NGX_ERROR;
  247.         }

  249.         its.it_interval.tv_sec = timer / 1000;
  250.         its.it_interval.tv_nsec = (timer % 1000) * 1000000;
  251.         its.it_value.tv_sec = timer / 1000;
  252.         its.it_value.tv_nsec = (timer % 1000) * 1000000;

  254.         if (timer_settime(event_timer, 0, &its, NULL) == -1) {
  255.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  256.                           "timer_settime() failed");
  257.             return NGX_ERROR;
  258.         }

  260.         ngx_event_flags |= NGX_USE_TIMER_EVENT;
  261.     }

  263.     nevents = epcf->events;

  265.     ngx_io = ngx_os_io;

  267.     ngx_event_actions = ngx_eventport_module_ctx.actions;

  269.     return NGX_OK;
  270. }


  273. static void
  274. ‌ngx_eventport_done(ngx_cycle_t *cycle)
  275. {
  276.     if (event_timer != (timer_t) -1) {
  277.         if (timer_delete(event_timer) == -1) {
  278.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  279.                           "timer_delete() failed");
  280.         }

  282.         event_timer = (timer_t) -1;
  283.     }

  285.     if (close(ep) == -1) {
  286.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  287.                       "close() event port failed");
  288.     }

  290.     ep = -1;

  292.     ngx_free(event_list);

  294.     event_list = NULL;
  295.     nevents = 0;
  296. }


  299. static ngx_int_t
  300. ‌ngx_eventport_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  301. {
  302.     ngx_int_t          events, prev;
  303.     ngx_event_t       *e;
  304.     ngx_connection_t  *c;

  306.     c = ev->data;

  308.     events = event;

  310.     if (event == NGX_READ_EVENT) {
  311.         e = c->write;
  312.         prev = POLLOUT;
  313. #if (NGX_READ_EVENT != POLLIN)
  314.         events = POLLIN;
  315. #endif

  317.     } else {
  318.         e = c->read;
  319.         prev = POLLIN;
  320. #if (NGX_WRITE_EVENT != POLLOUT)
  321.         events = POLLOUT;
  322. #endif
  323.     }

  325.     if (e->oneshot) {
  326.         events |= prev;
  327.     }

  329.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  330.                    "eventport add event: fd:%d ev:%04Xi", c->fd, events);

  332.     if (port_associate(ep, PORT_SOURCE_FD, c->fd, events,
  333.                        (void *) ((uintptr_t) ev | ev->instance))
  334.         == -1)
  335.     {
  336.         ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  337.                       "port_associate() failed");
  338.         return NGX_ERROR;
  339.     }

  341.     ev->active = 1;
  342.     ev->oneshot = 1;

  344.     return NGX_OK;
  345. }


  348. static ngx_int_t
  349. ‌ngx_eventport_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  350. {
  351.     ngx_event_t       *e;
  352.     ngx_connection_t  *c;

  354.     /*
  355.      * when the file descriptor is closed, the event port automatically
  356.      * dissociates it from the port, so we do not need to dissociate explicitly
  357.      * the event before the closing the file descriptor
  358.      */

  360.     if (flags & NGX_CLOSE_EVENT) {
  361.         ev->active = 0;
  362.         ev->oneshot = 0;
  363.         return NGX_OK;
  364.     }

  366.     c = ev->data;

  368.     if (event == NGX_READ_EVENT) {
  369.         e = c->write;
  370.         event = POLLOUT;

  372.     } else {
  373.         e = c->read;
  374.         event = POLLIN;
  375.     }

  377.     if (e->oneshot) {
  378.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  379.                        "eventport change event: fd:%d ev:%04Xi", c->fd, event);

  381.         if (port_associate(ep, PORT_SOURCE_FD, c->fd, event,
  382.                            (void *) ((uintptr_t) ev | ev->instance))
  383.             == -1)
  384.         {
  385.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  386.                           "port_associate() failed");
  387.             return NGX_ERROR;
  388.         }

  390.     } else {
  391.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  392.                        "eventport del event: fd:%d", c->fd);

  394.         if (port_dissociate(ep, PORT_SOURCE_FD, c->fd) == -1) {
  395.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  396.                           "port_dissociate() failed");
  397.             return NGX_ERROR;
  398.         }
  399.     }

  401.     ev->active = 0;
  402.     ev->oneshot = 0;

  404.     return NGX_OK;
  405. }


  408. ngx_int_t
  409. ‌ngx_eventport_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  410.     ngx_uint_t flags)
  411. {
  412.     int                 n, revents;
  413.     u_int               events;
  414.     ngx_err_t           err;
  415.     ngx_int_t           instance;
  416.     ngx_uint_t          i, level;
  417.     ngx_event_t        *ev, *rev, *wev;
  418.     ngx_queue_t        *queue;
  419.     ngx_connection_t   *c;
  420.     struct timespec     ts, *tp;

  422.     if (timer == NGX_TIMER_INFINITE) {
  423.         tp = NULL;

  425.     } else {
  426.         ts.tv_sec = timer / 1000;
  427.         ts.tv_nsec = (timer % 1000) * 1000000;
  428.         tp = &ts;
  429.     }

  431.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  432.                    "eventport timer: %M", timer);

  434.     events = 1;

  436.     n = port_getn(ep, event_list, (u_int) nevents, &events, tp);

  438.     err = ngx_errno;

  440.     if (flags & NGX_UPDATE_TIME) {
  441.         ngx_time_update();
  442.     }

  444.     if (n == -1) {
  445.         if (err == ETIME) {
  446.             if (timer != NGX_TIMER_INFINITE) {
  447.                 return NGX_OK;
  448.             }

  450.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  451.                           "port_getn() returned no events without timeout");
  452.             return NGX_ERROR;
  453.         }

  455.         level = (err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT;
  456.         ngx_log_error(level, cycle->log, err, "port_getn() failed");
  457.         return NGX_ERROR;
  458.     }

  460.     if (events == 0) {
  461.         if (timer != NGX_TIMER_INFINITE) {
  462.             return NGX_OK;
  463.         }

  465.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  466.                       "port_getn() returned no events without timeout");
  467.         return NGX_ERROR;
  468.     }

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

  472.         if (event_list[i].portev_source == PORT_SOURCE_TIMER) {
  473.             ngx_time_update();
  474.             continue;
  475.         }

  477.         ev = event_list[i].portev_user;

  479.         switch (event_list[i].portev_source) {

  481.         case PORT_SOURCE_FD:

  483.             instance = (uintptr_t) ev & 1;
  484.             ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);

  486.             if (ev->closed || ev->instance != instance) {

  488.                 /*
  489.                  * the stale event from a file descriptor
  490.                  * that was just closed in this iteration
  491.                  */

  493.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  494.                                "eventport: stale event %p", ev);
  495.                 continue;
  496.             }

  498.             revents = event_list[i].portev_events;

  500.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  501.                            "eventport: fd:%d, ev:%04Xd",
  502.                            event_list[i].portev_object, revents);

  504.             if (revents & (POLLERR|POLLHUP|POLLNVAL)) {
  505.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  506.                                "port_getn() error fd:%d ev:%04Xd",
  507.                                event_list[i].portev_object, revents);
  508.             }

  510.             if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
  511.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  512.                               "strange port_getn() events fd:%d ev:%04Xd",
  513.                               event_list[i].portev_object, revents);
  514.             }

  516.             if ((revents & (POLLERR|POLLHUP|POLLNVAL))
  517.                  && (revents & (POLLIN|POLLOUT)) == 0)
  518.             {
  519.                 /*
  520.                  * if the error events were returned without POLLIN or POLLOUT,
  521.                  * then add these flags to handle the events at least in one
  522.                  * active handler
  523.                  */

  525.                 revents |= POLLIN|POLLOUT;
  526.             }

  528.             c = ev->data;
  529.             rev = c->read;
  530.             wev = c->write;

  532.             rev->active = 0;
  533.             wev->active = 0;

  535.             if (revents & POLLIN) {
  536.                 rev->ready = 1;

  538.                 if (flags & NGX_POST_EVENTS) {
  539.                     queue = rev->accept ? &ngx_posted_accept_events
  540.                                         : &ngx_posted_events;

  542.                     ngx_post_event(rev, queue);

  544.                 } else {
  545.                     rev->handler(rev);

  547.                     if (ev->closed || ev->instance != instance) {
  548.                         continue;
  549.                     }
  550.                 }

  552.                 if (rev->accept) {
  553.                     if (ngx_use_accept_mutex) {
  554.                         ngx_accept_events = 1;
  555.                         continue;
  556.                     }

  558.                     if (port_associate(ep, PORT_SOURCE_FD, c->fd, POLLIN,
  559.                                        (void *) ((uintptr_t) ev | ev->instance))
  560.                         == -1)
  561.                     {
  562.                         ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  563.                                       "port_associate() failed");
  564.                         return NGX_ERROR;
  565.                     }
  566.                 }
  567.             }

  569.             if (revents & POLLOUT) {
  570.                 wev->ready = 1;

  572.                 if (flags & NGX_POST_EVENTS) {
  573.                     ngx_post_event(wev, &ngx_posted_events);

  575.                 } else {
  576.                     wev->handler(wev);
  577.                 }
  578.             }

  580.             continue;

  582.         default:
  583.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  584.                           "unexpected even_port object %d",
  585.                           event_list[i].portev_object);
  586.             continue;
  587.         }
  588.     }

  590.     return NGX_OK;
  591. }


  594. static void *
  595. ‌ngx_eventport_create_conf(ngx_cycle_t *cycle)
  596. {
  597.     ngx_eventport_conf_t  *epcf;

  599.     epcf = ngx_palloc(cycle->pool, sizeof(ngx_eventport_conf_t));
  600.     if (epcf == NULL) {
  601.         return NULL;
  602.     }

  604.     epcf->events = NGX_CONF_UNSET;

  606.     return epcf;
  607. }


  610. static char *
  611. ‌ngx_eventport_init_conf(ngx_cycle_t *cycle, void *conf)
  612. {
  613.     ngx_eventport_conf_t *epcf = conf;

  615.     ngx_conf_init_uint_value(epcf->events, 32);

  617.     return NGX_CONF_OK;
  618. }

One Level Up Top Level