One Level Up Top Level

src/event/modules/ngx_devpoll_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_DEVPOLL)

  15. /* Solaris declarations */

  17. ‌#define POLLREMOVE   0x0800
  18. ‌#define DP_POLL      0xD001
  19. ‌#define DP_ISPOLLED  0xD002

  21. ‌struct dvpoll {
  22.     struct pollfd  *dp_fds;
  23.     int             dp_nfds;
  24.     int             dp_timeout;
  25. };

  27. #endif


  30. typedef struct {
  31.     ngx_uint_t      changes;
  32.     ngx_uint_t      events;
  33. ‌} ngx_devpoll_conf_t;


  36. static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  37. static void ngx_devpoll_done(ngx_cycle_t *cycle);
  38. static ngx_int_t ngx_devpoll_add_event(ngx_event_t *ev, ngx_int_t event,
  39.     ngx_uint_t flags);
  40. static ngx_int_t ngx_devpoll_del_event(ngx_event_t *ev, ngx_int_t event,
  41.     ngx_uint_t flags);
  42. static ngx_int_t ngx_devpoll_set_event(ngx_event_t *ev, ngx_int_t event,
  43.     ngx_uint_t flags);
  44. static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle,
  45.     ngx_msec_t timer, ngx_uint_t flags);

  47. static void *ngx_devpoll_create_conf(ngx_cycle_t *cycle);
  48. static char *ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf);

  50. ‌static int              dp = -1;
  51. ‌‌static struct pollfd   *change_list, *event_list;
  52. ‌‌‌static ngx_uint_t       nchanges, max_changes, nevents;

  54. ‌static ngx_event_t    **change_index;


  57. ‌static ngx_str_t      devpoll_name = ngx_string("/dev/poll");

  59. ‌static ngx_command_t  ngx_devpoll_commands[] = {

  61.     { ngx_string("devpoll_changes"),
  62.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  63.       ngx_conf_set_num_slot,
  64.       0,
  65.       offsetof(ngx_devpoll_conf_t, changes),
  66.       NULL },

  68.     { ngx_string("devpoll_events"),
  69.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  70.       ngx_conf_set_num_slot,
  71.       0,
  72.       offsetof(ngx_devpoll_conf_t, events),
  73.       NULL },

  75.       ngx_null_command
  76. };


  79. ‌ngx_event_module_t  ngx_devpoll_module_ctx = {
  80.     &devpoll_name,
  81.     ngx_devpoll_create_conf,               /* create configuration */
  82.     ngx_devpoll_init_conf,                 /* init configuration */

  84.     {
  85.         ngx_devpoll_add_event,             /* add an event */
  86.         ngx_devpoll_del_event,             /* delete an event */
  87.         ngx_devpoll_add_event,             /* enable an event */
  88.         ngx_devpoll_del_event,             /* disable an event */
  89.         NULL,                              /* add an connection */
  90.         NULL,                              /* delete an connection */
  91.         NULL,                              /* process the changes */
  92.         ngx_devpoll_process_events,        /* process the events */
  93.         ngx_devpoll_init,                  /* init the events */
  94.         ngx_devpoll_done,                  /* done the events */
  95.     }

  97. };

  99. ‌ngx_module_t  ngx_devpoll_module = {
  100.     NGX_MODULE_V1,
  101.     &ngx_devpoll_module_ctx,               /* module context */
  102.     ngx_devpoll_commands,                  /* module directives */
  103.     NGX_EVENT_MODULE,                      /* module type */
  104.     NULL,                                  /* init master */
  105.     NULL,                                  /* init module */
  106.     NULL,                                  /* init process */
  107.     NULL,                                  /* init thread */
  108.     NULL,                                  /* exit thread */
  109.     NULL,                                  /* exit process */
  110.     NULL,                                  /* exit master */
  111.     NGX_MODULE_V1_PADDING
  112. };


  115. static ngx_int_t
  116. ‌ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  117. {
  118.     size_t               n;
  119.     ngx_devpoll_conf_t  *dpcf;

  121.     dpcf = ngx_event_get_conf(cycle->conf_ctx, ngx_devpoll_module);

  123.     if (dp == -1) {
  124.         dp = open("/dev/poll", O_RDWR);

  126.         if (dp == -1) {
  127.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  128.                           "open(/dev/poll) failed");
  129.             return NGX_ERROR;
  130.         }
  131.     }

  133.     if (max_changes < dpcf->changes) {
  134.         if (nchanges) {
  135.             n = nchanges * sizeof(struct pollfd);
  136.             if (write(dp, change_list, n) != (ssize_t) n) {
  137.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  138.                               "write(/dev/poll) failed");
  139.                 return NGX_ERROR;
  140.             }

  142.             nchanges = 0;
  143.         }

  145.         if (change_list) {
  146.             ngx_free(change_list);
  147.         }

  149.         change_list = ngx_alloc(sizeof(struct pollfd) * dpcf->changes,
  150.                                 cycle->log);
  151.         if (change_list == NULL) {
  152.             return NGX_ERROR;
  153.         }

  155.         if (change_index) {
  156.             ngx_free(change_index);
  157.         }

  159.         change_index = ngx_alloc(sizeof(ngx_event_t *) * dpcf->changes,
  160.                                  cycle->log);
  161.         if (change_index == NULL) {
  162.             return NGX_ERROR;
  163.         }
  164.     }

  166.     max_changes = dpcf->changes;

  168.     if (nevents < dpcf->events) {
  169.         if (event_list) {
  170.             ngx_free(event_list);
  171.         }

  173.         event_list = ngx_alloc(sizeof(struct pollfd) * dpcf->events,
  174.                                cycle->log);
  175.         if (event_list == NULL) {
  176.             return NGX_ERROR;
  177.         }
  178.     }

  180.     nevents = dpcf->events;

  182.     ngx_io = ngx_os_io;

  184.     ngx_event_actions = ngx_devpoll_module_ctx.actions;

  186.     ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_FD_EVENT;

  188.     return NGX_OK;
  189. }


  192. static void
  193. ‌ngx_devpoll_done(ngx_cycle_t *cycle)
  194. {
  195.     if (close(dp) == -1) {
  196.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  197.                       "close(/dev/poll) failed");
  198.     }

  200.     dp = -1;

  202.     ngx_free(change_list);
  203.     ngx_free(event_list);
  204.     ngx_free(change_index);

  206.     change_list = NULL;
  207.     event_list = NULL;
  208.     change_index = NULL;
  209.     max_changes = 0;
  210.     nchanges = 0;
  211.     nevents = 0;
  212. }


  215. static ngx_int_t
  216. ‌ngx_devpoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  217. {
  218. #if (NGX_DEBUG)
  219.     ngx_connection_t *c;
  220. #endif

  222. #if (NGX_READ_EVENT != POLLIN)
  223.     event = (event == NGX_READ_EVENT) ? POLLIN : POLLOUT;
  224. #endif

  226. #if (NGX_DEBUG)
  227.     c = ev->data;
  228.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  229.                    "devpoll add event: fd:%d ev:%04Xi", c->fd, event);
  230. #endif

  232.     ev->active = 1;

  234.     return ngx_devpoll_set_event(ev, event, 0);
  235. }


  238. static ngx_int_t
  239. ‌ngx_devpoll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  240. {
  241.     ngx_event_t       *e;
  242.     ngx_connection_t  *c;

  244.     c = ev->data;

  246. #if (NGX_READ_EVENT != POLLIN)
  247.     event = (event == NGX_READ_EVENT) ? POLLIN : POLLOUT;
  248. #endif

  250.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  251.                    "devpoll del event: fd:%d ev:%04Xi", c->fd, event);

  253.     if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) {
  254.         return NGX_ERROR;
  255.     }

  257.     ev->active = 0;

  259.     if (flags & NGX_CLOSE_EVENT) {
  260.         e = (event == POLLIN) ? c->write : c->read;

  262.         if (e) {
  263.             e->active = 0;
  264.         }

  266.         return NGX_OK;
  267.     }

  269.     /* restore the pair event if it exists */

  271.     if (event == POLLIN) {
  272.         e = c->write;
  273.         event = POLLOUT;

  275.     } else {
  276.         e = c->read;
  277.         event = POLLIN;
  278.     }

  280.     if (e && e->active) {
  281.         return ngx_devpoll_set_event(e, event, 0);
  282.     }

  284.     return NGX_OK;
  285. }


  288. static ngx_int_t
  289. ‌ngx_devpoll_set_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  290. {
  291.     size_t             n;
  292.     ngx_connection_t  *c;

  294.     c = ev->data;

  296.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  297.                    "devpoll fd:%d ev:%04Xi fl:%04Xi", c->fd, event, flags);

  299.     if (nchanges >= max_changes) {
  300.         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
  301.                       "/dev/pool change list is filled up");

  303.         n = nchanges * sizeof(struct pollfd);
  304.         if (write(dp, change_list, n) != (ssize_t) n) {
  305.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  306.                           "write(/dev/poll) failed");
  307.             return NGX_ERROR;
  308.         }

  310.         nchanges = 0;
  311.     }

  313.     change_list[nchanges].fd = c->fd;
  314.     change_list[nchanges].events = (short) event;
  315.     change_list[nchanges].revents = 0;

  317.     change_index[nchanges] = ev;
  318.     ev->index = nchanges;

  320.     nchanges++;

  322.     if (flags & NGX_CLOSE_EVENT) {
  323.         n = nchanges * sizeof(struct pollfd);
  324.         if (write(dp, change_list, n) != (ssize_t) n) {
  325.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
  326.                           "write(/dev/poll) failed");
  327.             return NGX_ERROR;
  328.         }

  330.         nchanges = 0;
  331.     }

  333.     return NGX_OK;
  334. }


  337. ngx_int_t
  338. ‌ngx_devpoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  339.     ngx_uint_t flags)
  340. {
  341.     int                 events, revents, rc;
  342.     size_t              n;
  343.     ngx_fd_t            fd;
  344.     ngx_err_t           err;
  345.     ngx_int_t           i;
  346.     ngx_uint_t          level, instance;
  347.     ngx_event_t        *rev, *wev;
  348.     ngx_queue_t        *queue;
  349.     ngx_connection_t   *c;
  350.     struct pollfd       pfd;
  351.     struct dvpoll       dvp;

  353.     /* NGX_TIMER_INFINITE == INFTIM */

  355.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  356.                    "devpoll timer: %M", timer);

  358.     if (nchanges) {
  359.         n = nchanges * sizeof(struct pollfd);
  360.         if (write(dp, change_list, n) != (ssize_t) n) {
  361.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  362.                           "write(/dev/poll) failed");
  363.             return NGX_ERROR;
  364.         }

  366.         nchanges = 0;
  367.     }

  369.     dvp.dp_fds = event_list;
  370.     dvp.dp_nfds = (int) nevents;
  371.     dvp.dp_timeout = timer;
  372.     events = ioctl(dp, DP_POLL, &dvp);

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

  376.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  377.         ngx_time_update();
  378.     }

  380.     if (err) {
  381.         if (err == NGX_EINTR) {

  383.             if (ngx_event_timer_alarm) {
  384.                 ngx_event_timer_alarm = 0;
  385.                 return NGX_OK;
  386.             }

  388.             level = NGX_LOG_INFO;

  390.         } else {
  391.             level = NGX_LOG_ALERT;
  392.         }

  394.         ngx_log_error(level, cycle->log, err, "ioctl(DP_POLL) failed");
  395.         return NGX_ERROR;
  396.     }

  398.     if (events == 0) {
  399.         if (timer != NGX_TIMER_INFINITE) {
  400.             return NGX_OK;
  401.         }

  403.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  404.                       "ioctl(DP_POLL) returned no events without timeout");
  405.         return NGX_ERROR;
  406.     }

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

  410.         fd = event_list[i].fd;
  411.         revents = event_list[i].revents;

  413.         c = ngx_cycle->files[fd];

  415.         if (c == NULL || c->fd == -1) {

  417.             pfd.fd = fd;
  418.             pfd.events = 0;
  419.             pfd.revents = 0;

  421.             rc = ioctl(dp, DP_ISPOLLED, &pfd);

  423.             switch (rc) {

  425.             case -1:
  426.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  427.                     "ioctl(DP_ISPOLLED) failed for socket %d, event %04Xd",
  428.                     fd, revents);
  429.                 break;

  431.             case 0:
  432.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  433.                     "phantom event %04Xd for closed and removed socket %d",
  434.                     revents, fd);
  435.                 break;

  437.             default:
  438.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  439.                     "unexpected event %04Xd for closed and removed socket %d, ",
  440.                     "ioctl(DP_ISPOLLED) returned rc:%d, fd:%d, event %04Xd",
  441.                     revents, fd, rc, pfd.fd, pfd.revents);

  443.                 pfd.fd = fd;
  444.                 pfd.events = POLLREMOVE;
  445.                 pfd.revents = 0;

  447.                 if (write(dp, &pfd, sizeof(struct pollfd))
  448.                     != (ssize_t) sizeof(struct pollfd))
  449.                 {
  450.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  451.                                   "write(/dev/poll) for %d failed", fd);
  452.                 }

  454.                 if (close(fd) == -1) {
  455.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  456.                                   "close(%d) failed", fd);
  457.                 }

  459.                 break;
  460.             }

  462.             continue;
  463.         }

  465.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  466.                        "devpoll: fd:%d, ev:%04Xd, rev:%04Xd",
  467.                        fd, event_list[i].events, revents);

  469.         if (revents & (POLLERR|POLLHUP|POLLNVAL)) {
  470.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  471.                           "ioctl(DP_POLL) error fd:%d ev:%04Xd rev:%04Xd",
  472.                           fd, event_list[i].events, revents);
  473.         }

  475.         if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
  476.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  477.                           "strange ioctl(DP_POLL) events "
  478.                           "fd:%d ev:%04Xd rev:%04Xd",
  479.                           fd, event_list[i].events, revents);
  480.         }

  482.         if ((revents & (POLLERR|POLLHUP|POLLNVAL))
  483.              && (revents & (POLLIN|POLLOUT)) == 0)
  484.         {
  485.             /*
  486.              * if the error events were returned without POLLIN or POLLOUT,
  487.              * then add these flags to handle the events at least in one
  488.              * active handler
  489.              */

  491.             revents |= POLLIN|POLLOUT;
  492.         }

  494.         rev = c->read;

  496.         if ((revents & POLLIN) && rev->active) {
  497.             rev->ready = 1;

  499.             if (flags & NGX_POST_EVENTS) {
  500.                 queue = rev->accept ? &ngx_posted_accept_events
  501.                                     : &ngx_posted_events;

  503.                 ngx_post_event(rev, queue);

  505.             } else {
  506.                 instance = rev->instance;

  508.                 rev->handler(rev);

  510.                 if (c->fd == -1 || rev->instance != instance) {
  511.                     continue;
  512.                 }
  513.             }
  514.         }

  516.         wev = c->write;

  518.         if ((revents & POLLOUT) && wev->active) {
  519.             wev->ready = 1;

  521.             if (flags & NGX_POST_EVENTS) {
  522.                 ngx_post_event(wev, &ngx_posted_events);

  524.             } else {
  525.                 wev->handler(wev);
  526.             }
  527.         }
  528.     }

  530.     return NGX_OK;
  531. }


  534. static void *
  535. ‌ngx_devpoll_create_conf(ngx_cycle_t *cycle)
  536. {
  537.     ngx_devpoll_conf_t  *dpcf;

  539.     dpcf = ngx_palloc(cycle->pool, sizeof(ngx_devpoll_conf_t));
  540.     if (dpcf == NULL) {
  541.         return NULL;
  542.     }

  544.     dpcf->changes = NGX_CONF_UNSET;
  545.     dpcf->events = NGX_CONF_UNSET;

  547.     return dpcf;
  548. }


  551. static char *
  552. ‌ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf)
  553. {
  554.     ngx_devpoll_conf_t *dpcf = conf;

  556.     ngx_conf_init_uint_value(dpcf->changes, 32);
  557.     ngx_conf_init_uint_value(dpcf->events, 32);

  559.     return NGX_CONF_OK;
  560. }

One Level Up Top Level