vlib: init logging eearlier
[vpp.git] / src / vlib / log.c
1 /*
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:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
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.
14  */
15
16 #include <stdbool.h>
17 #include <vlib/vlib.h>
18 #include <vlib/log.h>
19 #include <vlib/unix/unix.h>
20 #include <syslog.h>
21 #include <vppinfra/elog.h>
22
23 vlib_log_main_t log_main = {
24   .default_log_level = VLIB_LOG_LEVEL_NOTICE,
25   .default_syslog_log_level = VLIB_LOG_LEVEL_WARNING,
26   .unthrottle_time = 3,
27   .size = 512,
28   .add_to_elog = 1,
29   .default_rate_limit = 50,
30 };
31
32 /* *INDENT-OFF* */
33 VLIB_REGISTER_LOG_CLASS (log_log, static) = {
34   .class_name = "log",
35 };
36 /* *INDENT-ON* */
37
38 static const int colors[] = {
39   [VLIB_LOG_LEVEL_EMERG] = 1,   /* red */
40   [VLIB_LOG_LEVEL_ALERT] = 1,   /* red */
41   [VLIB_LOG_LEVEL_CRIT] = 1,    /* red */
42   [VLIB_LOG_LEVEL_ERR] = 1,     /* red */
43   [VLIB_LOG_LEVEL_WARNING] = 3, /* yellow */
44   [VLIB_LOG_LEVEL_NOTICE] = 2,  /* green */
45   [VLIB_LOG_LEVEL_INFO] = 4,    /* blue */
46   [VLIB_LOG_LEVEL_DEBUG] = 6,   /* cyan */
47 };
48
49 static const int log_level_to_syslog_priority[] = {
50   [VLIB_LOG_LEVEL_EMERG] = LOG_EMERG,
51   [VLIB_LOG_LEVEL_ALERT] = LOG_ALERT,
52   [VLIB_LOG_LEVEL_CRIT] = LOG_CRIT,
53   [VLIB_LOG_LEVEL_ERR] = LOG_ERR,
54   [VLIB_LOG_LEVEL_WARNING] = LOG_WARNING,
55   [VLIB_LOG_LEVEL_NOTICE] = LOG_NOTICE,
56   [VLIB_LOG_LEVEL_INFO] = LOG_INFO,
57   [VLIB_LOG_LEVEL_DEBUG] = LOG_DEBUG,
58   [VLIB_LOG_LEVEL_DISABLED] = LOG_DEBUG,
59 };
60
61 int
62 last_log_entry ()
63 {
64   vlib_log_main_t *lm = &log_main;
65   int i;
66
67   i = lm->next - lm->count;
68
69   if (i < 0)
70     i += lm->size;
71   return i;
72 }
73
74 static vlib_log_class_data_t *
75 get_class_data (vlib_log_class_t ci)
76 {
77   vlib_log_main_t *lm = &log_main;
78   return vec_elt_at_index (lm->classes, (ci >> 16));
79 }
80
81 static vlib_log_subclass_data_t *
82 get_subclass_data (vlib_log_class_t ci)
83 {
84   vlib_log_class_data_t *c = get_class_data (ci);
85   return vec_elt_at_index (c->subclasses, (ci & 0xffff));
86 }
87
88 u8 *
89 format_vlib_log_class (u8 * s, va_list * args)
90 {
91   vlib_log_class_t ci = va_arg (*args, vlib_log_class_t);
92   vlib_log_class_data_t *c = get_class_data (ci);
93   vlib_log_subclass_data_t *sc = get_subclass_data (ci);
94
95   if (sc->name)
96     return format (s, "%v/%v", c->name, sc->name);
97   else
98     return format (s, "%v", c->name, 0);
99 }
100
101 u8 *
102 format_indent (u8 * s, va_list * args)
103 {
104   u8 *v = va_arg (*args, u8 *);
105   u32 indent = va_arg (*args, u32);
106   u8 *c;
107
108   /* *INDENT-OFF* */
109   vec_foreach (c, v)
110     {
111       vec_add (s, c, 1);
112       if (c[0] == '\n')
113         for (u32 i = 0; i < indent; i++)
114           vec_add1 (s, (u8) ' ');
115     }
116   /* *INDENT-ON* */
117   return s;
118 }
119
120 static int
121 log_level_is_enabled (vlib_log_level_t level, vlib_log_level_t configured)
122 {
123   if (configured == VLIB_LOG_LEVEL_DISABLED)
124     return 0;
125   if (level > configured)
126     return 0;
127   return 1;
128 }
129
130 void
131 vlib_log (vlib_log_level_t level, vlib_log_class_t class, char *fmt, ...)
132 {
133   vlib_main_t *vm = vlib_get_main ();
134   vlib_log_main_t *lm = &log_main;
135   vlib_log_entry_t *e;
136   vlib_log_subclass_data_t *sc = get_subclass_data (class);
137   va_list va;
138   f64 t = vlib_time_now (vm);
139   f64 delta = t - sc->last_event_timestamp;
140   int log_enabled = log_level_is_enabled (level, sc->level);
141   int syslog_enabled = log_level_is_enabled (level, sc->syslog_level);
142   u8 *s = 0;
143
144   /* make sure we are running on the main thread to avoid use in dataplane
145      code, for dataplane logging consider use of event-logger */
146   ASSERT (vlib_get_thread_index () == 0);
147
148   if ((log_enabled || syslog_enabled) == 0)
149     return;
150
151   vec_validate (lm->entries, lm->size);
152
153   if ((delta > lm->unthrottle_time) ||
154       (sc->is_throttling == 0 && (delta > 1)))
155     {
156       sc->last_event_timestamp = t;
157       sc->last_sec_count = 0;
158       sc->is_throttling = 0;
159     }
160   else
161     {
162       sc->last_sec_count++;
163       if (sc->last_sec_count > sc->rate_limit)
164         return;
165       else if (sc->last_sec_count == sc->rate_limit)
166         {
167           vec_reset_length (s);
168           s = format (s, "--- message(s) throttled ---");
169           sc->is_throttling = 1;
170         }
171     }
172
173   if (s == 0)
174     {
175       va_start (va, fmt);
176       s = va_format (s, fmt, &va);
177       va_end (va);
178     }
179
180   if (syslog_enabled)
181     {
182       u8 *l = 0;
183       if (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))
184         {
185           int indent = 0;
186           int with_colors = (unix_main.flags & UNIX_FLAG_NOCOLOR) == 0;
187           u8 *fmt;
188           if (with_colors)
189             {
190               l = format (l, "\x1b[%um", 90 + colors[level]);
191               indent = vec_len (l);
192             }
193           fmt = format (0, "%%-%uU [%%-6U]: ", lm->max_class_name_length);
194           vec_terminate_c_string (fmt);
195           l = format (l, (char *) fmt, format_vlib_log_class, class,
196                       format_vlib_log_level, level);
197           vec_free (fmt);
198           indent = vec_len (l) - indent;
199           if (with_colors)
200             l = format (l, "\x1b[0m");
201           l = format (l, "%U", format_indent, s, indent);
202           fformat (stderr, "%v\n", l);
203           fflush (stderr);
204         }
205       else
206         {
207           l = format (l, "%U", format_vlib_log_class, class);
208           int prio = log_level_to_syslog_priority[level];
209           int is_term = vec_c_string_is_terminated (l) ? 1 : 0;
210
211           syslog (prio, "%.*s: %.*s", (int) vec_len (l), l,
212                   (int) vec_len (s) - is_term, s);
213         }
214       vec_free (l);
215     }
216
217   if (log_enabled)
218     {
219       e = vec_elt_at_index (lm->entries, lm->next);
220       vec_free (e->string);
221       e->level = level;
222       e->class = class;
223       e->string = s;
224       e->timestamp = t;
225       s = 0;
226
227       if (lm->add_to_elog)
228         {
229           /* *INDENT-OFF* */
230           ELOG_TYPE_DECLARE(ee) =
231             {
232              .format = "log-%s: %s",
233              .format_args = "t4T4",
234              .n_enum_strings = 9,
235              .enum_strings = {
236                 "emerg",
237                 "alert",
238                 "crit",
239                 "err",
240                 "warn",
241                 "notice",
242                 "info",
243                 "debug",
244                 "disabled",
245                 },
246             };
247           struct {
248             u32 log_level;
249             u32 string_index;
250           } *ed;
251           /* *INDENT-ON* */
252           ed = ELOG_DATA (&vlib_global_main.elog_main, ee);
253           ed->log_level = level;
254           ed->string_index =
255             elog_string (&vlib_global_main.elog_main, "%v%c", e->string, 0);
256         }
257
258       lm->next = (lm->next + 1) % lm->size;
259       if (lm->size > lm->count)
260         lm->count++;
261     }
262
263   vec_free (s);
264 }
265
266 static vlib_log_class_t
267 vlib_log_register_class_internal (char *class, char *subclass, u32 limit)
268 {
269   vlib_log_main_t *lm = &log_main;
270   vlib_log_class_data_t *c = NULL;
271   vlib_log_subclass_data_t *s;
272   vlib_log_class_data_t *tmp;
273   vlib_log_class_config_t *cc = 0, *scc = 0;
274   uword *p;
275   u8 *str;
276   u32 length = 0;
277
278   if ((p = hash_get_mem (lm->config_index_by_name, class)))
279     cc = vec_elt_at_index (lm->configs, p[0]);
280
281   str = format (0, "%s/%s%c", class, subclass, 0);
282   if ((p = hash_get_mem (lm->config_index_by_name, (char *) str)))
283     scc = vec_elt_at_index (lm->configs, p[0]);
284   vec_free (str);
285
286   vec_foreach (tmp, lm->classes)
287   {
288     if (vec_len (tmp->name) != strlen (class))
289       continue;
290     if (!memcmp (class, tmp->name, vec_len (tmp->name)))
291       {
292         c = tmp;
293         break;
294       }
295   }
296   if (!c)
297     {
298       vec_add2 (lm->classes, c, 1);
299       c->index = c - lm->classes;
300       c->name = format (0, "%s", class);
301     }
302   length = vec_len (c->name);
303
304   vec_add2 (c->subclasses, s, 1);
305   s->index = s - c->subclasses;
306   s->name = subclass ? format (0, "%s", subclass) : 0;
307
308   if (scc && scc->rate_limit != ~0)
309     s->rate_limit = scc->rate_limit;
310   else if (cc && cc->rate_limit != ~0)
311     s->rate_limit = cc->rate_limit;
312   else if (limit)
313     s->rate_limit = limit;
314   else
315     s->rate_limit = lm->default_rate_limit;
316
317   if (scc && scc->level != ~0)
318     s->level = scc->level;
319   else if (cc && cc->level != ~0)
320     s->level = cc->level;
321   else
322     s->level = lm->default_log_level;
323
324   if (scc && scc->syslog_level != ~0)
325     s->syslog_level = scc->syslog_level;
326   else if (cc && cc->syslog_level != ~0)
327     s->syslog_level = cc->syslog_level;
328   else
329     s->syslog_level = lm->default_syslog_log_level;
330
331   if (subclass)
332     length += 1 + vec_len (s->name);
333   if (length > lm->max_class_name_length)
334     lm->max_class_name_length = length;
335   return (c->index << 16) | (s->index);
336 }
337
338 vlib_log_class_t
339 vlib_log_register_class (char *class, char *subclass)
340 {
341   return vlib_log_register_class_internal (class, subclass,
342                                            0 /* default rate limit */ );
343 }
344
345 vlib_log_class_t
346 vlib_log_register_class_rate_limit (char *class, char *subclass, u32 limit)
347 {
348   return vlib_log_register_class_internal (class, subclass, limit);
349 }
350
351
352 u8 *
353 format_vlib_log_level (u8 * s, va_list * args)
354 {
355   vlib_log_level_t i = va_arg (*args, vlib_log_level_t);
356   char *t = 0;
357
358   switch (i)
359     {
360 #define _(uc,lc) case VLIB_LOG_LEVEL_##uc: t = #lc; break;
361       foreach_vlib_log_level
362 #undef _
363     default:
364       return format (s, "unknown");
365     }
366   return format (s, "%s", t);
367 }
368
369 clib_error_t *
370 vlib_log_init (vlib_main_t *vm)
371 {
372   vlib_log_main_t *lm = &log_main;
373   vlib_log_class_registration_t *r = lm->registrations;
374
375   gettimeofday (&lm->time_zero_timeval, 0);
376   lm->time_zero = vlib_time_now (vm);
377
378   vec_validate (lm->entries, lm->size);
379
380   while (r)
381     {
382       r->class = vlib_log_register_class (r->class_name, r->subclass_name);
383       if (r->default_level)
384         get_subclass_data (r->class)->level = r->default_level;
385       if (r->default_syslog_level)
386         get_subclass_data (r->class)->syslog_level = r->default_syslog_level;
387       r = r->next;
388     }
389
390   r = lm->registrations;
391   while (r)
392     {
393       vlib_log_debug (r->class, "initialized");
394       r = r->next;
395     }
396   return 0;
397 }
398
399 static clib_error_t *
400 show_log (vlib_main_t * vm,
401           unformat_input_t * input, vlib_cli_command_t * cmd)
402 {
403   clib_error_t *error = 0;
404   vlib_log_main_t *lm = &log_main;
405   vlib_log_entry_t *e;
406   int i = last_log_entry ();
407   int count = lm->count;
408   f64 time_offset;
409
410   time_offset = (f64) lm->time_zero_timeval.tv_sec
411     + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero;
412
413   while (count--)
414     {
415       e = vec_elt_at_index (lm->entries, i);
416       vlib_cli_output (vm, "%U %-10U %-14U %v",
417                        format_time_float, 0, e->timestamp + time_offset,
418                        format_vlib_log_level, e->level,
419                        format_vlib_log_class, e->class, e->string);
420       i = (i + 1) % lm->size;
421     }
422
423   return error;
424 }
425
426 /* *INDENT-OFF* */
427 VLIB_CLI_COMMAND (cli_show_log, static) = {
428   .path = "show logging",
429   .short_help = "show logging",
430   .function = show_log,
431 };
432 /* *INDENT-ON* */
433
434 static clib_error_t *
435 show_log_config (vlib_main_t * vm,
436                  unformat_input_t * input, vlib_cli_command_t * cmd)
437 {
438   clib_error_t *error = 0;
439   vlib_log_main_t *lm = &log_main;
440   vlib_log_class_data_t *c;
441   vlib_log_subclass_data_t *sc;
442
443   vlib_cli_output (vm, "%-20s %u entries", "Buffer Size:", lm->size);
444   vlib_cli_output (vm, "Defaults:\n");
445   vlib_cli_output (vm, "%-20s %U", "  Log Level:",
446                    format_vlib_log_level, lm->default_log_level);
447   vlib_cli_output (vm, "%-20s %U", "  Syslog Log Level:",
448                    format_vlib_log_level, lm->default_syslog_log_level);
449   vlib_cli_output (vm, "%-20s %u msgs/sec", "  Rate Limit:",
450                    lm->default_rate_limit);
451   vlib_cli_output (vm, "\n");
452   vlib_cli_output (vm, "%-22s %-14s %-14s %s",
453                    "Class/Subclass", "Level", "Syslog Level", "Rate Limit");
454
455
456   u8 *defstr = format (0, "default");
457   vec_foreach (c, lm->classes)
458   {
459     vlib_cli_output (vm, "%v", c->name);
460     vec_foreach (sc, c->subclasses)
461     {
462       vlib_cli_output (vm, "  %-20v %-14U %-14U %d",
463                        sc->name ? sc->name : defstr,
464                        format_vlib_log_level, sc->level,
465                        format_vlib_log_level, sc->syslog_level,
466                        sc->rate_limit);
467     }
468   }
469   vec_free (defstr);
470
471   return error;
472 }
473
474 /* *INDENT-OFF* */
475 VLIB_CLI_COMMAND (cli_show_log_config, static) = {
476   .path = "show logging configuration",
477   .short_help = "show logging configuration",
478   .function = show_log_config,
479 };
480 /* *INDENT-ON* */
481
482 static clib_error_t *
483 clear_log (vlib_main_t * vm,
484            unformat_input_t * input, vlib_cli_command_t * cmd)
485 {
486   clib_error_t *error = 0;
487   vlib_log_main_t *lm = &log_main;
488   vlib_log_entry_t *e;
489   int i = last_log_entry ();
490   int count = lm->count;
491
492   while (count--)
493     {
494       e = vec_elt_at_index (lm->entries, i);
495       vec_free (e->string);
496       i = (i + 1) % lm->size;
497     }
498
499   lm->count = 0;
500   lm->next = 0;
501   vlib_log_info (log_log.class, "log cleared");
502   return error;
503 }
504
505 /* *INDENT-OFF* */
506 VLIB_CLI_COMMAND (cli_clear_log, static) = {
507   .path = "clear logging",
508   .short_help = "clear logging",
509   .function = clear_log,
510 };
511 /* *INDENT-ON* */
512
513 static uword
514 unformat_vlib_log_level (unformat_input_t * input, va_list * args)
515 {
516   vlib_log_level_t *level = va_arg (*args, vlib_log_level_t *);
517   u8 *level_str = NULL;
518   uword rv = 1;
519   if (unformat (input, "%s", &level_str))
520     {
521 #define _(uc, lc)                                      \
522   const char __##uc[] = #lc;                           \
523   if (!strcmp ((const char *) level_str, __##uc))      \
524     {                                                  \
525       *level = VLIB_LOG_LEVEL_##uc;                    \
526       rv = 1;                                          \
527       goto done;                                       \
528     }
529       foreach_vlib_log_level;
530       rv = 0;
531 #undef _
532     }
533 done:
534   vec_free (level_str);
535   return rv;
536 }
537
538 static uword
539 unformat_vlib_log_class (unformat_input_t * input, va_list * args)
540 {
541   vlib_log_class_data_t **class = va_arg (*args, vlib_log_class_data_t **);
542   uword rv = 0;
543   u8 *class_str = NULL;
544   vlib_log_main_t *lm = &log_main;
545   if (unformat (input, "%v", &class_str))
546     {
547       vlib_log_class_data_t *cdata;
548       vec_foreach (cdata, lm->classes)
549       {
550         if (vec_is_equal (cdata->name, class_str))
551           {
552             *class = cdata;
553             rv = 1;
554             break;
555           }
556       }
557     }
558   vec_free (class_str);
559   return rv;
560 }
561
562 static clib_error_t *
563 set_log_class (vlib_main_t * vm,
564                unformat_input_t * input, vlib_cli_command_t * cmd)
565 {
566   unformat_input_t _line_input, *line_input = &_line_input;
567   clib_error_t *rv = NULL;
568   int rate_limit;
569   bool set_rate_limit = false;
570   bool set_level = false;
571   bool set_syslog_level = false;
572   vlib_log_level_t level;
573   vlib_log_level_t syslog_level;
574
575   /* Get a line of input. */
576   if (!unformat_user (input, unformat_line_input, line_input))
577     return 0;
578
579   vlib_log_class_data_t *class = NULL;
580   if (!unformat (line_input, "%U", unformat_vlib_log_class, &class))
581     {
582       return clib_error_return (0, "unknown log class `%U'",
583                                 format_unformat_error, line_input);
584     }
585   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
586     {
587       if (unformat (line_input, "rate-limit %d", &rate_limit))
588         {
589           set_rate_limit = true;
590         }
591       else
592         if (unformat
593             (line_input, "level %U", unformat_vlib_log_level, &level))
594         {
595           set_level = true;
596         }
597       else
598         if (unformat
599             (line_input, "syslog-level %U", unformat_vlib_log_level,
600              &syslog_level))
601         {
602           set_syslog_level = true;
603         }
604       else
605         {
606           return clib_error_return (0, "unknown input `%U'",
607                                     format_unformat_error, line_input);
608         }
609     }
610
611   if (set_level)
612     {
613       vlib_log_subclass_data_t *subclass;
614       vec_foreach (subclass, class->subclasses)
615       {
616         subclass->level = level;
617       }
618     }
619   if (set_syslog_level)
620     {
621       vlib_log_subclass_data_t *subclass;
622       vec_foreach (subclass, class->subclasses)
623       {
624         subclass->syslog_level = syslog_level;
625       }
626     }
627   if (set_rate_limit)
628     {
629       vlib_log_subclass_data_t *subclass;
630       vec_foreach (subclass, class->subclasses)
631       {
632         subclass->rate_limit = rate_limit;
633       }
634     }
635
636   return rv;
637 }
638
639 /* *INDENT-OFF* */
640 VLIB_CLI_COMMAND (cli_set_log, static) = {
641   .path = "set logging class",
642   .short_help = "set logging class <class> [rate-limit <int>] "
643     "[level <level>] [syslog-level <level>]",
644   .function = set_log_class,
645 };
646 /* *INDENT-ON* */
647
648 static clib_error_t *
649 set_log_unth_time (vlib_main_t * vm,
650                    unformat_input_t * input, vlib_cli_command_t * cmd)
651 {
652   unformat_input_t _line_input, *line_input = &_line_input;
653   clib_error_t *rv = NULL;
654   int unthrottle_time;
655   vlib_log_main_t *lm = &log_main;
656
657   /* Get a line of input. */
658   if (!unformat_user (input, unformat_line_input, line_input))
659     return 0;
660
661   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
662     {
663       if (unformat (line_input, "%d", &unthrottle_time))
664         lm->unthrottle_time = unthrottle_time;
665       else
666         return clib_error_return (0, "unknown input `%U'",
667                                   format_unformat_error, line_input);
668     }
669
670   return rv;
671 }
672
673 /* *INDENT-OFF* */
674 VLIB_CLI_COMMAND (cli_set_log_params, static) = {
675   .path = "set logging unthrottle-time",
676   .short_help = "set logging unthrottle-time <int>",
677   .function = set_log_unth_time,
678 };
679 /* *INDENT-ON* */
680
681 static clib_error_t *
682 set_log_size (vlib_main_t * vm,
683               unformat_input_t * input, vlib_cli_command_t * cmd)
684 {
685   unformat_input_t _line_input, *line_input = &_line_input;
686   clib_error_t *rv = NULL;
687   int size;
688   vlib_log_main_t *lm = &log_main;
689
690   /* Get a line of input. */
691   if (!unformat_user (input, unformat_line_input, line_input))
692     return 0;
693
694   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
695     {
696       if (unformat (line_input, "%d", &size))
697         {
698           lm->size = size;
699           vec_validate (lm->entries, lm->size);
700         }
701       else
702         return clib_error_return (0, "unknown input `%U'",
703                                   format_unformat_error, line_input);
704     }
705
706   return rv;
707 }
708
709 /* *INDENT-OFF* */
710 VLIB_CLI_COMMAND (cli_set_log_size, static) = {
711   .path = "set logging size",
712   .short_help = "set logging size <int>",
713   .function = set_log_size,
714 };
715 /* *INDENT-ON* */
716
717 static uword
718 unformat_vlib_log_subclass (unformat_input_t * input, va_list * args)
719 {
720   vlib_log_class_data_t *class = va_arg (*args, vlib_log_class_data_t *);
721   vlib_log_subclass_data_t **subclass =
722     va_arg (*args, vlib_log_subclass_data_t **);
723   uword rv = 0;
724   u8 *subclass_str = NULL;
725   if (unformat (input, "%v", &subclass_str))
726     {
727       vlib_log_subclass_data_t *scdata;
728       vec_foreach (scdata, class->subclasses)
729       {
730         if (vec_is_equal (scdata->name, subclass_str))
731           {
732             rv = 1;
733             *subclass = scdata;
734             break;
735           }
736       }
737     }
738   vec_free (subclass_str);
739   return rv;
740 }
741
742 static clib_error_t *
743 test_log_class_subclass (vlib_main_t * vm,
744                          unformat_input_t * input, vlib_cli_command_t * cmd)
745 {
746   unformat_input_t _line_input, *line_input = &_line_input;
747   /* Get a line of input. */
748   if (!unformat_user (input, unformat_line_input, line_input))
749     return 0;
750
751   vlib_log_class_data_t *class = NULL;
752   vlib_log_subclass_data_t *subclass = NULL;
753   vlib_log_level_t level;
754   if (unformat (line_input, "%U", unformat_vlib_log_level, &level))
755     {
756       if (unformat (line_input, "%U", unformat_vlib_log_class, &class))
757         {
758           if (unformat
759               (line_input, "%U", unformat_vlib_log_subclass, class,
760                &subclass))
761             {
762               vlib_log (level,
763                         (class->index << 16) | (subclass->index), "%U",
764                         format_unformat_input, line_input);
765             }
766           else
767             {
768               return clib_error_return (0,
769                                         "unknown log subclass near beginning of `%U'",
770                                         format_unformat_error, line_input);
771             }
772         }
773       else
774         {
775           return clib_error_return (0,
776                                     "unknown log class near beginning of `%U'",
777                                     format_unformat_error, line_input);
778         }
779     }
780   else
781     {
782       return clib_error_return (0, "unknown log level near beginning of `%U'",
783                                 format_unformat_error, line_input);
784     }
785   return 0;
786 }
787
788 /* *INDENT-OFF* */
789 VLIB_CLI_COMMAND (cli_test_log, static) = {
790   .path = "test log",
791   .short_help = "test log <level> <class> <subclass> <message>",
792   .function = test_log_class_subclass,
793 };
794 /* *INDENT-ON* */
795
796 static clib_error_t *
797 log_config_class (vlib_main_t * vm, char *name, unformat_input_t * input)
798 {
799   vlib_log_main_t *lm = &log_main;
800   vlib_log_class_config_t *cc, tmp;
801   uword *p;
802
803   if (lm->config_index_by_name == 0)
804     lm->config_index_by_name = hash_create_string (0, sizeof (uword));
805
806   p = hash_get_mem (lm->config_index_by_name, name);
807
808   if (p)
809     return clib_error_return (0, "logging class '%s' already configured",
810                               name);
811
812   clib_memset_u8 (&tmp, 0xff, sizeof (vlib_log_class_config_t));
813
814   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
815     {
816       if (unformat (input, "level %U", unformat_vlib_log_level, &tmp.level))
817         ;
818       else if (unformat (input, "syslog-level %U", unformat_vlib_log_level,
819                          &tmp.syslog_level))
820         ;
821       else if (unformat (input, "rate-limit %u", &tmp.rate_limit))
822         ;
823       else
824         return clib_error_return (0, "unknown input '%U'",
825                                   format_unformat_error, input);
826     }
827
828   vec_add2 (lm->configs, cc, 1);
829   clib_memcpy_fast (cc, &tmp, sizeof (vlib_log_class_config_t));
830   cc->name = name;
831   hash_set_mem (lm->config_index_by_name, name, cc - lm->configs);
832   return 0;
833 }
834
835 static clib_error_t *
836 log_config (vlib_main_t * vm, unformat_input_t * input)
837 {
838   vlib_log_main_t *lm = &log_main;
839   unformat_input_t sub_input;
840   u8 *class = 0;
841
842   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
843     {
844       if (unformat (input, "size %d", &lm->size))
845         vec_validate (lm->entries, lm->size);
846       else if (unformat (input, "unthrottle-time %d", &lm->unthrottle_time))
847         ;
848       else if (unformat (input, "default-log-level %U",
849                          unformat_vlib_log_level, &lm->default_log_level))
850         ;
851       else if (unformat (input, "default-syslog-log-level %U",
852                          unformat_vlib_log_level,
853                          &lm->default_syslog_log_level))
854         ;
855       else if (unformat (input, "add-to-elog"))
856         lm->add_to_elog = 1;
857       else if (unformat (input, "class %s %U", &class,
858                          unformat_vlib_cli_sub_input, &sub_input))
859         {
860           clib_error_t *err;
861           err = log_config_class (vm, (char *) class, &sub_input);
862           class = 0;
863           unformat_free (&sub_input);
864           if (err)
865             return err;
866         }
867       else
868         {
869           return unformat_parse_error (input);
870         }
871     }
872
873   return 0;
874 }
875
876 VLIB_EARLY_CONFIG_FUNCTION (log_config, "logging");
877
878 /*
879  * fd.io coding-style-patch-verification: ON
880  *
881  * Local Variables:
882  * eval: (c-set-style "gnu")
883  * End:
884  */