One Level Up Top Level

src/event/modules/ngx_select_module.c - nginx-1.31.4 nginx/ @ 8d9666701

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. ‌static 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,                              /* trigger a notify */
  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.     /* disable warning: the default FD_SETSIZE is 1024U in FreeBSD 5.x-10.x */

  151.     if ((event == NGX_READ_EVENT || event == NGX_WRITE_EVENT)
  152.         && (unsigned) c->fd >= FD_SETSIZE)
  153.     {
  154.         ngx_log_error(NGX_LOG_ERR, ev->log, 0,
  155.                       "maximum number of descriptors "
  156.                       "supported by select() is %ud", FD_SETSIZE);
  157.         return NGX_ERROR;
  158.     }

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

  163.     } else if (event == NGX_WRITE_EVENT) {
  164.         FD_SET(c->fd, &master_write_fd_set);
  165.     }

  167.     if (max_fd != -1 && max_fd < c->fd) {
  168.         max_fd = c->fd;
  169.     }

  171.     ev->active = 1;

  173.     event_index[nevents] = ev;
  174.     ev->index = nevents;
  175.     nevents++;

  177.     return NGX_OK;
  178. }


  181. static ngx_int_t
  182. ‌ngx_select_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  183. {
  184.     ngx_event_t       *e;
  185.     ngx_connection_t  *c;

  187.     c = ev->data;

  189.     ev->active = 0;

  191.     if (ev->index == NGX_INVALID_INDEX) {
  192.         return NGX_OK;
  193.     }

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

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

  201.     } else if (event == NGX_WRITE_EVENT) {
  202.         FD_CLR(c->fd, &master_write_fd_set);
  203.     }

  205.     if (max_fd == c->fd) {
  206.         max_fd = -1;
  207.     }

  209.     if (ev->index < --nevents) {
  210.         e = event_index[nevents];
  211.         event_index[ev->index] = e;
  212.         e->index = ev->index;
  213.     }

  215.     ev->index = NGX_INVALID_INDEX;

  217.     return NGX_OK;
  218. }


  221. static ngx_int_t
  222. ‌ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  223.     ngx_uint_t flags)
  224. {
  225.     int                ready, nready;
  226.     ngx_err_t          err;
  227.     ngx_uint_t         i, found;
  228.     ngx_event_t       *ev;
  229.     ngx_queue_t       *queue;
  230.     struct timeval     tv, *tp;
  231.     ngx_connection_t  *c;

  233.     if (max_fd == -1) {
  234.         for (i = 0; i < nevents; i++) {
  235.             c = event_index[i]->data;
  236.             if (max_fd < c->fd) {
  237.                 max_fd = c->fd;
  238.             }
  239.         }

  241.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  242.                        "change max_fd: %i", max_fd);
  243.     }

  245. #if (NGX_DEBUG)
  246.     if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
  247.         for (i = 0; i < nevents; i++) {
  248.             ev = event_index[i];
  249.             c = ev->data;
  250.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  251.                            "select event: fd:%d wr:%d", c->fd, ev->write);
  252.         }

  254.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  255.                        "max_fd: %i", max_fd);
  256.     }
  257. #endif

  259.     if (timer == NGX_TIMER_INFINITE) {
  260.         tp = NULL;

  262.     } else {
  263.         tv.tv_sec = (long) (timer / 1000);
  264.         tv.tv_usec = (long) ((timer % 1000) * 1000);
  265.         tp = &tv;
  266.     }

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

  271.     work_read_fd_set = master_read_fd_set;
  272.     work_write_fd_set = master_write_fd_set;

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

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

  278.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  279.         ngx_time_update();
  280.     }

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

  285.     if (err) {
  286.         ngx_uint_t  level;

  288.         if (err == NGX_EINTR) {

  290.             if (ngx_event_timer_alarm) {
  291.                 ngx_event_timer_alarm = 0;
  292.                 return NGX_OK;
  293.             }

  295.             level = NGX_LOG_INFO;

  297.         } else {
  298.             level = NGX_LOG_ALERT;
  299.         }

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

  303.         if (err == NGX_EBADF) {
  304.             ngx_select_repair_fd_sets(cycle);
  305.         }

  307.         return NGX_ERROR;
  308.     }

  310.     if (ready == 0) {
  311.         if (timer != NGX_TIMER_INFINITE) {
  312.             return NGX_OK;
  313.         }

  315.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  316.                       "select() returned no events without timeout");
  317.         return NGX_ERROR;
  318.     }

  320.     nready = 0;

  322.     for (i = 0; i < nevents; i++) {
  323.         ev = event_index[i];
  324.         c = ev->data;
  325.         found = 0;

  327.         if (ev->write) {
  328.             if (FD_ISSET(c->fd, &work_write_fd_set)) {
  329.                 found = 1;
  330.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  331.                                "select write %d", c->fd);
  332.             }

  334.         } else {
  335.             if (FD_ISSET(c->fd, &work_read_fd_set)) {
  336.                 found = 1;
  337.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  338.                                "select read %d", c->fd);
  339.             }
  340.         }

  342.         if (found) {
  343.             ev->ready = 1;
  344.             ev->available = -1;

  346.             queue = ev->accept ? &ngx_posted_accept_events
  347.                                : &ngx_posted_events;

  349.             ngx_post_event(ev, queue);

  351.             nready++;
  352.         }
  353.     }

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

  359.         ngx_select_repair_fd_sets(cycle);
  360.     }

  362.     return NGX_OK;
  363. }


  366. static void
  367. ‌ngx_select_repair_fd_sets(ngx_cycle_t *cycle)
  368. {
  369.     int           n;
  370.     socklen_t     len;
  371.     ngx_err_t     err;
  372.     ngx_socket_t  s;

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

  376.         if (FD_ISSET(s, &master_read_fd_set) == 0) {
  377.             continue;
  378.         }

  380.         len = sizeof(int);

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

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

  388.             FD_CLR(s, &master_read_fd_set);
  389.         }
  390.     }

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

  394.         if (FD_ISSET(s, &master_write_fd_set) == 0) {
  395.             continue;
  396.         }

  398.         len = sizeof(int);

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

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

  406.             FD_CLR(s, &master_write_fd_set);
  407.         }
  408.     }

  410.     max_fd = -1;
  411. }


  414. static char *
  415. ‌ngx_select_init_conf(ngx_cycle_t *cycle, void *conf)
  416. {
  417.     ngx_event_conf_t  *ecf;

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

  421.     if (ecf->use != ngx_select_module.ctx_index) {
  422.         return NGX_CONF_OK;
  423.     }

  425.     if (cycle->connection_n > FD_SETSIZE) {
  426.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  427.                       "the maximum number of files "
  428.                       "supported by select() is %ud", FD_SETSIZE);
  429.         return NGX_CONF_ERROR;
  430.     }

  432.     return NGX_CONF_OK;
  433. }

One Level Up Top Level