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>
22 vlib_log_main_t log_main = {
23 .default_log_level = VLIB_LOG_LEVEL_NOTICE,
24 .default_syslog_log_level = VLIB_LOG_LEVEL_WARNING,
27 .default_rate_limit = 50,
30 static const int colors[] = {
31 [VLIB_LOG_LEVEL_EMERG] = 1, /* red */
32 [VLIB_LOG_LEVEL_ALERT] = 1, /* red */
33 [VLIB_LOG_LEVEL_CRIT] = 1, /* red */
34 [VLIB_LOG_LEVEL_ERR] = 1, /* red */
35 [VLIB_LOG_LEVEL_WARNING] = 3, /* yellow */
36 [VLIB_LOG_LEVEL_NOTICE] = 2, /* green */
37 [VLIB_LOG_LEVEL_INFO] = 4, /* blue */
38 [VLIB_LOG_LEVEL_DEBUG] = 6, /* cyan */
44 vlib_log_main_t *lm = &log_main;
47 i = lm->next - lm->count;
54 static vlib_log_class_data_t *
55 get_class_data (vlib_log_class_t ci)
57 vlib_log_main_t *lm = &log_main;
58 return vec_elt_at_index (lm->classes, (ci >> 16));
61 static vlib_log_subclass_data_t *
62 get_subclass_data (vlib_log_class_t ci)
64 vlib_log_class_data_t *c = get_class_data (ci);
65 return vec_elt_at_index (c->subclasses, (ci & 0xffff));
69 vlib_log_level_to_syslog_priority (vlib_log_level_t level)
73 #define LOG_DISABLED LOG_DEBUG
75 case VLIB_LOG_LEVEL_##uc:\
77 foreach_vlib_log_level
85 format_vlib_log_class (u8 * s, va_list * args)
87 vlib_log_class_t ci = va_arg (*args, vlib_log_class_t);
88 vlib_log_class_data_t *c = get_class_data (ci);
89 vlib_log_subclass_data_t *sc = get_subclass_data (ci);
92 return format (s, "%v/%v", c->name, sc->name);
94 return format (s, "%v", c->name, 0);
98 format_indent (u8 * s, va_list * args)
100 u8 *v = va_arg (*args, u8 *);
101 u32 indent = va_arg (*args, u32);
109 for (u32 i = 0; i < indent; i++)
110 vec_add1 (s, (u8) ' ');
117 log_level_is_enabled (vlib_log_level_t level, vlib_log_level_t configured)
119 if (configured == VLIB_LOG_LEVEL_DISABLED)
121 if (level > configured)
127 vlib_log (vlib_log_level_t level, vlib_log_class_t class, char *fmt, ...)
129 vlib_main_t *vm = vlib_get_main ();
130 vlib_log_main_t *lm = &log_main;
132 vlib_log_subclass_data_t *sc = get_subclass_data (class);
134 f64 t = vlib_time_now (vm);
135 f64 delta = t - sc->last_event_timestamp;
136 int log_enabled = log_level_is_enabled (level, sc->level);
137 int syslog_enabled = log_level_is_enabled (level, sc->syslog_level);
140 /* make sure we are running on the main thread to avoid use in dataplane
141 code, for dataplane logging consider use of event-logger */
142 ASSERT (vlib_get_thread_index () == 0);
144 if ((log_enabled || syslog_enabled) == 0)
147 vec_validate (lm->entries, lm->size);
149 if ((delta > lm->unthrottle_time) ||
150 (sc->is_throttling == 0 && (delta > 1)))
152 sc->last_event_timestamp = t;
153 sc->last_sec_count = 0;
154 sc->is_throttling = 0;
158 sc->last_sec_count++;
159 if (sc->last_sec_count > sc->rate_limit)
161 else if (sc->last_sec_count == sc->rate_limit)
163 vec_reset_length (s);
164 s = format (s, "--- message(s) throttled ---");
165 sc->is_throttling = 1;
172 s = va_format (s, fmt, &va);
179 if (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))
182 int with_colors = (unix_main.flags & UNIX_FLAG_NOCOLOR) == 0;
186 l = format (l, "\x1b[%um", 90 + colors[level]);
187 indent = vec_len (l);
189 fmt = format (0, "%%-%uU [%%-6U]: ", lm->max_class_name_length);
190 l = format (l, (char *) fmt, format_vlib_log_class, class,
191 format_vlib_log_level, level);
193 indent = vec_len (l) - indent;
195 l = format (l, "\x1b[0m");
196 l = format (l, "%U", format_indent, s, indent);
197 fformat (stderr, "%v\n", l);
202 l = format (l, "%U", format_vlib_log_class, class);
203 int prio = vlib_log_level_to_syslog_priority (level);
204 int is_term = vec_c_string_is_terminated (l) ? 1 : 0;
206 syslog (prio, "%.*s: %.*s", (int) vec_len (l), l,
207 (int) vec_len (s) - is_term, s);
214 e = vec_elt_at_index (lm->entries, lm->next);
215 vec_free (e->string);
222 lm->next = (lm->next + 1) % lm->size;
223 if (lm->size > lm->count)
230 static vlib_log_class_t
231 vlib_log_register_class_internal (char *class, char *subclass, u32 limit)
233 vlib_log_main_t *lm = &log_main;
234 vlib_log_class_data_t *c = NULL;
235 vlib_log_subclass_data_t *s;
236 vlib_log_class_data_t *tmp;
237 vlib_log_class_config_t *cc = 0, *scc = 0;
242 if ((p = hash_get_mem (lm->config_index_by_name, class)))
243 cc = vec_elt_at_index (lm->configs, p[0]);
245 str = format (0, "%s/%s%c", class, subclass, 0);
246 if ((p = hash_get_mem (lm->config_index_by_name, (char *) str)))
247 scc = vec_elt_at_index (lm->configs, p[0]);
250 vec_foreach (tmp, lm->classes)
252 if (vec_len (tmp->name) != strlen (class))
254 if (!memcmp (class, tmp->name, vec_len (tmp->name)))
262 vec_add2 (lm->classes, c, 1);
263 c->index = c - lm->classes;
264 c->name = format (0, "%s", class);
265 length = vec_len (c->name);
268 vec_add2 (c->subclasses, s, 1);
269 s->index = s - c->subclasses;
270 s->name = subclass ? format (0, "%s", subclass) : 0;
272 if (scc && scc->rate_limit != ~0)
273 s->rate_limit = scc->rate_limit;
274 else if (cc && cc->rate_limit != ~0)
275 s->rate_limit = cc->rate_limit;
277 s->rate_limit = limit;
279 s->rate_limit = lm->default_rate_limit;
281 if (scc && scc->level != ~0)
282 s->level = scc->level;
283 else if (cc && cc->level != ~0)
284 s->level = cc->level;
286 s->level = lm->default_log_level;
288 if (scc && scc->syslog_level != ~0)
289 s->syslog_level = scc->syslog_level;
290 else if (cc && cc->syslog_level != ~0)
291 s->syslog_level = cc->syslog_level;
293 s->syslog_level = lm->default_syslog_log_level;
296 length += 1 + vec_len (s->name);
297 if (length > lm->max_class_name_length)
298 lm->max_class_name_length = length;
299 return (c->index << 16) | (s->index);
303 vlib_log_register_class (char *class, char *subclass)
305 return vlib_log_register_class_internal (class, subclass,
306 0 /* default rate limit */ );
310 vlib_log_register_class_rate_limit (char *class, char *subclass, u32 limit)
312 return vlib_log_register_class_internal (class, subclass, limit);
317 format_vlib_log_level (u8 * s, va_list * args)
319 vlib_log_level_t i = va_arg (*args, vlib_log_level_t);
324 #define _(v,uc,lc) case VLIB_LOG_LEVEL_##uc: t = #lc; break;
325 foreach_vlib_log_level
328 return format (s, "unknown");
330 return format (s, "%s", t);
333 static clib_error_t *
334 vlib_log_init (vlib_main_t * vm)
336 vlib_log_main_t *lm = &log_main;
338 gettimeofday (&lm->time_zero_timeval, 0);
339 lm->time_zero = vlib_time_now (vm);
341 vec_validate (lm->entries, lm->size);
342 lm->log_class = vlib_log_register_class ("log", 0);
346 VLIB_INIT_FUNCTION (vlib_log_init);
349 static clib_error_t *
350 show_log (vlib_main_t * vm,
351 unformat_input_t * input, vlib_cli_command_t * cmd)
353 clib_error_t *error = 0;
354 vlib_log_main_t *lm = &log_main;
356 int i = last_log_entry ();
357 int count = lm->count;
360 time_offset = (f64) lm->time_zero_timeval.tv_sec
361 + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero;
365 e = vec_elt_at_index (lm->entries, i);
366 vlib_cli_output (vm, "%U %-10U %-14U %v",
367 format_time_float, 0, e->timestamp + time_offset,
368 format_vlib_log_level, e->level,
369 format_vlib_log_class, e->class, e->string);
370 i = (i + 1) % lm->size;
377 VLIB_CLI_COMMAND (cli_show_log, static) = {
378 .path = "show logging",
379 .short_help = "show logging",
380 .function = show_log,
384 static clib_error_t *
385 show_log_config (vlib_main_t * vm,
386 unformat_input_t * input, vlib_cli_command_t * cmd)
388 clib_error_t *error = 0;
389 vlib_log_main_t *lm = &log_main;
390 vlib_log_class_data_t *c;
391 vlib_log_subclass_data_t *sc;
393 vlib_cli_output (vm, "%-20s %u entries", "Buffer Size:", lm->size);
394 vlib_cli_output (vm, "Defaults:\n");
395 vlib_cli_output (vm, "%-20s %U", " Log Level:",
396 format_vlib_log_level, lm->default_log_level);
397 vlib_cli_output (vm, "%-20s %U", " Syslog Log Level:",
398 format_vlib_log_level, lm->default_syslog_log_level);
399 vlib_cli_output (vm, "%-20s %u msgs/sec", " Rate Limit:",
400 lm->default_rate_limit);
401 vlib_cli_output (vm, "\n");
402 vlib_cli_output (vm, "%-22s %-14s %-14s %s",
403 "Class/Subclass", "Level", "Syslog Level", "Rate Limit");
406 u8 *defstr = format (0, "default");
407 vec_foreach (c, lm->classes)
409 vlib_cli_output (vm, "%v", c->name);
410 vec_foreach (sc, c->subclasses)
412 vlib_cli_output (vm, " %-20v %-14U %-14U %d",
413 sc->name ? sc->name : defstr,
414 format_vlib_log_level, sc->level,
415 format_vlib_log_level, sc->syslog_level,
425 VLIB_CLI_COMMAND (cli_show_log_config, static) = {
426 .path = "show logging configuration",
427 .short_help = "show logging configuration",
428 .function = show_log_config,
432 static clib_error_t *
433 clear_log (vlib_main_t * vm,
434 unformat_input_t * input, vlib_cli_command_t * cmd)
436 clib_error_t *error = 0;
437 vlib_log_main_t *lm = &log_main;
439 int i = last_log_entry ();
440 int count = lm->count;
444 e = vec_elt_at_index (lm->entries, i);
445 vec_free (e->string);
446 i = (i + 1) % lm->size;
451 vlib_log_info (lm->log_class, "log cleared");
456 VLIB_CLI_COMMAND (cli_clear_log, static) = {
457 .path = "clear logging",
458 .short_help = "clear logging",
459 .function = clear_log,
464 unformat_vlib_log_level (unformat_input_t * input, va_list * args)
466 vlib_log_level_t *level = va_arg (*args, vlib_log_level_t *);
467 u8 *level_str = NULL;
469 if (unformat (input, "%s", &level_str))
471 #define _(v, uc, lc) \
472 const char __##uc[] = #lc; \
473 if (!strcmp ((const char *) level_str, __##uc)) \
475 *level = VLIB_LOG_LEVEL_##uc; \
479 foreach_vlib_log_level;
484 vec_free (level_str);
489 unformat_vlib_log_class (unformat_input_t * input, va_list * args)
491 vlib_log_class_data_t **class = va_arg (*args, vlib_log_class_data_t **);
493 u8 *class_str = NULL;
494 vlib_log_main_t *lm = &log_main;
495 if (unformat (input, "%v", &class_str))
497 vlib_log_class_data_t *cdata;
498 vec_foreach (cdata, lm->classes)
500 if (vec_is_equal (cdata->name, class_str))
508 vec_free (class_str);
512 static clib_error_t *
513 set_log_class (vlib_main_t * vm,
514 unformat_input_t * input, vlib_cli_command_t * cmd)
516 unformat_input_t _line_input, *line_input = &_line_input;
517 clib_error_t *rv = NULL;
519 bool set_rate_limit = false;
520 bool set_level = false;
521 bool set_syslog_level = false;
522 vlib_log_level_t level;
523 vlib_log_level_t syslog_level;
525 /* Get a line of input. */
526 if (!unformat_user (input, unformat_line_input, line_input))
529 vlib_log_class_data_t *class = NULL;
530 if (!unformat (line_input, "%U", unformat_vlib_log_class, &class))
532 return clib_error_return (0, "unknown log class `%U'",
533 format_unformat_error, line_input);
535 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
537 if (unformat (line_input, "rate-limit %d", &rate_limit))
539 set_rate_limit = true;
543 (line_input, "level %U", unformat_vlib_log_level, &level))
549 (line_input, "syslog-level %U", unformat_vlib_log_level,
552 set_syslog_level = true;
556 return clib_error_return (0, "unknown input `%U'",
557 format_unformat_error, line_input);
563 vlib_log_subclass_data_t *subclass;
564 vec_foreach (subclass, class->subclasses)
566 subclass->level = level;
569 if (set_syslog_level)
571 vlib_log_subclass_data_t *subclass;
572 vec_foreach (subclass, class->subclasses)
574 subclass->syslog_level = syslog_level;
579 vlib_log_subclass_data_t *subclass;
580 vec_foreach (subclass, class->subclasses)
582 subclass->rate_limit = rate_limit;
590 VLIB_CLI_COMMAND (cli_set_log, static) = {
591 .path = "set logging class",
592 .short_help = "set logging class <class> [rate-limit <int>] "
593 "[level <level>] [syslog-level <level>]",
594 .function = set_log_class,
598 static clib_error_t *
599 set_log_unth_time (vlib_main_t * vm,
600 unformat_input_t * input, vlib_cli_command_t * cmd)
602 unformat_input_t _line_input, *line_input = &_line_input;
603 clib_error_t *rv = NULL;
605 vlib_log_main_t *lm = &log_main;
607 /* Get a line of input. */
608 if (!unformat_user (input, unformat_line_input, line_input))
611 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
613 if (unformat (line_input, "%d", &unthrottle_time))
614 lm->unthrottle_time = unthrottle_time;
616 return clib_error_return (0, "unknown input `%U'",
617 format_unformat_error, line_input);
624 VLIB_CLI_COMMAND (cli_set_log_params, static) = {
625 .path = "set logging unthrottle-time",
626 .short_help = "set logging unthrottle-time <int>",
627 .function = set_log_unth_time,
631 static clib_error_t *
632 set_log_size (vlib_main_t * vm,
633 unformat_input_t * input, vlib_cli_command_t * cmd)
635 unformat_input_t _line_input, *line_input = &_line_input;
636 clib_error_t *rv = NULL;
638 vlib_log_main_t *lm = &log_main;
640 /* Get a line of input. */
641 if (!unformat_user (input, unformat_line_input, line_input))
644 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
646 if (unformat (line_input, "%d", &size))
649 vec_validate (lm->entries, lm->size);
652 return clib_error_return (0, "unknown input `%U'",
653 format_unformat_error, line_input);
660 VLIB_CLI_COMMAND (cli_set_log_size, static) = {
661 .path = "set logging size",
662 .short_help = "set logging size <int>",
663 .function = set_log_size,
668 unformat_vlib_log_subclass (unformat_input_t * input, va_list * args)
670 vlib_log_class_data_t *class = va_arg (*args, vlib_log_class_data_t *);
671 vlib_log_subclass_data_t **subclass =
672 va_arg (*args, vlib_log_subclass_data_t **);
674 u8 *subclass_str = NULL;
675 if (unformat (input, "%v", &subclass_str))
677 vlib_log_subclass_data_t *scdata;
678 vec_foreach (scdata, class->subclasses)
680 if (vec_is_equal (scdata->name, subclass_str))
688 vec_free (subclass_str);
692 static clib_error_t *
693 test_log_class_subclass (vlib_main_t * vm,
694 unformat_input_t * input, vlib_cli_command_t * cmd)
696 unformat_input_t _line_input, *line_input = &_line_input;
697 /* Get a line of input. */
698 if (!unformat_user (input, unformat_line_input, line_input))
701 vlib_log_class_data_t *class = NULL;
702 vlib_log_subclass_data_t *subclass = NULL;
703 vlib_log_level_t level;
704 if (unformat (line_input, "%U", unformat_vlib_log_level, &level))
706 if (unformat (line_input, "%U", unformat_vlib_log_class, &class))
709 (line_input, "%U", unformat_vlib_log_subclass, class,
713 (class->index << 16) | (subclass->index), "%U",
714 format_unformat_input, line_input);
718 return clib_error_return (0,
719 "unknown log subclass near beginning of `%U'",
720 format_unformat_error, line_input);
725 return clib_error_return (0,
726 "unknown log class near beginning of `%U'",
727 format_unformat_error, line_input);
732 return clib_error_return (0, "unknown log level near beginning of `%U'",
733 format_unformat_error, line_input);
739 VLIB_CLI_COMMAND (cli_test_log, static) = {
741 .short_help = "test log <level> <class> <subclass> <message>",
742 .function = test_log_class_subclass,
746 static clib_error_t *
747 log_config_class (vlib_main_t * vm, char *name, unformat_input_t * input)
749 vlib_log_main_t *lm = &log_main;
750 vlib_log_class_config_t *cc, tmp;
753 if (lm->config_index_by_name == 0)
754 lm->config_index_by_name = hash_create_string (0, sizeof (uword));
756 p = hash_get_mem (lm->config_index_by_name, name);
759 return clib_error_return (0, "logging class '%s' already configured",
762 clib_memset_u8 (&tmp, 0xff, sizeof (vlib_log_class_config_t));
764 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
766 if (unformat (input, "level %U", unformat_vlib_log_level, &tmp.level))
768 else if (unformat (input, "syslog-level %U", unformat_vlib_log_level,
771 else if (unformat (input, "rate-limit %u", &tmp.rate_limit))
774 return clib_error_return (0, "unknown input '%U'",
775 format_unformat_error, input);
778 vec_add2 (lm->configs, cc, 1);
779 clib_memcpy_fast (cc, &tmp, sizeof (vlib_log_class_config_t));
781 hash_set_mem (lm->config_index_by_name, name, cc - lm->configs);
785 static clib_error_t *
786 log_config (vlib_main_t * vm, unformat_input_t * input)
788 vlib_log_main_t *lm = &log_main;
789 unformat_input_t sub_input;
792 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
794 if (unformat (input, "size %d", &lm->size))
795 vec_validate (lm->entries, lm->size);
796 else if (unformat (input, "unthrottle-time %d", &lm->unthrottle_time))
798 else if (unformat (input, "default-log-level %U",
799 unformat_vlib_log_level, &lm->default_log_level))
801 else if (unformat (input, "default-syslog-log-level %U",
802 unformat_vlib_log_level,
803 &lm->default_syslog_log_level))
805 else if (unformat (input, "class %s %U", &class,
806 unformat_vlib_cli_sub_input, &sub_input))
809 err = log_config_class (vm, (char *) class, &sub_input);
811 unformat_free (&sub_input);
817 return unformat_parse_error (input);
824 VLIB_EARLY_CONFIG_FUNCTION (log_config, "logging");
827 * fd.io coding-style-patch-verification: ON
830 * eval: (c-set-style "gnu")