One Level Up Top Level

src/event/ngx_event.c - nginx source code

Global variables 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. ‌#define DEFAULT_CONNECTIONS  512


  16. extern ngx_module_t ngx_kqueue_module;
  17. extern ngx_module_t ngx_eventport_module;
  18. extern ngx_module_t ngx_devpoll_module;
  19. extern ngx_module_t ngx_epoll_module;
  20. extern ngx_module_t ngx_select_module;


  23. static char *ngx_event_init_conf(ngx_cycle_t *cycle, void *conf);
  24. static ngx_int_t ngx_event_module_init(ngx_cycle_t *cycle);
  25. static ngx_int_t ngx_event_process_init(ngx_cycle_t *cycle);
  26. static char *ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

  28. static char *ngx_event_connections(ngx_conf_t *cf, ngx_command_t *cmd,
  29.     void *conf);
  30. static char *ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  31. static char *ngx_event_debug_connection(ngx_conf_t *cf, ngx_command_t *cmd,
  32.     void *conf);

  34. static void *ngx_event_core_create_conf(ngx_cycle_t *cycle);
  35. static char *ngx_event_core_init_conf(ngx_cycle_t *cycle, void *conf);


  38. ‌static ngx_uint_t     ngx_timer_resolution;
  39. ‌sig_atomic_t          ngx_event_timer_alarm;

  41. ‌static ngx_uint_t     ngx_event_max_module;

  43. ‌ngx_uint_t            ngx_event_flags;
  44. ‌ngx_event_actions_t   ngx_event_actions;


  47. ‌static ngx_atomic_t   connection_counter = 1;
  48. ‌ngx_atomic_t         *ngx_connection_counter = &connection_counter;


  51. ‌ngx_atomic_t         *ngx_accept_mutex_ptr;
  52. ‌ngx_shmtx_t           ngx_accept_mutex;
  53. ‌ngx_uint_t            ngx_use_accept_mutex;
  54. ‌ngx_uint_t            ngx_accept_events;
  55. ‌ngx_uint_t            ngx_accept_mutex_held;
  56. ‌ngx_msec_t            ngx_accept_mutex_delay;
  57. ‌ngx_int_t             ngx_accept_disabled;
  58. ‌ngx_uint_t            ngx_use_exclusive_accept;


  61. #if (NGX_STAT_STUB)

  63. ‌static ngx_atomic_t   ngx_stat_accepted0;
  64. ‌ngx_atomic_t         *ngx_stat_accepted = &ngx_stat_accepted0;
  65. ‌static ngx_atomic_t   ngx_stat_handled0;
  66. ‌ngx_atomic_t         *ngx_stat_handled = &ngx_stat_handled0;
  67. ‌static ngx_atomic_t   ngx_stat_requests0;
  68. ‌ngx_atomic_t         *ngx_stat_requests = &ngx_stat_requests0;
  69. ‌static ngx_atomic_t   ngx_stat_active0;
  70. ‌ngx_atomic_t         *ngx_stat_active = &ngx_stat_active0;
  71. ‌static ngx_atomic_t   ngx_stat_reading0;
  72. ‌ngx_atomic_t         *ngx_stat_reading = &ngx_stat_reading0;
  73. ‌static ngx_atomic_t   ngx_stat_writing0;
  74. ‌ngx_atomic_t         *ngx_stat_writing = &ngx_stat_writing0;
  75. ‌static ngx_atomic_t   ngx_stat_waiting0;
  76. ‌ngx_atomic_t         *ngx_stat_waiting = &ngx_stat_waiting0;

  78. #endif



  82. ‌static ngx_command_t  ngx_events_commands[] = {

  84.     { ngx_string("events"),
  85.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  86.       ngx_events_block,
  87.       0,
  88.       0,
  89.       NULL },

  91.       ngx_null_command
  92. };


  95. ‌static ngx_core_module_t  ngx_events_module_ctx = {
  96.     ngx_string("events"),
  97.     NULL,
  98.     ngx_event_init_conf
  99. };


  102. ‌ngx_module_t  ngx_events_module = {
  103.     NGX_MODULE_V1,
  104.     &ngx_events_module_ctx,                /* module context */
  105.     ngx_events_commands,                   /* module directives */
  106.     NGX_CORE_MODULE,                       /* module type */
  107.     NULL,                                  /* init master */
  108.     NULL,                                  /* init module */
  109.     NULL,                                  /* init process */
  110.     NULL,                                  /* init thread */
  111.     NULL,                                  /* exit thread */
  112.     NULL,                                  /* exit process */
  113.     NULL,                                  /* exit master */
  114.     NGX_MODULE_V1_PADDING
  115. };


  118. ‌static ngx_str_t  event_core_name = ngx_string("event_core");


  121. ‌static ngx_command_t  ngx_event_core_commands[] = {

  123.     { ngx_string("worker_connections"),
  124.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  125.       ngx_event_connections,
  126.       0,
  127.       0,
  128.       NULL },

  130.     { ngx_string("use"),
  131.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  132.       ngx_event_use,
  133.       0,
  134.       0,
  135.       NULL },

  137.     { ngx_string("multi_accept"),
  138.       NGX_EVENT_CONF|NGX_CONF_FLAG,
  139.       ngx_conf_set_flag_slot,
  140.       0,
  141.       offsetof(ngx_event_conf_t, multi_accept),
  142.       NULL },

  144.     { ngx_string("accept_mutex"),
  145.       NGX_EVENT_CONF|NGX_CONF_FLAG,
  146.       ngx_conf_set_flag_slot,
  147.       0,
  148.       offsetof(ngx_event_conf_t, accept_mutex),
  149.       NULL },

  151.     { ngx_string("accept_mutex_delay"),
  152.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  153.       ngx_conf_set_msec_slot,
  154.       0,
  155.       offsetof(ngx_event_conf_t, accept_mutex_delay),
  156.       NULL },

  158.     { ngx_string("debug_connection"),
  159.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  160.       ngx_event_debug_connection,
  161.       0,
  162.       0,
  163.       NULL },

  165.       ngx_null_command
  166. };


  169. ‌static ngx_event_module_t  ngx_event_core_module_ctx = {
  170.     &event_core_name,
  171.     ngx_event_core_create_conf,            /* create configuration */
  172.     ngx_event_core_init_conf,              /* init configuration */

  174.     { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  175. };


  178. ‌ngx_module_t  ngx_event_core_module = {
  179.     NGX_MODULE_V1,
  180.     &ngx_event_core_module_ctx,            /* module context */
  181.     ngx_event_core_commands,               /* module directives */
  182.     NGX_EVENT_MODULE,                      /* module type */
  183.     NULL,                                  /* init master */
  184.     ngx_event_module_init,                 /* init module */
  185.     ngx_event_process_init,                /* init process */
  186.     NULL,                                  /* init thread */
  187.     NULL,                                  /* exit thread */
  188.     NULL,                                  /* exit process */
  189.     NULL,                                  /* exit master */
  190.     NGX_MODULE_V1_PADDING
  191. };


  194. void
  195. ‌ngx_process_events_and_timers(ngx_cycle_t *cycle)
  196. {
  197.     ngx_uint_t  flags;
  198.     ngx_msec_t  timer, delta;

  200.     if (ngx_timer_resolution) {
  201.         timer = NGX_TIMER_INFINITE;
  202.         flags = 0;

  204.     } else {
  205.         timer = ngx_event_find_timer();
  206.         flags = NGX_UPDATE_TIME;

  208. #if (NGX_WIN32)

  210.         /* handle signals from master in case of network inactivity */

  212.         if (timer == NGX_TIMER_INFINITE || timer > 500) {
  213.             timer = 500;
  214.         }

  216. #endif
  217.     }

  219.     if (ngx_use_accept_mutex) {
  220.         if (ngx_accept_disabled > 0) {
  221.             ngx_accept_disabled--;

  223.         } else {
  224.             if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
  225.                 return;
  226.             }

  228.             if (ngx_accept_mutex_held) {
  229.                 flags |= NGX_POST_EVENTS;

  231.             } else {
  232.                 if (timer == NGX_TIMER_INFINITE
  233.                     || timer > ngx_accept_mutex_delay)
  234.                 {
  235.                     timer = ngx_accept_mutex_delay;
  236.                 }
  237.             }
  238.         }
  239.     }

  241.     if (!ngx_queue_empty(&ngx_posted_next_events)) {
  242.         ngx_event_move_posted_next(cycle);
  243.         timer = 0;
  244.     }

  246.     delta = ngx_current_msec;

  248.     (void) ngx_process_events(cycle, timer, flags);

  250.     delta = ngx_current_msec - delta;

  252.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  253.                    "timer delta: %M", delta);

  255.     ngx_event_process_posted(cycle, &ngx_posted_accept_events);

  257.     if (ngx_accept_mutex_held) {
  258.         ngx_shmtx_unlock(&ngx_accept_mutex);
  259.     }

  261.     ngx_event_expire_timers();

  263.     ngx_event_process_posted(cycle, &ngx_posted_events);
  264. }


  267. ngx_int_t
  268. ‌ngx_handle_read_event(ngx_event_t *rev, ngx_uint_t flags)
  269. {
  270. #if (NGX_QUIC)

  272.     ngx_connection_t  *c;

  274.     c = rev->data;

  276.     if (c->quic) {
  277.         return NGX_OK;
  278.     }

  280. #endif

  282.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  284.         /* kqueue, epoll */

  286.         if (!rev->active && !rev->ready) {
  287.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_CLEAR_EVENT)
  288.                 == NGX_ERROR)
  289.             {
  290.                 return NGX_ERROR;
  291.             }
  292.         }

  294.         return NGX_OK;

  296.     } else if (ngx_event_flags & NGX_USE_LEVEL_EVENT) {

  298.         /* select, poll, /dev/poll */

  300.         if (!rev->active && !rev->ready) {
  301.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_LEVEL_EVENT)
  302.                 == NGX_ERROR)
  303.             {
  304.                 return NGX_ERROR;
  305.             }

  307.             return NGX_OK;
  308.         }

  310.         if (rev->active && (rev->ready || (flags & NGX_CLOSE_EVENT))) {
  311.             if (ngx_del_event(rev, NGX_READ_EVENT, NGX_LEVEL_EVENT | flags)
  312.                 == NGX_ERROR)
  313.             {
  314.                 return NGX_ERROR;
  315.             }

  317.             return NGX_OK;
  318.         }

  320.     } else if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {

  322.         /* event ports */

  324.         if (!rev->active && !rev->ready) {
  325.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  326.                 return NGX_ERROR;
  327.             }

  329.             return NGX_OK;
  330.         }

  332.         if (rev->oneshot && rev->ready) {
  333.             if (ngx_del_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  334.                 return NGX_ERROR;
  335.             }

  337.             return NGX_OK;
  338.         }
  339.     }

  341.     /* iocp */

  343.     return NGX_OK;
  344. }


  347. ngx_int_t
  348. ‌ngx_handle_write_event(ngx_event_t *wev, size_t lowat)
  349. {
  350.     ngx_connection_t  *c;

  352.     c = wev->data;

  354. #if (NGX_QUIC)
  355.     if (c->quic) {
  356.         return NGX_OK;
  357.     }
  358. #endif

  360.     if (lowat) {
  361.         if (ngx_send_lowat(c, lowat) == NGX_ERROR) {
  362.             return NGX_ERROR;
  363.         }
  364.     }

  366.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  368.         /* kqueue, epoll */

  370.         if (!wev->active && !wev->ready) {
  371.             if (ngx_add_event(wev, NGX_WRITE_EVENT,
  372.                               NGX_CLEAR_EVENT | (lowat ? NGX_LOWAT_EVENT : 0))
  373.                 == NGX_ERROR)
  374.             {
  375.                 return NGX_ERROR;
  376.             }
  377.         }

  379.         return NGX_OK;

  381.     } else if (ngx_event_flags & NGX_USE_LEVEL_EVENT) {

  383.         /* select, poll, /dev/poll */

  385.         if (!wev->active && !wev->ready) {
  386.             if (ngx_add_event(wev, NGX_WRITE_EVENT, NGX_LEVEL_EVENT)
  387.                 == NGX_ERROR)
  388.             {
  389.                 return NGX_ERROR;
  390.             }

  392.             return NGX_OK;
  393.         }

  395.         if (wev->active && wev->ready) {
  396.             if (ngx_del_event(wev, NGX_WRITE_EVENT, NGX_LEVEL_EVENT)
  397.                 == NGX_ERROR)
  398.             {
  399.                 return NGX_ERROR;
  400.             }

  402.             return NGX_OK;
  403.         }

  405.     } else if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {

  407.         /* event ports */

  409.         if (!wev->active && !wev->ready) {
  410.             if (ngx_add_event(wev, NGX_WRITE_EVENT, 0) == NGX_ERROR) {
  411.                 return NGX_ERROR;
  412.             }

  414.             return NGX_OK;
  415.         }

  417.         if (wev->oneshot && wev->ready) {
  418.             if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) == NGX_ERROR) {
  419.                 return NGX_ERROR;
  420.             }

  422.             return NGX_OK;
  423.         }
  424.     }

  426.     /* iocp */

  428.     return NGX_OK;
  429. }


  432. static char *
  433. ‌ngx_event_init_conf(ngx_cycle_t *cycle, void *conf)
  434. {
  435. #if (NGX_HAVE_REUSEPORT)
  436.     ngx_uint_t        i;
  437.     ngx_core_conf_t  *ccf;
  438.     ngx_listening_t  *ls;
  439. #endif

  441.     if (ngx_get_conf(cycle->conf_ctx, ngx_events_module) == NULL) {
  442.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  443.                       "no \"events\" section in configuration");
  444.         return NGX_CONF_ERROR;
  445.     }

  447.     if (cycle->connection_n < cycle->listening.nelts + 1) {

  449.         /*
  450.          * there should be at least one connection for each listening
  451.          * socket, plus an additional connection for channel
  452.          */

  454.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  455.                       "%ui worker_connections are not enough "
  456.                       "for %ui listening sockets",
  457.                       cycle->connection_n, cycle->listening.nelts);

  459.         return NGX_CONF_ERROR;
  460.     }

  462. #if (NGX_HAVE_REUSEPORT)

  464.     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

  466.     if (!ngx_test_config && ccf->master) {

  468.         ls = cycle->listening.elts;
  469.         for (i = 0; i < cycle->listening.nelts; i++) {

  471.             if (!ls[i].reuseport || ls[i].worker != 0) {
  472.                 continue;
  473.             }

  475.             if (ngx_clone_listening(cycle, &ls[i]) != NGX_OK) {
  476.                 return NGX_CONF_ERROR;
  477.             }

  479.             /* cloning may change cycle->listening.elts */

  481.             ls = cycle->listening.elts;
  482.         }
  483.     }

  485. #endif

  487.     return NGX_CONF_OK;
  488. }


  491. static ngx_int_t
  492. ‌ngx_event_module_init(ngx_cycle_t *cycle)
  493. {
  494.     void              ***cf;
  495.     u_char              *shared;
  496.     size_t               size, cl;
  497.     ngx_shm_t            shm;
  498.     ngx_time_t          *tp;
  499.     ngx_core_conf_t     *ccf;
  500.     ngx_event_conf_t    *ecf;

  502.     cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);
  503.     ecf = (*cf)[ngx_event_core_module.ctx_index];

  505.     if (!ngx_test_config && ngx_process <= NGX_PROCESS_MASTER) {
  506.         ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
  507.                       "using the \"%s\" event method", ecf->name);
  508.     }

  510.     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

  512.     ngx_timer_resolution = ccf->timer_resolution;

  514. #if !(NGX_WIN32)
  515.     {
  516.     ngx_int_t      limit;
  517.     struct rlimit  rlmt;

  519.     if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  520.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  521.                       "getrlimit(RLIMIT_NOFILE) failed, ignored");

  523.     } else {
  524.         if (ecf->connections > (ngx_uint_t) rlmt.rlim_cur
  525.             && (ccf->rlimit_nofile == NGX_CONF_UNSET
  526.                 || ecf->connections > (ngx_uint_t) ccf->rlimit_nofile))
  527.         {
  528.             limit = (ccf->rlimit_nofile == NGX_CONF_UNSET) ?
  529.                          (ngx_int_t) rlmt.rlim_cur : ccf->rlimit_nofile;

  531.             ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  532.                           "%ui worker_connections exceed "
  533.                           "open file resource limit: %i",
  534.                           ecf->connections, limit);
  535.         }
  536.     }
  537.     }
  538. #endif /* !(NGX_WIN32) */


  541.     if (ccf->master == 0) {
  542.         return NGX_OK;
  543.     }

  545.     if (ngx_accept_mutex_ptr) {
  546.         return NGX_OK;
  547.     }


  550.     /* cl should be equal to or greater than cache line size */

  552.     cl = 128;

  554.     size = cl            /* ngx_accept_mutex */
  555.            + cl          /* ngx_connection_counter */
  556.            + cl;         /* ngx_temp_number */

  558. #if (NGX_STAT_STUB)

  560.     size += cl           /* ngx_stat_accepted */
  561.            + cl          /* ngx_stat_handled */
  562.            + cl          /* ngx_stat_requests */
  563.            + cl          /* ngx_stat_active */
  564.            + cl          /* ngx_stat_reading */
  565.            + cl          /* ngx_stat_writing */
  566.            + cl;         /* ngx_stat_waiting */

  568. #endif

  570.     shm.size = size;
  571.     ngx_str_set(&shm.name, "nginx_shared_zone");
  572.     shm.log = cycle->log;

  574.     if (ngx_shm_alloc(&shm) != NGX_OK) {
  575.         return NGX_ERROR;
  576.     }

  578.     shared = shm.addr;

  580.     ngx_accept_mutex_ptr = (ngx_atomic_t *) shared;
  581.     ngx_accept_mutex.spin = (ngx_uint_t) -1;

  583.     if (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) shared,
  584.                          cycle->lock_file.data)
  585.         != NGX_OK)
  586.     {
  587.         return NGX_ERROR;
  588.     }

  590.     ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);

  592.     (void) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1);

  594.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  595.                    "counter: %p, %uA",
  596.                    ngx_connection_counter, *ngx_connection_counter);

  598.     ngx_temp_number = (ngx_atomic_t *) (shared + 2 * cl);

  600.     tp = ngx_timeofday();

  602.     ngx_random_number = (tp->msec << 16) + ngx_pid;

  604. #if (NGX_STAT_STUB)

  606.     ngx_stat_accepted = (ngx_atomic_t *) (shared + 3 * cl);
  607.     ngx_stat_handled = (ngx_atomic_t *) (shared + 4 * cl);
  608.     ngx_stat_requests = (ngx_atomic_t *) (shared + 5 * cl);
  609.     ngx_stat_active = (ngx_atomic_t *) (shared + 6 * cl);
  610.     ngx_stat_reading = (ngx_atomic_t *) (shared + 7 * cl);
  611.     ngx_stat_writing = (ngx_atomic_t *) (shared + 8 * cl);
  612.     ngx_stat_waiting = (ngx_atomic_t *) (shared + 9 * cl);

  614. #endif

  616.     return NGX_OK;
  617. }


  620. #if !(NGX_WIN32)

  622. static void
  623. ‌ngx_timer_signal_handler(int signo)
  624. {
  625.     ngx_event_timer_alarm = 1;

  627. #if 1
  628.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");
  629. #endif
  630. }

  632. #endif


  635. static ngx_int_t
  636. ‌ngx_event_process_init(ngx_cycle_t *cycle)
  637. {
  638.     ngx_uint_t           m, i;
  639.     ngx_event_t         *rev, *wev;
  640.     ngx_listening_t     *ls;
  641.     ngx_connection_t    *c, *next, *old;
  642.     ngx_core_conf_t     *ccf;
  643.     ngx_event_conf_t    *ecf;
  644.     ngx_event_module_t  *module;

  646.     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
  647.     ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);

  649.     if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
  650.         ngx_use_accept_mutex = 1;
  651.         ngx_accept_mutex_held = 0;
  652.         ngx_accept_mutex_delay = ecf->accept_mutex_delay;

  654.     } else {
  655.         ngx_use_accept_mutex = 0;
  656.     }

  658. #if (NGX_WIN32)

  660.     /*
  661.      * disable accept mutex on win32 as it may cause deadlock if
  662.      * grabbed by a process which can't accept connections
  663.      */

  665.     ngx_use_accept_mutex = 0;

  667. #endif

  669.     ngx_use_exclusive_accept = 0;

  671.     ngx_queue_init(&ngx_posted_accept_events);
  672.     ngx_queue_init(&ngx_posted_next_events);
  673.     ngx_queue_init(&ngx_posted_events);

  675.     if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
  676.         return NGX_ERROR;
  677.     }

  679.     for (m = 0; cycle->modules[m]; m++) {
  680.         if (cycle->modules[m]->type != NGX_EVENT_MODULE) {
  681.             continue;
  682.         }

  684.         if (cycle->modules[m]->ctx_index != ecf->use) {
  685.             continue;
  686.         }

  688.         module = cycle->modules[m]->ctx;

  690.         if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
  691.             /* fatal */
  692.             exit(2);
  693.         }

  695.         break;
  696.     }

  698. #if !(NGX_WIN32)

  700.     if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
  701.         struct sigaction  sa;
  702.         struct itimerval  itv;

  704.         ngx_memzero(&sa, sizeof(struct sigaction));
  705.         sa.sa_handler = ngx_timer_signal_handler;
  706.         sigemptyset(&sa.sa_mask);

  708.         if (sigaction(SIGALRM, &sa, NULL) == -1) {
  709.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  710.                           "sigaction(SIGALRM) failed");
  711.             return NGX_ERROR;
  712.         }

  714.         itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
  715.         itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
  716.         itv.it_value.tv_sec = ngx_timer_resolution / 1000;
  717.         itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;

  719.         if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
  720.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  721.                           "setitimer() failed");
  722.         }
  723.     }

  725.     if (ngx_event_flags & NGX_USE_FD_EVENT) {
  726.         struct rlimit  rlmt;

  728.         if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  729.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  730.                           "getrlimit(RLIMIT_NOFILE) failed");
  731.             return NGX_ERROR;
  732.         }

  734.         cycle->files_n = (ngx_uint_t) rlmt.rlim_cur;

  736.         cycle->files = ngx_calloc(sizeof(ngx_connection_t *) * cycle->files_n,
  737.                                   cycle->log);
  738.         if (cycle->files == NULL) {
  739.             return NGX_ERROR;
  740.         }
  741.     }

  743. #else

  745.     if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
  746.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  747.                       "the \"timer_resolution\" directive is not supported "
  748.                       "with the configured event method, ignored");
  749.         ngx_timer_resolution = 0;
  750.     }

  752. #endif

  754.     cycle->connections =
  755.         ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
  756.     if (cycle->connections == NULL) {
  757.         return NGX_ERROR;
  758.     }

  760.     c = cycle->connections;

  762.     cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  763.                                    cycle->log);
  764.     if (cycle->read_events == NULL) {
  765.         return NGX_ERROR;
  766.     }

  768.     rev = cycle->read_events;
  769.     for (i = 0; i < cycle->connection_n; i++) {
  770.         rev[i].closed = 1;
  771.         rev[i].instance = 1;
  772.     }

  774.     cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  775.                                     cycle->log);
  776.     if (cycle->write_events == NULL) {
  777.         return NGX_ERROR;
  778.     }

  780.     wev = cycle->write_events;
  781.     for (i = 0; i < cycle->connection_n; i++) {
  782.         wev[i].closed = 1;
  783.     }

  785.     i = cycle->connection_n;
  786.     next = NULL;

  788.     do {
  789.         i--;

  791.         c[i].data = next;
  792.         c[i].read = &cycle->read_events[i];
  793.         c[i].write = &cycle->write_events[i];
  794.         c[i].fd = (ngx_socket_t) -1;

  796.         next = &c[i];
  797.     } while (i);

  799.     cycle->free_connections = next;
  800.     cycle->free_connection_n = cycle->connection_n;

  802.     /* for each listening socket */

  804.     ls = cycle->listening.elts;
  805.     for (i = 0; i < cycle->listening.nelts; i++) {

  807. #if (NGX_HAVE_REUSEPORT)
  808.         if (ls[i].reuseport && ls[i].worker != ngx_worker) {
  809.             continue;
  810.         }
  811. #endif

  813.         c = ngx_get_connection(ls[i].fd, cycle->log);

  815.         if (c == NULL) {
  816.             return NGX_ERROR;
  817.         }

  819.         c->type = ls[i].type;
  820.         c->log = &ls[i].log;

  822.         c->listening = &ls[i];
  823.         ls[i].connection = c;

  825.         rev = c->read;

  827.         rev->log = c->log;
  828.         rev->accept = 1;

  830. #if (NGX_HAVE_DEFERRED_ACCEPT)
  831.         rev->deferred_accept = ls[i].deferred_accept;
  832. #endif

  834.         if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)
  835.             && cycle->old_cycle)
  836.         {
  837.             if (ls[i].previous) {

  839.                 /*
  840.                  * delete the old accept events that were bound to
  841.                  * the old cycle read events array
  842.                  */

  844.                 old = ls[i].previous->connection;

  846.                 if (ngx_del_event(old->read, NGX_READ_EVENT, NGX_CLOSE_EVENT)
  847.                     == NGX_ERROR)
  848.                 {
  849.                     return NGX_ERROR;
  850.                 }

  852.                 old->fd = (ngx_socket_t) -1;
  853.             }
  854.         }

  856. #if (NGX_WIN32)

  858.         if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  859.             ngx_iocp_conf_t  *iocpcf;

  861.             rev->handler = ngx_event_acceptex;

  863.             if (ngx_use_accept_mutex) {
  864.                 continue;
  865.             }

  867.             if (ngx_add_event(rev, 0, NGX_IOCP_ACCEPT) == NGX_ERROR) {
  868.                 return NGX_ERROR;
  869.             }

  871.             ls[i].log.handler = ngx_acceptex_log_error;

  873.             iocpcf = ngx_event_get_conf(cycle->conf_ctx, ngx_iocp_module);
  874.             if (ngx_event_post_acceptex(&ls[i], iocpcf->post_acceptex)
  875.                 == NGX_ERROR)
  876.             {
  877.                 return NGX_ERROR;
  878.             }

  880.         } else {
  881.             rev->handler = ngx_event_accept;

  883.             if (ngx_use_accept_mutex) {
  884.                 continue;
  885.             }

  887.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  888.                 return NGX_ERROR;
  889.             }
  890.         }

  892. #else

  894.         if (c->type == SOCK_STREAM) {
  895.             rev->handler = ngx_event_accept;

  897. #if (NGX_QUIC)
  898.         } else if (ls[i].quic) {
  899.             rev->handler = ngx_quic_recvmsg;
  900. #endif
  901.         } else {
  902.             rev->handler = ngx_event_recvmsg;
  903.         }

  905. #if (NGX_HAVE_REUSEPORT)

  907.         if (ls[i].reuseport) {
  908.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  909.                 return NGX_ERROR;
  910.             }

  912.             continue;
  913.         }

  915. #endif

  917.         if (ngx_use_accept_mutex) {
  918.             continue;
  919.         }

  921. #if (NGX_HAVE_EPOLLEXCLUSIVE)

  923.         if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
  924.             && ccf->worker_processes > 1)
  925.         {
  926.             ngx_use_exclusive_accept = 1;

  928.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_EXCLUSIVE_EVENT)
  929.                 == NGX_ERROR)
  930.             {
  931.                 return NGX_ERROR;
  932.             }

  934.             continue;
  935.         }

  937. #endif

  939.         if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  940.             return NGX_ERROR;
  941.         }

  943. #endif

  945.     }

  947.     return NGX_OK;
  948. }


  951. ngx_int_t
  952. ‌ngx_send_lowat(ngx_connection_t *c, size_t lowat)
  953. {
  954.     int  sndlowat;

  956. #if (NGX_HAVE_LOWAT_EVENT)

  958.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  959.         c->write->available = lowat;
  960.         return NGX_OK;
  961.     }

  963. #endif

  965.     if (lowat == 0 || c->sndlowat) {
  966.         return NGX_OK;
  967.     }

  969.     sndlowat = (int) lowat;

  971.     if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT,
  972.                    (const void *) &sndlowat, sizeof(int))
  973.         == -1)
  974.     {
  975.         ngx_connection_error(c, ngx_socket_errno,
  976.                              "setsockopt(SO_SNDLOWAT) failed");
  977.         return NGX_ERROR;
  978.     }

  980.     c->sndlowat = 1;

  982.     return NGX_OK;
  983. }


  986. static char *
  987. ‌ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  988. {
  989.     char                 *rv;
  990.     void               ***ctx;
  991.     ngx_uint_t            i;
  992.     ngx_conf_t            pcf;
  993.     ngx_event_module_t   *m;

  995.     if (*(void **) conf) {
  996.         return "is duplicate";
  997.     }

  999.     /* count the number of the event modules and set up their indices */

  1001.     ngx_event_max_module = ngx_count_modules(cf->cycle, NGX_EVENT_MODULE);

  1003.     ctx = ngx_pcalloc(cf->pool, sizeof(void *));
  1004.     if (ctx == NULL) {
  1005.         return NGX_CONF_ERROR;
  1006.     }

  1008.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));
  1009.     if (*ctx == NULL) {
  1010.         return NGX_CONF_ERROR;
  1011.     }

  1013.     *(void **) conf = ctx;

  1015.     for (i = 0; cf->cycle->modules[i]; i++) {
  1016.         if (cf->cycle->modules[i]->type != NGX_EVENT_MODULE) {
  1017.             continue;
  1018.         }

  1020.         m = cf->cycle->modules[i]->ctx;

  1022.         if (m->create_conf) {
  1023.             (*ctx)[cf->cycle->modules[i]->ctx_index] =
  1024.                                                      m->create_conf(cf->cycle);
  1025.             if ((*ctx)[cf->cycle->modules[i]->ctx_index] == NULL) {
  1026.                 return NGX_CONF_ERROR;
  1027.             }
  1028.         }
  1029.     }

  1031.     pcf = *cf;
  1032.     cf->ctx = ctx;
  1033.     cf->module_type = NGX_EVENT_MODULE;
  1034.     cf->cmd_type = NGX_EVENT_CONF;

  1036.     rv = ngx_conf_parse(cf, NULL);

  1038.     *cf = pcf;

  1040.     if (rv != NGX_CONF_OK) {
  1041.         return rv;
  1042.     }

  1044.     for (i = 0; cf->cycle->modules[i]; i++) {
  1045.         if (cf->cycle->modules[i]->type != NGX_EVENT_MODULE) {
  1046.             continue;
  1047.         }

  1049.         m = cf->cycle->modules[i]->ctx;

  1051.         if (m->init_conf) {
  1052.             rv = m->init_conf(cf->cycle,
  1053.                               (*ctx)[cf->cycle->modules[i]->ctx_index]);
  1054.             if (rv != NGX_CONF_OK) {
  1055.                 return rv;
  1056.             }
  1057.         }
  1058.     }

  1060.     return NGX_CONF_OK;
  1061. }


  1064. static char *
  1065. ‌ngx_event_connections(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1066. {
  1067.     ngx_event_conf_t  *ecf = conf;

  1069.     ngx_str_t  *value;

  1071.     if (ecf->connections != NGX_CONF_UNSET_UINT) {
  1072.         return "is duplicate";
  1073.     }

  1075.     value = cf->args->elts;
  1076.     ecf->connections = ngx_atoi(value[1].data, value[1].len);
  1077.     if (ecf->connections == (ngx_uint_t) NGX_ERROR) {
  1078.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1079.                            "invalid number \"%V\"", &value[1]);

  1081.         return NGX_CONF_ERROR;
  1082.     }

  1084.     cf->cycle->connection_n = ecf->connections;

  1086.     return NGX_CONF_OK;
  1087. }


  1090. static char *
  1091. ‌ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1092. {
  1093.     ngx_event_conf_t  *ecf = conf;

  1095.     ngx_int_t             m;
  1096.     ngx_str_t            *value;
  1097.     ngx_event_conf_t     *old_ecf;
  1098.     ngx_event_module_t   *module;

  1100.     if (ecf->use != NGX_CONF_UNSET_UINT) {
  1101.         return "is duplicate";
  1102.     }

  1104.     value = cf->args->elts;

  1106.     if (cf->cycle->old_cycle->conf_ctx) {
  1107.         old_ecf = ngx_event_get_conf(cf->cycle->old_cycle->conf_ctx,
  1108.                                      ngx_event_core_module);
  1109.     } else {
  1110.         old_ecf = NULL;
  1111.     }


  1114.     for (m = 0; cf->cycle->modules[m]; m++) {
  1115.         if (cf->cycle->modules[m]->type != NGX_EVENT_MODULE) {
  1116.             continue;
  1117.         }

  1119.         module = cf->cycle->modules[m]->ctx;
  1120.         if (module->name->len == value[1].len) {
  1121.             if (ngx_strcmp(module->name->data, value[1].data) == 0) {
  1122.                 ecf->use = cf->cycle->modules[m]->ctx_index;
  1123.                 ecf->name = module->name->data;

  1125.                 if (ngx_process == NGX_PROCESS_SINGLE
  1126.                     && old_ecf
  1127.                     && old_ecf->use != ecf->use)
  1128.                 {
  1129.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1130.                                "when the server runs without a master process "
  1131.                                "the \"%V\" event type must be the same as "
  1132.                                "in previous configuration - \"%s\" "
  1133.                                "and it cannot be changed on the fly, "
  1134.                                "to change it you need to stop server "
  1135.                                "and start it again",
  1136.                                &value[1], old_ecf->name);

  1138.                     return NGX_CONF_ERROR;
  1139.                 }

  1141.                 return NGX_CONF_OK;
  1142.             }
  1143.         }
  1144.     }

  1146.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1147.                        "invalid event type \"%V\"", &value[1]);

  1149.     return NGX_CONF_ERROR;
  1150. }


  1153. static char *
  1154. ‌ngx_event_debug_connection(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1155. {
  1156. #if (NGX_DEBUG)
  1157.     ngx_event_conf_t  *ecf = conf;

  1159.     ngx_int_t             rc;
  1160.     ngx_str_t            *value;
  1161.     ngx_url_t             u;
  1162.     ngx_cidr_t            c, *cidr;
  1163.     ngx_uint_t            i;
  1164.     struct sockaddr_in   *sin;
  1165. #if (NGX_HAVE_INET6)
  1166.     struct sockaddr_in6  *sin6;
  1167. #endif

  1169.     value = cf->args->elts;

  1171. #if (NGX_HAVE_UNIX_DOMAIN)

  1173.     if (ngx_strcmp(value[1].data, "unix:") == 0) {
  1174.         cidr = ngx_array_push(&ecf->debug_connection);
  1175.         if (cidr == NULL) {
  1176.             return NGX_CONF_ERROR;
  1177.         }

  1179.         cidr->family = AF_UNIX;
  1180.         return NGX_CONF_OK;
  1181.     }

  1183. #endif

  1185.     rc = ngx_ptocidr(&value[1], &c);

  1187.     if (rc != NGX_ERROR) {
  1188.         if (rc == NGX_DONE) {
  1189.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1190.                                "low address bits of %V are meaningless",
  1191.                                &value[1]);
  1192.         }

  1194.         cidr = ngx_array_push(&ecf->debug_connection);
  1195.         if (cidr == NULL) {
  1196.             return NGX_CONF_ERROR;
  1197.         }

  1199.         *cidr = c;

  1201.         return NGX_CONF_OK;
  1202.     }

  1204.     ngx_memzero(&u, sizeof(ngx_url_t));
  1205.     u.host = value[1];

  1207.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  1208.         if (u.err) {
  1209.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1210.                                "%s in debug_connection \"%V\"",
  1211.                                u.err, &u.host);
  1212.         }

  1214.         return NGX_CONF_ERROR;
  1215.     }

  1217.     cidr = ngx_array_push_n(&ecf->debug_connection, u.naddrs);
  1218.     if (cidr == NULL) {
  1219.         return NGX_CONF_ERROR;
  1220.     }

  1222.     ngx_memzero(cidr, u.naddrs * sizeof(ngx_cidr_t));

  1224.     for (i = 0; i < u.naddrs; i++) {
  1225.         cidr[i].family = u.addrs[i].sockaddr->sa_family;

  1227.         switch (cidr[i].family) {

  1229. #if (NGX_HAVE_INET6)
  1230.         case AF_INET6:
  1231.             sin6 = (struct sockaddr_in6 *) u.addrs[i].sockaddr;
  1232.             cidr[i].u.in6.addr = sin6->sin6_addr;
  1233.             ngx_memset(cidr[i].u.in6.mask.s6_addr, 0xff, 16);
  1234.             break;
  1235. #endif

  1237.         default: /* AF_INET */
  1238.             sin = (struct sockaddr_in *) u.addrs[i].sockaddr;
  1239.             cidr[i].u.in.addr = sin->sin_addr.s_addr;
  1240.             cidr[i].u.in.mask = 0xffffffff;
  1241.             break;
  1242.         }
  1243.     }

  1245. #else

  1247.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1248.                        "\"debug_connection\" is ignored, you need to rebuild "
  1249.                        "nginx using --with-debug option to enable it");

  1251. #endif

  1253.     return NGX_CONF_OK;
  1254. }


  1257. static void *
  1258. ‌ngx_event_core_create_conf(ngx_cycle_t *cycle)
  1259. {
  1260.     ngx_event_conf_t  *ecf;

  1262.     ecf = ngx_palloc(cycle->pool, sizeof(ngx_event_conf_t));
  1263.     if (ecf == NULL) {
  1264.         return NULL;
  1265.     }

  1267.     ecf->connections = NGX_CONF_UNSET_UINT;
  1268.     ecf->use = NGX_CONF_UNSET_UINT;
  1269.     ecf->multi_accept = NGX_CONF_UNSET;
  1270.     ecf->accept_mutex = NGX_CONF_UNSET;
  1271.     ecf->accept_mutex_delay = NGX_CONF_UNSET_MSEC;
  1272.     ecf->name = (void *) NGX_CONF_UNSET;

  1274. #if (NGX_DEBUG)

  1276.     if (ngx_array_init(&ecf->debug_connection, cycle->pool, 4,
  1277.                        sizeof(ngx_cidr_t)) == NGX_ERROR)
  1278.     {
  1279.         return NULL;
  1280.     }

  1282. #endif

  1284.     return ecf;
  1285. }


  1288. static char *
  1289. ‌ngx_event_core_init_conf(ngx_cycle_t *cycle, void *conf)
  1290. {
  1291.     ngx_event_conf_t  *ecf = conf;

  1293. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)
  1294.     int                  fd;
  1295. #endif
  1296.     ngx_int_t            i;
  1297.     ngx_module_t        *module;
  1298.     ngx_event_module_t  *event_module;

  1300.     module = NULL;

  1302. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)

  1304.     fd = epoll_create(100);

  1306.     if (fd != -1) {
  1307.         (void) close(fd);
  1308.         module = &ngx_epoll_module;

  1310.     } else if (ngx_errno != NGX_ENOSYS) {
  1311.         module = &ngx_epoll_module;
  1312.     }

  1314. #endif

  1316. #if (NGX_HAVE_DEVPOLL) && !(NGX_TEST_BUILD_DEVPOLL)

  1318.     module = &ngx_devpoll_module;

  1320. #endif

  1322. #if (NGX_HAVE_KQUEUE)

  1324.     module = &ngx_kqueue_module;

  1326. #endif

  1328. #if (NGX_HAVE_SELECT)

  1330.     if (module == NULL) {
  1331.         module = &ngx_select_module;
  1332.     }

  1334. #endif

  1336.     if (module == NULL) {
  1337.         for (i = 0; cycle->modules[i]; i++) {

  1339.             if (cycle->modules[i]->type != NGX_EVENT_MODULE) {
  1340.                 continue;
  1341.             }

  1343.             event_module = cycle->modules[i]->ctx;

  1345.             if (ngx_strcmp(event_module->name->data, event_core_name.data) == 0)
  1346.             {
  1347.                 continue;
  1348.             }

  1350.             module = cycle->modules[i];
  1351.             break;
  1352.         }
  1353.     }

  1355.     if (module == NULL) {
  1356.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "no events module found");
  1357.         return NGX_CONF_ERROR;
  1358.     }

  1360.     ngx_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);
  1361.     cycle->connection_n = ecf->connections;

  1363.     ngx_conf_init_uint_value(ecf->use, module->ctx_index);

  1365.     event_module = module->ctx;
  1366.     ngx_conf_init_ptr_value(ecf->name, event_module->name->data);

  1368.     ngx_conf_init_value(ecf->multi_accept, 0);
  1369.     ngx_conf_init_value(ecf->accept_mutex, 0);
  1370.     ngx_conf_init_msec_value(ecf->accept_mutex_delay, 500);

  1372.     return NGX_CONF_OK;
  1373. }

One Level Up Top Level