1
2 /*
3 * Copyright (C) Igor Sysoev
4 * Copyright (C) Nginx, Inc.
5 */
6
7
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10
11
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);
15
16
17 #if (NGX_DEBUG)
18
19 static void ngx_log_memory_writer(ngx_log_t *log, ngx_uint_t level,
20 u_char *buf, size_t len);
21 static void ngx_log_memory_cleanup(void *data);
22
23
24 typedef struct {
25 u_char *start;
26 u_char *end;
27 u_char *pos;
28 ngx_atomic_t written;
29 } ngx_log_memory_buf_t;
30
31 #endif
32
33
34 static ngx_command_t ngx_errlog_commands[] = {
35
36 { ngx_string("error_log"),
37 NGX_MAIN_CONF|NGX_CONF_1MORE,
38 ngx_error_log,
39 0,
40 0,
41 NULL },
42
43 ngx_null_command
44 };
45
46
47 static ngx_core_module_t ngx_errlog_module_ctx = {
48 ngx_string("errlog"),
49 NULL,
50 NULL
51 };
52
53
54 ngx_module_t ngx_errlog_module = {
55 NGX_MODULE_V1,
56 &ngx_errlog_module_ctx, /* module context */
57 ngx_errlog_commands, /* module directives */
58 NGX_CORE_MODULE, /* module type */
59 NULL, /* init master */
60 NULL, /* init module */
61 NULL, /* init process */
62 NULL, /* init thread */
63 NULL, /* exit thread */
64 NULL, /* exit process */
65 NULL, /* exit master */
66 NGX_MODULE_V1_PADDING
67 };
68
69
70 static ngx_log_t ngx_log;
71 static ngx_open_file_t ngx_log_file;
72 ngx_uint_t ngx_use_stderr = 1;
73
74
75 static ngx_str_t err_levels[] = {
76 ngx_null_string,
77 ngx_string("emerg"),
78 ngx_string("alert"),
79 ngx_string("crit"),
80 ngx_string("error"),
81 ngx_string("warn"),
82 ngx_string("notice"),
83 ngx_string("info"),
84 ngx_string("debug")
85 };
86
87 static const char *debug_levels[] = {
88 "debug_core", "debug_alloc", "debug_mutex", "debug_event",
89 "debug_http", "debug_mail", "debug_stream"
90 };
91
92
93 #if (NGX_HAVE_VARIADIC_MACROS)
94
95 void
ngx_log_error_core(ngx_uint_t level,ngx_log_t * log,ngx_err_t err,const char * fmt,...)96 ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
97 const char *fmt, ...)
98
99 #else
100
101 void
102 ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
103 const char *fmt, va_list args)
104
105 #endif
106 {
107 #if (NGX_HAVE_VARIADIC_MACROS)
108 va_list args;
109 #endif
110 u_char *p, *last, *msg;
111 ssize_t n;
112 ngx_uint_t wrote_stderr, debug_connection;
113 u_char errstr[NGX_MAX_ERROR_STR];
114
115 last = errstr + NGX_MAX_ERROR_STR;
116
117 p = ngx_cpymem(errstr, ngx_cached_err_log_time.data,
118 ngx_cached_err_log_time.len);
119
120 p = ngx_slprintf(p, last, " [%V] ", &err_levels[level]);
121
122 /* pid#tid */
123 p = ngx_slprintf(p, last, "%P#" NGX_TID_T_FMT ": ",
124 ngx_log_pid, ngx_log_tid);
125
126 if (log->connection) {
127 p = ngx_slprintf(p, last, "*%uA ", log->connection);
128 }
129
130 msg = p;
131
132 #if (NGX_HAVE_VARIADIC_MACROS)
133
134 va_start(args, fmt);
135 p = ngx_vslprintf(p, last, fmt, args);
136 va_end(args);
137
138 #else
139
140 p = ngx_vslprintf(p, last, fmt, args);
141
142 #endif
143
144 if (err) {
145 p = ngx_log_errno(p, last, err);
146 }
147
148 if (level != NGX_LOG_DEBUG && log->handler) {
149 p = log->handler(log, p, last - p);
150 }
151
152 if (p > last - NGX_LINEFEED_SIZE) {
153 p = last - NGX_LINEFEED_SIZE;
154 }
155
156 ngx_linefeed(p);
157
158 wrote_stderr = 0;
159 debug_connection = (log->log_level & NGX_LOG_DEBUG_CONNECTION) != 0;
160
161 while (log) {
162
163 if (log->log_level < level && !debug_connection) {
164 break;
165 }
166
167 if (log->writer) {
168 log->writer(log, level, errstr, p - errstr);
169 goto next;
170 }
171
172 if (ngx_time() == log->disk_full_time) {
173
174 /*
175 * on FreeBSD writing to a full filesystem with enabled softupdates
176 * may block process for much longer time than writing to non-full
177 * filesystem, so we skip writing to a log for one second
178 */
179
180 goto next;
181 }
182
183 n = ngx_write_fd(log->file->fd, errstr, p - errstr);
184
185 if (n == -1 && ngx_errno == NGX_ENOSPC) {
186 log->disk_full_time = ngx_time();
187 }
188
189 if (log->file->fd == ngx_stderr) {
190 wrote_stderr = 1;
191 }
192
193 next:
194
195 log = log->next;
196 }
197
198 if (!ngx_use_stderr
199 || level > NGX_LOG_WARN
200 || wrote_stderr)
201 {
202 return;
203 }
204
205 msg -= (7 + err_levels[level].len + 3);
206
207 (void) ngx_sprintf(msg, "nginx: [%V] ", &err_levels[level]);
208
209 (void) ngx_write_console(ngx_stderr, msg, p - msg);
210 }
211
212
213 #if !(NGX_HAVE_VARIADIC_MACROS)
214
215 void ngx_cdecl
ngx_log_error(ngx_uint_t level,ngx_log_t * log,ngx_err_t err,const char * fmt,...)216 ngx_log_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
217 const char *fmt, ...)
218 {
219 va_list args;
220
221 if (log->log_level >= level) {
222 va_start(args, fmt);
223 ngx_log_error_core(level, log, err, fmt, args);
224 va_end(args);
225 }
226 }
227
228
229 void ngx_cdecl
ngx_log_debug_core(ngx_log_t * log,ngx_err_t err,const char * fmt,...)230 ngx_log_debug_core(ngx_log_t *log, ngx_err_t err, const char *fmt, ...)
231 {
232 va_list args;
233
234 va_start(args, fmt);
235 ngx_log_error_core(NGX_LOG_DEBUG, log, err, fmt, args);
236 va_end(args);
237 }
238
239 #endif
240
241
242 void ngx_cdecl
ngx_log_abort(ngx_err_t err,const char * fmt,...)243 ngx_log_abort(ngx_err_t err, const char *fmt, ...)
244 {
245 u_char *p;
246 va_list args;
247 u_char errstr[NGX_MAX_CONF_ERRSTR];
248
249 va_start(args, fmt);
250 p = ngx_vsnprintf(errstr, sizeof(errstr) - 1, fmt, args);
251 va_end(args);
252
253 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err,
254 "%*s", p - errstr, errstr);
255 }
256
257
258 void ngx_cdecl
ngx_log_stderr(ngx_err_t err,const char * fmt,...)259 ngx_log_stderr(ngx_err_t err, const char *fmt, ...)
260 {
261 u_char *p, *last;
262 va_list args;
263 u_char errstr[NGX_MAX_ERROR_STR];
264
265 last = errstr + NGX_MAX_ERROR_STR;
266
267 p = ngx_cpymem(errstr, "nginx: ", 7);
268
269 va_start(args, fmt);
270 p = ngx_vslprintf(p, last, fmt, args);
271 va_end(args);
272
273 if (err) {
274 p = ngx_log_errno(p, last, err);
275 }
276
277 if (p > last - NGX_LINEFEED_SIZE) {
278 p = last - NGX_LINEFEED_SIZE;
279 }
280
281 ngx_linefeed(p);
282
283 (void) ngx_write_console(ngx_stderr, errstr, p - errstr);
284 }
285
286
287 u_char *
ngx_log_errno(u_char * buf,u_char * last,ngx_err_t err)288 ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err)
289 {
290 if (buf > last - 50) {
291
292 /* leave a space for an error code */
293
294 buf = last - 50;
295 *buf++ = '.';
296 *buf++ = '.';
297 *buf++ = '.';
298 }
299
300 #if (NGX_WIN32)
301 buf = ngx_slprintf(buf, last, ((unsigned) err < 0x80000000)
302 ? " (%d: " : " (%Xd: ", err);
303 #else
304 buf = ngx_slprintf(buf, last, " (%d: ", err);
305 #endif
306
307 buf = ngx_strerror(err, buf, last - buf);
308
309 if (buf < last) {
310 *buf++ = ')';
311 }
312
313 return buf;
314 }
315
316
317 ngx_log_t *
ngx_log_init(u_char * prefix)318 ngx_log_init(u_char *prefix)
319 {
320 u_char *p, *name;
321 size_t nlen, plen;
322
323 ngx_log.file = &ngx_log_file;
324 ngx_log.log_level = NGX_LOG_NOTICE;
325
326 name = (u_char *) NGX_ERROR_LOG_PATH;
327
328 /*
329 * we use ngx_strlen() here since BCC warns about
330 * condition is always false and unreachable code
331 */
332
333 nlen = ngx_strlen(name);
334
335 if (nlen == 0) {
336 ngx_log_file.fd = ngx_stderr;
337 return &ngx_log;
338 }
339
340 p = NULL;
341
342 #if (NGX_WIN32)
343 if (name[1] != ':') {
344 #else
345 if (name[0] != '/') {
346 #endif
347
348 if (prefix) {
349 plen = ngx_strlen(prefix);
350
351 } else {
352 #ifdef NGX_PREFIX
353 prefix = (u_char *) NGX_PREFIX;
354 plen = ngx_strlen(prefix);
355 #else
356 plen = 0;
357 #endif
358 }
359
360 if (plen) {
361 name = malloc(plen + nlen + 2);
362 if (name == NULL) {
363 return NULL;
364 }
365
366 p = ngx_cpymem(name, prefix, plen);
367
368 if (!ngx_path_separator(*(p - 1))) {
369 *p++ = '/';
370 }
371
372 ngx_cpystrn(p, (u_char *) NGX_ERROR_LOG_PATH, nlen + 1);
373
374 p = name;
375 }
376 }
377
378 ngx_log_file.fd = ngx_open_file(name, NGX_FILE_APPEND,
379 NGX_FILE_CREATE_OR_OPEN,
380 NGX_FILE_DEFAULT_ACCESS);
381
382 if (ngx_log_file.fd == NGX_INVALID_FILE) {
383 ngx_log_stderr(ngx_errno,
384 "[alert] could not open error log file: "
385 ngx_open_file_n " \"%s\" failed", name);
386 #if (NGX_WIN32)
387 ngx_event_log(ngx_errno,
388 "could not open error log file: "
389 ngx_open_file_n " \"%s\" failed", name);
390 #endif
391
392 ngx_log_file.fd = ngx_stderr;
393 }
394
395 if (p) {
396 ngx_free(p);
397 }
398
399 return &ngx_log;
400 }
401
402
403 ngx_int_t
404 ngx_log_open_default(ngx_cycle_t *cycle)
405 {
406 ngx_log_t *log;
407 static ngx_str_t error_log = ngx_string(NGX_ERROR_LOG_PATH);
408
409 if (ngx_log_get_file_log(&cycle->new_log) != NULL) {
410 return NGX_OK;
411 }
412
413 if (cycle->new_log.log_level != 0) {
414 /* there are some error logs, but no files */
415
416 log = ngx_pcalloc(cycle->pool, sizeof(ngx_log_t));
417 if (log == NULL) {
418 return NGX_ERROR;
419 }
420
421 } else {
422 /* no error logs at all */
423 log = &cycle->new_log;
424 }
425
426 log->log_level = NGX_LOG_ERR;
427
428 log->file = ngx_conf_open_file(cycle, &error_log);
429 if (log->file == NULL) {
430 return NGX_ERROR;
431 }
432
433 if (log != &cycle->new_log) {
434 ngx_log_insert(&cycle->new_log, log);
435 }
436
437 return NGX_OK;
438 }
439
440
441 ngx_int_t
442 ngx_log_redirect_stderr(ngx_cycle_t *cycle)
443 {
444 ngx_fd_t fd;
445
446 if (cycle->log_use_stderr) {
447 return NGX_OK;
448 }
449
450 /* file log always exists when we are called */
451 fd = ngx_log_get_file_log(cycle->log)->file->fd;
452
453 if (fd != ngx_stderr) {
454 if (ngx_set_stderr(fd) == NGX_FILE_ERROR) {
455 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
456 ngx_set_stderr_n " failed");
457
458 return NGX_ERROR;
459 }
460 }
461
462 return NGX_OK;
463 }
464
465
466 ngx_log_t *
467 ngx_log_get_file_log(ngx_log_t *head)
468 {
469 ngx_log_t *log;
470
471 for (log = head; log; log = log->next) {
472 if (log->file != NULL) {
473 return log;
474 }
475 }
476
477 return NULL;
478 }
479
480
481 static char *
482 ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log)
483 {
484 ngx_uint_t i, n, d, found;
485 ngx_str_t *value;
486
487 if (cf->args->nelts == 2) {
488 log->log_level = NGX_LOG_ERR;
489 return NGX_CONF_OK;
490 }
491
492 value = cf->args->elts;
493
494 for (i = 2; i < cf->args->nelts; i++) {
495 found = 0;
496
497 for (n = 1; n <= NGX_LOG_DEBUG; n++) {
498 if (ngx_strcmp(value[i].data, err_levels[n].data) == 0) {
499
500 if (log->log_level != 0) {
501 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
502 "duplicate log level \"%V\"",
503 &value[i]);
504 return NGX_CONF_ERROR;
505 }
506
507 log->log_level = n;
508 found = 1;
509 break;
510 }
511 }
512
513 for (n = 0, d = NGX_LOG_DEBUG_FIRST; d <= NGX_LOG_DEBUG_LAST; d <<= 1) {
514 if (ngx_strcmp(value[i].data, debug_levels[n++]) == 0) {
515 if (log->log_level & ~NGX_LOG_DEBUG_ALL) {
516 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
517 "invalid log level \"%V\"",
518 &value[i]);
519 return NGX_CONF_ERROR;
520 }
521
522 log->log_level |= d;
523 found = 1;
524 break;
525 }
526 }
527
528
529 if (!found) {
530 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
531 "invalid log level \"%V\"", &value[i]);
532 return NGX_CONF_ERROR;
533 }
534 }
535
536 if (log->log_level == NGX_LOG_DEBUG) {
537 log->log_level = NGX_LOG_DEBUG_ALL;
538 }
539
540 return NGX_CONF_OK;
541 }
542
543
544 static char *
545 ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
546 {
547 ngx_log_t *dummy;
548
549 dummy = &cf->cycle->new_log;
550
551 return ngx_log_set_log(cf, &dummy);
552 }
553
554
555 char *
556 ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head)
557 {
558 ngx_log_t *new_log;
559 ngx_str_t *value, name;
560 ngx_syslog_peer_t *peer;
561
562 if (*head != NULL && (*head)->log_level == 0) {
563 new_log = *head;
564
565 } else {
566
567 new_log = ngx_pcalloc(cf->pool, sizeof(ngx_log_t));
568 if (new_log == NULL) {
569 return NGX_CONF_ERROR;
570 }
571
572 if (*head == NULL) {
573 *head = new_log;
574 }
575 }
576
577 value = cf->args->elts;
578
579 if (ngx_strcmp(value[1].data, "stderr") == 0) {
580 ngx_str_null(&name);
581 cf->cycle->log_use_stderr = 1;
582
583 new_log->file = ngx_conf_open_file(cf->cycle, &name);
584 if (new_log->file == NULL) {
585 return NGX_CONF_ERROR;
586 }
587
588 } else if (ngx_strncmp(value[1].data, "memory:", 7) == 0) {
589
590 #if (NGX_DEBUG)
591 size_t size, needed;
592 ngx_pool_cleanup_t *cln;
593 ngx_log_memory_buf_t *buf;
594
595 value[1].len -= 7;
596 value[1].data += 7;
597
598 needed = sizeof("MEMLOG :" NGX_LINEFEED)
599 + cf->conf_file->file.name.len
600 + NGX_SIZE_T_LEN
601 + NGX_INT_T_LEN
602 + NGX_MAX_ERROR_STR;
603
604 size = ngx_parse_size(&value[1]);
605
606 if (size == (size_t) NGX_ERROR || size < needed) {
607 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
608 "invalid buffer size \"%V\"", &value[1]);
609 return NGX_CONF_ERROR;
610 }
611
612 buf = ngx_pcalloc(cf->pool, sizeof(ngx_log_memory_buf_t));
613 if (buf == NULL) {
614 return NGX_CONF_ERROR;
615 }
616
617 buf->start = ngx_pnalloc(cf->pool, size);
618 if (buf->start == NULL) {
619 return NGX_CONF_ERROR;
620 }
621
622 buf->end = buf->start + size;
623
624 buf->pos = ngx_slprintf(buf->start, buf->end, "MEMLOG %uz %V:%ui%N",
625 size, &cf->conf_file->file.name,
626 cf->conf_file->line);
627
628 ngx_memset(buf->pos, ' ', buf->end - buf->pos);
629
630 cln = ngx_pool_cleanup_add(cf->pool, 0);
631 if (cln == NULL) {
632 return NGX_CONF_ERROR;
633 }
634
635 cln->data = new_log;
636 cln->handler = ngx_log_memory_cleanup;
637
638 new_log->writer = ngx_log_memory_writer;
639 new_log->wdata = buf;
640
641 #else
642 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
643 "nginx was built without debug support");
644 return NGX_CONF_ERROR;
645 #endif
646
647 } else if (ngx_strncmp(value[1].data, "syslog:", 7) == 0) {
648 peer = ngx_pcalloc(cf->pool, sizeof(ngx_syslog_peer_t));
649 if (peer == NULL) {
650 return NGX_CONF_ERROR;
651 }
652
653 if (ngx_syslog_process_conf(cf, peer) != NGX_CONF_OK) {
654 return NGX_CONF_ERROR;
655 }
656
657 new_log->writer = ngx_syslog_writer;
658 new_log->wdata = peer;
659
660 } else {
661 new_log->file = ngx_conf_open_file(cf->cycle, &value[1]);
662 if (new_log->file == NULL) {
663 return NGX_CONF_ERROR;
664 }
665 }
666
667 if (ngx_log_set_levels(cf, new_log) != NGX_CONF_OK) {
668 return NGX_CONF_ERROR;
669 }
670
671 if (*head != new_log) {
672 ngx_log_insert(*head, new_log);
673 }
674
675 return NGX_CONF_OK;
676 }
677
678
679 static void
680 ngx_log_insert(ngx_log_t *log, ngx_log_t *new_log)
681 {
682 ngx_log_t tmp;
683
684 if (new_log->log_level > log->log_level) {
685
686 /*
687 * list head address is permanent, insert new log after
688 * head and swap its contents with head
689 */
690
691 tmp = *log;
692 *log = *new_log;
693 *new_log = tmp;
694
695 log->next = new_log;
696 return;
697 }
698
699 while (log->next) {
700 if (new_log->log_level > log->next->log_level) {
701 new_log->next = log->next;
702 log->next = new_log;
703 return;
704 }
705
706 log = log->next;
707 }
708
709 log->next = new_log;
710 }
711
712
713 #if (NGX_DEBUG)
714
715 static void
716 ngx_log_memory_writer(ngx_log_t *log, ngx_uint_t level, u_char *buf,
717 size_t len)
718 {
719 u_char *p;
720 size_t avail, written;
721 ngx_log_memory_buf_t *mem;
722
723 mem = log->wdata;
724
725 if (mem == NULL) {
726 return;
727 }
728
729 written = ngx_atomic_fetch_add(&mem->written, len);
730
731 p = mem->pos + written % (mem->end - mem->pos);
732
733 avail = mem->end - p;
734
735 if (avail >= len) {
736 ngx_memcpy(p, buf, len);
737
738 } else {
739 ngx_memcpy(p, buf, avail);
740 ngx_memcpy(mem->pos, buf + avail, len - avail);
741 }
742 }
743
744
745 static void
746 ngx_log_memory_cleanup(void *data)
747 {
748 ngx_log_t *log = data;
749
750 ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "destroy memory log buffer");
751
752 log->wdata = NULL;
753 }
754
755 #endif
756