2 * Copyright (c) 2018 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
17 #include <vlib/vlib.h>
19 #include <vlib/unix/unix.h>
21 #include <vppinfra/elog.h>
23 vlib_log_main_t log_main = {
24 .default_log_level = VLIB_LOG_LEVEL_NOTICE,
25 .default_syslog_log_level = VLIB_LOG_LEVEL_WARNING,
29 .default_rate_limit = 50,
32 VLIB_REGISTER_LOG_CLASS (log_log, static) = {
36 static const int colors[] = {
37 [VLIB_LOG_LEVEL_EMERG] = 1, /* red */
38 [VLIB_LOG_LEVEL_ALERT] = 1, /* red */
39 [VLIB_LOG_LEVEL_CRIT] = 1, /* red */
40 [VLIB_LOG_LEVEL_ERR] = 1, /* red */
41 [VLIB_LOG_LEVEL_WARNING] = 3, /* yellow */
42 [VLIB_LOG_LEVEL_NOTICE] = 2, /* green */
43 [VLIB_LOG_LEVEL_INFO] = 4, /* blue */
44 [VLIB_LOG_LEVEL_DEBUG] = 6, /* cyan */
47 static const int log_level_to_syslog_priority[] = {
48 [VLIB_LOG_LEVEL_EMERG] = LOG_EMERG,
49 [VLIB_LOG_LEVEL_ALERT] = LOG_ALERT,
50 [VLIB_LOG_LEVEL_CRIT] = LOG_CRIT,
51 [VLIB_LOG_LEVEL_ERR] = LOG_ERR,
52 [VLIB_LOG_LEVEL_WARNING] = LOG_WARNING,
53 [VLIB_LOG_LEVEL_NOTICE] = LOG_NOTICE,
54 [VLIB_LOG_LEVEL_INFO] = LOG_INFO,
55 [VLIB_LOG_LEVEL_DEBUG] = LOG_DEBUG,
56 [VLIB_LOG_LEVEL_DISABLED] = LOG_DEBUG,
62 vlib_log_main_t *lm = &log_main;
65 i = lm->next - lm->count;
72 format_vlib_log_class (u8 * s, va_list * args)
74 vlib_log_class_t ci = va_arg (*args, vlib_log_class_t);
75 vlib_log_class_data_t *c = vlib_log_get_class_data (ci);
76 vlib_log_subclass_data_t *sc = vlib_log_get_subclass_data (ci);
79 return format (s, "%v/%v", c->name, sc->name);
81 return format (s, "%v", c->name, 0);
85 format_indent (u8 * s, va_list * args)
87 u8 *v = va_arg (*args, u8 *);
88 u32 indent = va_arg (*args, u32);
95 for (u32 i = 0; i < indent; i++)
96 vec_add1 (s, (u8) ' ');
102 log_level_is_enabled (vlib_log_level_t level, vlib_log_level_t configured)
104 if (configured == VLIB_LOG_LEVEL_DISABLED)
106 if (level > configured)
112 vlib_log (vlib_log_level_t level, vlib_log_class_t class, char *fmt, ...)
114 vlib_main_t *vm = vlib_get_main ();
115 vlib_log_main_t *lm = &log_main;
117 vlib_log_subclass_data_t *sc = vlib_log_get_subclass_data (class);
119 f64 t = vlib_time_now (vm);
120 f64 delta = t - sc->last_event_timestamp;
121 int log_enabled = log_level_is_enabled (level, sc->level);
122 int syslog_enabled = log_level_is_enabled (level, sc->syslog_level);
125 /* make sure we are running on the main thread to avoid use in dataplane
126 code, for dataplane logging consider use of event-logger */
127 ASSERT (vlib_get_thread_index () == 0);
129 if ((log_enabled || syslog_enabled) == 0)
132 vec_validate (lm->entries, lm->size);
134 if ((delta > lm->unthrottle_time) ||
135 (sc->is_throttling == 0 && (delta > 1)))
137 sc->last_event_timestamp = t;
138 sc->last_sec_count = 0;
139 sc->is_throttling = 0;
143 sc->last_sec_count++;
144 if (sc->last_sec_count > sc->rate_limit)
146 else if (sc->last_sec_count == sc->rate_limit)
148 vec_reset_length (s);
149 s = format (s, "--- message(s) throttled ---");
150 sc->is_throttling = 1;
157 s = va_format (s, fmt, &va);
164 if (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))
167 int with_colors = (unix_main.flags & UNIX_FLAG_NOCOLOR) == 0;
171 l = format (l, "\x1b[%um", 90 + colors[level]);
172 indent = vec_len (l);
174 fmt = format (0, "%%-%uU [%%-6U]: ", lm->max_class_name_length);
175 vec_terminate_c_string (fmt);
176 l = format (l, (char *) fmt, format_vlib_log_class, class,
177 format_vlib_log_level, level);
179 indent = vec_len (l) - indent;
181 l = format (l, "\x1b[0m");
182 l = format (l, "%U", format_indent, s, indent);
183 fformat (stderr, "%v\n", l);
188 l = format (l, "%U", format_vlib_log_class, class);
189 int prio = log_level_to_syslog_priority[level];
190 int is_term = vec_c_string_is_terminated (l) ? 1 : 0;
192 syslog (prio, "%.*s: %.*s", (int) vec_len (l), l,
193 (int) vec_len (s) - is_term, s);
200 e = vec_elt_at_index (lm->entries, lm->next);
201 vec_free (e->string);
210 ELOG_TYPE_DECLARE(ee) =
212 .format = "log-%s: %s",
213 .format_args = "t4T4",
214 .n_enum_strings = VLIB_LOG_N_LEVELS,
233 ed = ELOG_DATA (&vlib_global_main.elog_main, ee);
234 ed->log_level = level;
236 elog_string (&vlib_global_main.elog_main, "%v%c", e->string, 0);
239 lm->next = (lm->next + 1) % lm->size;
240 if (lm->size > lm->count)
247 static vlib_log_class_t
248 vlib_log_register_class_internal (char *class, char *subclass, u32 limit)
250 vlib_log_main_t *lm = &log_main;
251 vlib_log_class_data_t *c = NULL;
252 vlib_log_subclass_data_t *s;
253 vlib_log_class_data_t *tmp;
254 vlib_log_class_config_t *cc = 0, *scc = 0;
259 if ((p = hash_get_mem (lm->config_index_by_name, class)))
260 cc = vec_elt_at_index (lm->configs, p[0]);
262 str = format (0, "%s/%s%c", class, subclass, 0);
263 if ((p = hash_get_mem (lm->config_index_by_name, (char *) str)))
264 scc = vec_elt_at_index (lm->configs, p[0]);
267 vec_foreach (tmp, lm->classes)
269 if (vec_len (tmp->name) != strlen (class))
271 if (!memcmp (class, tmp->name, vec_len (tmp->name)))
279 vec_add2 (lm->classes, c, 1);
280 c->index = c - lm->classes;
281 c->name = format (0, "%s", class);
283 length = vec_len (c->name);
285 vec_add2 (c->subclasses, s, 1);
286 s->index = s - c->subclasses;
287 s->name = subclass ? format (0, "%s", subclass) : 0;
289 if (scc && scc->rate_limit != ~0)
290 s->rate_limit = scc->rate_limit;
291 else if (cc && cc->rate_limit != ~0)
292 s->rate_limit = cc->rate_limit;
294 s->rate_limit = limit;
296 s->rate_limit = lm->default_rate_limit;
298 if (scc && scc->level != ~0)
299 s->level = scc->level;
300 else if (cc && cc->level != ~0)
301 s->level = cc->level;
303 s->level = lm->default_log_level;
305 if (scc && scc->syslog_level != ~0)
306 s->syslog_level = scc->syslog_level;
307 else if (cc && cc->syslog_level != ~0)
308 s->syslog_level = cc->syslog_level;
310 s->syslog_level = lm->default_syslog_log_level;
313 length += 1 + vec_len (s->name);
314 if (length > lm->max_class_name_length)
315 lm->max_class_name_length = length;
316 return (c->index << 16) | (s->index);
320 vlib_log_register_class (char *class, char *subclass)
322 return vlib_log_register_class_internal (class, subclass,
323 0 /* default rate limit */ );
327 vlib_log_register_class_rate_limit (char *class, char *subclass, u32 limit)
329 return vlib_log_register_class_internal (class, subclass, limit);
334 format_vlib_log_level (u8 * s, va_list * args)
336 vlib_log_level_t i = va_arg (*args, vlib_log_level_t);
341 #define _(uc,lc) case VLIB_LOG_LEVEL_##uc: t = #lc; break;
342 foreach_vlib_log_level
345 return format (s, "unknown");
347 return format (s, "%s", t);
351 vlib_log_init (vlib_main_t *vm)
353 vlib_log_main_t *lm = &log_main;
354 vlib_log_class_registration_t *r = lm->registrations;
356 gettimeofday (&lm->time_zero_timeval, 0);
357 lm->time_zero = vlib_time_now (vm);
359 vec_validate (lm->entries, lm->size);
363 r->class = vlib_log_register_class (r->class_name, r->subclass_name);
364 if (r->default_level)
365 vlib_log_get_subclass_data (r->class)->level = r->default_level;
366 if (r->default_syslog_level)
367 vlib_log_get_subclass_data (r->class)->syslog_level =
368 r->default_syslog_level;
372 r = lm->registrations;
375 vlib_log_debug (r->class, "initialized");
381 static clib_error_t *
382 show_log (vlib_main_t * vm,
383 unformat_input_t * input, vlib_cli_command_t * cmd)
385 clib_error_t *error = 0;
386 vlib_log_main_t *lm = &log_main;
388 int i = last_log_entry ();
389 int count = lm->count;
392 time_offset = (f64) lm->time_zero_timeval.tv_sec
393 + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero;
397 e = vec_elt_at_index (lm->entries, i);
398 vlib_cli_output (vm, "%U %-10U %-14U %v", format_time_float, NULL,
399 e->timestamp + time_offset, format_vlib_log_level,
400 e->level, format_vlib_log_class, e->class, e->string);
401 i = (i + 1) % lm->size;
407 VLIB_CLI_COMMAND (cli_show_log, static) = {
408 .path = "show logging",
409 .short_help = "show logging",
410 .function = show_log,
413 static clib_error_t *
414 show_log_config (vlib_main_t * vm,
415 unformat_input_t * input, vlib_cli_command_t * cmd)
417 clib_error_t *error = 0;
418 vlib_log_main_t *lm = &log_main;
419 vlib_log_class_data_t *c;
420 vlib_log_subclass_data_t *sc;
422 vlib_cli_output (vm, "%-20s %u entries", "Buffer Size:", lm->size);
423 vlib_cli_output (vm, "Defaults:\n");
424 vlib_cli_output (vm, "%-20s %U", " Log Level:",
425 format_vlib_log_level, lm->default_log_level);
426 vlib_cli_output (vm, "%-20s %U", " Syslog Log Level:",
427 format_vlib_log_level, lm->default_syslog_log_level);
428 vlib_cli_output (vm, "%-20s %u msgs/sec", " Rate Limit:",
429 lm->default_rate_limit);
430 vlib_cli_output (vm, "\n");
431 vlib_cli_output (vm, "%-22s %-14s %-14s %s",
432 "Class/Subclass", "Level", "Syslog Level", "Rate Limit");
435 u8 *defstr = format (0, "default");
436 vec_foreach (c, lm->classes)
438 vlib_cli_output (vm, "%v", c->name);
439 vec_foreach (sc, c->subclasses)
441 vlib_cli_output (vm, " %-20v %-14U %-14U %d",
442 sc->name ? sc->name : defstr,
443 format_vlib_log_level, sc->level,
444 format_vlib_log_level, sc->syslog_level,
453 VLIB_CLI_COMMAND (cli_show_log_config, static) = {
454 .path = "show logging configuration",
455 .short_help = "show logging configuration",
456 .function = show_log_config,
459 static clib_error_t *
460 clear_log (vlib_main_t * vm,
461 unformat_input_t * input, vlib_cli_command_t * cmd)
463 clib_error_t *error = 0;
464 vlib_log_main_t *lm = &log_main;
466 int i = last_log_entry ();
467 int count = lm->count;
471 e = vec_elt_at_index (lm->entries, i);
472 vec_free (e->string);
473 i = (i + 1) % lm->size;
478 vlib_log_info (log_log.class, "log cleared");
482 VLIB_CLI_COMMAND (cli_clear_log, static) = {
483 .path = "clear logging",
484 .short_help = "clear logging",
485 .function = clear_log,
489 unformat_vlib_log_level (unformat_input_t * input, va_list * args)
491 vlib_log_level_t *level = va_arg (*args, vlib_log_level_t *);
492 u8 *level_str = NULL;
494 if (unformat (input, "%s", &level_str))
497 const char __##uc[] = #lc; \
498 if (!strcmp ((const char *) level_str, __##uc)) \
500 *level = VLIB_LOG_LEVEL_##uc; \
504 foreach_vlib_log_level;
509 vec_free (level_str);
514 unformat_vlib_log_class (unformat_input_t * input, va_list * args)
516 vlib_log_class_data_t **class = va_arg (*args, vlib_log_class_data_t **);
518 u8 *class_str = NULL;
519 vlib_log_main_t *lm = &log_main;
520 if (unformat (input, "%v", &class_str))
522 vlib_log_class_data_t *cdata;
523 vec_foreach (cdata, lm->classes)
525 if (vec_is_equal (cdata->name, class_str))
533 vec_free (class_str);
537 static clib_error_t *
538 set_log_class (vlib_main_t * vm,
539 unformat_input_t * input, vlib_cli_command_t * cmd)
541 unformat_input_t _line_input, *line_input = &_line_input;
542 clib_error_t *rv = NULL;
544 bool set_rate_limit = false;
545 bool set_level = false;
546 bool set_syslog_level = false;
547 vlib_log_level_t level;
548 vlib_log_level_t syslog_level;
550 /* Get a line of input. */
551 if (!unformat_user (input, unformat_line_input, line_input))
554 vlib_log_class_data_t *class = NULL;
555 if (!unformat (line_input, "%U", unformat_vlib_log_class, &class))
557 return clib_error_return (0, "unknown log class `%U'",
558 format_unformat_error, line_input);
560 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
562 if (unformat (line_input, "rate-limit %d", &rate_limit))
564 set_rate_limit = true;
568 (line_input, "level %U", unformat_vlib_log_level, &level))
574 (line_input, "syslog-level %U", unformat_vlib_log_level,
577 set_syslog_level = true;
581 return clib_error_return (0, "unknown input `%U'",
582 format_unformat_error, line_input);
588 vlib_log_subclass_data_t *subclass;
589 vec_foreach (subclass, class->subclasses)
591 subclass->level = level;
594 if (set_syslog_level)
596 vlib_log_subclass_data_t *subclass;
597 vec_foreach (subclass, class->subclasses)
599 subclass->syslog_level = syslog_level;
604 vlib_log_subclass_data_t *subclass;
605 vec_foreach (subclass, class->subclasses)
607 subclass->rate_limit = rate_limit;
614 VLIB_CLI_COMMAND (cli_set_log, static) = {
615 .path = "set logging class",
616 .short_help = "set logging class <class> [rate-limit <int>] "
617 "[level <level>] [syslog-level <level>]",
618 .function = set_log_class,
621 static clib_error_t *
622 set_log_unth_time (vlib_main_t * vm,
623 unformat_input_t * input, vlib_cli_command_t * cmd)
625 unformat_input_t _line_input, *line_input = &_line_input;
626 clib_error_t *rv = NULL;
628 vlib_log_main_t *lm = &log_main;
630 /* Get a line of input. */
631 if (!unformat_user (input, unformat_line_input, line_input))
634 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
636 if (unformat (line_input, "%d", &unthrottle_time))
637 lm->unthrottle_time = unthrottle_time;
639 return clib_error_return (0, "unknown input `%U'",
640 format_unformat_error, line_input);
646 VLIB_CLI_COMMAND (cli_set_log_params, static) = {
647 .path = "set logging unthrottle-time",
648 .short_help = "set logging unthrottle-time <int>",
649 .function = set_log_unth_time,
652 static clib_error_t *
653 set_log_size (vlib_main_t * vm,
654 unformat_input_t * input, vlib_cli_command_t * cmd)
656 unformat_input_t _line_input, *line_input = &_line_input;
657 clib_error_t *rv = NULL;
659 vlib_log_main_t *lm = &log_main;
661 /* Get a line of input. */
662 if (!unformat_user (input, unformat_line_input, line_input))
665 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
667 if (unformat (line_input, "%d", &size))
670 vec_validate (lm->entries, lm->size);
673 return clib_error_return (0, "unknown input `%U'",
674 format_unformat_error, line_input);
680 VLIB_CLI_COMMAND (cli_set_log_size, static) = {
681 .path = "set logging size",
682 .short_help = "set logging size <int>",
683 .function = set_log_size,
687 unformat_vlib_log_subclass (unformat_input_t * input, va_list * args)
689 vlib_log_class_data_t *class = va_arg (*args, vlib_log_class_data_t *);
690 vlib_log_subclass_data_t **subclass =
691 va_arg (*args, vlib_log_subclass_data_t **);
693 u8 *subclass_str = NULL;
694 if (unformat (input, "%v", &subclass_str))
696 vlib_log_subclass_data_t *scdata;
697 vec_foreach (scdata, class->subclasses)
699 if (vec_is_equal (scdata->name, subclass_str))
707 vec_free (subclass_str);
711 static clib_error_t *
712 test_log_class_subclass (vlib_main_t * vm,
713 unformat_input_t * input, vlib_cli_command_t * cmd)
715 unformat_input_t _line_input, *line_input = &_line_input;
716 /* Get a line of input. */
717 if (!unformat_user (input, unformat_line_input, line_input))
720 vlib_log_class_data_t *class = NULL;
721 vlib_log_subclass_data_t *subclass = NULL;
722 vlib_log_level_t level;
723 if (unformat (line_input, "%U", unformat_vlib_log_level, &level))
725 if (unformat (line_input, "%U", unformat_vlib_log_class, &class))
728 (line_input, "%U", unformat_vlib_log_subclass, class,
732 (class->index << 16) | (subclass->index), "%U",
733 format_unformat_input, line_input);
737 return clib_error_return (0,
738 "unknown log subclass near beginning of `%U'",
739 format_unformat_error, line_input);
744 return clib_error_return (0,
745 "unknown log class near beginning of `%U'",
746 format_unformat_error, line_input);
751 return clib_error_return (0, "unknown log level near beginning of `%U'",
752 format_unformat_error, line_input);
757 VLIB_CLI_COMMAND (cli_test_log, static) = {
759 .short_help = "test log <level> <class> <subclass> <message>",
760 .function = test_log_class_subclass,
763 static clib_error_t *
764 log_config_class (vlib_main_t * vm, char *name, unformat_input_t * input)
766 vlib_log_main_t *lm = &log_main;
767 vlib_log_class_config_t *cc, tmp;
770 if (lm->config_index_by_name == 0)
771 lm->config_index_by_name = hash_create_string (0, sizeof (uword));
773 p = hash_get_mem (lm->config_index_by_name, name);
776 return clib_error_return (0, "logging class '%s' already configured",
779 clib_memset_u8 (&tmp, 0xff, sizeof (vlib_log_class_config_t));
781 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
783 if (unformat (input, "level %U", unformat_vlib_log_level, &tmp.level))
785 else if (unformat (input, "syslog-level %U", unformat_vlib_log_level,
788 else if (unformat (input, "rate-limit %u", &tmp.rate_limit))
791 return clib_error_return (0, "unknown input '%U'",
792 format_unformat_error, input);
795 vec_add2 (lm->configs, cc, 1);
796 clib_memcpy_fast (cc, &tmp, sizeof (vlib_log_class_config_t));
798 hash_set_mem (lm->config_index_by_name, name, cc - lm->configs);
802 static clib_error_t *
803 log_config (vlib_main_t * vm, unformat_input_t * input)
805 vlib_log_main_t *lm = &log_main;
806 unformat_input_t sub_input;
809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
811 if (unformat (input, "size %d", &lm->size))
812 vec_validate (lm->entries, lm->size);
813 else if (unformat (input, "unthrottle-time %d", &lm->unthrottle_time))
815 else if (unformat (input, "default-log-level %U",
816 unformat_vlib_log_level, &lm->default_log_level))
818 else if (unformat (input, "default-syslog-log-level %U",
819 unformat_vlib_log_level,
820 &lm->default_syslog_log_level))
822 else if (unformat (input, "add-to-elog"))
824 else if (unformat (input, "class %s %U", &class,
825 unformat_vlib_cli_sub_input, &sub_input))
828 err = log_config_class (vm, (char *) class, &sub_input);
830 unformat_free (&sub_input);
836 return unformat_parse_error (input);
843 VLIB_EARLY_CONFIG_FUNCTION (log_config, "logging");
846 * fd.io coding-style-patch-verification: ON
849 * eval: (c-set-style "gnu")