One Level Up Top Level

src/core/nginx.c - nginx-1.7.10

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 ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle);
  14. static ngx_int_t ngx_get_options(int argc, char *const *argv);
  15. static ngx_int_t ngx_process_options(ngx_cycle_t *cycle);
  16. static ngx_int_t ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv);
  17. static void *ngx_core_module_create_conf(ngx_cycle_t *cycle);
  18. static char *ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf);
  19. static char *ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  20. static char *ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  21. static char *ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  22. static char *ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd,
  23.     void *conf);
  24. static char *ngx_set_worker_processes(ngx_conf_t *cf, ngx_command_t *cmd,
  25.     void *conf);


  28. ‌static ngx_conf_enum_t  ngx_debug_points[] = {
  29.     { ngx_string("stop"), NGX_DEBUG_POINTS_STOP },
  30.     { ngx_string("abort"), NGX_DEBUG_POINTS_ABORT },
  31.     { ngx_null_string, 0 }
  32. };


  35. ‌static ngx_command_t  ngx_core_commands[] = {

  37.     { ngx_string("daemon"),
  38.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  39.       ngx_conf_set_flag_slot,
  40.       0,
  41.       offsetof(ngx_core_conf_t, daemon),
  42.       NULL },

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

  51.     { ngx_string("timer_resolution"),
  52.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  53.       ngx_conf_set_msec_slot,
  54.       0,
  55.       offsetof(ngx_core_conf_t, timer_resolution),
  56.       NULL },

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

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

  72.     { ngx_string("worker_processes"),
  73.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  74.       ngx_set_worker_processes,
  75.       0,
  76.       0,
  77.       NULL },

  79.     { ngx_string("debug_points"),
  80.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  81.       ngx_conf_set_enum_slot,
  82.       0,
  83.       offsetof(ngx_core_conf_t, debug_points),
  84.       &ngx_debug_points },

  86.     { ngx_string("user"),
  87.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE12,
  88.       ngx_set_user,
  89.       0,
  90.       0,
  91.       NULL },

  93.     { ngx_string("worker_priority"),
  94.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  95.       ngx_set_priority,
  96.       0,
  97.       0,
  98.       NULL },

  100.     { ngx_string("worker_cpu_affinity"),
  101.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_1MORE,
  102.       ngx_set_cpu_affinity,
  103.       0,
  104.       0,
  105.       NULL },

  107.     { ngx_string("worker_rlimit_nofile"),
  108.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  109.       ngx_conf_set_num_slot,
  110.       0,
  111.       offsetof(ngx_core_conf_t, rlimit_nofile),
  112.       NULL },

  114.     { ngx_string("worker_rlimit_core"),
  115.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  116.       ngx_conf_set_off_slot,
  117.       0,
  118.       offsetof(ngx_core_conf_t, rlimit_core),
  119.       NULL },

  121.     { ngx_string("worker_rlimit_sigpending"),
  122.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  123.       ngx_conf_set_num_slot,
  124.       0,
  125.       offsetof(ngx_core_conf_t, rlimit_sigpending),
  126.       NULL },

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

  135.     { ngx_string("env"),
  136.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  137.       ngx_set_env,
  138.       0,
  139.       0,
  140.       NULL },

  142. #if (NGX_THREADS)

  144.     { ngx_string("worker_threads"),
  145.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  146.       ngx_conf_set_num_slot,
  147.       0,
  148.       offsetof(ngx_core_conf_t, worker_threads),
  149.       NULL },

  151.     { ngx_string("thread_stack_size"),
  152.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  153.       ngx_conf_set_size_slot,
  154.       0,
  155.       offsetof(ngx_core_conf_t, thread_stack_size),
  156.       NULL },

  158. #endif

  160.       ngx_null_command
  161. };


  164. ‌static ngx_core_module_t  ngx_core_module_ctx = {
  165.     ngx_string("core"),
  166.     ngx_core_module_create_conf,
  167.     ngx_core_module_init_conf
  168. };


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


  187. ‌ngx_uint_t          ngx_max_module;

  189. ‌static ngx_uint_t   ngx_show_help;
  190. ‌static ngx_uint_t   ngx_show_version;
  191. ‌static ngx_uint_t   ngx_show_configure;
  192. ‌static u_char      *ngx_prefix;
  193. ‌static u_char      *ngx_conf_file;
  194. ‌static u_char      *ngx_conf_params;
  195. ‌static char        *ngx_signal;


  198. ‌static char **ngx_os_environ;


  201. int ngx_cdecl
  202. ‌main(int argc, char *const *argv)
  203. {
  204.     ngx_int_t         i;
  205.     ngx_log_t        *log;
  206.     ngx_cycle_t      *cycle, init_cycle;
  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_write_stderr("nginx version: " NGINX_VER_BUILD NGX_LINEFEED);

  222.         if (ngx_show_help) {
  223.             ngx_write_stderr(
  224.                 "Usage: nginx [-?hvVtq] [-s signal] [-c filename] "
  225.                              "[-p prefix] [-g directives]" NGX_LINEFEED
  226.                              NGX_LINEFEED
  227.                 "Options:" NGX_LINEFEED
  228.                 "  -?,-h         : this help" NGX_LINEFEED
  229.                 "  -v            : show version and exit" NGX_LINEFEED
  230.                 "  -V            : show version and configure options then exit"
  231.                                    NGX_LINEFEED
  232.                 "  -t            : test configuration and exit" NGX_LINEFEED
  233.                 "  -q            : suppress non-error messages "
  234.                                    "during configuration testing" NGX_LINEFEED
  235.                 "  -s signal     : send signal to a master process: "
  236.                                    "stop, quit, reopen, reload" NGX_LINEFEED
  237. #ifdef NGX_PREFIX
  238.                 "  -p prefix     : set prefix path (default: "
  239.                                    NGX_PREFIX ")" NGX_LINEFEED
  240. #else
  241.                 "  -p prefix     : set prefix path (default: NONE)" NGX_LINEFEED
  242. #endif
  243.                 "  -c filename   : set configuration file (default: "
  244.                                    NGX_CONF_PATH ")" NGX_LINEFEED
  245.                 "  -g directives : set global directives out of configuration "
  246.                                    "file" NGX_LINEFEED NGX_LINEFEED
  247.                 );
  248.         }

  250.         if (ngx_show_configure) {
  251.             ngx_write_stderr(
  252. #ifdef NGX_COMPILER
  253.                 "built by " NGX_COMPILER NGX_LINEFEED
  254. #endif
  255. #if (NGX_SSL)
  256. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
  257.                 "TLS SNI support enabled" NGX_LINEFEED
  258. #else
  259.                 "TLS SNI support disabled" NGX_LINEFEED
  260. #endif
  261. #endif
  262.                 "configure arguments:" NGX_CONFIGURE NGX_LINEFEED);
  263.         }

  265.         if (!ngx_test_config) {
  266.             return 0;
  267.         }
  268.     }

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

  272.     ngx_time_init();

  274. #if (NGX_PCRE)
  275.     ngx_regex_init();
  276. #endif

  278.     ngx_pid = ngx_getpid();

  280.     log = ngx_log_init(ngx_prefix);
  281.     if (log == NULL) {
  282.         return 1;
  283.     }

  285.     /* STUB */
  286. #if (NGX_OPENSSL)
  287.     ngx_ssl_init(log);
  288. #endif

  290.     /*
  291.      * init_cycle->log is required for signal handlers and
  292.      * ngx_process_options()
  293.      */

  295.     ngx_memzero(&init_cycle, sizeof(ngx_cycle_t));
  296.     init_cycle.log = log;
  297.     ngx_cycle = &init_cycle;

  299.     init_cycle.pool = ngx_create_pool(1024, log);
  300.     if (init_cycle.pool == NULL) {
  301.         return 1;
  302.     }

  304.     if (ngx_save_argv(&init_cycle, argc, argv) != NGX_OK) {
  305.         return 1;
  306.     }

  308.     if (ngx_process_options(&init_cycle) != NGX_OK) {
  309.         return 1;
  310.     }

  312.     if (ngx_os_init(log) != NGX_OK) {
  313.         return 1;
  314.     }

  316.     /*
  317.      * ngx_crc32_table_init() requires ngx_cacheline_size set in ngx_os_init()
  318.      */

  320.     if (ngx_crc32_table_init() != NGX_OK) {
  321.         return 1;
  322.     }

  324.     if (ngx_add_inherited_sockets(&init_cycle) != NGX_OK) {
  325.         return 1;
  326.     }

  328.     ngx_max_module = 0;
  329.     for (i = 0; ngx_modules[i]; i++) {
  330.         ngx_modules[i]->index = ngx_max_module++;
  331.     }

  333.     cycle = ngx_init_cycle(&init_cycle);
  334.     if (cycle == NULL) {
  335.         if (ngx_test_config) {
  336.             ngx_log_stderr(0, "configuration file %s test failed",
  337.                            init_cycle.conf_file.data);
  338.         }

  340.         return 1;
  341.     }

  343.     if (ngx_test_config) {
  344.         if (!ngx_quiet_mode) {
  345.             ngx_log_stderr(0, "configuration file %s test is successful",
  346.                            cycle->conf_file.data);
  347.         }

  349.         return 0;
  350.     }

  352.     if (ngx_signal) {
  353.         return ngx_signal_process(cycle, ngx_signal);
  354.     }

  356.     ngx_os_status(cycle->log);

  358.     ngx_cycle = cycle;

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

  362.     if (ccf->master && ngx_process == NGX_PROCESS_SINGLE) {
  363.         ngx_process = NGX_PROCESS_MASTER;
  364.     }

  366. #if !(NGX_WIN32)

  368.     if (ngx_init_signals(cycle->log) != NGX_OK) {
  369.         return 1;
  370.     }

  372.     if (!ngx_inherited && ccf->daemon) {
  373.         if (ngx_daemon(cycle->log) != NGX_OK) {
  374.             return 1;
  375.         }

  377.         ngx_daemonized = 1;
  378.     }

  380.     if (ngx_inherited) {
  381.         ngx_daemonized = 1;
  382.     }

  384. #endif

  386.     if (ngx_create_pidfile(&ccf->pid, cycle->log) != NGX_OK) {
  387.         return 1;
  388.     }

  390.     if (ngx_log_redirect_stderr(cycle) != NGX_OK) {
  391.         return 1;
  392.     }

  394.     if (log->file->fd != ngx_stderr) {
  395.         if (ngx_close_file(log->file->fd) == NGX_FILE_ERROR) {
  396.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  397.                           ngx_close_file_n " built-in log failed");
  398.         }
  399.     }

  401.     ngx_use_stderr = 0;

  403.     if (ngx_process == NGX_PROCESS_SINGLE) {
  404.         ngx_single_process_cycle(cycle);

  406.     } else {
  407.         ngx_master_process_cycle(cycle);
  408.     }

  410.     return 0;
  411. }


  414. static ngx_int_t
  415. ‌ngx_add_inherited_sockets(ngx_cycle_t *cycle)
  416. {
  417.     u_char           *p, *v, *inherited;
  418.     ngx_int_t         s;
  419.     ngx_listening_t  *ls;

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

  423.     if (inherited == NULL) {
  424.         return NGX_OK;
  425.     }

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

  430.     if (ngx_array_init(&cycle->listening, cycle->pool, 10,
  431.                        sizeof(ngx_listening_t))
  432.         != NGX_OK)
  433.     {
  434.         return NGX_ERROR;
  435.     }

  437.     for (p = inherited, v = p; *p; p++) {
  438.         if (*p == ':' || *p == ';') {
  439.             s = ngx_atoi(v, p - v);
  440.             if (s == NGX_ERROR) {
  441.                 ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  442.                               "invalid socket number \"%s\" in " NGINX_VAR
  443.                               " environment variable, ignoring the rest"
  444.                               " of the variable", v);
  445.                 break;
  446.             }

  448.             v = p + 1;

  450.             ls = ngx_array_push(&cycle->listening);
  451.             if (ls == NULL) {
  452.                 return NGX_ERROR;
  453.             }

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

  457.             ls->fd = (ngx_socket_t) s;
  458.         }
  459.     }

  461.     ngx_inherited = 1;

  463.     return ngx_set_inherited_sockets(cycle);
  464. }


  467. char **
  468. ‌ngx_set_environment(ngx_cycle_t *cycle, ngx_uint_t *last)
  469. {
  470.     char             **p, **env;
  471.     ngx_str_t         *var;
  472.     ngx_uint_t         i, n;
  473.     ngx_core_conf_t   *ccf;

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

  477.     if (last == NULL && ccf->environment) {
  478.         return ccf->environment;
  479.     }

  481.     var = ccf->env.elts;

  483.     for (i = 0; i < ccf->env.nelts; i++) {
  484.         if (ngx_strcmp(var[i].data, "TZ") == 0
  485.             || ngx_strncmp(var[i].data, "TZ=", 3) == 0)
  486.         {
  487.             goto tz_found;
  488.         }
  489.     }

  491.     var = ngx_array_push(&ccf->env);
  492.     if (var == NULL) {
  493.         return NULL;
  494.     }

  496.     var->len = 2;
  497.     var->data = (u_char *) "TZ";

  499.     var = ccf->env.elts;

  501. tz_found:

  503.     n = 0;

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

  507.         if (var[i].data[var[i].len] == '=') {
  508.             n++;
  509.             continue;
  510.         }

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

  514.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  515.                 && (*p)[var[i].len] == '=')
  516.             {
  517.                 n++;
  518.                 break;
  519.             }
  520.         }
  521.     }

  523.     if (last) {
  524.         env = ngx_alloc((*last + n + 1) * sizeof(char *), cycle->log);
  525.         *last = n;

  527.     } else {
  528.         env = ngx_palloc(cycle->pool, (n + 1) * sizeof(char *));
  529.     }

  531.     if (env == NULL) {
  532.         return NULL;
  533.     }

  535.     n = 0;

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

  539.         if (var[i].data[var[i].len] == '=') {
  540.             env[n++] = (char *) var[i].data;
  541.             continue;
  542.         }

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

  546.             if (ngx_strncmp(*p, var[i].data, var[i].len) == 0
  547.                 && (*p)[var[i].len] == '=')
  548.             {
  549.                 env[n++] = *p;
  550.                 break;
  551.             }
  552.         }
  553.     }

  555.     env[n] = NULL;

  557.     if (last == NULL) {
  558.         ccf->environment = env;
  559.         environ = env;
  560.     }

  562.     return env;
  563. }


  566. ngx_pid_t
  567. ‌ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
  568. {
  569.     char             **env, *var;
  570.     u_char            *p;
  571.     ngx_uint_t         i, n;
  572.     ngx_pid_t          pid;
  573.     ngx_exec_ctx_t     ctx;
  574.     ngx_core_conf_t   *ccf;
  575.     ngx_listening_t   *ls;

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

  579.     ctx.path = argv[0];
  580.     ctx.name = "new binary process";
  581.     ctx.argv = argv;

  583.     n = 2;
  584.     env = ngx_set_environment(cycle, &n);
  585.     if (env == NULL) {
  586.         return NGX_INVALID_PID;
  587.     }

  589.     var = ngx_alloc(sizeof(NGINX_VAR)
  590.                     + cycle->listening.nelts * (NGX_INT32_LEN + 1) + 2,
  591.                     cycle->log);
  592.     if (var == NULL) {
  593.         ngx_free(env);
  594.         return NGX_INVALID_PID;
  595.     }

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

  599.     ls = cycle->listening.elts;
  600.     for (i = 0; i < cycle->listening.nelts; i++) {
  601.         p = ngx_sprintf(p, "%ud;", ls[i].fd);
  602.     }

  604.     *p = '\0';

  606.     env[n++] = var;

  608. #if (NGX_SETPROCTITLE_USES_ENV)

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

  612.     env[n++] = "SPARE=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  613.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  614.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  615.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
  616.                "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

  618. #endif

  620.     env[n] = NULL;

  622. #if (NGX_DEBUG)
  623.     {
  624.     char  **e;
  625.     for (e = env; *e; e++) {
  626.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0, "env: %s", *e);
  627.     }
  628.     }
  629. #endif

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

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

  635.     if (ngx_rename_file(ccf->pid.data, ccf->oldpid.data) == NGX_FILE_ERROR) {
  636.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  637.                       ngx_rename_file_n " %s to %s failed "
  638.                       "before executing new binary process \"%s\"",
  639.                       ccf->pid.data, ccf->oldpid.data, argv[0]);

  641.         ngx_free(env);
  642.         ngx_free(var);

  644.         return NGX_INVALID_PID;
  645.     }

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

  649.     if (pid == NGX_INVALID_PID) {
  650.         if (ngx_rename_file(ccf->oldpid.data, ccf->pid.data)
  651.             == NGX_FILE_ERROR)
  652.         {
  653.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  654.                           ngx_rename_file_n " %s back to %s failed after "
  655.                           "an attempt to execute new binary process \"%s\"",
  656.                           ccf->oldpid.data, ccf->pid.data, argv[0]);
  657.         }
  658.     }

  660.     ngx_free(env);
  661.     ngx_free(var);

  663.     return pid;
  664. }


  667. static ngx_int_t
  668. ‌ngx_get_options(int argc, char *const *argv)
  669. {
  670.     u_char     *p;
  671.     ngx_int_t   i;

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

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

  677.         if (*p++ != '-') {
  678.             ngx_log_stderr(0, "invalid option: \"%s\"", argv[i]);
  679.             return NGX_ERROR;
  680.         }

  682.         while (*p) {

  684.             switch (*p++) {

  686.             case '?':
  687.             case 'h':
  688.                 ngx_show_version = 1;
  689.                 ngx_show_help = 1;
  690.                 break;

  692.             case 'v':
  693.                 ngx_show_version = 1;
  694.                 break;

  696.             case 'V':
  697.                 ngx_show_version = 1;
  698.                 ngx_show_configure = 1;
  699.                 break;

  701.             case 't':
  702.                 ngx_test_config = 1;
  703.                 break;

  705.             case 'q':
  706.                 ngx_quiet_mode = 1;
  707.                 break;

  709.             case 'p':
  710.                 if (*p) {
  711.                     ngx_prefix = p;
  712.                     goto next;
  713.                 }

  715.                 if (argv[++i]) {
  716.                     ngx_prefix = (u_char *) argv[i];
  717.                     goto next;
  718.                 }

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

  723.             case 'c':
  724.                 if (*p) {
  725.                     ngx_conf_file = p;
  726.                     goto next;
  727.                 }

  729.                 if (argv[++i]) {
  730.                     ngx_conf_file = (u_char *) argv[i];
  731.                     goto next;
  732.                 }

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

  737.             case 'g':
  738.                 if (*p) {
  739.                     ngx_conf_params = p;
  740.                     goto next;
  741.                 }

  743.                 if (argv[++i]) {
  744.                     ngx_conf_params = (u_char *) argv[i];
  745.                     goto next;
  746.                 }

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

  751.             case 's':
  752.                 if (*p) {
  753.                     ngx_signal = (char *) p;

  755.                 } else if (argv[++i]) {
  756.                     ngx_signal = argv[i];

  758.                 } else {
  759.                     ngx_log_stderr(0, "option \"-s\" requires parameter");
  760.                     return NGX_ERROR;
  761.                 }

  763.                 if (ngx_strcmp(ngx_signal, "stop") == 0
  764.                     || ngx_strcmp(ngx_signal, "quit") == 0
  765.                     || ngx_strcmp(ngx_signal, "reopen") == 0
  766.                     || ngx_strcmp(ngx_signal, "reload") == 0)
  767.                 {
  768.                     ngx_process = NGX_PROCESS_SIGNALLER;
  769.                     goto next;
  770.                 }

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

  775.             default:
  776.                 ngx_log_stderr(0, "invalid option: \"%c\"", *(p - 1));
  777.                 return NGX_ERROR;
  778.             }
  779.         }

  781.     next:

  783.         continue;
  784.     }

  786.     return NGX_OK;
  787. }


  790. static ngx_int_t
  791. ‌ngx_save_argv(ngx_cycle_t *cycle, int argc, char *const *argv)
  792. {
  793. #if (NGX_FREEBSD)

  795.     ngx_os_argv = (char **) argv;
  796.     ngx_argc = argc;
  797.     ngx_argv = (char **) argv;

  799. #else
  800.     size_t     len;
  801.     ngx_int_t  i;

  803.     ngx_os_argv = (char **) argv;
  804.     ngx_argc = argc;

  806.     ngx_argv = ngx_alloc((argc + 1) * sizeof(char *), cycle->log);
  807.     if (ngx_argv == NULL) {
  808.         return NGX_ERROR;
  809.     }

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

  814.         ngx_argv[i] = ngx_alloc(len, cycle->log);
  815.         if (ngx_argv[i] == NULL) {
  816.             return NGX_ERROR;
  817.         }

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

  822.     ngx_argv[i] = NULL;

  824. #endif

  826.     ngx_os_environ = environ;

  828.     return NGX_OK;
  829. }


  832. static ngx_int_t
  833. ‌ngx_process_options(ngx_cycle_t *cycle)
  834. {
  835.     u_char  *p;
  836.     size_t   len;

  838.     if (ngx_prefix) {
  839.         len = ngx_strlen(ngx_prefix);
  840.         p = ngx_prefix;

  842.         if (len && !ngx_path_separator(p[len - 1])) {
  843.             p = ngx_pnalloc(cycle->pool, len + 1);
  844.             if (p == NULL) {
  845.                 return NGX_ERROR;
  846.             }

  848.             ngx_memcpy(p, ngx_prefix, len);
  849.             p[len++] = '/';
  850.         }

  852.         cycle->conf_prefix.len = len;
  853.         cycle->conf_prefix.data = p;
  854.         cycle->prefix.len = len;
  855.         cycle->prefix.data = p;

  857.     } else {

  859. #ifndef NGX_PREFIX

  861.         p = ngx_pnalloc(cycle->pool, NGX_MAX_PATH);
  862.         if (p == NULL) {
  863.             return NGX_ERROR;
  864.         }

  866.         if (ngx_getcwd(p, NGX_MAX_PATH) == 0) {
  867.             ngx_log_stderr(ngx_errno, "[emerg]: " ngx_getcwd_n " failed");
  868.             return NGX_ERROR;
  869.         }

  871.         len = ngx_strlen(p);

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

  875.         cycle->conf_prefix.len = len;
  876.         cycle->conf_prefix.data = p;
  877.         cycle->prefix.len = len;
  878.         cycle->prefix.data = p;

  880. #else

  882. #ifdef NGX_CONF_PREFIX
  883.         ngx_str_set(&cycle->conf_prefix, NGX_CONF_PREFIX);
  884. #else
  885.         ngx_str_set(&cycle->conf_prefix, NGX_PREFIX);
  886. #endif
  887.         ngx_str_set(&cycle->prefix, NGX_PREFIX);

  889. #endif
  890.     }

  892.     if (ngx_conf_file) {
  893.         cycle->conf_file.len = ngx_strlen(ngx_conf_file);
  894.         cycle->conf_file.data = ngx_conf_file;

  896.     } else {
  897.         ngx_str_set(&cycle->conf_file, NGX_CONF_PATH);
  898.     }

  900.     if (ngx_conf_full_name(cycle, &cycle->conf_file, 0) != NGX_OK) {
  901.         return NGX_ERROR;
  902.     }

  904.     for (p = cycle->conf_file.data + cycle->conf_file.len - 1;
  905.          p > cycle->conf_file.data;
  906.          p--)
  907.     {
  908.         if (ngx_path_separator(*p)) {
  909.             cycle->conf_prefix.len = p - ngx_cycle->conf_file.data + 1;
  910.             cycle->conf_prefix.data = ngx_cycle->conf_file.data;
  911.             break;
  912.         }
  913.     }

  915.     if (ngx_conf_params) {
  916.         cycle->conf_param.len = ngx_strlen(ngx_conf_params);
  917.         cycle->conf_param.data = ngx_conf_params;
  918.     }

  920.     if (ngx_test_config) {
  921.         cycle->log->log_level = NGX_LOG_INFO;
  922.     }

  924.     return NGX_OK;
  925. }


  928. static void *
  929. ‌ngx_core_module_create_conf(ngx_cycle_t *cycle)
  930. {
  931.     ngx_core_conf_t  *ccf;

  933.     ccf = ngx_pcalloc(cycle->pool, sizeof(ngx_core_conf_t));
  934.     if (ccf == NULL) {
  935.         return NULL;
  936.     }

  938.     /*
  939.      * set by ngx_pcalloc()
  940.      *
  941.      *     ccf->pid = NULL;
  942.      *     ccf->oldpid = NULL;
  943.      *     ccf->priority = 0;
  944.      *     ccf->cpu_affinity_n = 0;
  945.      *     ccf->cpu_affinity = NULL;
  946.      */

  948.     ccf->daemon = NGX_CONF_UNSET;
  949.     ccf->master = NGX_CONF_UNSET;
  950.     ccf->timer_resolution = NGX_CONF_UNSET_MSEC;

  952.     ccf->worker_processes = NGX_CONF_UNSET;
  953.     ccf->debug_points = NGX_CONF_UNSET;

  955.     ccf->rlimit_nofile = NGX_CONF_UNSET;
  956.     ccf->rlimit_core = NGX_CONF_UNSET;
  957.     ccf->rlimit_sigpending = NGX_CONF_UNSET;

  959.     ccf->user = (ngx_uid_t) NGX_CONF_UNSET_UINT;
  960.     ccf->group = (ngx_gid_t) NGX_CONF_UNSET_UINT;

  962. #if (NGX_THREADS)
  963.     ccf->worker_threads = NGX_CONF_UNSET;
  964.     ccf->thread_stack_size = NGX_CONF_UNSET_SIZE;
  965. #endif

  967.     if (ngx_array_init(&ccf->env, cycle->pool, 1, sizeof(ngx_str_t))
  968.         != NGX_OK)
  969.     {
  970.         return NULL;
  971.     }

  973.     return ccf;
  974. }


  977. static char *
  978. ‌ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf)
  979. {
  980.     ngx_core_conf_t  *ccf = conf;

  982.     ngx_conf_init_value(ccf->daemon, 1);
  983.     ngx_conf_init_value(ccf->master, 1);
  984.     ngx_conf_init_msec_value(ccf->timer_resolution, 0);

  986.     ngx_conf_init_value(ccf->worker_processes, 1);
  987.     ngx_conf_init_value(ccf->debug_points, 0);

  989. #if (NGX_HAVE_CPU_AFFINITY)

  991.     if (ccf->cpu_affinity_n
  992.         && ccf->cpu_affinity_n != 1
  993.         && ccf->cpu_affinity_n != (ngx_uint_t) ccf->worker_processes)
  994.     {
  995.         ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
  996.                       "the number of \"worker_processes\" is not equal to "
  997.                       "the number of \"worker_cpu_affinity\" masks, "
  998.                       "using last mask for remaining worker processes");
  999.     }

  1001. #endif

  1003. #if (NGX_THREADS)

  1005.     ngx_conf_init_value(ccf->worker_threads, 0);
  1006.     ngx_threads_n = ccf->worker_threads;
  1007.     ngx_conf_init_size_value(ccf->thread_stack_size, 2 * 1024 * 1024);

  1009. #endif


  1012.     if (ccf->pid.len == 0) {
  1013.         ngx_str_set(&ccf->pid, NGX_PID_PATH);
  1014.     }

  1016.     if (ngx_conf_full_name(cycle, &ccf->pid, 0) != NGX_OK) {
  1017.         return NGX_CONF_ERROR;
  1018.     }

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

  1022.     ccf->oldpid.data = ngx_pnalloc(cycle->pool, ccf->oldpid.len);
  1023.     if (ccf->oldpid.data == NULL) {
  1024.         return NGX_CONF_ERROR;
  1025.     }

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


  1031. #if !(NGX_WIN32)

  1033.     if (ccf->user == (uid_t) NGX_CONF_UNSET_UINT && geteuid() == 0) {
  1034.         struct group   *grp;
  1035.         struct passwd  *pwd;

  1037.         ngx_set_errno(0);
  1038.         pwd = getpwnam(NGX_USER);
  1039.         if (pwd == NULL) {
  1040.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1041.                           "getpwnam(\"" NGX_USER "\") failed");
  1042.             return NGX_CONF_ERROR;
  1043.         }

  1045.         ccf->username = NGX_USER;
  1046.         ccf->user = pwd->pw_uid;

  1048.         ngx_set_errno(0);
  1049.         grp = getgrnam(NGX_GROUP);
  1050.         if (grp == NULL) {
  1051.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  1052.                           "getgrnam(\"" NGX_GROUP "\") failed");
  1053.             return NGX_CONF_ERROR;
  1054.         }

  1056.         ccf->group = grp->gr_gid;
  1057.     }


  1060.     if (ccf->lock_file.len == 0) {
  1061.         ngx_str_set(&ccf->lock_file, NGX_LOCK_PATH);
  1062.     }

  1064.     if (ngx_conf_full_name(cycle, &ccf->lock_file, 0) != NGX_OK) {
  1065.         return NGX_CONF_ERROR;
  1066.     }

  1068.     {
  1069.     ngx_str_t  lock_file;

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

  1073.     if (lock_file.len) {
  1074.         lock_file.len--;

  1076.         if (ccf->lock_file.len != lock_file.len
  1077.             || ngx_strncmp(ccf->lock_file.data, lock_file.data, lock_file.len)
  1078.                != 0)
  1079.         {
  1080.             ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
  1081.                           "\"lock_file\" could not be changed, ignored");
  1082.         }

  1084.         cycle->lock_file.len = lock_file.len + 1;
  1085.         lock_file.len += sizeof(".accept");

  1087.         cycle->lock_file.data = ngx_pstrdup(cycle->pool, &lock_file);
  1088.         if (cycle->lock_file.data == NULL) {
  1089.             return NGX_CONF_ERROR;
  1090.         }

  1092.     } else {
  1093.         cycle->lock_file.len = ccf->lock_file.len + 1;
  1094.         cycle->lock_file.data = ngx_pnalloc(cycle->pool,
  1095.                                       ccf->lock_file.len + sizeof(".accept"));
  1096.         if (cycle->lock_file.data == NULL) {
  1097.             return NGX_CONF_ERROR;
  1098.         }

  1100.         ngx_memcpy(ngx_cpymem(cycle->lock_file.data, ccf->lock_file.data,
  1101.                               ccf->lock_file.len),
  1102.                    ".accept", sizeof(".accept"));
  1103.     }
  1104.     }

  1106. #endif

  1108.     return NGX_CONF_OK;
  1109. }


  1112. static char *
  1113. ‌ngx_set_user(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1114. {
  1115. #if (NGX_WIN32)

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

  1120.     return NGX_CONF_OK;

  1122. #else

  1124.     ngx_core_conf_t  *ccf = conf;

  1126.     char             *group;
  1127.     struct passwd    *pwd;
  1128.     struct group     *grp;
  1129.     ngx_str_t        *value;

  1131.     if (ccf->user != (uid_t) NGX_CONF_UNSET_UINT) {
  1132.         return "is duplicate";
  1133.     }

  1135.     if (geteuid() != 0) {
  1136.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1137.                            "the \"user\" directive makes sense only "
  1138.                            "if the master process runs "
  1139.                            "with super-user privileges, ignored");
  1140.         return NGX_CONF_OK;
  1141.     }

  1143.     value = (ngx_str_t *) cf->args->elts;

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

  1147.     ngx_set_errno(0);
  1148.     pwd = getpwnam((const char *) value[1].data);
  1149.     if (pwd == NULL) {
  1150.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1151.                            "getpwnam(\"%s\") failed", value[1].data);
  1152.         return NGX_CONF_ERROR;
  1153.     }

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

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

  1159.     ngx_set_errno(0);
  1160.     grp = getgrnam(group);
  1161.     if (grp == NULL) {
  1162.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  1163.                            "getgrnam(\"%s\") failed", group);
  1164.         return NGX_CONF_ERROR;
  1165.     }

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

  1169.     return NGX_CONF_OK;

  1171. #endif
  1172. }


  1175. static char *
  1176. ‌ngx_set_env(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1177. {
  1178.     ngx_core_conf_t  *ccf = conf;

  1180.     ngx_str_t   *value, *var;
  1181.     ngx_uint_t   i;

  1183.     var = ngx_array_push(&ccf->env);
  1184.     if (var == NULL) {
  1185.         return NGX_CONF_ERROR;
  1186.     }

  1188.     value = cf->args->elts;
  1189.     *var = value[1];

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

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

  1195.             var->len = i;

  1197.             return NGX_CONF_OK;
  1198.         }
  1199.     }

  1201.     return NGX_CONF_OK;
  1202. }


  1205. static char *
  1206. ‌ngx_set_priority(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1207. {
  1208.     ngx_core_conf_t  *ccf = conf;

  1210.     ngx_str_t        *value;
  1211.     ngx_uint_t        n, minus;

  1213.     if (ccf->priority != 0) {
  1214.         return "is duplicate";
  1215.     }

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

  1219.     if (value[1].data[0] == '-') {
  1220.         n = 1;
  1221.         minus = 1;

  1223.     } else if (value[1].data[0] == '+') {
  1224.         n = 1;
  1225.         minus = 0;

  1227.     } else {
  1228.         n = 0;
  1229.         minus = 0;
  1230.     }

  1232.     ccf->priority = ngx_atoi(&value[1].data[n], value[1].len - n);
  1233.     if (ccf->priority == NGX_ERROR) {
  1234.         return "invalid number";
  1235.     }

  1237.     if (minus) {
  1238.         ccf->priority = -ccf->priority;
  1239.     }

  1241.     return NGX_CONF_OK;
  1242. }


  1245. static char *
  1246. ‌ngx_set_cpu_affinity(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1247. {
  1248. #if (NGX_HAVE_CPU_AFFINITY)
  1249.     ngx_core_conf_t  *ccf = conf;

  1251.     u_char            ch;
  1252.     uint64_t         *mask;
  1253.     ngx_str_t        *value;
  1254.     ngx_uint_t        i, n;

  1256.     if (ccf->cpu_affinity) {
  1257.         return "is duplicate";
  1258.     }

  1260.     mask = ngx_palloc(cf->pool, (cf->args->nelts - 1) * sizeof(uint64_t));
  1261.     if (mask == NULL) {
  1262.         return NGX_CONF_ERROR;
  1263.     }

  1265.     ccf->cpu_affinity_n = cf->args->nelts - 1;
  1266.     ccf->cpu_affinity = mask;

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

  1270.     for (n = 1; n < cf->args->nelts; n++) {

  1272.         if (value[n].len > 64) {
  1273.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1274.                          "\"worker_cpu_affinity\" supports up to 64 CPUs only");
  1275.             return NGX_CONF_ERROR;
  1276.         }

  1278.         mask[n - 1] = 0;

  1280.         for (i = 0; i < value[n].len; i++) {

  1282.             ch = value[n].data[i];

  1284.             if (ch == ' ') {
  1285.                 continue;
  1286.             }

  1288.             mask[n - 1] <<= 1;

  1290.             if (ch == '0') {
  1291.                 continue;
  1292.             }

  1294.             if (ch == '1') {
  1295.                 mask[n - 1] |= 1;
  1296.                 continue;
  1297.             }

  1299.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1300.                           "invalid character \"%c\" in \"worker_cpu_affinity\"",
  1301.                           ch);
  1302.             return NGX_CONF_ERROR;
  1303.         }
  1304.     }

  1306. #else

  1308.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1309.                        "\"worker_cpu_affinity\" is not supported "
  1310.                        "on this platform, ignored");
  1311. #endif

  1313.     return NGX_CONF_OK;
  1314. }


  1317. uint64_t
  1318. ‌ngx_get_cpu_affinity(ngx_uint_t n)
  1319. {
  1320.     ngx_core_conf_t  *ccf;

  1322.     ccf = (ngx_core_conf_t *) ngx_get_conf(ngx_cycle->conf_ctx,
  1323.                                            ngx_core_module);

  1325.     if (ccf->cpu_affinity == NULL) {
  1326.         return 0;
  1327.     }

  1329.     if (ccf->cpu_affinity_n > n) {
  1330.         return ccf->cpu_affinity[n];
  1331.     }

  1333.     return ccf->cpu_affinity[ccf->cpu_affinity_n - 1];
  1334. }


  1337. static char *
  1338. ‌ngx_set_worker_processes(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1339. {
  1340.     ngx_str_t        *value;
  1341.     ngx_core_conf_t  *ccf;

  1343.     ccf = (ngx_core_conf_t *) conf;

  1345.     if (ccf->worker_processes != NGX_CONF_UNSET) {
  1346.         return "is duplicate";
  1347.     }

  1349.     value = (ngx_str_t *) cf->args->elts;

  1351.     if (ngx_strcmp(value[1].data, "auto") == 0) {
  1352.         ccf->worker_processes = ngx_ncpu;
  1353.         return NGX_CONF_OK;
  1354.     }

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

  1358.     if (ccf->worker_processes == NGX_ERROR) {
  1359.         return "invalid value";
  1360.     }

  1362.     return NGX_CONF_OK;
  1363. }

One Level Up Top Level