One Level Up Top Level

src/event/ngx_event.c - nginx-1.7.10

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_rtsig_module;
  21. extern ngx_module_t ngx_select_module;


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

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

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


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

  42. ‌static ngx_uint_t     ngx_event_max_module;

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


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


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


  61. #if (NGX_STAT_STUB)

  63. ‌ngx_atomic_t   ngx_stat_accepted0;
  64. ‌ngx_atomic_t  *ngx_stat_accepted = &ngx_stat_accepted0;
  65. ‌ngx_atomic_t   ngx_stat_handled0;
  66. ‌ngx_atomic_t  *ngx_stat_handled = &ngx_stat_handled0;
  67. ‌ngx_atomic_t   ngx_stat_requests0;
  68. ‌ngx_atomic_t  *ngx_stat_requests = &ngx_stat_requests0;
  69. ‌ngx_atomic_t   ngx_stat_active0;
  70. ‌ngx_atomic_t  *ngx_stat_active = &ngx_stat_active0;
  71. ‌ngx_atomic_t   ngx_stat_reading0;
  72. ‌ngx_atomic_t  *ngx_stat_reading = &ngx_stat_reading0;
  73. ‌ngx_atomic_t   ngx_stat_writing0;
  74. ‌ngx_atomic_t  *ngx_stat_writing = &ngx_stat_writing0;
  75. ‌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("connections"),
  131.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  132.       ngx_event_connections,
  133.       0,
  134.       0,
  135.       NULL },

  137.     { ngx_string("use"),
  138.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  139.       ngx_event_use,
  140.       0,
  141.       0,
  142.       NULL },

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

  151.     { ngx_string("accept_mutex"),
  152.       NGX_EVENT_CONF|NGX_CONF_FLAG,
  153.       ngx_conf_set_flag_slot,
  154.       0,
  155.       offsetof(ngx_event_conf_t, accept_mutex),
  156.       NULL },

  158.     { ngx_string("accept_mutex_delay"),
  159.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  160.       ngx_conf_set_msec_slot,
  161.       0,
  162.       offsetof(ngx_event_conf_t, accept_mutex_delay),
  163.       NULL },

  165.     { ngx_string("debug_connection"),
  166.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  167.       ngx_event_debug_connection,
  168.       0,
  169.       0,
  170.       NULL },

  172.       ngx_null_command
  173. };


  176. ‌ngx_event_module_t  ngx_event_core_module_ctx = {
  177.     &event_core_name,
  178.     ngx_event_core_create_conf,            /* create configuration */
  179.     ngx_event_core_init_conf,              /* init configuration */

  181.     { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
  182. };


  185. ‌ngx_module_t  ngx_event_core_module = {
  186.     NGX_MODULE_V1,
  187.     &ngx_event_core_module_ctx,            /* module context */
  188.     ngx_event_core_commands,               /* module directives */
  189.     NGX_EVENT_MODULE,                      /* module type */
  190.     NULL,                                  /* init master */
  191.     ngx_event_module_init,                 /* init module */
  192.     ngx_event_process_init,                /* init process */
  193.     NULL,                                  /* init thread */
  194.     NULL,                                  /* exit thread */
  195.     NULL,                                  /* exit process */
  196.     NULL,                                  /* exit master */
  197.     NGX_MODULE_V1_PADDING
  198. };


  201. void
  202. ‌ngx_process_events_and_timers(ngx_cycle_t *cycle)
  203. {
  204.     ngx_uint_t  flags;
  205.     ngx_msec_t  timer, delta;

  207.     if (ngx_timer_resolution) {
  208.         timer = NGX_TIMER_INFINITE;
  209.         flags = 0;

  211.     } else {
  212.         timer = ngx_event_find_timer();
  213.         flags = NGX_UPDATE_TIME;

  215. #if (NGX_THREADS)

  217.         if (timer == NGX_TIMER_INFINITE || timer > 500) {
  218.             timer = 500;
  219.         }

  221. #endif
  222.     }

  224.     if (ngx_use_accept_mutex) {
  225.         if (ngx_accept_disabled > 0) {
  226.             ngx_accept_disabled--;

  228.         } else {
  229.             if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
  230.                 return;
  231.             }

  233.             if (ngx_accept_mutex_held) {
  234.                 flags |= NGX_POST_EVENTS;

  236.             } else {
  237.                 if (timer == NGX_TIMER_INFINITE
  238.                     || timer > ngx_accept_mutex_delay)
  239.                 {
  240.                     timer = ngx_accept_mutex_delay;
  241.                 }
  242.             }
  243.         }
  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.     if (delta) {
  262.         ngx_event_expire_timers();
  263.     }

  265.     ngx_event_process_posted(cycle, &ngx_posted_events);
  266. }


  269. ngx_int_t
  270. ‌ngx_handle_read_event(ngx_event_t *rev, ngx_uint_t flags)
  271. {
  272.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  274.         /* kqueue, epoll */

  276.         if (!rev->active && !rev->ready) {
  277.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_CLEAR_EVENT)
  278.                 == NGX_ERROR)
  279.             {
  280.                 return NGX_ERROR;
  281.             }
  282.         }

  284.         return NGX_OK;

  286.     } else if (ngx_event_flags & NGX_USE_LEVEL_EVENT) {

  288.         /* select, poll, /dev/poll */

  290.         if (!rev->active && !rev->ready) {
  291.             if (ngx_add_event(rev, NGX_READ_EVENT, NGX_LEVEL_EVENT)
  292.                 == NGX_ERROR)
  293.             {
  294.                 return NGX_ERROR;
  295.             }

  297.             return NGX_OK;
  298.         }

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

  307.             return NGX_OK;
  308.         }

  310.     } else if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {

  312.         /* event ports */

  314.         if (!rev->active && !rev->ready) {
  315.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  316.                 return NGX_ERROR;
  317.             }

  319.             return NGX_OK;
  320.         }

  322.         if (rev->oneshot && !rev->ready) {
  323.             if (ngx_del_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  324.                 return NGX_ERROR;
  325.             }

  327.             return NGX_OK;
  328.         }
  329.     }

  331.     /* aio, iocp, rtsig */

  333.     return NGX_OK;
  334. }


  337. ngx_int_t
  338. ‌ngx_handle_write_event(ngx_event_t *wev, size_t lowat)
  339. {
  340.     ngx_connection_t  *c;

  342.     if (lowat) {
  343.         c = wev->data;

  345.         if (ngx_send_lowat(c, lowat) == NGX_ERROR) {
  346.             return NGX_ERROR;
  347.         }
  348.     }

  350.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  352.         /* kqueue, epoll */

  354.         if (!wev->active && !wev->ready) {
  355.             if (ngx_add_event(wev, NGX_WRITE_EVENT,
  356.                               NGX_CLEAR_EVENT | (lowat ? NGX_LOWAT_EVENT : 0))
  357.                 == NGX_ERROR)
  358.             {
  359.                 return NGX_ERROR;
  360.             }
  361.         }

  363.         return NGX_OK;

  365.     } else if (ngx_event_flags & NGX_USE_LEVEL_EVENT) {

  367.         /* select, poll, /dev/poll */

  369.         if (!wev->active && !wev->ready) {
  370.             if (ngx_add_event(wev, NGX_WRITE_EVENT, NGX_LEVEL_EVENT)
  371.                 == NGX_ERROR)
  372.             {
  373.                 return NGX_ERROR;
  374.             }

  376.             return NGX_OK;
  377.         }

  379.         if (wev->active && wev->ready) {
  380.             if (ngx_del_event(wev, NGX_WRITE_EVENT, NGX_LEVEL_EVENT)
  381.                 == NGX_ERROR)
  382.             {
  383.                 return NGX_ERROR;
  384.             }

  386.             return NGX_OK;
  387.         }

  389.     } else if (ngx_event_flags & NGX_USE_EVENTPORT_EVENT) {

  391.         /* event ports */

  393.         if (!wev->active && !wev->ready) {
  394.             if (ngx_add_event(wev, NGX_WRITE_EVENT, 0) == NGX_ERROR) {
  395.                 return NGX_ERROR;
  396.             }

  398.             return NGX_OK;
  399.         }

  401.         if (wev->oneshot && wev->ready) {
  402.             if (ngx_del_event(wev, NGX_WRITE_EVENT, 0) == NGX_ERROR) {
  403.                 return NGX_ERROR;
  404.             }

  406.             return NGX_OK;
  407.         }
  408.     }

  410.     /* aio, iocp, rtsig */

  412.     return NGX_OK;
  413. }


  416. static char *
  417. ‌ngx_event_init_conf(ngx_cycle_t *cycle, void *conf)
  418. {
  419.     if (ngx_get_conf(cycle->conf_ctx, ngx_events_module) == NULL) {
  420.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  421.                       "no \"events\" section in configuration");
  422.         return NGX_CONF_ERROR;
  423.     }

  425.     return NGX_CONF_OK;
  426. }


  429. static ngx_int_t
  430. ‌ngx_event_module_init(ngx_cycle_t *cycle)
  431. {
  432.     void              ***cf;
  433.     u_char              *shared;
  434.     size_t               size, cl;
  435.     ngx_shm_t            shm;
  436.     ngx_time_t          *tp;
  437.     ngx_core_conf_t     *ccf;
  438.     ngx_event_conf_t    *ecf;

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

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

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

  450.     ngx_timer_resolution = ccf->timer_resolution;

  452. #if !(NGX_WIN32)
  453.     {
  454.     ngx_int_t      limit;
  455.     struct rlimit  rlmt;

  457.     if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  458.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  459.                       "getrlimit(RLIMIT_NOFILE) failed, ignored");

  461.     } else {
  462.         if (ecf->connections > (ngx_uint_t) rlmt.rlim_cur
  463.             && (ccf->rlimit_nofile == NGX_CONF_UNSET
  464.                 || ecf->connections > (ngx_uint_t) ccf->rlimit_nofile))
  465.         {
  466.             limit = (ccf->rlimit_nofile == NGX_CONF_UNSET) ?
  467.                          (ngx_int_t) rlmt.rlim_cur : ccf->rlimit_nofile;

  469.             ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  470.                           "%ui worker_connections exceed "
  471.                           "open file resource limit: %i",
  472.                           ecf->connections, limit);
  473.         }
  474.     }
  475.     }
  476. #endif /* !(NGX_WIN32) */


  479.     if (ccf->master == 0) {
  480.         return NGX_OK;
  481.     }

  483.     if (ngx_accept_mutex_ptr) {
  484.         return NGX_OK;
  485.     }


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

  490.     cl = 128;

  492.     size = cl            /* ngx_accept_mutex */
  493.            + cl          /* ngx_connection_counter */
  494.            + cl;         /* ngx_temp_number */

  496. #if (NGX_STAT_STUB)

  498.     size += cl           /* ngx_stat_accepted */
  499.            + cl          /* ngx_stat_handled */
  500.            + cl          /* ngx_stat_requests */
  501.            + cl          /* ngx_stat_active */
  502.            + cl          /* ngx_stat_reading */
  503.            + cl          /* ngx_stat_writing */
  504.            + cl;         /* ngx_stat_waiting */

  506. #endif

  508.     shm.size = size;
  509.     shm.name.len = sizeof("nginx_shared_zone");
  510.     shm.name.data = (u_char *) "nginx_shared_zone";
  511.     shm.log = cycle->log;

  513.     if (ngx_shm_alloc(&shm) != NGX_OK) {
  514.         return NGX_ERROR;
  515.     }

  517.     shared = shm.addr;

  519.     ngx_accept_mutex_ptr = (ngx_atomic_t *) shared;
  520.     ngx_accept_mutex.spin = (ngx_uint_t) -1;

  522.     if (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) shared,
  523.                          cycle->lock_file.data)
  524.         != NGX_OK)
  525.     {
  526.         return NGX_ERROR;
  527.     }

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

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

  533.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  534.                    "counter: %p, %d",
  535.                    ngx_connection_counter, *ngx_connection_counter);

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

  539.     tp = ngx_timeofday();

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

  543. #if (NGX_STAT_STUB)

  545.     ngx_stat_accepted = (ngx_atomic_t *) (shared + 3 * cl);
  546.     ngx_stat_handled = (ngx_atomic_t *) (shared + 4 * cl);
  547.     ngx_stat_requests = (ngx_atomic_t *) (shared + 5 * cl);
  548.     ngx_stat_active = (ngx_atomic_t *) (shared + 6 * cl);
  549.     ngx_stat_reading = (ngx_atomic_t *) (shared + 7 * cl);
  550.     ngx_stat_writing = (ngx_atomic_t *) (shared + 8 * cl);
  551.     ngx_stat_waiting = (ngx_atomic_t *) (shared + 9 * cl);

  553. #endif

  555.     return NGX_OK;
  556. }


  559. #if !(NGX_WIN32)

  561. static void
  562. ‌ngx_timer_signal_handler(int signo)
  563. {
  564.     ngx_event_timer_alarm = 1;

  566. #if 1
  567.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");
  568. #endif
  569. }

  571. #endif


  574. static ngx_int_t
  575. ‌ngx_event_process_init(ngx_cycle_t *cycle)
  576. {
  577.     ngx_uint_t           m, i;
  578.     ngx_event_t         *rev, *wev;
  579.     ngx_listening_t     *ls;
  580.     ngx_connection_t    *c, *next, *old;
  581.     ngx_core_conf_t     *ccf;
  582.     ngx_event_conf_t    *ecf;
  583.     ngx_event_module_t  *module;

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

  588.     if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
  589.         ngx_use_accept_mutex = 1;
  590.         ngx_accept_mutex_held = 0;
  591.         ngx_accept_mutex_delay = ecf->accept_mutex_delay;

  593.     } else {
  594.         ngx_use_accept_mutex = 0;
  595.     }

  597. #if (NGX_WIN32)

  599.     /*
  600.      * disable accept mutex on win32 as it may cause deadlock if
  601.      * grabbed by a process which can't accept connections
  602.      */

  604.     ngx_use_accept_mutex = 0;

  606. #endif

  608.     ngx_queue_init(&ngx_posted_accept_events);
  609.     ngx_queue_init(&ngx_posted_events);

  611.     if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
  612.         return NGX_ERROR;
  613.     }

  615.     for (m = 0; ngx_modules[m]; m++) {
  616.         if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
  617.             continue;
  618.         }

  620.         if (ngx_modules[m]->ctx_index != ecf->use) {
  621.             continue;
  622.         }

  624.         module = ngx_modules[m]->ctx;

  626.         if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
  627.             /* fatal */
  628.             exit(2);
  629.         }

  631.         break;
  632.     }

  634. #if !(NGX_WIN32)

  636.     if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
  637.         struct sigaction  sa;
  638.         struct itimerval  itv;

  640.         ngx_memzero(&sa, sizeof(struct sigaction));
  641.         sa.sa_handler = ngx_timer_signal_handler;
  642.         sigemptyset(&sa.sa_mask);

  644.         if (sigaction(SIGALRM, &sa, NULL) == -1) {
  645.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  646.                           "sigaction(SIGALRM) failed");
  647.             return NGX_ERROR;
  648.         }

  650.         itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
  651.         itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
  652.         itv.it_value.tv_sec = ngx_timer_resolution / 1000;
  653.         itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;

  655.         if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
  656.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  657.                           "setitimer() failed");
  658.         }
  659.     }

  661.     if (ngx_event_flags & NGX_USE_FD_EVENT) {
  662.         struct rlimit  rlmt;

  664.         if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  665.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  666.                           "getrlimit(RLIMIT_NOFILE) failed");
  667.             return NGX_ERROR;
  668.         }

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

  672.         cycle->files = ngx_calloc(sizeof(ngx_connection_t *) * cycle->files_n,
  673.                                   cycle->log);
  674.         if (cycle->files == NULL) {
  675.             return NGX_ERROR;
  676.         }
  677.     }

  679. #endif

  681.     cycle->connections =
  682.         ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
  683.     if (cycle->connections == NULL) {
  684.         return NGX_ERROR;
  685.     }

  687.     c = cycle->connections;

  689.     cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  690.                                    cycle->log);
  691.     if (cycle->read_events == NULL) {
  692.         return NGX_ERROR;
  693.     }

  695.     rev = cycle->read_events;
  696.     for (i = 0; i < cycle->connection_n; i++) {
  697.         rev[i].closed = 1;
  698.         rev[i].instance = 1;
  699.     }

  701.     cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
  702.                                     cycle->log);
  703.     if (cycle->write_events == NULL) {
  704.         return NGX_ERROR;
  705.     }

  707.     wev = cycle->write_events;
  708.     for (i = 0; i < cycle->connection_n; i++) {
  709.         wev[i].closed = 1;
  710.     }

  712.     i = cycle->connection_n;
  713.     next = NULL;

  715.     do {
  716.         i--;

  718.         c[i].data = next;
  719.         c[i].read = &cycle->read_events[i];
  720.         c[i].write = &cycle->write_events[i];
  721.         c[i].fd = (ngx_socket_t) -1;

  723.         next = &c[i];

  725. #if (NGX_THREADS)
  726.         c[i].lock = 0;
  727. #endif
  728.     } while (i);

  730.     cycle->free_connections = next;
  731.     cycle->free_connection_n = cycle->connection_n;

  733.     /* for each listening socket */

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

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

  740.         if (c == NULL) {
  741.             return NGX_ERROR;
  742.         }

  744.         c->log = &ls[i].log;

  746.         c->listening = &ls[i];
  747.         ls[i].connection = c;

  749.         rev = c->read;

  751.         rev->log = c->log;
  752.         rev->accept = 1;

  754. #if (NGX_HAVE_DEFERRED_ACCEPT)
  755.         rev->deferred_accept = ls[i].deferred_accept;
  756. #endif

  758.         if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {
  759.             if (ls[i].previous) {

  761.                 /*
  762.                  * delete the old accept events that were bound to
  763.                  * the old cycle read events array
  764.                  */

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

  768.                 if (ngx_del_event(old->read, NGX_READ_EVENT, NGX_CLOSE_EVENT)
  769.                     == NGX_ERROR)
  770.                 {
  771.                     return NGX_ERROR;
  772.                 }

  774.                 old->fd = (ngx_socket_t) -1;
  775.             }
  776.         }

  778. #if (NGX_WIN32)

  780.         if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  781.             ngx_iocp_conf_t  *iocpcf;

  783.             rev->handler = ngx_event_acceptex;

  785.             if (ngx_use_accept_mutex) {
  786.                 continue;
  787.             }

  789.             if (ngx_add_event(rev, 0, NGX_IOCP_ACCEPT) == NGX_ERROR) {
  790.                 return NGX_ERROR;
  791.             }

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

  795.             iocpcf = ngx_event_get_conf(cycle->conf_ctx, ngx_iocp_module);
  796.             if (ngx_event_post_acceptex(&ls[i], iocpcf->post_acceptex)
  797.                 == NGX_ERROR)
  798.             {
  799.                 return NGX_ERROR;
  800.             }

  802.         } else {
  803.             rev->handler = ngx_event_accept;

  805.             if (ngx_use_accept_mutex) {
  806.                 continue;
  807.             }

  809.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  810.                 return NGX_ERROR;
  811.             }
  812.         }

  814. #else

  816.         rev->handler = ngx_event_accept;

  818.         if (ngx_use_accept_mutex) {
  819.             continue;
  820.         }

  822.         if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
  823.             if (ngx_add_conn(c) == NGX_ERROR) {
  824.                 return NGX_ERROR;
  825.             }

  827.         } else {
  828.             if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
  829.                 return NGX_ERROR;
  830.             }
  831.         }

  833. #endif

  835.     }

  837.     return NGX_OK;
  838. }


  841. ngx_int_t
  842. ‌ngx_send_lowat(ngx_connection_t *c, size_t lowat)
  843. {
  844.     int  sndlowat;

  846. #if (NGX_HAVE_LOWAT_EVENT)

  848.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  849.         c->write->available = lowat;
  850.         return NGX_OK;
  851.     }

  853. #endif

  855.     if (lowat == 0 || c->sndlowat) {
  856.         return NGX_OK;
  857.     }

  859.     sndlowat = (int) lowat;

  861.     if (setsockopt(c->fd, SOL_SOCKET, SO_SNDLOWAT,
  862.                    (const void *) &sndlowat, sizeof(int))
  863.         == -1)
  864.     {
  865.         ngx_connection_error(c, ngx_socket_errno,
  866.                              "setsockopt(SO_SNDLOWAT) failed");
  867.         return NGX_ERROR;
  868.     }

  870.     c->sndlowat = 1;

  872.     return NGX_OK;
  873. }


  876. static char *
  877. ‌ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  878. {
  879.     char                 *rv;
  880.     void               ***ctx;
  881.     ngx_uint_t            i;
  882.     ngx_conf_t            pcf;
  883.     ngx_event_module_t   *m;

  885.     if (*(void **) conf) {
  886.         return "is duplicate";
  887.     }

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

  891.     ngx_event_max_module = 0;
  892.     for (i = 0; ngx_modules[i]; i++) {
  893.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {
  894.             continue;
  895.         }

  897.         ngx_modules[i]->ctx_index = ngx_event_max_module++;
  898.     }

  900.     ctx = ngx_pcalloc(cf->pool, sizeof(void *));
  901.     if (ctx == NULL) {
  902.         return NGX_CONF_ERROR;
  903.     }

  905.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));
  906.     if (*ctx == NULL) {
  907.         return NGX_CONF_ERROR;
  908.     }

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

  912.     for (i = 0; ngx_modules[i]; i++) {
  913.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {
  914.             continue;
  915.         }

  917.         m = ngx_modules[i]->ctx;

  919.         if (m->create_conf) {
  920.             (*ctx)[ngx_modules[i]->ctx_index] = m->create_conf(cf->cycle);
  921.             if ((*ctx)[ngx_modules[i]->ctx_index] == NULL) {
  922.                 return NGX_CONF_ERROR;
  923.             }
  924.         }
  925.     }

  927.     pcf = *cf;
  928.     cf->ctx = ctx;
  929.     cf->module_type = NGX_EVENT_MODULE;
  930.     cf->cmd_type = NGX_EVENT_CONF;

  932.     rv = ngx_conf_parse(cf, NULL);

  934.     *cf = pcf;

  936.     if (rv != NGX_CONF_OK)
  937.         return rv;

  939.     for (i = 0; ngx_modules[i]; i++) {
  940.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {
  941.             continue;
  942.         }

  944.         m = ngx_modules[i]->ctx;

  946.         if (m->init_conf) {
  947.             rv = m->init_conf(cf->cycle, (*ctx)[ngx_modules[i]->ctx_index]);
  948.             if (rv != NGX_CONF_OK) {
  949.                 return rv;
  950.             }
  951.         }
  952.     }

  954.     return NGX_CONF_OK;
  955. }


  958. static char *
  959. ‌ngx_event_connections(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  960. {
  961.     ngx_event_conf_t  *ecf = conf;

  963.     ngx_str_t  *value;

  965.     if (ecf->connections != NGX_CONF_UNSET_UINT) {
  966.         return "is duplicate";
  967.     }

  969.     if (ngx_strcmp(cmd->name.data, "connections") == 0) {
  970.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  971.                            "the \"connections\" directive is deprecated, "
  972.                            "use the \"worker_connections\" directive instead");
  973.     }

  975.     value = cf->args->elts;
  976.     ecf->connections = ngx_atoi(value[1].data, value[1].len);
  977.     if (ecf->connections == (ngx_uint_t) NGX_ERROR) {
  978.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  979.                            "invalid number \"%V\"", &value[1]);

  981.         return NGX_CONF_ERROR;
  982.     }

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

  986.     return NGX_CONF_OK;
  987. }


  990. static char *
  991. ‌ngx_event_use(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  992. {
  993.     ngx_event_conf_t  *ecf = conf;

  995.     ngx_int_t             m;
  996.     ngx_str_t            *value;
  997.     ngx_event_conf_t     *old_ecf;
  998.     ngx_event_module_t   *module;

  1000.     if (ecf->use != NGX_CONF_UNSET_UINT) {
  1001.         return "is duplicate";
  1002.     }

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

  1006.     if (cf->cycle->old_cycle->conf_ctx) {
  1007.         old_ecf = ngx_event_get_conf(cf->cycle->old_cycle->conf_ctx,
  1008.                                      ngx_event_core_module);
  1009.     } else {
  1010.         old_ecf = NULL;
  1011.     }


  1014.     for (m = 0; ngx_modules[m]; m++) {
  1015.         if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
  1016.             continue;
  1017.         }

  1019.         module = ngx_modules[m]->ctx;
  1020.         if (module->name->len == value[1].len) {
  1021.             if (ngx_strcmp(module->name->data, value[1].data) == 0) {
  1022.                 ecf->use = ngx_modules[m]->ctx_index;
  1023.                 ecf->name = module->name->data;

  1025.                 if (ngx_process == NGX_PROCESS_SINGLE
  1026.                     && old_ecf
  1027.                     && old_ecf->use != ecf->use)
  1028.                 {
  1029.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1030.                                "when the server runs without a master process "
  1031.                                "the \"%V\" event type must be the same as "
  1032.                                "in previous configuration - \"%s\" "
  1033.                                "and it cannot be changed on the fly, "
  1034.                                "to change it you need to stop server "
  1035.                                "and start it again",
  1036.                                &value[1], old_ecf->name);

  1038.                     return NGX_CONF_ERROR;
  1039.                 }

  1041.                 return NGX_CONF_OK;
  1042.             }
  1043.         }
  1044.     }

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

  1049.     return NGX_CONF_ERROR;
  1050. }


  1053. static char *
  1054. ‌ngx_event_debug_connection(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1055. {
  1056. #if (NGX_DEBUG)
  1057.     ngx_event_conf_t  *ecf = conf;

  1059.     ngx_int_t             rc;
  1060.     ngx_str_t            *value;
  1061.     ngx_url_t             u;
  1062.     ngx_cidr_t            c, *cidr;
  1063.     ngx_uint_t            i;
  1064.     struct sockaddr_in   *sin;
  1065. #if (NGX_HAVE_INET6)
  1066.     struct sockaddr_in6  *sin6;
  1067. #endif

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

  1071. #if (NGX_HAVE_UNIX_DOMAIN)

  1073.     if (ngx_strcmp(value[1].data, "unix:") == 0) {
  1074.         cidr = ngx_array_push(&ecf->debug_connection);
  1075.         if (cidr == NULL) {
  1076.             return NGX_CONF_ERROR;
  1077.         }

  1079.         cidr->family = AF_UNIX;
  1080.         return NGX_CONF_OK;
  1081.     }

  1083. #endif

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

  1087.     if (rc != NGX_ERROR) {
  1088.         if (rc == NGX_DONE) {
  1089.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1090.                                "low address bits of %V are meaningless",
  1091.                                &value[1]);
  1092.         }

  1094.         cidr = ngx_array_push(&ecf->debug_connection);
  1095.         if (cidr == NULL) {
  1096.             return NGX_CONF_ERROR;
  1097.         }

  1099.         *cidr = c;

  1101.         return NGX_CONF_OK;
  1102.     }

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

  1107.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  1108.         if (u.err) {
  1109.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1110.                                "%s in debug_connection \"%V\"",
  1111.                                u.err, &u.host);
  1112.         }

  1114.         return NGX_CONF_ERROR;
  1115.     }

  1117.     cidr = ngx_array_push_n(&ecf->debug_connection, u.naddrs);
  1118.     if (cidr == NULL) {
  1119.         return NGX_CONF_ERROR;
  1120.     }

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

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

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

  1129. #if (NGX_HAVE_INET6)
  1130.         case AF_INET6:
  1131.             sin6 = (struct sockaddr_in6 *) u.addrs[i].sockaddr;
  1132.             cidr[i].u.in6.addr = sin6->sin6_addr;
  1133.             ngx_memset(cidr[i].u.in6.mask.s6_addr, 0xff, 16);
  1134.             break;
  1135. #endif

  1137.         default: /* AF_INET */
  1138.             sin = (struct sockaddr_in *) u.addrs[i].sockaddr;
  1139.             cidr[i].u.in.addr = sin->sin_addr.s_addr;
  1140.             cidr[i].u.in.mask = 0xffffffff;
  1141.             break;
  1142.         }
  1143.     }

  1145. #else

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

  1151. #endif

  1153.     return NGX_CONF_OK;
  1154. }


  1157. static void *
  1158. ‌ngx_event_core_create_conf(ngx_cycle_t *cycle)
  1159. {
  1160.     ngx_event_conf_t  *ecf;

  1162.     ecf = ngx_palloc(cycle->pool, sizeof(ngx_event_conf_t));
  1163.     if (ecf == NULL) {
  1164.         return NULL;
  1165.     }

  1167.     ecf->connections = NGX_CONF_UNSET_UINT;
  1168.     ecf->use = NGX_CONF_UNSET_UINT;
  1169.     ecf->multi_accept = NGX_CONF_UNSET;
  1170.     ecf->accept_mutex = NGX_CONF_UNSET;
  1171.     ecf->accept_mutex_delay = NGX_CONF_UNSET_MSEC;
  1172.     ecf->name = (void *) NGX_CONF_UNSET;

  1174. #if (NGX_DEBUG)

  1176.     if (ngx_array_init(&ecf->debug_connection, cycle->pool, 4,
  1177.                        sizeof(ngx_cidr_t)) == NGX_ERROR)
  1178.     {
  1179.         return NULL;
  1180.     }

  1182. #endif

  1184.     return ecf;
  1185. }


  1188. static char *
  1189. ‌ngx_event_core_init_conf(ngx_cycle_t *cycle, void *conf)
  1190. {
  1191.     ngx_event_conf_t  *ecf = conf;

  1193. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)
  1194.     int                  fd;
  1195. #endif
  1196. #if (NGX_HAVE_RTSIG)
  1197.     ngx_uint_t           rtsig;
  1198.     ngx_core_conf_t     *ccf;
  1199. #endif
  1200.     ngx_int_t            i;
  1201.     ngx_module_t        *module;
  1202.     ngx_event_module_t  *event_module;

  1204.     module = NULL;

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

  1208.     fd = epoll_create(100);

  1210.     if (fd != -1) {
  1211.         (void) close(fd);
  1212.         module = &ngx_epoll_module;

  1214.     } else if (ngx_errno != NGX_ENOSYS) {
  1215.         module = &ngx_epoll_module;
  1216.     }

  1218. #endif

  1220. #if (NGX_HAVE_RTSIG)

  1222.     if (module == NULL) {
  1223.         module = &ngx_rtsig_module;
  1224.         rtsig = 1;

  1226.     } else {
  1227.         rtsig = 0;
  1228.     }

  1230. #endif

  1232. #if (NGX_HAVE_DEVPOLL)

  1234.     module = &ngx_devpoll_module;

  1236. #endif

  1238. #if (NGX_HAVE_KQUEUE)

  1240.     module = &ngx_kqueue_module;

  1242. #endif

  1244. #if (NGX_HAVE_SELECT)

  1246.     if (module == NULL) {
  1247.         module = &ngx_select_module;
  1248.     }

  1250. #endif

  1252.     if (module == NULL) {
  1253.         for (i = 0; ngx_modules[i]; i++) {

  1255.             if (ngx_modules[i]->type != NGX_EVENT_MODULE) {
  1256.                 continue;
  1257.             }

  1259.             event_module = ngx_modules[i]->ctx;

  1261.             if (ngx_strcmp(event_module->name->data, event_core_name.data) == 0)
  1262.             {
  1263.                 continue;
  1264.             }

  1266.             module = ngx_modules[i];
  1267.             break;
  1268.         }
  1269.     }

  1271.     if (module == NULL) {
  1272.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "no events module found");
  1273.         return NGX_CONF_ERROR;
  1274.     }

  1276.     ngx_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);
  1277.     cycle->connection_n = ecf->connections;

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

  1281.     event_module = module->ctx;
  1282.     ngx_conf_init_ptr_value(ecf->name, event_module->name->data);

  1284.     ngx_conf_init_value(ecf->multi_accept, 0);
  1285.     ngx_conf_init_value(ecf->accept_mutex, 1);
  1286.     ngx_conf_init_msec_value(ecf->accept_mutex_delay, 500);


  1289. #if (NGX_HAVE_RTSIG)

  1291.     if (!rtsig) {
  1292.         return NGX_CONF_OK;
  1293.     }

  1295.     if (ecf->accept_mutex) {
  1296.         return NGX_CONF_OK;
  1297.     }

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

  1301.     if (ccf->worker_processes == 0) {
  1302.         return NGX_CONF_OK;
  1303.     }

  1305.     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  1306.                   "the \"rtsig\" method requires \"accept_mutex\" to be on");

  1308.     return NGX_CONF_ERROR;

  1310. #else

  1312.     return NGX_CONF_OK;

  1314. #endif
  1315. }

One Level Up Top Level