One Level Up Top Level

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

Global variables defined

Functions 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. static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  14. static void ngx_poll_done(ngx_cycle_t *cycle);
  15. static ngx_int_t ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event,
  16.     ngx_uint_t flags);
  17. static ngx_int_t ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event,
  18.     ngx_uint_t flags);
  19. static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  20.     ngx_uint_t flags);
  21. static char *ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf);


  24. ‌static struct pollfd  *event_list;
  25. ‌static ngx_uint_t      nevents;


  28. ‌static ngx_str_t    poll_name = ngx_string("poll");

  30. ‌ngx_event_module_t  ngx_poll_module_ctx = {
  31.     &poll_name,
  32.     NULL,                                  /* create configuration */
  33.     ngx_poll_init_conf,                    /* init configuration */

  35.     {
  36.         ngx_poll_add_event,                /* add an event */
  37.         ngx_poll_del_event,                /* delete an event */
  38.         ngx_poll_add_event,                /* enable an event */
  39.         ngx_poll_del_event,                /* disable an event */
  40.         NULL,                              /* add an connection */
  41.         NULL,                              /* delete an connection */
  42.         NULL,                              /* process the changes */
  43.         ngx_poll_process_events,           /* process the events */
  44.         ngx_poll_init,                     /* init the events */
  45.         ngx_poll_done                      /* done the events */
  46.     }

  48. };

  50. ‌ngx_module_t  ngx_poll_module = {
  51.     NGX_MODULE_V1,
  52.     &ngx_poll_module_ctx,                  /* module context */
  53.     NULL,                                  /* module directives */
  54.     NGX_EVENT_MODULE,                      /* module type */
  55.     NULL,                                  /* init master */
  56.     NULL,                                  /* init module */
  57.     NULL,                                  /* init process */
  58.     NULL,                                  /* init thread */
  59.     NULL,                                  /* exit thread */
  60.     NULL,                                  /* exit process */
  61.     NULL,                                  /* exit master */
  62.     NGX_MODULE_V1_PADDING
  63. };



  67. static ngx_int_t
  68. ‌ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  69. {
  70.     struct pollfd   *list;

  72.     if (event_list == NULL) {
  73.         nevents = 0;
  74.     }

  76.     if (ngx_process >= NGX_PROCESS_WORKER
  77.         || cycle->old_cycle == NULL
  78.         || cycle->old_cycle->connection_n < cycle->connection_n)
  79.     {
  80.         list = ngx_alloc(sizeof(struct pollfd) * cycle->connection_n,
  81.                          cycle->log);
  82.         if (list == NULL) {
  83.             return NGX_ERROR;
  84.         }

  86.         if (event_list) {
  87.             ngx_memcpy(list, event_list, sizeof(ngx_event_t *) * nevents);
  88.             ngx_free(event_list);
  89.         }

  91.         event_list = list;
  92.     }

  94.     ngx_io = ngx_os_io;

  96.     ngx_event_actions = ngx_poll_module_ctx.actions;

  98.     ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_FD_EVENT;

  100.     return NGX_OK;
  101. }


  104. static void
  105. ‌ngx_poll_done(ngx_cycle_t *cycle)
  106. {
  107.     ngx_free(event_list);

  109.     event_list = NULL;
  110. }


  113. static ngx_int_t
  114. ‌ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  115. {
  116.     ngx_event_t       *e;
  117.     ngx_connection_t  *c;

  119.     c = ev->data;

  121.     ev->active = 1;

  123.     if (ev->index != NGX_INVALID_INDEX) {
  124.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  125.                       "poll event fd:%d ev:%i is already set", c->fd, event);
  126.         return NGX_OK;
  127.     }

  129.     if (event == NGX_READ_EVENT) {
  130.         e = c->write;
  131. #if (NGX_READ_EVENT != POLLIN)
  132.         event = POLLIN;
  133. #endif

  135.     } else {
  136.         e = c->read;
  137. #if (NGX_WRITE_EVENT != POLLOUT)
  138.         event = POLLOUT;
  139. #endif
  140.     }

  142.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  143.                    "poll add event: fd:%d ev:%i", c->fd, event);

  145.     if (e == NULL || e->index == NGX_INVALID_INDEX) {
  146.         event_list[nevents].fd = c->fd;
  147.         event_list[nevents].events = (short) event;
  148.         event_list[nevents].revents = 0;

  150.         ev->index = nevents;
  151.         nevents++;

  153.     } else {
  154.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  155.                        "poll add index: %i", e->index);

  157.         event_list[e->index].events |= (short) event;
  158.         ev->index = e->index;
  159.     }

  161.     return NGX_OK;
  162. }


  165. static ngx_int_t
  166. ‌ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  167. {
  168.     ngx_event_t       *e;
  169.     ngx_connection_t  *c;

  171.     c = ev->data;

  173.     ev->active = 0;

  175.     if (ev->index == NGX_INVALID_INDEX) {
  176.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  177.                       "poll event fd:%d ev:%i is already deleted",
  178.                       c->fd, event);
  179.         return NGX_OK;
  180.     }

  182.     if (event == NGX_READ_EVENT) {
  183.         e = c->write;
  184. #if (NGX_READ_EVENT != POLLIN)
  185.         event = POLLIN;
  186. #endif

  188.     } else {
  189.         e = c->read;
  190. #if (NGX_WRITE_EVENT != POLLOUT)
  191.         event = POLLOUT;
  192. #endif
  193.     }

  195.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  196.                    "poll del event: fd:%d ev:%i", c->fd, event);

  198.     if (e == NULL || e->index == NGX_INVALID_INDEX) {
  199.         nevents--;

  201.         if (ev->index < nevents) {

  203.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  204.                            "index: copy event %ui to %i", nevents, ev->index);

  206.             event_list[ev->index] = event_list[nevents];

  208.             c = ngx_cycle->files[event_list[nevents].fd];

  210.             if (c->fd == -1) {
  211.                 ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  212.                               "unexpected last event");

  214.             } else {
  215.                 if (c->read->index == nevents) {
  216.                     c->read->index = ev->index;
  217.                 }

  219.                 if (c->write->index == nevents) {
  220.                     c->write->index = ev->index;
  221.                 }
  222.             }
  223.         }

  225.     } else {
  226.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  227.                        "poll del index: %i", e->index);

  229.         event_list[e->index].events &= (short) ~event;
  230.     }

  232.     ev->index = NGX_INVALID_INDEX;

  234.     return NGX_OK;
  235. }


  238. static ngx_int_t
  239. ‌ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
  240. {
  241.     int                 ready, revents;
  242.     ngx_err_t           err;
  243.     ngx_uint_t          i, found, level;
  244.     ngx_event_t        *ev;
  245.     ngx_queue_t        *queue;
  246.     ngx_connection_t   *c;

  248.     /* NGX_TIMER_INFINITE == INFTIM */

  250. #if (NGX_DEBUG0)
  251.     if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
  252.         for (i = 0; i < nevents; i++) {
  253.             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  254.                            "poll: %ui: fd:%d ev:%04Xd",
  255.                            i, event_list[i].fd, event_list[i].events);
  256.         }
  257.     }
  258. #endif

  260.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);

  262.     ready = poll(event_list, (u_int) nevents, (int) timer);

  264.     err = (ready == -1) ? ngx_errno : 0;

  266.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  267.         ngx_time_update();
  268.     }

  270.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  271.                    "poll ready %d of %ui", ready, nevents);

  273.     if (err) {
  274.         if (err == NGX_EINTR) {

  276.             if (ngx_event_timer_alarm) {
  277.                 ngx_event_timer_alarm = 0;
  278.                 return NGX_OK;
  279.             }

  281.             level = NGX_LOG_INFO;

  283.         } else {
  284.             level = NGX_LOG_ALERT;
  285.         }

  287.         ngx_log_error(level, cycle->log, err, "poll() failed");
  288.         return NGX_ERROR;
  289.     }

  291.     if (ready == 0) {
  292.         if (timer != NGX_TIMER_INFINITE) {
  293.             return NGX_OK;
  294.         }

  296.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  297.                       "poll() returned no events without timeout");
  298.         return NGX_ERROR;
  299.     }

  301.     for (i = 0; i < nevents && ready; i++) {

  303.         revents = event_list[i].revents;

  305. #if 1
  306.         ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  307.                        "poll: %ui: fd:%d ev:%04Xd rev:%04Xd",
  308.                        i, event_list[i].fd, event_list[i].events, revents);
  309. #else
  310.         if (revents) {
  311.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  312.                            "poll: %ui: fd:%d ev:%04Xd rev:%04Xd",
  313.                            i, event_list[i].fd, event_list[i].events, revents);
  314.         }
  315. #endif

  317.         if (revents & POLLNVAL) {
  318.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  319.                           "poll() error fd:%d ev:%04Xd rev:%04Xd",
  320.                           event_list[i].fd, event_list[i].events, revents);
  321.         }

  323.         if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
  324.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  325.                           "strange poll() events fd:%d ev:%04Xd rev:%04Xd",
  326.                           event_list[i].fd, event_list[i].events, revents);
  327.         }

  329.         if (event_list[i].fd == -1) {
  330.             /*
  331.              * the disabled event, a workaround for our possible bug,
  332.              * see the comment below
  333.              */
  334.             continue;
  335.         }

  337.         c = ngx_cycle->files[event_list[i].fd];

  339.         if (c->fd == -1) {
  340.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");

  342.             /*
  343.              * it is certainly our fault and it should be investigated,
  344.              * in the meantime we disable this event to avoid a CPU spinning
  345.              */

  347.             if (i == nevents - 1) {
  348.                 nevents--;
  349.             } else {
  350.                 event_list[i].fd = -1;
  351.             }

  353.             continue;
  354.         }

  356.         if ((revents & (POLLERR|POLLHUP|POLLNVAL))
  357.              && (revents & (POLLIN|POLLOUT)) == 0)
  358.         {
  359.             /*
  360.              * if the error events were returned without POLLIN or POLLOUT,
  361.              * then add these flags to handle the events at least in one
  362.              * active handler
  363.              */

  365.             revents |= POLLIN|POLLOUT;
  366.         }

  368.         found = 0;

  370.         if ((revents & POLLIN) && c->read->active) {
  371.             found = 1;

  373.             ev = c->read;
  374.             ev->ready = 1;

  376.             queue = ev->accept ? &ngx_posted_accept_events
  377.                                : &ngx_posted_events;

  379.             ngx_post_event(ev, queue);
  380.         }

  382.         if ((revents & POLLOUT) && c->write->active) {
  383.             found = 1;

  385.             ev = c->write;
  386.             ev->ready = 1;

  388.             ngx_post_event(ev, &ngx_posted_events);
  389.         }

  391.         if (found) {
  392.             ready--;
  393.             continue;
  394.         }
  395.     }

  397.     if (ready != 0) {
  398.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
  399.     }

  401.     return NGX_OK;
  402. }


  405. static char *
  406. ‌ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf)
  407. {
  408.     ngx_event_conf_t  *ecf;

  410.     ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);

  412.     if (ecf->use != ngx_poll_module.ctx_index) {
  413.         return NGX_CONF_OK;
  414.     }

  416. #if (NGX_THREADS)

  418.     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  419.                   "poll() is not supported in the threaded mode");
  420.     return NGX_CONF_ERROR;

  422. #else

  424.     return NGX_CONF_OK;

  426. #endif
  427. }

One Level Up Top Level