One Level Up Top Level

src/event/ngx_event.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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.     return NGX_OK;
  342. }


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

  350.     c = wev->data;

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

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

  364.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  366.         /* kqueue, epoll */

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

  377.         return NGX_OK;

  379.     } else if (ngx_event_flags & NGX_USE_LEVEL_EVENT) {

  381.         /* select, poll, /dev/poll */

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

  390.             return NGX_OK;
  391.         }

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

  400.             return NGX_OK;
  401.         }

  403.     } else if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {

  405.         /* event ports */

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

  412.             return NGX_OK;
  413.         }

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

  420.             return NGX_OK;
  421.         }
  422.     }

  424.     return NGX_OK;
  425. }


  428. static char *
  429. ‌ngx_event_init_conf(ngx_cycle_t *cycle, void *conf)
  430. {
  431. #if (NGX_HAVE_REUSEPORT)
  432.     ngx_uint_t        i;
  433.     ngx_core_conf_t  *ccf;
  434.     ngx_listening_t  *ls;
  435. #endif

  437.     if (ngx_get_conf(cycle->conf_ctx, ngx_events_module) == NULL) {
  438.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  439.                       "no \"events\" section in configuration");
  440.         return NGX_CONF_ERROR;
  441.     }

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

  445.         /*
  446.          * there should be at least one connection for each listening
  447.          * socket, plus an additional connection for channel
  448.          */

  450.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  451.                       "%ui worker_connections are not enough "
  452.                       "for %ui listening sockets",
  453.                       cycle->connection_n, cycle->listening.nelts);

  455.         return NGX_CONF_ERROR;
  456.     }

  458. #if (NGX_HAVE_REUSEPORT)

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

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

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

  467.             if (!ls[i].reuseport || ls[i].worker != 0) {
  468.                 continue;
  469.             }

  471.             if (ngx_clone_listening(cycle, &ls[i]) != NGX_OK) {
  472.                 return NGX_CONF_ERROR;
  473.             }

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

  477.             ls = cycle->listening.elts;
  478.         }
  479.     }

  481. #endif

  483.     return NGX_CONF_OK;
  484. }


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

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

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

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

  508.     ngx_timer_resolution = ccf->timer_resolution;

  510. #if !(NGX_WIN32)
  511.     {
  512.     ngx_int_t      limit;
  513.     struct rlimit  rlmt;

  515.     if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  516.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  517.                       "getrlimit(RLIMIT_NOFILE) failed, ignored");

  519.     } else {
  520.         if (ecf->connections > (ngx_uint_t) rlmt.rlim_cur
  521.             && (ccf->rlimit_nofile == NGX_CONF_UNSET
  522.                 || ecf->connections > (ngx_uint_t) ccf->rlimit_nofile))
  523.         {
  524.             limit = (ccf->rlimit_nofile == NGX_CONF_UNSET) ?
  525.                          (ngx_int_t) rlmt.rlim_cur : ccf->rlimit_nofile;

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


  537.     if (ccf->master == 0) {
  538.         return NGX_OK;
  539.     }

  541.     if (ngx_accept_mutex_ptr) {
  542.         return NGX_OK;
  543.     }


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

  548.     cl = 128;

  550.     size = cl            /* ngx_accept_mutex */
  551.            + cl          /* ngx_connection_counter */
  552.            + cl;         /* ngx_temp_number */

  554. #if (NGX_STAT_STUB)

  556.     size += cl           /* ngx_stat_accepted */
  557.            + cl          /* ngx_stat_handled */
  558.            + cl          /* ngx_stat_requests */
  559.            + cl          /* ngx_stat_active */
  560.            + cl          /* ngx_stat_reading */
  561.            + cl          /* ngx_stat_writing */
  562.            + cl;         /* ngx_stat_waiting */

  564. #endif

  566.     shm.size = size;
  567.     ngx_str_set(&shm.name, "nginx_shared_zone");
  568.     shm.log = cycle->log;

  570.     if (ngx_shm_alloc(&shm) != NGX_OK) {
  571.         return NGX_ERROR;
  572.     }

  574.     shared = shm.addr;

  576.     ngx_accept_mutex_ptr = (ngx_atomic_t *) shared;
  577.     ngx_accept_mutex.spin = (ngx_uint_t) -1;

  579.     if (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) shared,
  580.                          cycle->lock_file.data)
  581.         != NGX_OK)
  582.     {
  583.         return NGX_ERROR;
  584.     }

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

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

  590.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  591.                    "counter: %p, %uA",
  592.                    ngx_connection_counter, *ngx_connection_counter);

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

  596.     tp = ngx_timeofday();

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

  600. #if (NGX_STAT_STUB)

  602.     ngx_stat_accepted = (ngx_atomic_t *) (shared + 3 * cl);
  603.     ngx_stat_handled = (ngx_atomic_t *) (shared + 4 * cl);
  604.     ngx_stat_requests = (ngx_atomic_t *) (shared + 5 * cl);
  605.     ngx_stat_active = (ngx_atomic_t *) (shared + 6 * cl);
  606.     ngx_stat_reading = (ngx_atomic_t *) (shared + 7 * cl);
  607.     ngx_stat_writing = (ngx_atomic_t *) (shared + 8 * cl);
  608.     ngx_stat_waiting = (ngx_atomic_t *) (shared + 9 * cl);

  610. #endif

  612.     return NGX_OK;
  613. }


  616. #if !(NGX_WIN32)

  618. static void
  619. ‌ngx_timer_signal_handler(int signo)
  620. {
  621.     ngx_event_timer_alarm = 1;

  623. #if 1
  624.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");
  625. #endif
  626. }

  628. #endif


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

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

  645.     if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
  646.         ngx_use_accept_mutex = 1;
  647.         ngx_accept_mutex_held = 0;
  648.         ngx_accept_mutex_delay = ecf->accept_mutex_delay;

  650.     } else {
  651.         ngx_use_accept_mutex = 0;
  652.     }

  654. #if (NGX_WIN32)

  656.     /*
  657.      * disable accept mutex on win32 as it may cause deadlock if
  658.      * grabbed by a process which can't accept connections
  659.      */

  661.     ngx_use_accept_mutex = 0;

  663. #endif

  665.     ngx_use_exclusive_accept = 0;

  667.     ngx_queue_init(&ngx_posted_accept_events);
  668.     ngx_queue_init(&ngx_posted_next_events);
  669.     ngx_queue_init(&ngx_posted_events);

  671.     if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
  672.         return NGX_ERROR;
  673.     }

  675.     for (m = 0; cycle->modules[m]; m++) {
  676.         if (cycle->modules[m]->type != NGX_EVENT_MODULE) {
  677.             continue;
  678.         }

  680.         if (cycle->modules[m]->ctx_index != ecf->use) {
  681.             continue;
  682.         }

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

  686.         if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
  687.             /* fatal */
  688.             exit(2);
  689.         }

  691.         break;
  692.     }

  694. #if !(NGX_WIN32)

  696.     if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
  697.         struct sigaction  sa;
  698.         struct itimerval  itv;

  700.         ngx_memzero(&sa, sizeof(struct sigaction));
  701.         sa.sa_handler = ngx_timer_signal_handler;
  702.         sigemptyset(&sa.sa_mask);

  704.         if (sigaction(SIGALRM, &sa, NULL) == -1) {
  705.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  706.                           "sigaction(SIGALRM) failed");
  707.             return NGX_ERROR;
  708.         }

  710.         itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
  711.         itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
  712.         itv.it_value.tv_sec = ngx_timer_resolution / 1000;
  713.         itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;

  715.         if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
  716.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  717.                           "setitimer() failed");
  718.         }
  719.     }

  721.     if (ngx_event_flags & NGX_USE_FD_EVENT) {
  722.         struct rlimit  rlmt;

  724.         if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  725.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  726.                           "getrlimit(RLIMIT_NOFILE) failed");
  727.             return NGX_ERROR;
  728.         }

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

  732.         cycle->files = ngx_calloc(sizeof(ngx_connection_t *) * cycle->files_n,
  733.                                   cycle->log);
  734.         if (cycle->files == NULL) {
  735.             return NGX_ERROR;
  736.         }
  737.     }

  739. #else

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

  748. #endif

  750.     cycle->connections =
  751.         ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
  752.     if (cycle->connections == NULL) {
  753.         return NGX_ERROR;
  754.     }

  756.     c = cycle->connections;

  758.     cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  759.                                    cycle->log);
  760.     if (cycle->read_events == NULL) {
  761.         return NGX_ERROR;
  762.     }

  764.     rev = cycle->read_events;
  765.     for (i = 0; i < cycle->connection_n; i++) {
  766.         rev[i].closed = 1;
  767.         rev[i].instance = 1;
  768.     }

  770.     cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  771.                                     cycle->log);
  772.     if (cycle->write_events == NULL) {
  773.         return NGX_ERROR;
  774.     }

  776.     wev = cycle->write_events;
  777.     for (i = 0; i < cycle->connection_n; i++) {
  778.         wev[i].closed = 1;
  779.     }

  781.     i = cycle->connection_n;
  782.     next = NULL;

  784.     do {
  785.         i--;

  787.         c[i].data = next;
  788.         c[i].read = &cycle->read_events[i];
  789.         c[i].write = &cycle->write_events[i];
  790.         c[i].fd = (ngx_socket_t) -1;

  792.         next = &c[i];
  793.     } while (i);

  795.     cycle->free_connections = next;
  796.     cycle->free_connection_n = cycle->connection_n;

  798.     /* for each listening socket */

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

  803. #if (NGX_HAVE_REUSEPORT)
  804.         if (ls[i].reuseport && ls[i].worker != ngx_worker) {
  805.             continue;
  806.         }
  807. #endif

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

  811.         if (c == NULL) {
  812.             return NGX_ERROR;
  813.         }

  815.         c->type = ls[i].type;
  816.         c->log = &ls[i].log;

  818.         c->listening = &ls[i];
  819.         ls[i].connection = c;

  821.         rev = c->read;

  823.         rev->log = c->log;
  824.         rev->accept = 1;

  826. #if (NGX_HAVE_DEFERRED_ACCEPT)
  827.         rev->deferred_accept = ls[i].deferred_accept;
  828. #endif

  830.         if (cycle->old_cycle) {
  831.             if (ls[i].previous) {

  833.                 /*
  834.                  * delete the old accept events that were bound to
  835.                  * the old cycle read events array
  836.                  */

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

  840.                 if (ngx_del_event(old->read, NGX_READ_EVENT, NGX_CLOSE_EVENT)
  841.                     == NGX_ERROR)
  842.                 {
  843.                     return NGX_ERROR;
  844.                 }

  846.                 old->fd = (ngx_socket_t) -1;
  847.             }
  848.         }

  850. #if (NGX_WIN32)

  852.         rev->handler = ngx_event_accept;

  854.         if (ngx_use_accept_mutex) {
  855.             continue;
  856.         }

  858.         if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  859.             return NGX_ERROR;
  860.         }

  862. #else

  864.         if (c->type == SOCK_STREAM) {
  865.             rev->handler = ngx_event_accept;

  867. #if (NGX_QUIC)
  868.         } else if (ls[i].quic) {
  869.             rev->handler = ngx_quic_recvmsg;
  870. #endif
  871.         } else {
  872.             rev->handler = ngx_event_recvmsg;
  873.         }

  875. #if (NGX_HAVE_REUSEPORT)

  877.         if (ls[i].reuseport) {
  878.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  879.                 return NGX_ERROR;
  880.             }

  882.             continue;
  883.         }

  885. #endif

  887.         if (ngx_use_accept_mutex) {
  888.             continue;
  889.         }

  891. #if (NGX_HAVE_EPOLLEXCLUSIVE)

  893.         if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
  894.             && ccf->worker_processes > 1)
  895.         {
  896.             ngx_use_exclusive_accept = 1;

  898.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_EXCLUSIVE_EVENT)
  899.                 == NGX_ERROR)
  900.             {
  901.                 return NGX_ERROR;
  902.             }

  904.             continue;
  905.         }

  907. #endif

  909.         if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  910.             return NGX_ERROR;
  911.         }

  913. #endif

  915.     }

  917.     return NGX_OK;
  918. }


  921. ngx_int_t
  922. ‌ngx_send_lowat(ngx_connection_t *c, size_t lowat)
  923. {
  924.     int  sndlowat;

  926. #if (NGX_HAVE_LOWAT_EVENT)

  928.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  929.         c->write->available = lowat;
  930.         return NGX_OK;
  931.     }

  933. #endif

  935.     if (lowat == 0 || c->sndlowat) {
  936.         return NGX_OK;
  937.     }

  939.     sndlowat = (int) lowat;

  941.     if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT,
  942.                    (const void *) &sndlowat, sizeof(int))
  943.         == -1)
  944.     {
  945.         ngx_connection_error(c, ngx_socket_errno,
  946.                              "setsockopt(SO_SNDLOWAT) failed");
  947.         return NGX_ERROR;
  948.     }

  950.     c->sndlowat = 1;

  952.     return NGX_OK;
  953. }


  956. static char *
  957. ‌ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  958. {
  959.     char                 *rv;
  960.     void               ***ctx;
  961.     ngx_uint_t            i;
  962.     ngx_conf_t            pcf;
  963.     ngx_event_module_t   *m;

  965.     if (*(void **) conf) {
  966.         return "is duplicate";
  967.     }

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

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

  973.     ctx = ngx_pcalloc(cf->pool, sizeof(void *));
  974.     if (ctx == NULL) {
  975.         return NGX_CONF_ERROR;
  976.     }

  978.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));
  979.     if (*ctx == NULL) {
  980.         return NGX_CONF_ERROR;
  981.     }

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

  985.     for (i = 0; cf->cycle->modules[i]; i++) {
  986.         if (cf->cycle->modules[i]->type != NGX_EVENT_MODULE) {
  987.             continue;
  988.         }

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

  992.         if (m->create_conf) {
  993.             (*ctx)[cf->cycle->modules[i]->ctx_index] =
  994.                                                      m->create_conf(cf->cycle);
  995.             if ((*ctx)[cf->cycle->modules[i]->ctx_index] == NULL) {
  996.                 return NGX_CONF_ERROR;
  997.             }
  998.         }
  999.     }

  1001.     pcf = *cf;
  1002.     cf->ctx = ctx;
  1003.     cf->module_type = NGX_EVENT_MODULE;
  1004.     cf->cmd_type = NGX_EVENT_CONF;

  1006.     rv = ngx_conf_parse(cf, NULL);

  1008.     *cf = pcf;

  1010.     if (rv != NGX_CONF_OK) {
  1011.         return rv;
  1012.     }

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

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

  1021.         if (m->init_conf) {
  1022.             rv = m->init_conf(cf->cycle,
  1023.                               (*ctx)[cf->cycle->modules[i]->ctx_index]);
  1024.             if (rv != NGX_CONF_OK) {
  1025.                 return rv;
  1026.             }
  1027.         }
  1028.     }

  1030.     return NGX_CONF_OK;
  1031. }


  1034. static char *
  1035. ‌ngx_event_connections(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1036. {
  1037.     ngx_event_conf_t  *ecf = conf;

  1039.     ngx_str_t  *value;

  1041.     if (ecf->connections != NGX_CONF_UNSET_UINT) {
  1042.         return "is duplicate";
  1043.     }

  1045.     value = cf->args->elts;
  1046.     ecf->connections = ngx_atoi(value[1].data, value[1].len);
  1047.     if (ecf->connections == (ngx_uint_t) NGX_ERROR) {
  1048.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1049.                            "invalid number \"%V\"", &value[1]);

  1051.         return NGX_CONF_ERROR;
  1052.     }

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

  1056.     return NGX_CONF_OK;
  1057. }


  1060. static char *
  1061. ‌ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1062. {
  1063.     ngx_event_conf_t  *ecf = conf;

  1065.     ngx_int_t             m;
  1066.     ngx_str_t            *value;
  1067.     ngx_event_conf_t     *old_ecf;
  1068.     ngx_event_module_t   *module;

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

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

  1076.     if (cf->cycle->old_cycle->conf_ctx) {
  1077.         old_ecf = ngx_event_get_conf(cf->cycle->old_cycle->conf_ctx,
  1078.                                      ngx_event_core_module);
  1079.     } else {
  1080.         old_ecf = NULL;
  1081.     }


  1084.     for (m = 0; cf->cycle->modules[m]; m++) {
  1085.         if (cf->cycle->modules[m]->type != NGX_EVENT_MODULE) {
  1086.             continue;
  1087.         }

  1089.         module = cf->cycle->modules[m]->ctx;
  1090.         if (module->name->len == value[1].len) {
  1091.             if (ngx_strcmp(module->name->data, value[1].data) == 0) {
  1092.                 ecf->use = cf->cycle->modules[m]->ctx_index;
  1093.                 ecf->name = module->name->data;

  1095.                 if (ngx_process == NGX_PROCESS_SINGLE
  1096.                     && old_ecf
  1097.                     && old_ecf->use != ecf->use)
  1098.                 {
  1099.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1100.                                "when the server runs without a master process "
  1101.                                "the \"%V\" event type must be the same as "
  1102.                                "in previous configuration - \"%s\" "
  1103.                                "and it cannot be changed on the fly, "
  1104.                                "to change it you need to stop server "
  1105.                                "and start it again",
  1106.                                &value[1], old_ecf->name);

  1108.                     return NGX_CONF_ERROR;
  1109.                 }

  1111.                 return NGX_CONF_OK;
  1112.             }
  1113.         }
  1114.     }

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

  1119.     return NGX_CONF_ERROR;
  1120. }


  1123. static char *
  1124. ‌ngx_event_debug_connection(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1125. {
  1126. #if (NGX_DEBUG)
  1127.     ngx_event_conf_t  *ecf = conf;

  1129.     ngx_int_t             rc;
  1130.     ngx_str_t            *value;
  1131.     ngx_url_t             u;
  1132.     ngx_cidr_t            c, *cidr;
  1133.     ngx_uint_t            i;
  1134.     struct sockaddr_in   *sin;
  1135. #if (NGX_HAVE_INET6)
  1136.     struct sockaddr_in6  *sin6;
  1137. #endif

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

  1141. #if (NGX_HAVE_UNIX_DOMAIN)

  1143.     if (ngx_strcmp(value[1].data, "unix:") == 0) {
  1144.         cidr = ngx_array_push(&ecf->debug_connection);
  1145.         if (cidr == NULL) {
  1146.             return NGX_CONF_ERROR;
  1147.         }

  1149.         cidr->family = AF_UNIX;
  1150.         return NGX_CONF_OK;
  1151.     }

  1153. #endif

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

  1157.     if (rc != NGX_ERROR) {
  1158.         if (rc == NGX_DONE) {
  1159.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1160.                                "low address bits of %V are meaningless",
  1161.                                &value[1]);
  1162.         }

  1164.         cidr = ngx_array_push(&ecf->debug_connection);
  1165.         if (cidr == NULL) {
  1166.             return NGX_CONF_ERROR;
  1167.         }

  1169.         *cidr = c;

  1171.         return NGX_CONF_OK;
  1172.     }

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

  1177.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  1178.         if (u.err) {
  1179.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1180.                                "%s in debug_connection \"%V\"",
  1181.                                u.err, &u.host);
  1182.         }

  1184.         return NGX_CONF_ERROR;
  1185.     }

  1187.     cidr = ngx_array_push_n(&ecf->debug_connection, u.naddrs);
  1188.     if (cidr == NULL) {
  1189.         return NGX_CONF_ERROR;
  1190.     }

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

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

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

  1199. #if (NGX_HAVE_INET6)
  1200.         case AF_INET6:
  1201.             sin6 = (struct sockaddr_in6 *) u.addrs[i].sockaddr;
  1202.             cidr[i].u.in6.addr = sin6->sin6_addr;
  1203.             ngx_memset(cidr[i].u.in6.mask.s6_addr, 0xff, 16);
  1204.             break;
  1205. #endif

  1207.         default: /* AF_INET */
  1208.             sin = (struct sockaddr_in *) u.addrs[i].sockaddr;
  1209.             cidr[i].u.in.addr = sin->sin_addr.s_addr;
  1210.             cidr[i].u.in.mask = 0xffffffff;
  1211.             break;
  1212.         }
  1213.     }

  1215. #else

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

  1221. #endif

  1223.     return NGX_CONF_OK;
  1224. }


  1227. static void *
  1228. ‌ngx_event_core_create_conf(ngx_cycle_t *cycle)
  1229. {
  1230.     ngx_event_conf_t  *ecf;

  1232.     ecf = ngx_palloc(cycle->pool, sizeof(ngx_event_conf_t));
  1233.     if (ecf == NULL) {
  1234.         return NULL;
  1235.     }

  1237.     ecf->connections = NGX_CONF_UNSET_UINT;
  1238.     ecf->use = NGX_CONF_UNSET_UINT;
  1239.     ecf->multi_accept = NGX_CONF_UNSET;
  1240.     ecf->accept_mutex = NGX_CONF_UNSET;
  1241.     ecf->accept_mutex_delay = NGX_CONF_UNSET_MSEC;
  1242.     ecf->name = (void *) NGX_CONF_UNSET;

  1244. #if (NGX_DEBUG)

  1246.     if (ngx_array_init(&ecf->debug_connection, cycle->pool, 4,
  1247.                        sizeof(ngx_cidr_t)) == NGX_ERROR)
  1248.     {
  1249.         return NULL;
  1250.     }

  1252. #endif

  1254.     return ecf;
  1255. }


  1258. static char *
  1259. ‌ngx_event_core_init_conf(ngx_cycle_t *cycle, void *conf)
  1260. {
  1261.     ngx_event_conf_t  *ecf = conf;

  1263. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)
  1264.     int                  fd;
  1265. #endif
  1266.     ngx_int_t            i;
  1267.     ngx_module_t        *module;
  1268.     ngx_event_module_t  *event_module;

  1270.     module = NULL;

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

  1274.     fd = epoll_create(100);

  1276.     if (fd != -1) {
  1277.         (void) close(fd);
  1278.         module = &ngx_epoll_module;

  1280.     } else if (ngx_errno != NGX_ENOSYS) {
  1281.         module = &ngx_epoll_module;
  1282.     }

  1284. #endif

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

  1288.     module = &ngx_devpoll_module;

  1290. #endif

  1292. #if (NGX_HAVE_KQUEUE)

  1294.     module = &ngx_kqueue_module;

  1296. #endif

  1298. #if (NGX_HAVE_SELECT)

  1300.     if (module == NULL) {
  1301.         module = &ngx_select_module;
  1302.     }

  1304. #endif

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

  1309.             if (cycle->modules[i]->type != NGX_EVENT_MODULE) {
  1310.                 continue;
  1311.             }

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

  1315.             if (ngx_strcmp(event_module->name->data, event_core_name.data) == 0)
  1316.             {
  1317.                 continue;
  1318.             }

  1320.             module = cycle->modules[i];
  1321.             break;
  1322.         }
  1323.     }

  1325.     if (module == NULL) {
  1326.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "no events module found");
  1327.         return NGX_CONF_ERROR;
  1328.     }

  1330.     ngx_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);
  1331.     cycle->connection_n = ecf->connections;

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

  1335.     event_module = module->ctx;
  1336.     ngx_conf_init_ptr_value(ecf->name, event_module->name->data);

  1338.     ngx_conf_init_value(ecf->multi_accept, 0);
  1339.     ngx_conf_init_value(ecf->accept_mutex, 0);
  1340.     ngx_conf_init_msec_value(ecf->accept_mutex_delay, 500);

  1342.     return NGX_CONF_OK;
  1343. }

One Level Up Top Level