One Level Up Top Level

src/core/nginx.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <nginx.h>


  13. static void ngx_show_version_info(void);
  14. static ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle);
  15. static void ngx_cleanup_environment(void *data);
  16. static void ngx_cleanup_environment_variable(void *data);
  17. static ngx_int_t ngx_get_options(int argc, char *const *argv);
  18. static ngx_int_t ngx_process_options(ngx_cycle_t *cycle);
  19. static ngx_int_t ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv);
  20. static void *ngx_core_module_create_conf(ngx_cycle_t *cycle);
  21. static char *ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf);
  22. static char *ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  23. static char *ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  24. static char *ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  25. static char *ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd,
  26.     void *conf);
  27. static char *ngx_set_worker_processes(ngx_conf_t *cf, ngx_command_t *cmd,
  28.     void *conf);
  29. static char *ngx_load_module(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  30. #if (NGX_HAVE_DLOPEN)
  31. static void ngx_unload_module(void *data);
  32. #endif


  35. ‌static ngx_conf_enum_t  ngx_debug_points[] = {
  36.     { ngx_string("stop"), NGX_DEBUG_POINTS_STOP },
  37.     { ngx_string("abort"), NGX_DEBUG_POINTS_ABORT },
  38.     { ngx_null_string, 0 }
  39. };


  42. ‌static ngx_command_t  ngx_core_commands[] = {

  44.     { ngx_string("daemon"),
  45.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  46.       ngx_conf_set_flag_slot,
  47.       0,
  48.       offsetof(ngx_core_conf_t, daemon),
  49.       NULL },

  51.     { ngx_string("master_process"),
  52.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  53.       ngx_conf_set_flag_slot,
  54.       0,
  55.       offsetof(ngx_core_conf_t, master),
  56.       NULL },

  58.     { ngx_string("timer_resolution"),
  59.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  60.       ngx_conf_set_msec_slot,
  61.       0,
  62.       offsetof(ngx_core_conf_t, timer_resolution),
  63.       NULL },

  65.     { ngx_string("pid"),
  66.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  67.       ngx_conf_set_str_slot,
  68.       0,
  69.       offsetof(ngx_core_conf_t, pid),
  70.       NULL },

  72.     { ngx_string("lock_file"),
  73.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  74.       ngx_conf_set_str_slot,
  75.       0,
  76.       offsetof(ngx_core_conf_t, lock_file),
  77.       NULL },

  79.     { ngx_string("worker_processes"),
  80.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  81.       ngx_set_worker_processes,
  82.       0,
  83.       0,
  84.       NULL },

  86.     { ngx_string("debug_points"),
  87.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  88.       ngx_conf_set_enum_slot,
  89.       0,
  90.       offsetof(ngx_core_conf_t, debug_points),
  91.       &ngx_debug_points },

  93.     { ngx_string("user"),
  94.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE12,
  95.       ngx_set_user,
  96.       0,
  97.       0,
  98.       NULL },

  100.     { ngx_string("worker_priority"),
  101.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  102.       ngx_set_priority,
  103.       0,
  104.       0,
  105.       NULL },

  107.     { ngx_string("worker_cpu_affinity"),
  108.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_1MORE,
  109.       ngx_set_cpu_affinity,
  110.       0,
  111.       0,
  112.       NULL },

  114.     { ngx_string("worker_rlimit_nofile"),
  115.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  116.       ngx_conf_set_num_slot,
  117.       0,
  118.       offsetof(ngx_core_conf_t, rlimit_nofile),
  119.       NULL },

  121.     { ngx_string("worker_rlimit_core"),
  122.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  123.       ngx_conf_set_off_slot,
  124.       0,
  125.       offsetof(ngx_core_conf_t, rlimit_core),
  126.       NULL },

  128.     { ngx_string("worker_shutdown_timeout"),
  129.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  130.       ngx_conf_set_msec_slot,
  131.       0,
  132.       offsetof(ngx_core_conf_t, shutdown_timeout),
  133.       NULL },

  135.     { ngx_string("working_directory"),
  136.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  137.       ngx_conf_set_str_slot,
  138.       0,
  139.       offsetof(ngx_core_conf_t, working_directory),
  140.       NULL },

  142.     { ngx_string("env"),
  143.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  144.       ngx_set_env,
  145.       0,
  146.       0,
  147.       NULL },

  149.     { ngx_string("load_module"),
  150.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  151.       ngx_load_module,
  152.       0,
  153.       0,
  154.       NULL },

  156.       ngx_null_command
  157. };


  160. ‌static ngx_core_module_t  ngx_core_module_ctx = {
  161.     ngx_string("core"),
  162.     ngx_core_module_create_conf,
  163.     ngx_core_module_init_conf
  164. };


  167. ‌ngx_module_t  ngx_core_module = {
  168.     NGX_MODULE_V1,
  169.     &ngx_core_module_ctx,                  /* module context */
  170.     ngx_core_commands,                     /* module directives */
  171.     NGX_CORE_MODULE,                       /* module type */
  172.     NULL,                                  /* init master */
  173.     NULL,                                  /* init module */
  174.     NULL,                                  /* init process */
  175.     NULL,                                  /* init thread */
  176.     NULL,                                  /* exit thread */
  177.     NULL,                                  /* exit process */
  178.     NULL,                                  /* exit master */
  179.     NGX_MODULE_V1_PADDING
  180. };


  183. ‌static ngx_uint_t   ngx_show_help;
  184. ‌static ngx_uint_t   ngx_show_version;
  185. ‌static ngx_uint_t   ngx_show_configure;
  186. ‌static u_char      *ngx_prefix;
  187. ‌static u_char      *ngx_error_log;
  188. ‌static u_char      *ngx_conf_file;
  189. ‌static u_char      *ngx_conf_params;
  190. #if (NGX_CONTROL_API)
  191. ‌static u_char      *ngx_control_addr;
  192. #endif
  193. ‌static char        *ngx_signal;


  196. ‌static char **ngx_os_environ;


  199. int ngx_cdecl
  200. ‌main(int argc, char *const *argv)
  201. {
  202.     ngx_buf_t        *b;
  203.     ngx_log_t        *log;
  204.     ngx_uint_t        i;
  205.     ngx_cycle_t      *cycle, init_cycle;
  206.     ngx_conf_dump_t  *cd;
  207.     ngx_core_conf_t  *ccf;

  209.     ngx_debug_init();

  211.     if (ngx_strerror_init() != NGX_OK) {
  212.         return 1;
  213.     }

  215.     if (ngx_get_options(argc, argv) != NGX_OK) {
  216.         return 1;
  217.     }

  219.     if (ngx_show_version) {
  220.         ngx_show_version_info();

  222.         if (!ngx_test_config) {
  223.             return 0;
  224.         }
  225.     }

  227.     /* TODO */ ngx_max_sockets = -1;

  229.     ngx_time_init();

  231. #if (NGX_PCRE)
  232.     ngx_regex_init();
  233. #endif

  235.     ngx_pid = ngx_getpid();
  236.     ngx_parent = ngx_getppid();

  238.     log = ngx_log_init(ngx_prefix, ngx_error_log);
  239.     if (log == NULL) {
  240.         return 1;
  241.     }

  243.     /* STUB */
  244. #if (NGX_OPENSSL)
  245.     ngx_ssl_init(log);
  246. #endif

  248.     /*
  249.      * init_cycle->log is required for signal handlers and
  250.      * ngx_process_options()
  251.      */

  253.     ngx_memzero(&init_cycle, sizeof(ngx_cycle_t));
  254.     init_cycle.log = log;
  255.     ngx_cycle = &init_cycle;

  257.     init_cycle.pool = ngx_create_pool(1024, log);
  258.     if (init_cycle.pool == NULL) {
  259.         return 1;
  260.     }

  262.     if (ngx_save_argv(&init_cycle, argc, argv) != NGX_OK) {
  263.         return 1;
  264.     }

  266.     if (ngx_process_options(&init_cycle) != NGX_OK) {
  267.         return 1;
  268.     }

  270.     if (ngx_os_init(log) != NGX_OK) {
  271.         return 1;
  272.     }

  274.     /*
  275.      * ngx_crc32_table_init() requires ngx_cacheline_size set in ngx_os_init()
  276.      */

  278.     if (ngx_crc32_table_init() != NGX_OK) {
  279.         return 1;
  280.     }

  282.     /*
  283.      * ngx_slab_sizes_init() requires ngx_pagesize set in ngx_os_init()
  284.      */

  286.     ngx_slab_sizes_init();

  288.     if (ngx_add_inherited_sockets(&init_cycle) != NGX_OK) {
  289.         return 1;
  290.     }

  292. #if (NGX_CONTROL_API)
  293.     ngx_control_preinit();
  294. #endif

  296.     if (ngx_preinit_modules() != NGX_OK) {
  297.         return 1;
  298.     }

  300.     cycle = ngx_init_cycle(&init_cycle);
  301.     if (cycle == NULL) {
  302.         if (ngx_test_config) {
  303.             ngx_log_stderr(0, "configuration file %s test failed",
  304.                            init_cycle.conf_file.data);
  305.         }

  307.         return 1;
  308.     }

  310.     if (ngx_test_config) {
  311.         if (!ngx_quiet_mode) {
  312.             ngx_log_stderr(0, "configuration file %s test is successful",
  313.                            cycle->conf_file.data);
  314.         }

  316.         if (ngx_dump_config) {
  317.             cd = cycle->config_dump.elts;

  319.             for (i = 0; i < cycle->config_dump.nelts; i++) {

  321.                 ngx_write_stdout("# configuration file ");
  322.                 (void) ngx_write_fd(ngx_stdout, cd[i].name.data,
  323.                                     cd[i].name.len);
  324.                 ngx_write_stdout(":" NGX_LINEFEED);

  326.                 b = cd[i].buffer;

  328.                 (void) ngx_write_fd(ngx_stdout, b->pos, b->last - b->pos);
  329.                 ngx_write_stdout(NGX_LINEFEED);
  330.             }
  331.         }

  333.         return 0;
  334.     }

  336.     if (ngx_signal) {
  337.         return ngx_signal_process(cycle, ngx_signal);
  338.     }

  340.     ngx_os_status(cycle->log);

  342.     ngx_cycle = cycle;

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

  346.     if (ccf->master && ngx_process == NGX_PROCESS_SINGLE) {
  347.         ngx_process = NGX_PROCESS_MASTER;
  348.     }

  350. #if !(NGX_WIN32)

  352.     if (ngx_init_signals(cycle->log) != NGX_OK) {
  353.         return 1;
  354.     }

  356.     if (!ngx_inherited && ccf->daemon) {
  357.         if (ngx_daemon(cycle->log) != NGX_OK) {
  358.             return 1;
  359.         }

  361.         ngx_daemonized = 1;
  362.     }

  364.     if (ngx_inherited) {
  365.         ngx_daemonized = 1;
  366.     }

  368. #endif

  370. #if (NGX_CONTROL_API)
  371.     if (ngx_process == NGX_PROCESS_SINGLE) {
  372.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  373.                       "control API unavailable in single process mode");

  375.     } else {
  376.         if (ngx_control_init(ngx_control_addr) != NGX_OK) {
  377.             return 1;
  378.         }
  379.     }
  380. #endif

  382.     if (ngx_create_pidfile(&ccf->pid, cycle->log) != NGX_OK) {
  383.         return 1;
  384.     }

  386.     if (ngx_log_redirect_stderr(cycle) != NGX_OK) {
  387.         return 1;
  388.     }

  390.     if (log->file->fd != ngx_stderr) {
  391.         if (ngx_close_file(log->file->fd) == NGX_FILE_ERROR) {
  392.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  393.                           ngx_close_file_n " built-in log failed");
  394.         }
  395.     }

  397.     ngx_use_stderr = 0;

  399.     if (ngx_process == NGX_PROCESS_SINGLE) {
  400.         ngx_single_process_cycle(cycle);

  402.     } else {
  403.         ngx_master_process_cycle(cycle);
  404.     }

  406.     return 0;
  407. }


  410. static void
  411. ‌ngx_show_version_info(void)
  412. {
  413.     ngx_write_stderr("nginx version: " NGINX_VER_BUILD NGX_LINEFEED);

  415.     if (ngx_show_help) {
  416.         ngx_write_stderr(
  417.             "Usage: nginx [-?hvVtTq] [-s signal] [-p prefix]" NGX_LINEFEED
  418.             "             [-e filename] [-c filename] [-g directives]"
  419.                           NGX_LINEFEED NGX_LINEFEED
  420.             "Options:" NGX_LINEFEED
  421.             "  -?,-h         : this help" NGX_LINEFEED
  422.             "  -v            : show version and exit" NGX_LINEFEED
  423.             "  -V            : show version and configure options then exit"
  424.                                NGX_LINEFEED
  425.             "  -t            : test configuration and exit" NGX_LINEFEED
  426.             "  -T            : test configuration, dump it and exit"
  427.                                NGX_LINEFEED
  428.             "  -q            : suppress non-error messages "
  429.                                "during configuration testing" NGX_LINEFEED
  430.             "  -s signal     : send signal to a master process: "
  431.                                "stop, quit, reopen, reload" NGX_LINEFEED
  432. #if (NGX_CONTROL_API)
  433.             "  -l addr       : open control socket on address" NGX_LINEFEED
  434. #endif
  435. #ifdef NGX_PREFIX
  436.             "  -p prefix     : set prefix path (default: " NGX_PREFIX ")"
  437.                                NGX_LINEFEED
  438. #else
  439.             "  -p prefix     : set prefix path (default: NONE)" NGX_LINEFEED
  440. #endif
  441.             "  -e filename   : set error log file (default: "
  442. #ifdef NGX_ERROR_LOG_STDERR
  443.                                "stderr)" NGX_LINEFEED
  444. #else
  445.                                NGX_ERROR_LOG_PATH ")" NGX_LINEFEED
  446. #endif
  447.             "  -c filename   : set configuration file (default: " NGX_CONF_PATH
  448.                                ")" NGX_LINEFEED
  449.             "  -g directives : set global directives out of configuration "
  450.                                "file" NGX_LINEFEED NGX_LINEFEED
  451.         );
  452.     }

  454.     if (ngx_show_configure) {

  456. #ifdef NGX_COMPILER
  457.         ngx_write_stderr("built by " NGX_COMPILER NGX_LINEFEED);
  458. #endif

  460. #if (NGX_SSL)
  461.         if (ngx_strcmp(ngx_ssl_version(), OPENSSL_VERSION_TEXT) == 0) {
  462.             ngx_write_stderr("built with " OPENSSL_VERSION_TEXT NGX_LINEFEED);
  463.         } else {
  464.             ngx_write_stderr("built with " OPENSSL_VERSION_TEXT
  465.                              " (running with ");
  466.             ngx_write_stderr((char *) (uintptr_t) ngx_ssl_version());
  467.             ngx_write_stderr(")" NGX_LINEFEED);
  468.         }
  469. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  470.         ngx_write_stderr("TLS SNI support enabled" NGX_LINEFEED);
  471. #else
  472.         ngx_write_stderr("TLS SNI support disabled" NGX_LINEFEED);
  473. #endif
  474. #endif

  476.         ngx_write_stderr("configure arguments:" NGX_CONFIGURE NGX_LINEFEED);
  477.     }
  478. }


  481. static ngx_int_t
  482. ‌ngx_add_inherited_sockets(ngx_cycle_t *cycle)
  483. {
  484.     u_char           *p, *v, *inherited;
  485.     ngx_int_t         s;
  486.     ngx_listening_t  *ls;

  488.     inherited = (u_char *) getenv(NGINX_VAR);

  490.     if (inherited == NULL) {
  491.         return NGX_OK;
  492.     }

  494.     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
  495.                   "using inherited sockets from \"%s\"", inherited);

  497.     if (ngx_array_init(&cycle->listening, cycle->pool, 10,
  498.                        sizeof(ngx_listening_t))
  499.         != NGX_OK)
  500.     {
  501.         return NGX_ERROR;
  502.     }

  504.     for (p = inherited, v = p; *p; p++) {
  505.         if (*p == ':' || *p == ';') {
  506.             s = ngx_atoi(v, p - v);
  507.             if (s == NGX_ERROR) {
  508.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  509.                               "invalid socket number \"%s\" in " NGINX_VAR
  510.                               " environment variable, ignoring the rest"
  511.                               " of the variable", v);
  512.                 break;
  513.             }

  515.             v = p + 1;

  517.             ls = ngx_array_push(&cycle->listening);
  518.             if (ls == NULL) {
  519.                 return NGX_ERROR;
  520.             }

  522.             ngx_memzero(ls, sizeof(ngx_listening_t));

  524.             ls->fd = (ngx_socket_t) s;
  525.             ls->inherited = 1;
  526.         }
  527.     }

  529.     if (v != p) {
  530.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  531.                       "invalid socket number \"%s\" in " NGINX_VAR
  532.                       " environment variable, ignoring", v);
  533.     }

  535.     ngx_inherited = 1;

  537.     return ngx_set_inherited_sockets(cycle);
  538. }


  541. char **
  542. ‌ngx_set_environment(ngx_cycle_t *cycle, ngx_uint_t *last)
  543. {
  544.     char                **p, **env, *str;
  545.     size_t                len;
  546.     ngx_str_t            *var;
  547.     ngx_uint_t            i, n;
  548.     ngx_core_conf_t      *ccf;
  549.     ngx_pool_cleanup_t   *cln;

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

  553.     if (last == NULL && ccf->environment) {
  554.         return ccf->environment;
  555.     }

  557.     var = ccf->env.elts;

  559.     for (i = 0; i < ccf->env.nelts; i++) {
  560.         if (ngx_strcmp(var[i].data, "TZ") == 0
  561.             || ngx_strncmp(var[i].data, "TZ=", 3) == 0)
  562.         {
  563.             goto tz_found;
  564.         }
  565.     }

  567.     var = ngx_array_push(&ccf->env);
  568.     if (var == NULL) {
  569.         return NULL;
  570.     }

  572.     var->len = 2;
  573.     var->data = (u_char *) "TZ";

  575.     var = ccf->env.elts;

  577. tz_found:

  579.     n = 0;

  581.     for (i = 0; i < ccf->env.nelts; i++) {

  583.         if (var[i].data[var[i].len] == '=') {
  584.             n++;
  585.             continue;
  586.         }

  588.         for (p = ngx_os_environ; *p; p++) {

  590.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  591.                 && (*p)[var[i].len] == '=')
  592.             {
  593.                 n++;
  594.                 break;
  595.             }
  596.         }
  597.     }

  599.     if (last) {
  600.         env = ngx_alloc((*last + n + 1) * sizeof(char *), cycle->log);
  601.         if (env == NULL) {
  602.             return NULL;
  603.         }

  605.         *last = n;

  607.     } else {
  608.         cln = ngx_pool_cleanup_add(cycle->pool, 0);
  609.         if (cln == NULL) {
  610.             return NULL;
  611.         }

  613.         env = ngx_alloc((n + 1) * sizeof(char *), cycle->log);
  614.         if (env == NULL) {
  615.             return NULL;
  616.         }

  618.         cln->handler = ngx_cleanup_environment;
  619.         cln->data = env;
  620.     }

  622.     n = 0;

  624.     for (i = 0; i < ccf->env.nelts; i++) {

  626.         if (var[i].data[var[i].len] == '=') {

  628.             if (last) {
  629.                 env[n++] = (char *) var[i].data;
  630.                 continue;
  631.             }

  633.             cln = ngx_pool_cleanup_add(cycle->pool, 0);
  634.             if (cln == NULL) {
  635.                 return NULL;
  636.             }

  638.             len = ngx_strlen(var[i].data) + 1;

  640.             str = ngx_alloc(len, cycle->log);
  641.             if (str == NULL) {
  642.                 return NULL;
  643.             }

  645.             ngx_memcpy(str, var[i].data, len);

  647.             cln->handler = ngx_cleanup_environment_variable;
  648.             cln->data = str;

  650.             env[n++] = str;

  652.             continue;
  653.         }

  655.         for (p = ngx_os_environ; *p; p++) {

  657.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  658.                 && (*p)[var[i].len] == '=')
  659.             {
  660.                 env[n++] = *p;
  661.                 break;
  662.             }
  663.         }
  664.     }

  666.     env[n] = NULL;

  668.     if (last == NULL) {
  669.         ccf->environment = env;
  670.         environ = env;
  671.     }

  673.     return env;
  674. }


  677. static void
  678. ‌ngx_cleanup_environment(void *data)
  679. {
  680.     char  **env = data;

  682.     if (environ == env) {

  684.         /*
  685.          * if the environment is still used, as it happens on exit,
  686.          * the only option is to leak it
  687.          */

  689.         return;
  690.     }

  692.     ngx_free(env);
  693. }


  696. static void
  697. ‌ngx_cleanup_environment_variable(void *data)
  698. {
  699.     char  *var = data;

  701.     char  **p;

  703.     for (p = environ; *p; p++) {

  705.         /*
  706.          * if an environment variable is still used, as it happens on exit,
  707.          * the only option is to leak it
  708.          */

  710.         if (*p == var) {
  711.             return;
  712.         }
  713.     }

  715.     ngx_free(var);
  716. }


  719. ngx_pid_t
  720. ‌ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
  721. {
  722.     char             **env, *var;
  723.     u_char            *p;
  724.     ngx_uint_t         i, n;
  725.     ngx_pid_t          pid;
  726.     ngx_exec_ctx_t     ctx;
  727.     ngx_core_conf_t   *ccf;
  728.     ngx_listening_t   *ls;

  730.     ngx_memzero(&ctx, sizeof(ngx_exec_ctx_t));

  732.     ctx.path = argv[0];
  733.     ctx.name = "new binary process";
  734.     ctx.argv = argv;

  736.     n = 3;
  737.     env = ngx_set_environment(cycle, &n);
  738.     if (env == NULL) {
  739.         return NGX_INVALID_PID;
  740.     }

  742.     var = ngx_alloc(sizeof(NGINX_VAR)
  743.                     + cycle->listening.nelts * (NGX_INT32_LEN + 1) + 2,
  744.                     cycle->log);
  745.     if (var == NULL) {
  746.         ngx_free(env);
  747.         return NGX_INVALID_PID;
  748.     }

  750.     p = ngx_cpymem(var, NGINX_VAR "=", sizeof(NGINX_VAR));

  752.     ls = cycle->listening.elts;
  753.     for (i = 0; i < cycle->listening.nelts; i++) {
  754.         if (ls[i].ignore) {
  755.             continue;
  756.         }
  757.         p = ngx_sprintf(p, "%ud;", ls[i].fd);
  758.     }

  760.     *p = '\0';

  762.     env[n++] = var;

  764. #if (NGX_SETPROCTITLE_USES_ENV)

  766.     /* allocate the spare 300 bytes for the new binary process title */

  768.     env[n++] = "SPARE=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  769.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  770.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  771.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  772.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

  774. #endif

  776. #if (NGX_CONTROL_API)
  777.     env[n] = ngx_control_handoff();

  779.     if (env[n] != NULL) {
  780.         n++;
  781.     }
  782. #endif

  784.     env[n] = NULL;

  786. #if (NGX_DEBUG)
  787.     {
  788.     char  **e;
  789.     for (e = env; *e; e++) {
  790.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0, "env: %s", *e);
  791.     }
  792.     }
  793. #endif

  795.     ctx.envp = (char *const *) env;

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

  799.     if (ngx_rename_file(ccf->pid.data, ccf->oldpid.data) == NGX_FILE_ERROR) {
  800.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  801.                       ngx_rename_file_n " %s to %s failed "
  802.                       "before executing new binary process \"%s\"",
  803.                       ccf->pid.data, ccf->oldpid.data, argv[0]);

  805.         ngx_free(env);
  806.         ngx_free(var);

  808.         return NGX_INVALID_PID;
  809.     }

  811.     pid = ngx_execute(cycle, &ctx);

  813.     if (pid == NGX_INVALID_PID) {
  814.         if (ngx_rename_file(ccf->oldpid.data, ccf->pid.data)
  815.             == NGX_FILE_ERROR)
  816.         {
  817.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  818.                           ngx_rename_file_n " %s back to %s failed after "
  819.                           "an attempt to execute new binary process \"%s\"",
  820.                           ccf->oldpid.data, ccf->pid.data, argv[0]);
  821.         }
  822.     }

  824.     ngx_free(env);
  825.     ngx_free(var);

  827.     return pid;
  828. }


  831. static ngx_int_t
  832. ‌ngx_get_options(int argc, char *const *argv)
  833. {
  834.     u_char     *p;
  835.     ngx_int_t   i;

  837.     for (i = 1; i < argc; i++) {

  839.         p = (u_char *) argv[i];

  841.         if (*p++ != '-') {
  842.             ngx_log_stderr(0, "invalid option: \"%s\"", argv[i]);
  843.             return NGX_ERROR;
  844.         }

  846.         while (*p) {

  848.             switch (*p++) {

  850.             case '?':
  851.             case 'h':
  852.                 ngx_show_version = 1;
  853.                 ngx_show_help = 1;
  854.                 break;

  856.             case 'v':
  857.                 ngx_show_version = 1;
  858.                 break;

  860.             case 'V':
  861.                 ngx_show_version = 1;
  862.                 ngx_show_configure = 1;
  863.                 break;

  865.             case 't':
  866.                 ngx_test_config = 1;
  867.                 break;

  869.             case 'T':
  870.                 ngx_test_config = 1;
  871.                 ngx_dump_config = 1;
  872.                 break;

  874.             case 'q':
  875.                 ngx_quiet_mode = 1;
  876.                 break;

  878.             case 'p':
  879.                 if (*p) {
  880.                     ngx_prefix = p;
  881.                     goto next;
  882.                 }

  884.                 if (argv[++i]) {
  885.                     ngx_prefix = (u_char *) argv[i];
  886.                     goto next;
  887.                 }

  889.                 ngx_log_stderr(0, "option \"-p\" requires directory name");
  890.                 return NGX_ERROR;

  892.             case 'e':
  893.                 if (*p) {
  894.                     ngx_error_log = p;

  896.                 } else if (argv[++i]) {
  897.                     ngx_error_log = (u_char *) argv[i];

  899.                 } else {
  900.                     ngx_log_stderr(0, "option \"-e\" requires file name");
  901.                     return NGX_ERROR;
  902.                 }

  904.                 if (ngx_strcmp(ngx_error_log, "stderr") == 0) {
  905.                     ngx_error_log = (u_char *) "";
  906.                 }

  908.                 goto next;

  910.             case 'c':
  911.                 if (*p) {
  912.                     ngx_conf_file = p;
  913.                     goto next;
  914.                 }

  916.                 if (argv[++i]) {
  917.                     ngx_conf_file = (u_char *) argv[i];
  918.                     goto next;
  919.                 }

  921.                 ngx_log_stderr(0, "option \"-c\" requires file name");
  922.                 return NGX_ERROR;

  924.             case 'g':
  925.                 if (*p) {
  926.                     ngx_conf_params = p;
  927.                     goto next;
  928.                 }

  930.                 if (argv[++i]) {
  931.                     ngx_conf_params = (u_char *) argv[i];
  932.                     goto next;
  933.                 }

  935.                 ngx_log_stderr(0, "option \"-g\" requires parameter");
  936.                 return NGX_ERROR;

  938.             case 's':
  939.                 if (*p) {
  940.                     ngx_signal = (char *) p;

  942.                 } else if (argv[++i]) {
  943.                     ngx_signal = argv[i];

  945.                 } else {
  946.                     ngx_log_stderr(0, "option \"-s\" requires parameter");
  947.                     return NGX_ERROR;
  948.                 }

  950.                 if (ngx_strcmp(ngx_signal, "stop") == 0
  951.                     || ngx_strcmp(ngx_signal, "quit") == 0
  952.                     || ngx_strcmp(ngx_signal, "reopen") == 0
  953.                     || ngx_strcmp(ngx_signal, "reload") == 0)
  954.                 {
  955.                     ngx_process = NGX_PROCESS_SIGNALLER;
  956.                     goto next;
  957.                 }

  959.                 ngx_log_stderr(0, "invalid option: \"-s %s\"", ngx_signal);
  960.                 return NGX_ERROR;

  962. #if (NGX_CONTROL_API)
  963.             case 'l':
  964.                 ngx_control_api_enabled = 1;

  966.                 if (*p) {
  967.                     ngx_control_addr = p;
  968.                     goto next;
  969.                 }

  971.                 if (argv[++i]) {
  972.                     ngx_control_addr = (u_char *) argv[i];
  973.                     goto next;
  974.                 }

  976.                 ngx_log_stderr(0, "option \"-l\" requires listen address");
  977.                 return NGX_ERROR;
  978. #endif

  980.             default:
  981.                 ngx_log_stderr(0, "invalid option: \"%c\"", *(p - 1));
  982.                 return NGX_ERROR;
  983.             }
  984.         }

  986.     next:

  988.         continue;
  989.     }

  991.     return NGX_OK;
  992. }


  995. static ngx_int_t
  996. ‌ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv)
  997. {
  998. #if (NGX_FREEBSD)

  1000.     ngx_os_argv = (char **) argv;
  1001.     ngx_argc = argc;
  1002.     ngx_argv = (char **) argv;

  1004. #else
  1005.     size_t     len;
  1006.     ngx_int_t  i;

  1008.     ngx_os_argv = (char **) argv;
  1009.     ngx_argc = argc;

  1011.     ngx_argv = ngx_alloc((argc + 1) * sizeof(char *), cycle->log);
  1012.     if (ngx_argv == NULL) {
  1013.         return NGX_ERROR;
  1014.     }

  1016.     for (i = 0; i < argc; i++) {
  1017.         len = ngx_strlen(argv[i]) + 1;

  1019.         ngx_argv[i] = ngx_alloc(len, cycle->log);
  1020.         if (ngx_argv[i] == NULL) {
  1021.             return NGX_ERROR;
  1022.         }

  1024.         (void) ngx_cpystrn((u_char *) ngx_argv[i], (u_char *) argv[i], len);
  1025.     }

  1027.     ngx_argv[i] = NULL;

  1029. #endif

  1031.     ngx_os_environ = environ;

  1033.     return NGX_OK;
  1034. }


  1037. static ngx_int_t
  1038. ‌ngx_process_options(ngx_cycle_t *cycle)
  1039. {
  1040.     u_char  *p;
  1041.     size_t   len;

  1043.     if (ngx_prefix) {
  1044.         len = ngx_strlen(ngx_prefix);
  1045.         p = ngx_prefix;

  1047.         if (len && !ngx_path_separator(p[len - 1])) {
  1048.             p = ngx_pnalloc(cycle->pool, len + 1);
  1049.             if (p == NULL) {
  1050.                 return NGX_ERROR;
  1051.             }

  1053.             ngx_memcpy(p, ngx_prefix, len);
  1054.             p[len++] = '/';
  1055.         }

  1057.         cycle->conf_prefix.len = len;
  1058.         cycle->conf_prefix.data = p;
  1059.         cycle->prefix.len = len;
  1060.         cycle->prefix.data = p;

  1062.     } else {

  1064. #ifndef NGX_PREFIX

  1066.         p = ngx_pnalloc(cycle->pool, NGX_MAX_PATH);
  1067.         if (p == NULL) {
  1068.             return NGX_ERROR;
  1069.         }

  1071.         if (ngx_getcwd(p, NGX_MAX_PATH) == 0) {
  1072.             ngx_log_stderr(ngx_errno, "[emerg]: " ngx_getcwd_n " failed");
  1073.             return NGX_ERROR;
  1074.         }

  1076.         len = ngx_strlen(p);

  1078.         p[len++] = '/';

  1080.         cycle->conf_prefix.len = len;
  1081.         cycle->conf_prefix.data = p;
  1082.         cycle->prefix.len = len;
  1083.         cycle->prefix.data = p;

  1085. #else

  1087. #ifdef NGX_CONF_PREFIX
  1088.         ngx_str_set(&cycle->conf_prefix, NGX_CONF_PREFIX);
  1089. #else
  1090.         ngx_str_set(&cycle->conf_prefix, NGX_PREFIX);
  1091. #endif
  1092.         ngx_str_set(&cycle->prefix, NGX_PREFIX);

  1094. #endif
  1095.     }

  1097.     if (ngx_conf_file) {
  1098.         cycle->conf_file.len = ngx_strlen(ngx_conf_file);
  1099.         cycle->conf_file.data = ngx_conf_file;

  1101.     } else {
  1102.         ngx_str_set(&cycle->conf_file, NGX_CONF_PATH);
  1103.     }

  1105.     if (ngx_conf_full_name(cycle, &cycle->conf_file, 0) != NGX_OK) {
  1106.         return NGX_ERROR;
  1107.     }

  1109.     for (p = cycle->conf_file.data + cycle->conf_file.len - 1;
  1110.          p > cycle->conf_file.data;
  1111.          p--)
  1112.     {
  1113.         if (ngx_path_separator(*p)) {
  1114.             cycle->conf_prefix.len = p - cycle->conf_file.data + 1;
  1115.             cycle->conf_prefix.data = cycle->conf_file.data;
  1116.             break;
  1117.         }
  1118.     }

  1120.     if (ngx_error_log) {
  1121.         cycle->error_log.len = ngx_strlen(ngx_error_log);
  1122.         cycle->error_log.data = ngx_error_log;

  1124.     } else {
  1125.         ngx_str_set(&cycle->error_log, NGX_ERROR_LOG_PATH);
  1126.     }

  1128.     if (ngx_conf_params) {
  1129.         cycle->conf_param.len = ngx_strlen(ngx_conf_params);
  1130.         cycle->conf_param.data = ngx_conf_params;
  1131.     }

  1133.     if (ngx_test_config) {
  1134.         cycle->log->log_level = NGX_LOG_INFO;
  1135.     }

  1137.     return NGX_OK;
  1138. }


  1141. static void *
  1142. ‌ngx_core_module_create_conf(ngx_cycle_t *cycle)
  1143. {
  1144.     ngx_core_conf_t  *ccf;

  1146.     ccf = ngx_pcalloc(cycle->pool, sizeof(ngx_core_conf_t));
  1147.     if (ccf == NULL) {
  1148.         return NULL;
  1149.     }

  1151.     /*
  1152.      * set by ngx_pcalloc()
  1153.      *
  1154.      *     ccf->pid = NULL;
  1155.      *     ccf->oldpid = NULL;
  1156.      *     ccf->priority = 0;
  1157.      *     ccf->cpu_affinity_auto = 0;
  1158.      *     ccf->cpu_affinity_n = 0;
  1159.      *     ccf->cpu_affinity = NULL;
  1160.      */

  1162.     ccf->daemon = NGX_CONF_UNSET;
  1163.     ccf->master = NGX_CONF_UNSET;
  1164.     ccf->timer_resolution = NGX_CONF_UNSET_MSEC;
  1165.     ccf->shutdown_timeout = NGX_CONF_UNSET_MSEC;

  1167.     ccf->worker_processes = NGX_CONF_UNSET;
  1168.     ccf->debug_points = NGX_CONF_UNSET;

  1170.     ccf->rlimit_nofile = NGX_CONF_UNSET;
  1171.     ccf->rlimit_core = NGX_CONF_UNSET;

  1173.     ccf->user = (ngx_uid_t) NGX_CONF_UNSET_UINT;
  1174.     ccf->group = (ngx_gid_t) NGX_CONF_UNSET_UINT;

  1176.     if (ngx_array_init(&ccf->env, cycle->pool, 1, sizeof(ngx_str_t))
  1177.         != NGX_OK)
  1178.     {
  1179.         return NULL;
  1180.     }

  1182.     return ccf;
  1183. }


  1186. static char *
  1187. ‌ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf)
  1188. {
  1189.     ngx_core_conf_t  *ccf = conf;

  1191.     ngx_conf_init_value(ccf->daemon, 1);
  1192.     ngx_conf_init_value(ccf->master, 1);
  1193.     ngx_conf_init_msec_value(ccf->timer_resolution, 0);
  1194.     ngx_conf_init_msec_value(ccf->shutdown_timeout, 0);

  1196.     ngx_conf_init_value(ccf->worker_processes, 1);
  1197.     ngx_conf_init_value(ccf->debug_points, 0);

  1199. #if (NGX_HAVE_CPU_AFFINITY)

  1201.     if (!ccf->cpu_affinity_auto
  1202.         && ccf->cpu_affinity_n
  1203.         && ccf->cpu_affinity_n != 1
  1204.         && ccf->cpu_affinity_n != (ngx_uint_t) ccf->worker_processes)
  1205.     {
  1206.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  1207.                       "the number of \"worker_processes\" is not equal to "
  1208.                       "the number of \"worker_cpu_affinity\" masks, "
  1209.                       "using last mask for remaining worker processes");
  1210.     }

  1212. #endif


  1215.     if (ccf->pid.len == 0) {
  1216.         ngx_str_set(&ccf->pid, NGX_PID_PATH);
  1217.     }

  1219.     if (ngx_conf_full_name(cycle, &ccf->pid, 0) != NGX_OK) {
  1220.         return NGX_CONF_ERROR;
  1221.     }

  1223.     ccf->oldpid.len = ccf->pid.len + sizeof(NGX_OLDPID_EXT);

  1225.     ccf->oldpid.data = ngx_pnalloc(cycle->pool, ccf->oldpid.len);
  1226.     if (ccf->oldpid.data == NULL) {
  1227.         return NGX_CONF_ERROR;
  1228.     }

  1230.     ngx_memcpy(ngx_cpymem(ccf->oldpid.data, ccf->pid.data, ccf->pid.len),
  1231.                NGX_OLDPID_EXT, sizeof(NGX_OLDPID_EXT));


  1234. #if !(NGX_WIN32)

  1236.     if (ccf->user == (uid_t) NGX_CONF_UNSET_UINT && geteuid() == 0) {
  1237.         struct group   *grp;
  1238.         struct passwd  *pwd;

  1240.         ngx_set_errno(0);
  1241.         pwd = getpwnam(NGX_USER);
  1242.         if (pwd == NULL) {
  1243.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1244.                           "getpwnam(\"" NGX_USER "\") failed");
  1245.             return NGX_CONF_ERROR;
  1246.         }

  1248.         ccf->username = NGX_USER;
  1249.         ccf->user = pwd->pw_uid;

  1251.         ngx_set_errno(0);
  1252.         grp = getgrnam(NGX_GROUP);
  1253.         if (grp == NULL) {
  1254.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1255.                           "getgrnam(\"" NGX_GROUP "\") failed");
  1256.             return NGX_CONF_ERROR;
  1257.         }

  1259.         ccf->group = grp->gr_gid;
  1260.     }


  1263.     if (ccf->lock_file.len == 0) {
  1264.         ngx_str_set(&ccf->lock_file, NGX_LOCK_PATH);
  1265.     }

  1267.     if (ngx_conf_full_name(cycle, &ccf->lock_file, 0) != NGX_OK) {
  1268.         return NGX_CONF_ERROR;
  1269.     }

  1271.     {
  1272.     ngx_str_t  lock_file;

  1274.     lock_file = cycle->old_cycle->lock_file;

  1276.     if (lock_file.len) {
  1277.         lock_file.len--;

  1279.         if (ccf->lock_file.len != lock_file.len
  1280.             || ngx_strncmp(ccf->lock_file.data, lock_file.data, lock_file.len)
  1281.                != 0)
  1282.         {
  1283.             ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  1284.                           "\"lock_file\" could not be changed, ignored");
  1285.         }

  1287.         cycle->lock_file.len = lock_file.len + 1;
  1288.         lock_file.len += sizeof(".accept");

  1290.         cycle->lock_file.data = ngx_pstrdup(cycle->pool, &lock_file);
  1291.         if (cycle->lock_file.data == NULL) {
  1292.             return NGX_CONF_ERROR;
  1293.         }

  1295.     } else {
  1296.         cycle->lock_file.len = ccf->lock_file.len + 1;
  1297.         cycle->lock_file.data = ngx_pnalloc(cycle->pool,
  1298.                                       ccf->lock_file.len + sizeof(".accept"));
  1299.         if (cycle->lock_file.data == NULL) {
  1300.             return NGX_CONF_ERROR;
  1301.         }

  1303.         ngx_memcpy(ngx_cpymem(cycle->lock_file.data, ccf->lock_file.data,
  1304.                               ccf->lock_file.len),
  1305.                    ".accept", sizeof(".accept"));
  1306.     }
  1307.     }

  1309. #endif

  1311.     return NGX_CONF_OK;
  1312. }


  1315. static char *
  1316. ‌ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1317. {
  1318. #if (NGX_WIN32)

  1320.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1321.                        "\"user\" is not supported, ignored");

  1323.     return NGX_CONF_OK;

  1325. #else

  1327.     ngx_core_conf_t  *ccf = conf;

  1329.     char             *group;
  1330.     struct passwd    *pwd;
  1331.     struct group     *grp;
  1332.     ngx_str_t        *value;

  1334.     if (ccf->user != (uid_t) NGX_CONF_UNSET_UINT) {
  1335.         return "is duplicate";
  1336.     }

  1338.     if (geteuid() != 0) {
  1339.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1340.                            "the \"user\" directive makes sense only "
  1341.                            "if the master process runs "
  1342.                            "with super-user privileges, ignored");
  1343.         return NGX_CONF_OK;
  1344.     }

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

  1348.     ccf->username = (char *) value[1].data;

  1350.     ngx_set_errno(0);
  1351.     pwd = getpwnam((const char *) value[1].data);
  1352.     if (pwd == NULL) {
  1353.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1354.                            "getpwnam(\"%s\") failed", value[1].data);
  1355.         return NGX_CONF_ERROR;
  1356.     }

  1358.     ccf->user = pwd->pw_uid;

  1360.     group = (char *) ((cf->args->nelts == 2) ? value[1].data : value[2].data);

  1362.     ngx_set_errno(0);
  1363.     grp = getgrnam(group);
  1364.     if (grp == NULL) {
  1365.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1366.                            "getgrnam(\"%s\") failed", group);
  1367.         return NGX_CONF_ERROR;
  1368.     }

  1370.     ccf->group = grp->gr_gid;

  1372.     return NGX_CONF_OK;

  1374. #endif
  1375. }


  1378. static char *
  1379. ‌ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1380. {
  1381.     ngx_core_conf_t  *ccf = conf;

  1383.     ngx_str_t   *value, *var;
  1384.     ngx_uint_t   i;

  1386.     var = ngx_array_push(&ccf->env);
  1387.     if (var == NULL) {
  1388.         return NGX_CONF_ERROR;
  1389.     }

  1391.     value = cf->args->elts;
  1392.     *var = value[1];

  1394.     for (i = 0; i < value[1].len; i++) {

  1396.         if (value[1].data[i] == '=') {

  1398.             var->len = i;

  1400.             return NGX_CONF_OK;
  1401.         }
  1402.     }

  1404.     return NGX_CONF_OK;
  1405. }


  1408. static char *
  1409. ‌ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1410. {
  1411.     ngx_core_conf_t  *ccf = conf;

  1413.     ngx_str_t        *value;
  1414.     ngx_uint_t        n, minus;

  1416.     if (ccf->priority != 0) {
  1417.         return "is duplicate";
  1418.     }

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

  1422.     if (value[1].data[0] == '-') {
  1423.         n = 1;
  1424.         minus = 1;

  1426.     } else if (value[1].data[0] == '+') {
  1427.         n = 1;
  1428.         minus = 0;

  1430.     } else {
  1431.         n = 0;
  1432.         minus = 0;
  1433.     }

  1435.     ccf->priority = ngx_atoi(&value[1].data[n], value[1].len - n);
  1436.     if (ccf->priority == NGX_ERROR) {
  1437.         return "invalid number";
  1438.     }

  1440.     if (minus) {
  1441.         ccf->priority = -ccf->priority;
  1442.     }

  1444.     return NGX_CONF_OK;
  1445. }


  1448. static char *
  1449. ‌ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1450. {
  1451. #if (NGX_HAVE_CPU_AFFINITY)
  1452.     ngx_core_conf_t  *ccf = conf;

  1454.     u_char            ch, *p;
  1455.     ngx_str_t        *value;
  1456.     ngx_uint_t        i, n;
  1457.     ngx_cpuset_t     *mask;

  1459.     if (ccf->cpu_affinity) {
  1460.         return "is duplicate";
  1461.     }

  1463.     mask = ngx_palloc(cf->pool, (cf->args->nelts - 1) * sizeof(ngx_cpuset_t));
  1464.     if (mask == NULL) {
  1465.         return NGX_CONF_ERROR;
  1466.     }

  1468.     ccf->cpu_affinity_n = cf->args->nelts - 1;
  1469.     ccf->cpu_affinity = mask;

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

  1473.     if (ngx_strcmp(value[1].data, "auto") == 0) {

  1475.         if (cf->args->nelts > 3) {
  1476.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1477.                                "invalid number of arguments in "
  1478.                                "\"worker_cpu_affinity\" directive");
  1479.             return NGX_CONF_ERROR;
  1480.         }

  1482.         ccf->cpu_affinity_auto = 1;

  1484.         CPU_ZERO(&mask[0]);
  1485.         for (i = 0; i < (ngx_uint_t) ngx_min(ngx_ncpu, CPU_SETSIZE); i++) {
  1486.             CPU_SET(i, &mask[0]);
  1487.         }

  1489.         n = 2;

  1491.     } else {
  1492.         n = 1;
  1493.     }

  1495.     for ( /* void */ ; n < cf->args->nelts; n++) {

  1497.         if (value[n].len > CPU_SETSIZE) {
  1498.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1499.                          "\"worker_cpu_affinity\" supports up to %d CPUs only",
  1500.                          CPU_SETSIZE);
  1501.             return NGX_CONF_ERROR;
  1502.         }

  1504.         i = 0;
  1505.         CPU_ZERO(&mask[n - 1]);

  1507.         for (p = value[n].data + value[n].len - 1;
  1508.              p >= value[n].data;
  1509.              p--)
  1510.         {
  1511.             ch = *p;

  1513.             if (ch == ' ') {
  1514.                 continue;
  1515.             }

  1517.             i++;

  1519.             if (ch == '0') {
  1520.                 continue;
  1521.             }

  1523.             if (ch == '1') {
  1524.                 CPU_SET(i - 1, &mask[n - 1]);
  1525.                 continue;
  1526.             }

  1528.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1529.                           "invalid character \"%c\" in \"worker_cpu_affinity\"",
  1530.                           ch);
  1531.             return NGX_CONF_ERROR;
  1532.         }
  1533.     }

  1535. #else

  1537.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1538.                        "\"worker_cpu_affinity\" is not supported "
  1539.                        "on this platform, ignored");
  1540. #endif

  1542.     return NGX_CONF_OK;
  1543. }


  1546. ngx_cpuset_t *
  1547. ‌ngx_get_cpu_affinity(ngx_uint_t n)
  1548. {
  1549. #if (NGX_HAVE_CPU_AFFINITY)
  1550.     ngx_uint_t        i, j;
  1551.     ngx_cpuset_t     *mask;
  1552.     ngx_core_conf_t  *ccf;

  1554.     static ngx_cpuset_t  result;

  1556.     ccf = (ngx_core_conf_t *) ngx_get_conf(ngx_cycle->conf_ctx,
  1557.                                            ngx_core_module);

  1559.     if (ccf->cpu_affinity == NULL) {
  1560.         return NULL;
  1561.     }

  1563.     if (ccf->cpu_affinity_auto) {
  1564.         mask = &ccf->cpu_affinity[ccf->cpu_affinity_n - 1];

  1566.         for (i = 0, j = n; /* void */ ; i++) {

  1568.             if (CPU_ISSET(i % CPU_SETSIZE, mask) && j-- == 0) {
  1569.                 break;
  1570.             }

  1572.             if (i == CPU_SETSIZE && j == n) {
  1573.                 /* empty mask */
  1574.                 return NULL;
  1575.             }

  1577.             /* void */
  1578.         }

  1580.         CPU_ZERO(&result);
  1581.         CPU_SET(i % CPU_SETSIZE, &result);

  1583.         return &result;
  1584.     }

  1586.     if (ccf->cpu_affinity_n > n) {
  1587.         return &ccf->cpu_affinity[n];
  1588.     }

  1590.     return &ccf->cpu_affinity[ccf->cpu_affinity_n - 1];

  1592. #else

  1594.     return NULL;

  1596. #endif
  1597. }


  1600. static char *
  1601. ‌ngx_set_worker_processes(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1602. {
  1603.     ngx_str_t        *value;
  1604.     ngx_core_conf_t  *ccf;

  1606.     ccf = (ngx_core_conf_t *) conf;

  1608.     if (ccf->worker_processes != NGX_CONF_UNSET) {
  1609.         return "is duplicate";
  1610.     }

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

  1614.     if (ngx_strcmp(value[1].data, "auto") == 0) {
  1615.         ccf->worker_processes = ngx_ncpu;
  1616.         return NGX_CONF_OK;
  1617.     }

  1619.     ccf->worker_processes = ngx_atoi(value[1].data, value[1].len);

  1621.     if (ccf->worker_processes == NGX_ERROR) {
  1622.         return "invalid value";
  1623.     }

  1625.     return NGX_CONF_OK;
  1626. }


  1629. static char *
  1630. ‌ngx_load_module(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1631. {
  1632. #if (NGX_HAVE_DLOPEN)
  1633.     void                *handle;
  1634.     char               **names, **order;
  1635.     ngx_str_t           *value, file;
  1636.     ngx_uint_t           i;
  1637.     ngx_module_t        *module, **modules;
  1638.     ngx_pool_cleanup_t  *cln;

  1640.     if (cf->cycle->modules_used) {
  1641.         return "is specified too late";
  1642.     }

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

  1646.     file = value[1];

  1648.     if (ngx_conf_full_name(cf->cycle, &file, 0) != NGX_OK) {
  1649.         return NGX_CONF_ERROR;
  1650.     }

  1652.     cln = ngx_pool_cleanup_add(cf->cycle->pool, 0);
  1653.     if (cln == NULL) {
  1654.         return NGX_CONF_ERROR;
  1655.     }

  1657.     handle = ngx_dlopen(file.data);
  1658.     if (handle == NULL) {
  1659.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1660.                            ngx_dlopen_n " \"%s\" failed (%s)",
  1661.                            file.data, ngx_dlerror());
  1662.         return NGX_CONF_ERROR;
  1663.     }

  1665.     cln->handler = ngx_unload_module;
  1666.     cln->data = handle;

  1668.     modules = ngx_dlsym(handle, "ngx_modules");
  1669.     if (modules == NULL) {
  1670.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1671.                            ngx_dlsym_n " \"%V\", \"%s\" failed (%s)",
  1672.                            &value[1], "ngx_modules", ngx_dlerror());
  1673.         return NGX_CONF_ERROR;
  1674.     }

  1676.     names = ngx_dlsym(handle, "ngx_module_names");
  1677.     if (names == NULL) {
  1678.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1679.                            ngx_dlsym_n " \"%V\", \"%s\" failed (%s)",
  1680.                            &value[1], "ngx_module_names", ngx_dlerror());
  1681.         return NGX_CONF_ERROR;
  1682.     }

  1684.     order = ngx_dlsym(handle, "ngx_module_order");

  1686.     for (i = 0; modules[i]; i++) {
  1687.         module = modules[i];
  1688.         module->name = names[i];

  1690.         if (ngx_add_module(cf, &file, module, order) != NGX_OK) {
  1691.             return NGX_CONF_ERROR;
  1692.         }

  1694.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, cf->log, 0, "module: %s i:%ui",
  1695.                        module->name, module->index);
  1696.     }

  1698.     return NGX_CONF_OK;

  1700. #else

  1702.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1703.                        "\"load_module\" is not supported "
  1704.                        "on this platform");
  1705.     return NGX_CONF_ERROR;

  1707. #endif
  1708. }


  1711. #if (NGX_HAVE_DLOPEN)

  1713. static void
  1714. ‌ngx_unload_module(void *data)
  1715. {
  1716.     void  *handle = data;

  1718.     if (ngx_dlclose(handle) != 0) {
  1719.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1720.                       ngx_dlclose_n " failed (%s)", ngx_dlerror());
  1721.     }
  1722. }

  1724. #endif

One Level Up Top Level