One Level Up Top Level

src/core/nginx.c - nginx source code

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. ‌static char        *ngx_signal;


  193. ‌static char **ngx_os_environ;


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

  206.     ngx_debug_init();

  208.     if (ngx_strerror_init() != NGX_OK) {
  209.         return 1;
  210.     }

  212.     if (ngx_get_options(argc, argv) != NGX_OK) {
  213.         return 1;
  214.     }

  216.     if (ngx_show_version) {
  217.         ngx_show_version_info();

  219.         if (!ngx_test_config) {
  220.             return 0;
  221.         }
  222.     }

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

  226.     ngx_time_init();

  228. #if (NGX_PCRE)
  229.     ngx_regex_init();
  230. #endif

  232.     ngx_pid = ngx_getpid();
  233.     ngx_parent = ngx_getppid();

  235.     log = ngx_log_init(ngx_prefix, ngx_error_log);
  236.     if (log == NULL) {
  237.         return 1;
  238.     }

  240.     /* STUB */
  241. #if (NGX_OPENSSL)
  242.     ngx_ssl_init(log);
  243. #endif

  245.     /*
  246.      * init_cycle->log is required for signal handlers and
  247.      * ngx_process_options()
  248.      */

  250.     ngx_memzero(&init_cycle, sizeof(ngx_cycle_t));
  251.     init_cycle.log = log;
  252.     ngx_cycle = &init_cycle;

  254.     init_cycle.pool = ngx_create_pool(1024, log);
  255.     if (init_cycle.pool == NULL) {
  256.         return 1;
  257.     }

  259.     if (ngx_save_argv(&init_cycle, argc, argv) != NGX_OK) {
  260.         return 1;
  261.     }

  263.     if (ngx_process_options(&init_cycle) != NGX_OK) {
  264.         return 1;
  265.     }

  267.     if (ngx_os_init(log) != NGX_OK) {
  268.         return 1;
  269.     }

  271.     /*
  272.      * ngx_crc32_table_init() requires ngx_cacheline_size set in ngx_os_init()
  273.      */

  275.     if (ngx_crc32_table_init() != NGX_OK) {
  276.         return 1;
  277.     }

  279.     /*
  280.      * ngx_slab_sizes_init() requires ngx_pagesize set in ngx_os_init()
  281.      */

  283.     ngx_slab_sizes_init();

  285.     if (ngx_add_inherited_sockets(&init_cycle) != NGX_OK) {
  286.         return 1;
  287.     }

  289.     if (ngx_preinit_modules() != NGX_OK) {
  290.         return 1;
  291.     }

  293.     cycle = ngx_init_cycle(&init_cycle);
  294.     if (cycle == NULL) {
  295.         if (ngx_test_config) {
  296.             ngx_log_stderr(0, "configuration file %s test failed",
  297.                            init_cycle.conf_file.data);
  298.         }

  300.         return 1;
  301.     }

  303.     if (ngx_test_config) {
  304.         if (!ngx_quiet_mode) {
  305.             ngx_log_stderr(0, "configuration file %s test is successful",
  306.                            cycle->conf_file.data);
  307.         }

  309.         if (ngx_dump_config) {
  310.             cd = cycle->config_dump.elts;

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

  314.                 ngx_write_stdout("# configuration file ");
  315.                 (void) ngx_write_fd(ngx_stdout, cd[i].name.data,
  316.                                     cd[i].name.len);
  317.                 ngx_write_stdout(":" NGX_LINEFEED);

  319.                 b = cd[i].buffer;

  321.                 (void) ngx_write_fd(ngx_stdout, b->pos, b->last - b->pos);
  322.                 ngx_write_stdout(NGX_LINEFEED);
  323.             }
  324.         }

  326.         return 0;
  327.     }

  329.     if (ngx_signal) {
  330.         return ngx_signal_process(cycle, ngx_signal);
  331.     }

  333.     ngx_os_status(cycle->log);

  335.     ngx_cycle = cycle;

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

  339.     if (ccf->master && ngx_process == NGX_PROCESS_SINGLE) {
  340.         ngx_process = NGX_PROCESS_MASTER;
  341.     }

  343. #if !(NGX_WIN32)

  345.     if (ngx_init_signals(cycle->log) != NGX_OK) {
  346.         return 1;
  347.     }

  349.     if (!ngx_inherited && ccf->daemon) {
  350.         if (ngx_daemon(cycle->log) != NGX_OK) {
  351.             return 1;
  352.         }

  354.         ngx_daemonized = 1;
  355.     }

  357.     if (ngx_inherited) {
  358.         ngx_daemonized = 1;
  359.     }

  361. #endif

  363.     if (ngx_create_pidfile(&ccf->pid, cycle->log) != NGX_OK) {
  364.         return 1;
  365.     }

  367.     if (ngx_log_redirect_stderr(cycle) != NGX_OK) {
  368.         return 1;
  369.     }

  371.     if (log->file->fd != ngx_stderr) {
  372.         if (ngx_close_file(log->file->fd) == NGX_FILE_ERROR) {
  373.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  374.                           ngx_close_file_n " built-in log failed");
  375.         }
  376.     }

  378.     ngx_use_stderr = 0;

  380.     if (ngx_process == NGX_PROCESS_SINGLE) {
  381.         ngx_single_process_cycle(cycle);

  383.     } else {
  384.         ngx_master_process_cycle(cycle);
  385.     }

  387.     return 0;
  388. }


  391. static void
  392. ‌ngx_show_version_info(void)
  393. {
  394.     ngx_write_stderr("nginx version: " NGINX_VER_BUILD NGX_LINEFEED);

  396.     if (ngx_show_help) {
  397.         ngx_write_stderr(
  398.             "Usage: nginx [-?hvVtTq] [-s signal] [-p prefix]" NGX_LINEFEED
  399.             "             [-e filename] [-c filename] [-g directives]"
  400.                           NGX_LINEFEED NGX_LINEFEED
  401.             "Options:" NGX_LINEFEED
  402.             "  -?,-h         : this help" NGX_LINEFEED
  403.             "  -v            : show version and exit" NGX_LINEFEED
  404.             "  -V            : show version and configure options then exit"
  405.                                NGX_LINEFEED
  406.             "  -t            : test configuration and exit" NGX_LINEFEED
  407.             "  -T            : test configuration, dump it and exit"
  408.                                NGX_LINEFEED
  409.             "  -q            : suppress non-error messages "
  410.                                "during configuration testing" NGX_LINEFEED
  411.             "  -s signal     : send signal to a master process: "
  412.                                "stop, quit, reopen, reload" NGX_LINEFEED
  413. #ifdef NGX_PREFIX
  414.             "  -p prefix     : set prefix path (default: " NGX_PREFIX ")"
  415.                                NGX_LINEFEED
  416. #else
  417.             "  -p prefix     : set prefix path (default: NONE)" NGX_LINEFEED
  418. #endif
  419.             "  -e filename   : set error log file (default: "
  420. #ifdef NGX_ERROR_LOG_STDERR
  421.                                "stderr)" NGX_LINEFEED
  422. #else
  423.                                NGX_ERROR_LOG_PATH ")" NGX_LINEFEED
  424. #endif
  425.             "  -c filename   : set configuration file (default: " NGX_CONF_PATH
  426.                                ")" NGX_LINEFEED
  427.             "  -g directives : set global directives out of configuration "
  428.                                "file" NGX_LINEFEED NGX_LINEFEED
  429.         );
  430.     }

  432.     if (ngx_show_configure) {

  434. #ifdef NGX_COMPILER
  435.         ngx_write_stderr("built by " NGX_COMPILER NGX_LINEFEED);
  436. #endif

  438. #if (NGX_SSL)
  439.         if (ngx_strcmp(ngx_ssl_version(), OPENSSL_VERSION_TEXT) == 0) {
  440.             ngx_write_stderr("built with " OPENSSL_VERSION_TEXT NGX_LINEFEED);
  441.         } else {
  442.             ngx_write_stderr("built with " OPENSSL_VERSION_TEXT
  443.                              " (running with ");
  444.             ngx_write_stderr((char *) (uintptr_t) ngx_ssl_version());
  445.             ngx_write_stderr(")" NGX_LINEFEED);
  446.         }
  447. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  448.         ngx_write_stderr("TLS SNI support enabled" NGX_LINEFEED);
  449. #else
  450.         ngx_write_stderr("TLS SNI support disabled" NGX_LINEFEED);
  451. #endif
  452. #endif

  454.         ngx_write_stderr("configure arguments:" NGX_CONFIGURE NGX_LINEFEED);
  455.     }
  456. }


  459. static ngx_int_t
  460. ‌ngx_add_inherited_sockets(ngx_cycle_t *cycle)
  461. {
  462.     u_char           *p, *v, *inherited;
  463.     ngx_int_t         s;
  464.     ngx_listening_t  *ls;

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

  468.     if (inherited == NULL) {
  469.         return NGX_OK;
  470.     }

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

  475.     if (ngx_array_init(&cycle->listening, cycle->pool, 10,
  476.                        sizeof(ngx_listening_t))
  477.         != NGX_OK)
  478.     {
  479.         return NGX_ERROR;
  480.     }

  482.     for (p = inherited, v = p; *p; p++) {
  483.         if (*p == ':' || *p == ';') {
  484.             s = ngx_atoi(v, p - v);
  485.             if (s == NGX_ERROR) {
  486.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  487.                               "invalid socket number \"%s\" in " NGINX_VAR
  488.                               " environment variable, ignoring the rest"
  489.                               " of the variable", v);
  490.                 break;
  491.             }

  493.             v = p + 1;

  495.             ls = ngx_array_push(&cycle->listening);
  496.             if (ls == NULL) {
  497.                 return NGX_ERROR;
  498.             }

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

  502.             ls->fd = (ngx_socket_t) s;
  503.             ls->inherited = 1;
  504.         }
  505.     }

  507.     if (v != p) {
  508.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  509.                       "invalid socket number \"%s\" in " NGINX_VAR
  510.                       " environment variable, ignoring", v);
  511.     }

  513.     ngx_inherited = 1;

  515.     return ngx_set_inherited_sockets(cycle);
  516. }


  519. char **
  520. ‌ngx_set_environment(ngx_cycle_t *cycle, ngx_uint_t *last)
  521. {
  522.     char                **p, **env, *str;
  523.     size_t                len;
  524.     ngx_str_t            *var;
  525.     ngx_uint_t            i, n;
  526.     ngx_core_conf_t      *ccf;
  527.     ngx_pool_cleanup_t   *cln;

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

  531.     if (last == NULL && ccf->environment) {
  532.         return ccf->environment;
  533.     }

  535.     var = ccf->env.elts;

  537.     for (i = 0; i < ccf->env.nelts; i++) {
  538.         if (ngx_strcmp(var[i].data, "TZ") == 0
  539.             || ngx_strncmp(var[i].data, "TZ=", 3) == 0)
  540.         {
  541.             goto tz_found;
  542.         }
  543.     }

  545.     var = ngx_array_push(&ccf->env);
  546.     if (var == NULL) {
  547.         return NULL;
  548.     }

  550.     var->len = 2;
  551.     var->data = (u_char *) "TZ";

  553.     var = ccf->env.elts;

  555. tz_found:

  557.     n = 0;

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

  561.         if (var[i].data[var[i].len] == '=') {
  562.             n++;
  563.             continue;
  564.         }

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

  568.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  569.                 && (*p)[var[i].len] == '=')
  570.             {
  571.                 n++;
  572.                 break;
  573.             }
  574.         }
  575.     }

  577.     if (last) {
  578.         env = ngx_alloc((*last + n + 1) * sizeof(char *), cycle->log);
  579.         if (env == NULL) {
  580.             return NULL;
  581.         }

  583.         *last = n;

  585.     } else {
  586.         cln = ngx_pool_cleanup_add(cycle->pool, 0);
  587.         if (cln == NULL) {
  588.             return NULL;
  589.         }

  591.         env = ngx_alloc((n + 1) * sizeof(char *), cycle->log);
  592.         if (env == NULL) {
  593.             return NULL;
  594.         }

  596.         cln->handler = ngx_cleanup_environment;
  597.         cln->data = env;
  598.     }

  600.     n = 0;

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

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

  606.             if (last) {
  607.                 env[n++] = (char *) var[i].data;
  608.                 continue;
  609.             }

  611.             cln = ngx_pool_cleanup_add(cycle->pool, 0);
  612.             if (cln == NULL) {
  613.                 return NULL;
  614.             }

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

  618.             str = ngx_alloc(len, cycle->log);
  619.             if (str == NULL) {
  620.                 return NULL;
  621.             }

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

  625.             cln->handler = ngx_cleanup_environment_variable;
  626.             cln->data = str;

  628.             env[n++] = str;

  630.             continue;
  631.         }

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

  635.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  636.                 && (*p)[var[i].len] == '=')
  637.             {
  638.                 env[n++] = *p;
  639.                 break;
  640.             }
  641.         }
  642.     }

  644.     env[n] = NULL;

  646.     if (last == NULL) {
  647.         ccf->environment = env;
  648.         environ = env;
  649.     }

  651.     return env;
  652. }


  655. static void
  656. ‌ngx_cleanup_environment(void *data)
  657. {
  658.     char  **env = data;

  660.     if (environ == env) {

  662.         /*
  663.          * if the environment is still used, as it happens on exit,
  664.          * the only option is to leak it
  665.          */

  667.         return;
  668.     }

  670.     ngx_free(env);
  671. }


  674. static void
  675. ‌ngx_cleanup_environment_variable(void *data)
  676. {
  677.     char  *var = data;

  679.     char  **p;

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

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

  688.         if (*p == var) {
  689.             return;
  690.         }
  691.     }

  693.     ngx_free(var);
  694. }


  697. ngx_pid_t
  698. ‌ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
  699. {
  700.     char             **env, *var;
  701.     u_char            *p;
  702.     ngx_uint_t         i, n;
  703.     ngx_pid_t          pid;
  704.     ngx_exec_ctx_t     ctx;
  705.     ngx_core_conf_t   *ccf;
  706.     ngx_listening_t   *ls;

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

  710.     ctx.path = argv[0];
  711.     ctx.name = "new binary process";
  712.     ctx.argv = argv;

  714.     n = 2;
  715.     env = ngx_set_environment(cycle, &n);
  716.     if (env == NULL) {
  717.         return NGX_INVALID_PID;
  718.     }

  720.     var = ngx_alloc(sizeof(NGINX_VAR)
  721.                     + cycle->listening.nelts * (NGX_INT32_LEN + 1) + 2,
  722.                     cycle->log);
  723.     if (var == NULL) {
  724.         ngx_free(env);
  725.         return NGX_INVALID_PID;
  726.     }

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

  730.     ls = cycle->listening.elts;
  731.     for (i = 0; i < cycle->listening.nelts; i++) {
  732.         if (ls[i].ignore) {
  733.             continue;
  734.         }
  735.         p = ngx_sprintf(p, "%ud;", ls[i].fd);
  736.     }

  738.     *p = '\0';

  740.     env[n++] = var;

  742. #if (NGX_SETPROCTITLE_USES_ENV)

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

  746.     env[n++] = "SPARE=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  747.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  748.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  749.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  750.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

  752. #endif

  754.     env[n] = NULL;

  756. #if (NGX_DEBUG)
  757.     {
  758.     char  **e;
  759.     for (e = env; *e; e++) {
  760.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0, "env: %s", *e);
  761.     }
  762.     }
  763. #endif

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

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

  769.     if (ngx_rename_file(ccf->pid.data, ccf->oldpid.data) == NGX_FILE_ERROR) {
  770.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  771.                       ngx_rename_file_n " %s to %s failed "
  772.                       "before executing new binary process \"%s\"",
  773.                       ccf->pid.data, ccf->oldpid.data, argv[0]);

  775.         ngx_free(env);
  776.         ngx_free(var);

  778.         return NGX_INVALID_PID;
  779.     }

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

  783.     if (pid == NGX_INVALID_PID) {
  784.         if (ngx_rename_file(ccf->oldpid.data, ccf->pid.data)
  785.             == NGX_FILE_ERROR)
  786.         {
  787.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  788.                           ngx_rename_file_n " %s back to %s failed after "
  789.                           "an attempt to execute new binary process \"%s\"",
  790.                           ccf->oldpid.data, ccf->pid.data, argv[0]);
  791.         }
  792.     }

  794.     ngx_free(env);
  795.     ngx_free(var);

  797.     return pid;
  798. }


  801. static ngx_int_t
  802. ‌ngx_get_options(int argc, char *const *argv)
  803. {
  804.     u_char     *p;
  805.     ngx_int_t   i;

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

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

  811.         if (*p++ != '-') {
  812.             ngx_log_stderr(0, "invalid option: \"%s\"", argv[i]);
  813.             return NGX_ERROR;
  814.         }

  816.         while (*p) {

  818.             switch (*p++) {

  820.             case '?':
  821.             case 'h':
  822.                 ngx_show_version = 1;
  823.                 ngx_show_help = 1;
  824.                 break;

  826.             case 'v':
  827.                 ngx_show_version = 1;
  828.                 break;

  830.             case 'V':
  831.                 ngx_show_version = 1;
  832.                 ngx_show_configure = 1;
  833.                 break;

  835.             case 't':
  836.                 ngx_test_config = 1;
  837.                 break;

  839.             case 'T':
  840.                 ngx_test_config = 1;
  841.                 ngx_dump_config = 1;
  842.                 break;

  844.             case 'q':
  845.                 ngx_quiet_mode = 1;
  846.                 break;

  848.             case 'p':
  849.                 if (*p) {
  850.                     ngx_prefix = p;
  851.                     goto next;
  852.                 }

  854.                 if (argv[++i]) {
  855.                     ngx_prefix = (u_char *) argv[i];
  856.                     goto next;
  857.                 }

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

  862.             case 'e':
  863.                 if (*p) {
  864.                     ngx_error_log = p;

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

  869.                 } else {
  870.                     ngx_log_stderr(0, "option \"-e\" requires file name");
  871.                     return NGX_ERROR;
  872.                 }

  874.                 if (ngx_strcmp(ngx_error_log, "stderr") == 0) {
  875.                     ngx_error_log = (u_char *) "";
  876.                 }

  878.                 goto next;

  880.             case 'c':
  881.                 if (*p) {
  882.                     ngx_conf_file = p;
  883.                     goto next;
  884.                 }

  886.                 if (argv[++i]) {
  887.                     ngx_conf_file = (u_char *) argv[i];
  888.                     goto next;
  889.                 }

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

  894.             case 'g':
  895.                 if (*p) {
  896.                     ngx_conf_params = p;
  897.                     goto next;
  898.                 }

  900.                 if (argv[++i]) {
  901.                     ngx_conf_params = (u_char *) argv[i];
  902.                     goto next;
  903.                 }

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

  908.             case 's':
  909.                 if (*p) {
  910.                     ngx_signal = (char *) p;

  912.                 } else if (argv[++i]) {
  913.                     ngx_signal = argv[i];

  915.                 } else {
  916.                     ngx_log_stderr(0, "option \"-s\" requires parameter");
  917.                     return NGX_ERROR;
  918.                 }

  920.                 if (ngx_strcmp(ngx_signal, "stop") == 0
  921.                     || ngx_strcmp(ngx_signal, "quit") == 0
  922.                     || ngx_strcmp(ngx_signal, "reopen") == 0
  923.                     || ngx_strcmp(ngx_signal, "reload") == 0)
  924.                 {
  925.                     ngx_process = NGX_PROCESS_SIGNALLER;
  926.                     goto next;
  927.                 }

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

  932.             default:
  933.                 ngx_log_stderr(0, "invalid option: \"%c\"", *(p - 1));
  934.                 return NGX_ERROR;
  935.             }
  936.         }

  938.     next:

  940.         continue;
  941.     }

  943.     return NGX_OK;
  944. }


  947. static ngx_int_t
  948. ‌ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv)
  949. {
  950. #if (NGX_FREEBSD)

  952.     ngx_os_argv = (char **) argv;
  953.     ngx_argc = argc;
  954.     ngx_argv = (char **) argv;

  956. #else
  957.     size_t     len;
  958.     ngx_int_t  i;

  960.     ngx_os_argv = (char **) argv;
  961.     ngx_argc = argc;

  963.     ngx_argv = ngx_alloc((argc + 1) * sizeof(char *), cycle->log);
  964.     if (ngx_argv == NULL) {
  965.         return NGX_ERROR;
  966.     }

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

  971.         ngx_argv[i] = ngx_alloc(len, cycle->log);
  972.         if (ngx_argv[i] == NULL) {
  973.             return NGX_ERROR;
  974.         }

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

  979.     ngx_argv[i] = NULL;

  981. #endif

  983.     ngx_os_environ = environ;

  985.     return NGX_OK;
  986. }


  989. static ngx_int_t
  990. ‌ngx_process_options(ngx_cycle_t *cycle)
  991. {
  992.     u_char  *p;
  993.     size_t   len;

  995.     if (ngx_prefix) {
  996.         len = ngx_strlen(ngx_prefix);
  997.         p = ngx_prefix;

  999.         if (len && !ngx_path_separator(p[len - 1])) {
  1000.             p = ngx_pnalloc(cycle->pool, len + 1);
  1001.             if (p == NULL) {
  1002.                 return NGX_ERROR;
  1003.             }

  1005.             ngx_memcpy(p, ngx_prefix, len);
  1006.             p[len++] = '/';
  1007.         }

  1009.         cycle->conf_prefix.len = len;
  1010.         cycle->conf_prefix.data = p;
  1011.         cycle->prefix.len = len;
  1012.         cycle->prefix.data = p;

  1014.     } else {

  1016. #ifndef NGX_PREFIX

  1018.         p = ngx_pnalloc(cycle->pool, NGX_MAX_PATH);
  1019.         if (p == NULL) {
  1020.             return NGX_ERROR;
  1021.         }

  1023.         if (ngx_getcwd(p, NGX_MAX_PATH) == 0) {
  1024.             ngx_log_stderr(ngx_errno, "[emerg]: " ngx_getcwd_n " failed");
  1025.             return NGX_ERROR;
  1026.         }

  1028.         len = ngx_strlen(p);

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

  1032.         cycle->conf_prefix.len = len;
  1033.         cycle->conf_prefix.data = p;
  1034.         cycle->prefix.len = len;
  1035.         cycle->prefix.data = p;

  1037. #else

  1039. #ifdef NGX_CONF_PREFIX
  1040.         ngx_str_set(&cycle->conf_prefix, NGX_CONF_PREFIX);
  1041. #else
  1042.         ngx_str_set(&cycle->conf_prefix, NGX_PREFIX);
  1043. #endif
  1044.         ngx_str_set(&cycle->prefix, NGX_PREFIX);

  1046. #endif
  1047.     }

  1049.     if (ngx_conf_file) {
  1050.         cycle->conf_file.len = ngx_strlen(ngx_conf_file);
  1051.         cycle->conf_file.data = ngx_conf_file;

  1053.     } else {
  1054.         ngx_str_set(&cycle->conf_file, NGX_CONF_PATH);
  1055.     }

  1057.     if (ngx_conf_full_name(cycle, &cycle->conf_file, 0) != NGX_OK) {
  1058.         return NGX_ERROR;
  1059.     }

  1061.     for (p = cycle->conf_file.data + cycle->conf_file.len - 1;
  1062.          p > cycle->conf_file.data;
  1063.          p--)
  1064.     {
  1065.         if (ngx_path_separator(*p)) {
  1066.             cycle->conf_prefix.len = p - cycle->conf_file.data + 1;
  1067.             cycle->conf_prefix.data = cycle->conf_file.data;
  1068.             break;
  1069.         }
  1070.     }

  1072.     if (ngx_error_log) {
  1073.         cycle->error_log.len = ngx_strlen(ngx_error_log);
  1074.         cycle->error_log.data = ngx_error_log;

  1076.     } else {
  1077.         ngx_str_set(&cycle->error_log, NGX_ERROR_LOG_PATH);
  1078.     }

  1080.     if (ngx_conf_params) {
  1081.         cycle->conf_param.len = ngx_strlen(ngx_conf_params);
  1082.         cycle->conf_param.data = ngx_conf_params;
  1083.     }

  1085.     if (ngx_test_config) {
  1086.         cycle->log->log_level = NGX_LOG_INFO;
  1087.     }

  1089.     return NGX_OK;
  1090. }


  1093. static void *
  1094. ‌ngx_core_module_create_conf(ngx_cycle_t *cycle)
  1095. {
  1096.     ngx_core_conf_t  *ccf;

  1098.     ccf = ngx_pcalloc(cycle->pool, sizeof(ngx_core_conf_t));
  1099.     if (ccf == NULL) {
  1100.         return NULL;
  1101.     }

  1103.     /*
  1104.      * set by ngx_pcalloc()
  1105.      *
  1106.      *     ccf->pid = NULL;
  1107.      *     ccf->oldpid = NULL;
  1108.      *     ccf->priority = 0;
  1109.      *     ccf->cpu_affinity_auto = 0;
  1110.      *     ccf->cpu_affinity_n = 0;
  1111.      *     ccf->cpu_affinity = NULL;
  1112.      */

  1114.     ccf->daemon = NGX_CONF_UNSET;
  1115.     ccf->master = NGX_CONF_UNSET;
  1116.     ccf->timer_resolution = NGX_CONF_UNSET_MSEC;
  1117.     ccf->shutdown_timeout = NGX_CONF_UNSET_MSEC;

  1119.     ccf->worker_processes = NGX_CONF_UNSET;
  1120.     ccf->debug_points = NGX_CONF_UNSET;

  1122.     ccf->rlimit_nofile = NGX_CONF_UNSET;
  1123.     ccf->rlimit_core = NGX_CONF_UNSET;

  1125.     ccf->user = (ngx_uid_t) NGX_CONF_UNSET_UINT;
  1126.     ccf->group = (ngx_gid_t) NGX_CONF_UNSET_UINT;

  1128.     if (ngx_array_init(&ccf->env, cycle->pool, 1, sizeof(ngx_str_t))
  1129.         != NGX_OK)
  1130.     {
  1131.         return NULL;
  1132.     }

  1134.     return ccf;
  1135. }


  1138. static char *
  1139. ‌ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf)
  1140. {
  1141.     ngx_core_conf_t  *ccf = conf;

  1143.     ngx_conf_init_value(ccf->daemon, 1);
  1144.     ngx_conf_init_value(ccf->master, 1);
  1145.     ngx_conf_init_msec_value(ccf->timer_resolution, 0);
  1146.     ngx_conf_init_msec_value(ccf->shutdown_timeout, 0);

  1148.     ngx_conf_init_value(ccf->worker_processes, 1);
  1149.     ngx_conf_init_value(ccf->debug_points, 0);

  1151. #if (NGX_HAVE_CPU_AFFINITY)

  1153.     if (!ccf->cpu_affinity_auto
  1154.         && ccf->cpu_affinity_n
  1155.         && ccf->cpu_affinity_n != 1
  1156.         && ccf->cpu_affinity_n != (ngx_uint_t) ccf->worker_processes)
  1157.     {
  1158.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  1159.                       "the number of \"worker_processes\" is not equal to "
  1160.                       "the number of \"worker_cpu_affinity\" masks, "
  1161.                       "using last mask for remaining worker processes");
  1162.     }

  1164. #endif


  1167.     if (ccf->pid.len == 0) {
  1168.         ngx_str_set(&ccf->pid, NGX_PID_PATH);
  1169.     }

  1171.     if (ngx_conf_full_name(cycle, &ccf->pid, 0) != NGX_OK) {
  1172.         return NGX_CONF_ERROR;
  1173.     }

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

  1177.     ccf->oldpid.data = ngx_pnalloc(cycle->pool, ccf->oldpid.len);
  1178.     if (ccf->oldpid.data == NULL) {
  1179.         return NGX_CONF_ERROR;
  1180.     }

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


  1186. #if !(NGX_WIN32)

  1188.     if (ccf->user == (uid_t) NGX_CONF_UNSET_UINT && geteuid() == 0) {
  1189.         struct group   *grp;
  1190.         struct passwd  *pwd;

  1192.         ngx_set_errno(0);
  1193.         pwd = getpwnam(NGX_USER);
  1194.         if (pwd == NULL) {
  1195.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1196.                           "getpwnam(\"" NGX_USER "\") failed");
  1197.             return NGX_CONF_ERROR;
  1198.         }

  1200.         ccf->username = NGX_USER;
  1201.         ccf->user = pwd->pw_uid;

  1203.         ngx_set_errno(0);
  1204.         grp = getgrnam(NGX_GROUP);
  1205.         if (grp == NULL) {
  1206.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1207.                           "getgrnam(\"" NGX_GROUP "\") failed");
  1208.             return NGX_CONF_ERROR;
  1209.         }

  1211.         ccf->group = grp->gr_gid;
  1212.     }


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

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

  1223.     {
  1224.     ngx_str_t  lock_file;

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

  1228.     if (lock_file.len) {
  1229.         lock_file.len--;

  1231.         if (ccf->lock_file.len != lock_file.len
  1232.             || ngx_strncmp(ccf->lock_file.data, lock_file.data, lock_file.len)
  1233.                != 0)
  1234.         {
  1235.             ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  1236.                           "\"lock_file\" could not be changed, ignored");
  1237.         }

  1239.         cycle->lock_file.len = lock_file.len + 1;
  1240.         lock_file.len += sizeof(".accept");

  1242.         cycle->lock_file.data = ngx_pstrdup(cycle->pool, &lock_file);
  1243.         if (cycle->lock_file.data == NULL) {
  1244.             return NGX_CONF_ERROR;
  1245.         }

  1247.     } else {
  1248.         cycle->lock_file.len = ccf->lock_file.len + 1;
  1249.         cycle->lock_file.data = ngx_pnalloc(cycle->pool,
  1250.                                       ccf->lock_file.len + sizeof(".accept"));
  1251.         if (cycle->lock_file.data == NULL) {
  1252.             return NGX_CONF_ERROR;
  1253.         }

  1255.         ngx_memcpy(ngx_cpymem(cycle->lock_file.data, ccf->lock_file.data,
  1256.                               ccf->lock_file.len),
  1257.                    ".accept", sizeof(".accept"));
  1258.     }
  1259.     }

  1261. #endif

  1263.     return NGX_CONF_OK;
  1264. }


  1267. static char *
  1268. ‌ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1269. {
  1270. #if (NGX_WIN32)

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

  1275.     return NGX_CONF_OK;

  1277. #else

  1279.     ngx_core_conf_t  *ccf = conf;

  1281.     char             *group;
  1282.     struct passwd    *pwd;
  1283.     struct group     *grp;
  1284.     ngx_str_t        *value;

  1286.     if (ccf->user != (uid_t) NGX_CONF_UNSET_UINT) {
  1287.         return "is duplicate";
  1288.     }

  1290.     if (geteuid() != 0) {
  1291.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1292.                            "the \"user\" directive makes sense only "
  1293.                            "if the master process runs "
  1294.                            "with super-user privileges, ignored");
  1295.         return NGX_CONF_OK;
  1296.     }

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

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

  1302.     ngx_set_errno(0);
  1303.     pwd = getpwnam((const char *) value[1].data);
  1304.     if (pwd == NULL) {
  1305.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1306.                            "getpwnam(\"%s\") failed", value[1].data);
  1307.         return NGX_CONF_ERROR;
  1308.     }

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

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

  1314.     ngx_set_errno(0);
  1315.     grp = getgrnam(group);
  1316.     if (grp == NULL) {
  1317.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1318.                            "getgrnam(\"%s\") failed", group);
  1319.         return NGX_CONF_ERROR;
  1320.     }

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

  1324.     return NGX_CONF_OK;

  1326. #endif
  1327. }


  1330. static char *
  1331. ‌ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1332. {
  1333.     ngx_core_conf_t  *ccf = conf;

  1335.     ngx_str_t   *value, *var;
  1336.     ngx_uint_t   i;

  1338.     var = ngx_array_push(&ccf->env);
  1339.     if (var == NULL) {
  1340.         return NGX_CONF_ERROR;
  1341.     }

  1343.     value = cf->args->elts;
  1344.     *var = value[1];

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

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

  1350.             var->len = i;

  1352.             return NGX_CONF_OK;
  1353.         }
  1354.     }

  1356.     return NGX_CONF_OK;
  1357. }


  1360. static char *
  1361. ‌ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1362. {
  1363.     ngx_core_conf_t  *ccf = conf;

  1365.     ngx_str_t        *value;
  1366.     ngx_uint_t        n, minus;

  1368.     if (ccf->priority != 0) {
  1369.         return "is duplicate";
  1370.     }

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

  1374.     if (value[1].data[0] == '-') {
  1375.         n = 1;
  1376.         minus = 1;

  1378.     } else if (value[1].data[0] == '+') {
  1379.         n = 1;
  1380.         minus = 0;

  1382.     } else {
  1383.         n = 0;
  1384.         minus = 0;
  1385.     }

  1387.     ccf->priority = ngx_atoi(&value[1].data[n], value[1].len - n);
  1388.     if (ccf->priority == NGX_ERROR) {
  1389.         return "invalid number";
  1390.     }

  1392.     if (minus) {
  1393.         ccf->priority = -ccf->priority;
  1394.     }

  1396.     return NGX_CONF_OK;
  1397. }


  1400. static char *
  1401. ‌ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1402. {
  1403. #if (NGX_HAVE_CPU_AFFINITY)
  1404.     ngx_core_conf_t  *ccf = conf;

  1406.     u_char            ch, *p;
  1407.     ngx_str_t        *value;
  1408.     ngx_uint_t        i, n;
  1409.     ngx_cpuset_t     *mask;

  1411.     if (ccf->cpu_affinity) {
  1412.         return "is duplicate";
  1413.     }

  1415.     mask = ngx_palloc(cf->pool, (cf->args->nelts - 1) * sizeof(ngx_cpuset_t));
  1416.     if (mask == NULL) {
  1417.         return NGX_CONF_ERROR;
  1418.     }

  1420.     ccf->cpu_affinity_n = cf->args->nelts - 1;
  1421.     ccf->cpu_affinity = mask;

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

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

  1427.         if (cf->args->nelts > 3) {
  1428.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1429.                                "invalid number of arguments in "
  1430.                                "\"worker_cpu_affinity\" directive");
  1431.             return NGX_CONF_ERROR;
  1432.         }

  1434.         ccf->cpu_affinity_auto = 1;

  1436.         CPU_ZERO(&mask[0]);
  1437.         for (i = 0; i < (ngx_uint_t) ngx_min(ngx_ncpu, CPU_SETSIZE); i++) {
  1438.             CPU_SET(i, &mask[0]);
  1439.         }

  1441.         n = 2;

  1443.     } else {
  1444.         n = 1;
  1445.     }

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

  1449.         if (value[n].len > CPU_SETSIZE) {
  1450.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1451.                          "\"worker_cpu_affinity\" supports up to %d CPUs only",
  1452.                          CPU_SETSIZE);
  1453.             return NGX_CONF_ERROR;
  1454.         }

  1456.         i = 0;
  1457.         CPU_ZERO(&mask[n - 1]);

  1459.         for (p = value[n].data + value[n].len - 1;
  1460.              p >= value[n].data;
  1461.              p--)
  1462.         {
  1463.             ch = *p;

  1465.             if (ch == ' ') {
  1466.                 continue;
  1467.             }

  1469.             i++;

  1471.             if (ch == '0') {
  1472.                 continue;
  1473.             }

  1475.             if (ch == '1') {
  1476.                 CPU_SET(i - 1, &mask[n - 1]);
  1477.                 continue;
  1478.             }

  1480.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1481.                           "invalid character \"%c\" in \"worker_cpu_affinity\"",
  1482.                           ch);
  1483.             return NGX_CONF_ERROR;
  1484.         }
  1485.     }

  1487. #else

  1489.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1490.                        "\"worker_cpu_affinity\" is not supported "
  1491.                        "on this platform, ignored");
  1492. #endif

  1494.     return NGX_CONF_OK;
  1495. }


  1498. ngx_cpuset_t *
  1499. ‌ngx_get_cpu_affinity(ngx_uint_t n)
  1500. {
  1501. #if (NGX_HAVE_CPU_AFFINITY)
  1502.     ngx_uint_t        i, j;
  1503.     ngx_cpuset_t     *mask;
  1504.     ngx_core_conf_t  *ccf;

  1506.     static ngx_cpuset_t  result;

  1508.     ccf = (ngx_core_conf_t *) ngx_get_conf(ngx_cycle->conf_ctx,
  1509.                                            ngx_core_module);

  1511.     if (ccf->cpu_affinity == NULL) {
  1512.         return NULL;
  1513.     }

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

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

  1520.             if (CPU_ISSET(i % CPU_SETSIZE, mask) && j-- == 0) {
  1521.                 break;
  1522.             }

  1524.             if (i == CPU_SETSIZE && j == n) {
  1525.                 /* empty mask */
  1526.                 return NULL;
  1527.             }

  1529.             /* void */
  1530.         }

  1532.         CPU_ZERO(&result);
  1533.         CPU_SET(i % CPU_SETSIZE, &result);

  1535.         return &result;
  1536.     }

  1538.     if (ccf->cpu_affinity_n > n) {
  1539.         return &ccf->cpu_affinity[n];
  1540.     }

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

  1544. #else

  1546.     return NULL;

  1548. #endif
  1549. }


  1552. static char *
  1553. ‌ngx_set_worker_processes(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1554. {
  1555.     ngx_str_t        *value;
  1556.     ngx_core_conf_t  *ccf;

  1558.     ccf = (ngx_core_conf_t *) conf;

  1560.     if (ccf->worker_processes != NGX_CONF_UNSET) {
  1561.         return "is duplicate";
  1562.     }

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

  1566.     if (ngx_strcmp(value[1].data, "auto") == 0) {
  1567.         ccf->worker_processes = ngx_ncpu;
  1568.         return NGX_CONF_OK;
  1569.     }

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

  1573.     if (ccf->worker_processes == NGX_ERROR) {
  1574.         return "invalid value";
  1575.     }

  1577.     return NGX_CONF_OK;
  1578. }


  1581. static char *
  1582. ‌ngx_load_module(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1583. {
  1584. #if (NGX_HAVE_DLOPEN)
  1585.     void                *handle;
  1586.     char               **names, **order;
  1587.     ngx_str_t           *value, file;
  1588.     ngx_uint_t           i;
  1589.     ngx_module_t        *module, **modules;
  1590.     ngx_pool_cleanup_t  *cln;

  1592.     if (cf->cycle->modules_used) {
  1593.         return "is specified too late";
  1594.     }

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

  1598.     file = value[1];

  1600.     if (ngx_conf_full_name(cf->cycle, &file, 0) != NGX_OK) {
  1601.         return NGX_CONF_ERROR;
  1602.     }

  1604.     cln = ngx_pool_cleanup_add(cf->cycle->pool, 0);
  1605.     if (cln == NULL) {
  1606.         return NGX_CONF_ERROR;
  1607.     }

  1609.     handle = ngx_dlopen(file.data);
  1610.     if (handle == NULL) {
  1611.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1612.                            ngx_dlopen_n " \"%s\" failed (%s)",
  1613.                            file.data, ngx_dlerror());
  1614.         return NGX_CONF_ERROR;
  1615.     }

  1617.     cln->handler = ngx_unload_module;
  1618.     cln->data = handle;

  1620.     modules = ngx_dlsym(handle, "ngx_modules");
  1621.     if (modules == NULL) {
  1622.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1623.                            ngx_dlsym_n " \"%V\", \"%s\" failed (%s)",
  1624.                            &value[1], "ngx_modules", ngx_dlerror());
  1625.         return NGX_CONF_ERROR;
  1626.     }

  1628.     names = ngx_dlsym(handle, "ngx_module_names");
  1629.     if (names == NULL) {
  1630.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1631.                            ngx_dlsym_n " \"%V\", \"%s\" failed (%s)",
  1632.                            &value[1], "ngx_module_names", ngx_dlerror());
  1633.         return NGX_CONF_ERROR;
  1634.     }

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

  1638.     for (i = 0; modules[i]; i++) {
  1639.         module = modules[i];
  1640.         module->name = names[i];

  1642.         if (ngx_add_module(cf, &file, module, order) != NGX_OK) {
  1643.             return NGX_CONF_ERROR;
  1644.         }

  1646.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, cf->log, 0, "module: %s i:%ui",
  1647.                        module->name, module->index);
  1648.     }

  1650.     return NGX_CONF_OK;

  1652. #else

  1654.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1655.                        "\"load_module\" is not supported "
  1656.                        "on this platform");
  1657.     return NGX_CONF_ERROR;

  1659. #endif
  1660. }


  1663. #if (NGX_HAVE_DLOPEN)

  1665. static void
  1666. ‌ngx_unload_module(void *data)
  1667. {
  1668.     void  *handle = data;

  1670.     if (ngx_dlclose(handle) != 0) {
  1671.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1672.                       ngx_dlclose_n " failed (%s)", ngx_dlerror());
  1673.     }
  1674. }

  1676. #endif

One Level Up Top Level