One Level Up Top Level

src/event/modules/ngx_select_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_select_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  14. static void ngx_select_done(ngx_cycle_t *cycle);
  15. static ngx_int_t ngx_select_add_event(ngx_event_t *ev, ngx_int_t event,
  16.     ngx_uint_t flags);
  17. static ngx_int_t ngx_select_del_event(ngx_event_t *ev, ngx_int_t event,
  18.     ngx_uint_t flags);
  19. static ngx_int_t ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  20.     ngx_uint_t flags);
  21. static void ngx_select_repair_fd_sets(ngx_cycle_t *cycle);
  22. static char *ngx_select_init_conf(ngx_cycle_t *cycle, void *conf);


  25. ‌static fd_set         master_read_fd_set;
  26. ‌static fd_set         master_write_fd_set;
  27. ‌static fd_set         work_read_fd_set;
  28. ‌static fd_set         work_write_fd_set;

  30. ‌static ngx_int_t      max_fd;
  31. ‌static ngx_uint_t     nevents;

  33. ‌static ngx_event_t  **event_index;


  36. ‌static ngx_str_t    select_name = ngx_string("select");

  38. ‌ngx_event_module_t  ngx_select_module_ctx = {
  39.     &select_name,
  40.     NULL,                                  /* create configuration */
  41.     ngx_select_init_conf,                  /* init configuration */

  43.     {
  44.         ngx_select_add_event,              /* add an event */
  45.         ngx_select_del_event,              /* delete an event */
  46.         ngx_select_add_event,              /* enable an event */
  47.         ngx_select_del_event,              /* disable an event */
  48.         NULL,                              /* add an connection */
  49.         NULL,                              /* delete an connection */
  50.         NULL,                              /* process the changes */
  51.         ngx_select_process_events,         /* process the events */
  52.         ngx_select_init,                   /* init the events */
  53.         ngx_select_done                    /* done the events */
  54.     }

  56. };

  58. ‌ngx_module_t  ngx_select_module = {
  59.     NGX_MODULE_V1,
  60.     &ngx_select_module_ctx,                /* module context */
  61.     NULL,                                  /* module directives */
  62.     NGX_EVENT_MODULE,                      /* module type */
  63.     NULL,                                  /* init master */
  64.     NULL,                                  /* init module */
  65.     NULL,                                  /* init process */
  66.     NULL,                                  /* init thread */
  67.     NULL,                                  /* exit thread */
  68.     NULL,                                  /* exit process */
  69.     NULL,                                  /* exit master */
  70.     NGX_MODULE_V1_PADDING
  71. };


  74. static ngx_int_t
  75. ‌ngx_select_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  76. {
  77.     ngx_event_t  **index;

  79.     if (event_index == NULL) {
  80.         FD_ZERO(&master_read_fd_set);
  81.         FD_ZERO(&master_write_fd_set);
  82.         nevents = 0;
  83.     }

  85.     if (ngx_process >= NGX_PROCESS_WORKER
  86.         || cycle->old_cycle == NULL
  87.         || cycle->old_cycle->connection_n < cycle->connection_n)
  88.     {
  89.         index = ngx_alloc(sizeof(ngx_event_t *) * 2 * cycle->connection_n,
  90.                           cycle->log);
  91.         if (index == NULL) {
  92.             return NGX_ERROR;
  93.         }

  95.         if (event_index) {
  96.             ngx_memcpy(index, event_index, sizeof(ngx_event_t *) * nevents);
  97.             ngx_free(event_index);
  98.         }

  100.         event_index = index;
  101.     }

  103.     ngx_io = ngx_os_io;

  105.     ngx_event_actions = ngx_select_module_ctx.actions;

  107.     ngx_event_flags = NGX_USE_LEVEL_EVENT;

  109.     max_fd = -1;

  111.     return NGX_OK;
  112. }


  115. static void
  116. ‌ngx_select_done(ngx_cycle_t *cycle)
  117. {
  118.     ngx_free(event_index);

  120.     event_index = NULL;
  121. }


  124. static ngx_int_t
  125. ‌ngx_select_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  126. {
  127.     ngx_connection_t  *c;

  129.     c = ev->data;

  131.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  132.                    "select add event fd:%d ev:%i", c->fd, event);

  134.     if (ev->index != NGX_INVALID_INDEX) {
  135.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  136.                       "select event fd:%d ev:%i is already set", c->fd, event);
  137.         return NGX_OK;
  138.     }

  140.     if ((event == NGX_READ_EVENT && ev->write)
  141.         || (event == NGX_WRITE_EVENT && !ev->write))
  142.     {
  143.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  144.                       "invalid select %s event fd:%d ev:%i",
  145.                       ev->write ? "write" : "read", c->fd, event);
  146.         return NGX_ERROR;
  147.     }

  149.     if (event == NGX_READ_EVENT) {
  150.         FD_SET(c->fd, &master_read_fd_set);

  152.     } else if (event == NGX_WRITE_EVENT) {
  153.         FD_SET(c->fd, &master_write_fd_set);
  154.     }

  156.     if (max_fd != -1 && max_fd < c->fd) {
  157.         max_fd = c->fd;
  158.     }

  160.     ev->active = 1;

  162.     event_index[nevents] = ev;
  163.     ev->index = nevents;
  164.     nevents++;

  166.     return NGX_OK;
  167. }


  170. static ngx_int_t
  171. ‌ngx_select_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  172. {
  173.     ngx_event_t       *e;
  174.     ngx_connection_t  *c;

  176.     c = ev->data;

  178.     ev->active = 0;

  180.     if (ev->index == NGX_INVALID_INDEX) {
  181.         return NGX_OK;
  182.     }

  184.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  185.                    "select del event fd:%d ev:%i", c->fd, event);

  187.     if (event == NGX_READ_EVENT) {
  188.         FD_CLR(c->fd, &master_read_fd_set);

  190.     } else if (event == NGX_WRITE_EVENT) {
  191.         FD_CLR(c->fd, &master_write_fd_set);
  192.     }

  194.     if (max_fd == c->fd) {
  195.         max_fd = -1;
  196.     }

  198.     if (ev->index < --nevents) {
  199.         e = event_index[nevents];
  200.         event_index[ev->index] = e;
  201.         e->index = ev->index;
  202.     }

  204.     ev->index = NGX_INVALID_INDEX;

  206.     return NGX_OK;
  207. }


  210. static ngx_int_t
  211. ‌ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  212.     ngx_uint_t flags)
  213. {
  214.     int                ready, nready;
  215.     ngx_err_t          err;
  216.     ngx_uint_t         i, found;
  217.     ngx_event_t       *ev;
  218.     ngx_queue_t       *queue;
  219.     struct timeval     tv, *tp;
  220.     ngx_connection_t  *c;

  222.     if (max_fd == -1) {
  223.         for (i = 0; i < nevents; i++) {
  224.             c = event_index[i]->data;
  225.             if (max_fd < c->fd) {
  226.                 max_fd = c->fd;
  227.             }
  228.         }

  230.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  231.                        "change max_fd: %i", max_fd);
  232.     }

  234. #if (NGX_DEBUG)
  235.     if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
  236.         for (i = 0; i < nevents; i++) {
  237.             ev = event_index[i];
  238.             c = ev->data;
  239.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  240.                            "select event: fd:%d wr:%d", c->fd, ev->write);
  241.         }

  243.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  244.                        "max_fd: %i", max_fd);
  245.     }
  246. #endif

  248.     if (timer == NGX_TIMER_INFINITE) {
  249.         tp = NULL;

  251.     } else {
  252.         tv.tv_sec = (long) (timer / 1000);
  253.         tv.tv_usec = (long) ((timer % 1000) * 1000);
  254.         tp = &tv;
  255.     }

  257.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  258.                    "select timer: %M", timer);

  260.     work_read_fd_set = master_read_fd_set;
  261.     work_write_fd_set = master_write_fd_set;

  263.     ready = select(max_fd + 1, &work_read_fd_set, &work_write_fd_set, NULL, tp);

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

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

  271.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  272.                    "select ready %d", ready);

  274.     if (err) {
  275.         ngx_uint_t  level;

  277.         if (err == NGX_EINTR) {

  279.             if (ngx_event_timer_alarm) {
  280.                 ngx_event_timer_alarm = 0;
  281.                 return NGX_OK;
  282.             }

  284.             level = NGX_LOG_INFO;

  286.         } else {
  287.             level = NGX_LOG_ALERT;
  288.         }

  290.         ngx_log_error(level, cycle->log, err, "select() failed");

  292.         if (err == NGX_EBADF) {
  293.             ngx_select_repair_fd_sets(cycle);
  294.         }

  296.         return NGX_ERROR;
  297.     }

  299.     if (ready == 0) {
  300.         if (timer != NGX_TIMER_INFINITE) {
  301.             return NGX_OK;
  302.         }

  304.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  305.                       "select() returned no events without timeout");
  306.         return NGX_ERROR;
  307.     }

  309.     nready = 0;

  311.     for (i = 0; i < nevents; i++) {
  312.         ev = event_index[i];
  313.         c = ev->data;
  314.         found = 0;

  316.         if (ev->write) {
  317.             if (FD_ISSET(c->fd, &work_write_fd_set)) {
  318.                 found = 1;
  319.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  320.                                "select write %d", c->fd);
  321.             }

  323.         } else {
  324.             if (FD_ISSET(c->fd, &work_read_fd_set)) {
  325.                 found = 1;
  326.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  327.                                "select read %d", c->fd);
  328.             }
  329.         }

  331.         if (found) {
  332.             ev->ready = 1;

  334.             queue = ev->accept ? &ngx_posted_accept_events
  335.                                : &ngx_posted_events;

  337.             ngx_post_event(ev, queue);

  339.             nready++;
  340.         }
  341.     }

  343.     if (ready != nready) {
  344.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  345.                       "select ready != events: %d:%d", ready, nready);

  347.         ngx_select_repair_fd_sets(cycle);
  348.     }

  350.     return NGX_OK;
  351. }


  354. static void
  355. ‌ngx_select_repair_fd_sets(ngx_cycle_t *cycle)
  356. {
  357.     int           n;
  358.     socklen_t     len;
  359.     ngx_err_t     err;
  360.     ngx_socket_t  s;

  362.     for (s = 0; s <= max_fd; s++) {

  364.         if (FD_ISSET(s, &master_read_fd_set) == 0) {
  365.             continue;
  366.         }

  368.         len = sizeof(int);

  370.         if (getsockopt(s, SOL_SOCKET, SO_TYPE, &n, &len) == -1) {
  371.             err = ngx_socket_errno;

  373.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  374.                           "invalid descriptor #%d in read fd_set", s);

  376.             FD_CLR(s, &master_read_fd_set);
  377.         }
  378.     }

  380.     for (s = 0; s <= max_fd; s++) {

  382.         if (FD_ISSET(s, &master_write_fd_set) == 0) {
  383.             continue;
  384.         }

  386.         len = sizeof(int);

  388.         if (getsockopt(s, SOL_SOCKET, SO_TYPE, &n, &len) == -1) {
  389.             err = ngx_socket_errno;

  391.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  392.                           "invalid descriptor #%d in write fd_set", s);

  394.             FD_CLR(s, &master_write_fd_set);
  395.         }
  396.     }

  398.     max_fd = -1;
  399. }


  402. static char *
  403. ‌ngx_select_init_conf(ngx_cycle_t *cycle, void *conf)
  404. {
  405.     ngx_event_conf_t  *ecf;

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

  409.     if (ecf->use != ngx_select_module.ctx_index) {
  410.         return NGX_CONF_OK;
  411.     }

  413.     /* disable warning: the default FD_SETSIZE is 1024U in FreeBSD 5.x */

  415.     if (cycle->connection_n > FD_SETSIZE) {
  416.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  417.                       "the maximum number of files "
  418.                       "supported by select() is %ud", FD_SETSIZE);
  419.         return NGX_CONF_ERROR;
  420.     }

  422. #if (NGX_THREADS)

  424.     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  425.                   "select() is not supported in the threaded mode");
  426.     return NGX_CONF_ERROR;

  428. #else

  430.     return NGX_CONF_OK;

  432. #endif
  433. }

One Level Up Top Level