One Level Up Top Level

src/core/ngx_log.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>


  12. static char *ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  13. static char *ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log);
  14. static void ngx_log_insert(ngx_log_t *log, ngx_log_t *new_log);


  17. ‌static ngx_command_t  ngx_errlog_commands[] = {

  19.     {ngx_string("error_log"),
  20.      NGX_MAIN_CONF|NGX_CONF_1MORE,
  21.      ngx_error_log,
  22.      0,
  23.      0,
  24.      NULL},

  26.     ngx_null_command
  27. };


  30. ‌static ngx_core_module_t  ngx_errlog_module_ctx = {
  31.     ngx_string("errlog"),
  32.     NULL,
  33.     NULL
  34. };


  37. ‌ngx_module_t  ngx_errlog_module = {
  38.     NGX_MODULE_V1,
  39.     &ngx_errlog_module_ctx,                /* module context */
  40.     ngx_errlog_commands,                   /* module directives */
  41.     NGX_CORE_MODULE,                       /* module type */
  42.     NULL,                                  /* init master */
  43.     NULL,                                  /* init module */
  44.     NULL,                                  /* init process */
  45.     NULL,                                  /* init thread */
  46.     NULL,                                  /* exit thread */
  47.     NULL,                                  /* exit process */
  48.     NULL,                                  /* exit master */
  49.     NGX_MODULE_V1_PADDING
  50. };


  53. ‌static ngx_log_t        ngx_log;
  54. ‌static ngx_open_file_t  ngx_log_file;
  55. ‌ngx_uint_t              ngx_use_stderr = 1;


  58. ‌static ngx_str_t err_levels[] = {
  59.     ngx_null_string,
  60.     ngx_string("emerg"),
  61.     ngx_string("alert"),
  62.     ngx_string("crit"),
  63.     ngx_string("error"),
  64.     ngx_string("warn"),
  65.     ngx_string("notice"),
  66.     ngx_string("info"),
  67.     ngx_string("debug")
  68. };

  70. ‌static const char *debug_levels[] = {
  71.     "debug_core", "debug_alloc", "debug_mutex", "debug_event",
  72.     "debug_http", "debug_mail", "debug_mysql"
  73. };


  76. #if (NGX_HAVE_VARIADIC_MACROS)

  78. void
  79. ‌ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
  80.     const char *fmt, ...)

  82. #else

  84. void
  85. ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
  86.     const char *fmt, va_list args)

  88. #endif
  89. {
  90. #if (NGX_HAVE_VARIADIC_MACROS)
  91.     va_list      args;
  92. #endif
  93.     u_char      *p, *last, *msg;
  94.     ssize_t      n;
  95.     ngx_uint_t   wrote_stderr, debug_connection;
  96.     u_char       errstr[NGX_MAX_ERROR_STR];

  98.     last = errstr + NGX_MAX_ERROR_STR;

  100.     ngx_memcpy(errstr, ngx_cached_err_log_time.data,
  101.                ngx_cached_err_log_time.len);

  103.     p = errstr + ngx_cached_err_log_time.len;

  105.     p = ngx_slprintf(p, last, " [%V] ", &err_levels[level]);

  107.     /* pid#tid */
  108.     p = ngx_slprintf(p, last, "%P#" NGX_TID_T_FMT ": ",
  109.                     ngx_log_pid, ngx_log_tid);

  111.     if (log->connection) {
  112.         p = ngx_slprintf(p, last, "*%uA ", log->connection);
  113.     }

  115.     msg = p;

  117. #if (NGX_HAVE_VARIADIC_MACROS)

  119.     va_start(args, fmt);
  120.     p = ngx_vslprintf(p, last, fmt, args);
  121.     va_end(args);

  123. #else

  125.     p = ngx_vslprintf(p, last, fmt, args);

  127. #endif

  129.     if (err) {
  130.         p = ngx_log_errno(p, last, err);
  131.     }

  133.     if (level != NGX_LOG_DEBUG && log->handler) {
  134.         p = log->handler(log, p, last - p);
  135.     }

  137.     if (p > last - NGX_LINEFEED_SIZE) {
  138.         p = last - NGX_LINEFEED_SIZE;
  139.     }

  141.     ngx_linefeed(p);

  143.     wrote_stderr = 0;
  144.     debug_connection = (log->log_level & NGX_LOG_DEBUG_CONNECTION) != 0;

  146.     while (log) {

  148.         if (log->log_level < level && !debug_connection) {
  149.             break;
  150.         }

  152.         if (log->writer) {
  153.             log->writer(log, level, errstr, p - errstr);
  154.             goto next;
  155.         }

  157.         if (ngx_time() == log->disk_full_time) {

  159.             /*
  160.              * on FreeBSD writing to a full filesystem with enabled softupdates
  161.              * may block process for much longer time than writing to non-full
  162.              * filesystem, so we skip writing to a log for one second
  163.              */

  165.             goto next;
  166.         }

  168.         n = ngx_write_fd(log->file->fd, errstr, p - errstr);

  170.         if (n == -1 && ngx_errno == NGX_ENOSPC) {
  171.             log->disk_full_time = ngx_time();
  172.         }

  174.         if (log->file->fd == ngx_stderr) {
  175.             wrote_stderr = 1;
  176.         }

  178.     next:

  180.         log = log->next;
  181.     }

  183.     if (!ngx_use_stderr
  184.         || level > NGX_LOG_WARN
  185.         || wrote_stderr)
  186.     {
  187.         return;
  188.     }

  190.     msg -= (7 + err_levels[level].len + 3);

  192.     (void) ngx_sprintf(msg, "nginx: [%V] ", &err_levels[level]);

  194.     (void) ngx_write_console(ngx_stderr, msg, p - msg);
  195. }


  198. #if !(NGX_HAVE_VARIADIC_MACROS)

  200. void ngx_cdecl
  201. ‌ngx_log_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
  202.     const char *fmt, ...)
  203. {
  204.     va_list  args;

  206.     if (log->log_level >= level) {
  207.         va_start(args, fmt);
  208.         ngx_log_error_core(level, log, err, fmt, args);
  209.         va_end(args);
  210.     }
  211. }


  214. void ngx_cdecl
  215. ‌ngx_log_debug_core(ngx_log_t *log, ngx_err_t err, const char *fmt, ...)
  216. {
  217.     va_list  args;

  219.     va_start(args, fmt);
  220.     ngx_log_error_core(NGX_LOG_DEBUG, log, err, fmt, args);
  221.     va_end(args);
  222. }

  224. #endif


  227. void ngx_cdecl
  228. ‌ngx_log_abort(ngx_err_t err, const char *fmt, ...)
  229. {
  230.     u_char   *p;
  231.     va_list   args;
  232.     u_char    errstr[NGX_MAX_CONF_ERRSTR];

  234.     va_start(args, fmt);
  235.     p = ngx_vsnprintf(errstr, sizeof(errstr) - 1, fmt, args);
  236.     va_end(args);

  238.     ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err,
  239.                   "%*s", p - errstr, errstr);
  240. }


  243. void ngx_cdecl
  244. ‌ngx_log_stderr(ngx_err_t err, const char *fmt, ...)
  245. {
  246.     u_char   *p, *last;
  247.     va_list   args;
  248.     u_char    errstr[NGX_MAX_ERROR_STR];

  250.     last = errstr + NGX_MAX_ERROR_STR;
  251.     p = errstr + 7;

  253.     ngx_memcpy(errstr, "nginx: ", 7);

  255.     va_start(args, fmt);
  256.     p = ngx_vslprintf(p, last, fmt, args);
  257.     va_end(args);

  259.     if (err) {
  260.         p = ngx_log_errno(p, last, err);
  261.     }

  263.     if (p > last - NGX_LINEFEED_SIZE) {
  264.         p = last - NGX_LINEFEED_SIZE;
  265.     }

  267.     ngx_linefeed(p);

  269.     (void) ngx_write_console(ngx_stderr, errstr, p - errstr);
  270. }


  273. u_char *
  274. ‌ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err)
  275. {
  276.     if (buf > last - 50) {

  278.         /* leave a space for an error code */

  280.         buf = last - 50;
  281.         *buf++ = '.';
  282.         *buf++ = '.';
  283.         *buf++ = '.';
  284.     }

  286. #if (NGX_WIN32)
  287.     buf = ngx_slprintf(buf, last, ((unsigned) err < 0x80000000)
  288.                                        ? " (%d: " : " (%Xd: ", err);
  289. #else
  290.     buf = ngx_slprintf(buf, last, " (%d: ", err);
  291. #endif

  293.     buf = ngx_strerror(err, buf, last - buf);

  295.     if (buf < last) {
  296.         *buf++ = ')';
  297.     }

  299.     return buf;
  300. }


  303. ngx_log_t *
  304. ‌ngx_log_init(u_char *prefix)
  305. {
  306.     u_char  *p, *name;
  307.     size_t   nlen, plen;

  309.     ngx_log.file = &ngx_log_file;
  310.     ngx_log.log_level = NGX_LOG_NOTICE;

  312.     name = (u_char *) NGX_ERROR_LOG_PATH;

  314.     /*
  315.      * we use ngx_strlen() here since BCC warns about
  316.      * condition is always false and unreachable code
  317.      */

  319.     nlen = ngx_strlen(name);

  321.     if (nlen == 0) {
  322.         ngx_log_file.fd = ngx_stderr;
  323.         return &ngx_log;
  324.     }

  326.     p = NULL;

  328. #if (NGX_WIN32)
  329.     if (name[1] != ':') {
  330. #else
  331.     if (name[0] != '/') {
  332. #endif

  334.         if (prefix) {
  335.             plen = ngx_strlen(prefix);

  337.         } else {
  338. #ifdef NGX_PREFIX
  339.             prefix = (u_char *) NGX_PREFIX;
  340.             plen = ngx_strlen(prefix);
  341. #else
  342.             plen = 0;
  343. #endif
  344.         }

  346.         if (plen) {
  347.             name = malloc(plen + nlen + 2);
  348.             if (name == NULL) {
  349.                 return NULL;
  350.             }

  352.             p = ngx_cpymem(name, prefix, plen);

  354.             if (!ngx_path_separator(*(p - 1))) {
  355.                 *p++ = '/';
  356.             }

  358.             ngx_cpystrn(p, (u_char *) NGX_ERROR_LOG_PATH, nlen + 1);

  360.             p = name;
  361.         }
  362.     }

  364.     ngx_log_file.fd = ngx_open_file(name, NGX_FILE_APPEND,
  365.                                     NGX_FILE_CREATE_OR_OPEN,
  366.                                     NGX_FILE_DEFAULT_ACCESS);

  368.     if (ngx_log_file.fd == NGX_INVALID_FILE) {
  369.         ngx_log_stderr(ngx_errno,
  370.                        "[alert] could not open error log file: "
  371.                        ngx_open_file_n " \"%s\" failed", name);
  372. #if (NGX_WIN32)
  373.         ngx_event_log(ngx_errno,
  374.                        "could not open error log file: "
  375.                        ngx_open_file_n " \"%s\" failed", name);
  376. #endif

  378.         ngx_log_file.fd = ngx_stderr;
  379.     }

  381.     if (p) {
  382.         ngx_free(p);
  383.     }

  385.     return &ngx_log;
  386. }


  389. ngx_int_t
  390. ‌ngx_log_open_default(ngx_cycle_t *cycle)
  391. {
  392.     ngx_log_t         *log;
  393.     static ngx_str_t   error_log = ngx_string(NGX_ERROR_LOG_PATH);

  395.     if (ngx_log_get_file_log(&cycle->new_log) != NULL) {
  396.         return NGX_OK;
  397.     }

  399.     if (cycle->new_log.log_level != 0) {
  400.         /* there are some error logs, but no files */

  402.         log = ngx_pcalloc(cycle->pool, sizeof(ngx_log_t));
  403.         if (log == NULL) {
  404.             return NGX_ERROR;
  405.         }

  407.     } else {
  408.         /* no error logs at all */
  409.         log = &cycle->new_log;
  410.     }

  412.     log->log_level = NGX_LOG_ERR;

  414.     log->file = ngx_conf_open_file(cycle, &error_log);
  415.     if (log->file == NULL) {
  416.         return NGX_ERROR;
  417.     }

  419.     if (log != &cycle->new_log) {
  420.         ngx_log_insert(&cycle->new_log, log);
  421.     }

  423.     return NGX_OK;
  424. }


  427. ngx_int_t
  428. ‌ngx_log_redirect_stderr(ngx_cycle_t *cycle)
  429. {
  430.     ngx_fd_t  fd;

  432.     if (cycle->log_use_stderr) {
  433.         return NGX_OK;
  434.     }

  436.     /* file log always exists when we are called */
  437.     fd = ngx_log_get_file_log(cycle->log)->file->fd;

  439.     if (fd != ngx_stderr) {
  440.         if (ngx_set_stderr(fd) == NGX_FILE_ERROR) {
  441.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  442.                           ngx_set_stderr_n " failed");

  444.             return NGX_ERROR;
  445.         }
  446.     }

  448.     return NGX_OK;
  449. }


  452. ngx_log_t *
  453. ‌ngx_log_get_file_log(ngx_log_t *head)
  454. {
  455.     ngx_log_t  *log;

  457.     for (log = head; log; log = log->next) {
  458.         if (log->file != NULL) {
  459.             return log;
  460.         }
  461.     }

  463.     return NULL;
  464. }


  467. static char *
  468. ‌ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log)
  469. {
  470.     ngx_uint_t   i, n, d, found;
  471.     ngx_str_t   *value;

  473.     if (cf->args->nelts == 2) {
  474.         log->log_level = NGX_LOG_ERR;
  475.         return NGX_CONF_OK;
  476.     }

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

  480.     for (i = 2; i < cf->args->nelts; i++) {
  481.         found = 0;

  483.         for (n = 1; n <= NGX_LOG_DEBUG; n++) {
  484.             if (ngx_strcmp(value[i].data, err_levels[n].data) == 0) {

  486.                 if (log->log_level != 0) {
  487.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  488.                                        "duplicate log level \"%V\"",
  489.                                        &value[i]);
  490.                     return NGX_CONF_ERROR;
  491.                 }

  493.                 log->log_level = n;
  494.                 found = 1;
  495.                 break;
  496.             }
  497.         }

  499.         for (n = 0, d = NGX_LOG_DEBUG_FIRST; d <= NGX_LOG_DEBUG_LAST; d <<= 1) {
  500.             if (ngx_strcmp(value[i].data, debug_levels[n++]) == 0) {
  501.                 if (log->log_level & ~NGX_LOG_DEBUG_ALL) {
  502.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  503.                                        "invalid log level \"%V\"",
  504.                                        &value[i]);
  505.                     return NGX_CONF_ERROR;
  506.                 }

  508.                 log->log_level |= d;
  509.                 found = 1;
  510.                 break;
  511.             }
  512.         }


  515.         if (!found) {
  516.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  517.                                "invalid log level \"%V\"", &value[i]);
  518.             return NGX_CONF_ERROR;
  519.         }
  520.     }

  522.     if (log->log_level == NGX_LOG_DEBUG) {
  523.         log->log_level = NGX_LOG_DEBUG_ALL;
  524.     }

  526.     return NGX_CONF_OK;
  527. }


  530. static char *
  531. ‌ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  532. {
  533.     ngx_log_t  *dummy;

  535.     dummy = &cf->cycle->new_log;

  537.     return ngx_log_set_log(cf, &dummy);
  538. }


  541. char *
  542. ‌ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head)
  543. {
  544.     ngx_log_t          *new_log;
  545.     ngx_str_t          *value, name;
  546.     ngx_syslog_peer_t  *peer;

  548.     if (*head != NULL && (*head)->log_level == 0) {
  549.         new_log = *head;

  551.     } else {

  553.         new_log = ngx_pcalloc(cf->pool, sizeof(ngx_log_t));
  554.         if (new_log == NULL) {
  555.             return NGX_CONF_ERROR;
  556.         }

  558.         if (*head == NULL) {
  559.             *head = new_log;
  560.         }
  561.     }

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

  565.     if (ngx_strcmp(value[1].data, "stderr") == 0) {
  566.         ngx_str_null(&name);
  567.         cf->cycle->log_use_stderr = 1;

  569.         new_log->file = ngx_conf_open_file(cf->cycle, &name);
  570.         if (new_log->file == NULL) {
  571.             return NGX_CONF_ERROR;
  572.         }


  575.      } else if (ngx_strncmp(value[1].data, "syslog:", 7) == 0) {
  576.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_syslog_peer_t));
  577.         if (peer == NULL) {
  578.             return NGX_CONF_ERROR;
  579.         }

  581.         if (ngx_syslog_process_conf(cf, peer) != NGX_CONF_OK) {
  582.             return NGX_CONF_ERROR;
  583.         }

  585.         new_log->writer = ngx_syslog_writer;
  586.         new_log->wdata = peer;

  588.     } else {
  589.         new_log->file = ngx_conf_open_file(cf->cycle, &value[1]);
  590.         if (new_log->file == NULL) {
  591.             return NGX_CONF_ERROR;
  592.         }
  593.     }

  595.     if (ngx_log_set_levels(cf, new_log) != NGX_CONF_OK) {
  596.         return NGX_CONF_ERROR;
  597.     }

  599.     if (*head != new_log) {
  600.         ngx_log_insert(*head, new_log);
  601.     }

  603.     return NGX_CONF_OK;
  604. }


  607. static void
  608. ‌ngx_log_insert(ngx_log_t *log, ngx_log_t *new_log)
  609. {
  610.     ngx_log_t  tmp;

  612.     if (new_log->log_level > log->log_level) {

  614.         /*
  615.          * list head address is permanent, insert new log after
  616.          * head and swap its contents with head
  617.          */

  619.         tmp = *log;
  620.         *log = *new_log;
  621.         *new_log = tmp;

  623.         log->next = new_log;
  624.         return;
  625.     }

  627.     while (log->next) {
  628.         if (new_log->log_level > log->next->log_level) {
  629.             new_log->next = log->next;
  630.             log->next = new_log;
  631.             return;
  632.         }

  634.         log = log->next;
  635.     }

  637.     log->next = new_log;
  638. }

One Level Up Top Level