FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
cli.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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  * cli.c: command line interface
17  *
18  * Copyright (c) 2008 Eliot Dresselhaus
19  *
20  * Permission is hereby granted, free of charge, to any person obtaining
21  * a copy of this software and associated documentation files (the
22  * "Software"), to deal in the Software without restriction, including
23  * without limitation the rights to use, copy, modify, merge, publish,
24  * distribute, sublicense, and/or sell copies of the Software, and to
25  * permit persons to whom the Software is furnished to do so, subject to
26  * the following conditions:
27  *
28  * The above copyright notice and this permission notice shall be
29  * included in all copies or substantial portions of the Software.
30  *
31  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38  */
39 
40 #include <vlib/vlib.h>
41 #include <vlib/unix/unix.h>
42 #include <vppinfra/cpu.h>
43 #include <vppinfra/elog.h>
44 #include <unistd.h>
45 #include <ctype.h>
46 
47 /** \file src/vlib/cli.c Debug CLI Implementation
48  */
49 
50 int vl_api_set_elog_trace_api_messages (int enable);
52 
53 static void *current_traced_heap;
54 
55 /* Root of all show commands. */
56 /* *INDENT-OFF* */
57 VLIB_CLI_COMMAND (vlib_cli_show_command, static) = {
58  .path = "show",
59  .short_help = "Show commands",
60 };
61 /* *INDENT-ON* */
62 
63 /* Root of all clear commands. */
64 /* *INDENT-OFF* */
65 VLIB_CLI_COMMAND (vlib_cli_clear_command, static) = {
66  .path = "clear",
67  .short_help = "Clear commands",
68 };
69 /* *INDENT-ON* */
70 
71 /* Root of all set commands. */
72 /* *INDENT-OFF* */
73 VLIB_CLI_COMMAND (vlib_cli_set_command, static) = {
74  .path = "set",
75  .short_help = "Set commands",
76 };
77 /* *INDENT-ON* */
78 
79 /* Root of all test commands. */
80 /* *INDENT-OFF* */
81 VLIB_CLI_COMMAND (vlib_cli_test_command, static) = {
82  .path = "test",
83  .short_help = "Test commands",
84 };
85 /* *INDENT-ON* */
86 
87 /* Returns bitmap of commands which match key. */
88 static uword *
90 {
91  int i, n;
92  uword *match = 0;
94 
96 
97  for (i = 0;; i++)
98  {
99  uword k;
100 
101  k = unformat_get_input (input);
102  switch (k)
103  {
104  case 'a' ... 'z':
105  case 'A' ... 'Z':
106  case '0' ... '9':
107  case '-':
108  case '_':
109  break;
110 
111  case ' ':
112  case '\t':
113  case '\r':
114  case '\n':
116  /* White space or end of input removes any non-white
117  matches that were before possible. */
118  if (i < vec_len (c->sub_command_positions)
119  && clib_bitmap_count_set_bits (match) > 1)
120  {
122  for (n = 0; n < vec_len (p->bitmaps); n++)
123  match = clib_bitmap_andnot (match, p->bitmaps[n]);
124  }
125  goto done;
126 
127  default:
128  unformat_put_input (input);
129  goto done;
130  }
131 
132  if (i >= vec_len (c->sub_command_positions))
133  {
134  no_match:
135  clib_bitmap_free (match);
136  return 0;
137  }
138 
140  if (vec_len (p->bitmaps) == 0)
141  goto no_match;
142 
143  n = k - p->min_char;
144  if (n < 0 || n >= vec_len (p->bitmaps))
145  goto no_match;
146 
147  if (i == 0)
148  match = clib_bitmap_dup (p->bitmaps[n]);
149  else
150  match = clib_bitmap_and (match, p->bitmaps[n]);
151 
152  if (clib_bitmap_is_zero (match))
153  goto no_match;
154  }
155 
156 done:
157  return match;
158 }
159 
160 /* Looks for string based sub-input formatted { SUB-INPUT }. */
161 uword
163 {
164  unformat_input_t *sub_input = va_arg (*args, unformat_input_t *);
165  u8 *s;
166  uword c;
167 
168  while (1)
169  {
170  c = unformat_get_input (i);
171  switch (c)
172  {
173  case ' ':
174  case '\t':
175  case '\n':
176  case '\r':
177  case '\f':
178  break;
179 
180  case '{':
181  default:
182  /* Put back paren. */
183  if (c != UNFORMAT_END_OF_INPUT)
184  unformat_put_input (i);
185 
186  if (c == '{' && unformat (i, "%v", &s))
187  {
188  unformat_init_vector (sub_input, s);
189  return 1;
190  }
191  return 0;
192  }
193  }
194  return 0;
195 }
196 
197 static vlib_cli_command_t *
199 {
201  return vec_elt_at_index (cm->commands, s->index);
202 }
203 
204 static uword
206 {
207  vlib_main_t *vm = va_arg (*args, vlib_main_t *);
208  vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
209  vlib_cli_command_t **result = va_arg (*args, vlib_cli_command_t **);
210  vlib_cli_main_t *cm = &vm->cli_main;
211  uword *match_bitmap, is_unique, index;
212 
213  match_bitmap = vlib_cli_sub_command_match (c, i);
214  is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
215  index = ~0;
216  if (is_unique)
217  {
218  index = clib_bitmap_first_set (match_bitmap);
219  *result = get_sub_command (cm, c, index);
220  }
221  clib_bitmap_free (match_bitmap);
222 
223  return is_unique;
224 }
225 
226 static int
227 vlib_cli_cmp_strings (void *a1, void *a2)
228 {
229  u8 *c1 = *(u8 **) a1;
230  u8 *c2 = *(u8 **) a2;
231 
232  return vec_cmp (c1, c2);
233 }
234 
235 u8 **
237 {
240  vlib_main_t *vm = vlib_get_main ();
241  vlib_cli_main_t *vcm = &vm->cli_main;
242  uword *match_bitmap = 0;
243  uword index, is_unique, help_next_level;
244  u8 **result = 0;
245  unformat_input_t input;
246  unformat_init_vector (&input, vec_dup (str));
247  c = vec_elt_at_index (vcm->commands, 0);
248 
249  /* remove trailing whitespace, except for one of them */
250  while (vec_len (input.buffer) >= 2 &&
251  isspace (input.buffer[vec_len (input.buffer) - 1]) &&
252  isspace (input.buffer[vec_len (input.buffer) - 2]))
253  {
254  vec_del1 (input.buffer, vec_len (input.buffer) - 1);
255  }
256 
257  /* if input is empty, directly return list of root commands */
258  if (vec_len (input.buffer) == 0 ||
259  (vec_len (input.buffer) == 1 && isspace (input.buffer[0])))
260  {
261  vec_foreach (sc, c->sub_commands)
262  {
263  vec_add1 (result, (u8 *) sc->name);
264  }
265  goto done;
266  }
267 
268  /* add a trailing '?' so that vlib_cli_sub_command_match can find
269  * all commands starting with the input string */
270  vec_add1 (input.buffer, '?');
271 
272  while (1)
273  {
274  match_bitmap = vlib_cli_sub_command_match (c, &input);
275  /* no match: return no result */
276  if (match_bitmap == 0)
277  {
278  goto done;
279  }
280  is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
281  /* unique match: try to step one subcommand level further */
282  if (is_unique)
283  {
284  /* stop if no more input */
285  if (input.index >= vec_len (input.buffer) - 1)
286  {
287  break;
288  }
289 
290  index = clib_bitmap_first_set (match_bitmap);
291  c = get_sub_command (vcm, c, index);
292  clib_bitmap_free (match_bitmap);
293  continue;
294  }
295  /* multiple matches: stop here, return all matches */
296  break;
297  }
298 
299  /* remove trailing '?' */
300  vec_del1 (input.buffer, vec_len (input.buffer) - 1);
301 
302  /* if we have a space at the end of input, and a unique match,
303  * autocomplete the next level of subcommands */
304  help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]);
305  /* *INDENT-OFF* */
306  clib_bitmap_foreach(index, match_bitmap, {
307  if (help_next_level && is_unique) {
308  c = get_sub_command (vcm, c, index);
309  vec_foreach (sc, c->sub_commands) {
310  vec_add1 (result, (u8*) sc->name);
311  }
312  goto done; /* break doesn't work in this macro-loop */
313  }
314  sc = &c->sub_commands[index];
315  vec_add1(result, (u8*) sc->name);
316  });
317  /* *INDENT-ON* */
318 
319 done:
320  clib_bitmap_free (match_bitmap);
321  unformat_free (&input);
322 
323  if (result)
325  return result;
326 }
327 
328 static u8 *
329 format_vlib_cli_command_help (u8 * s, va_list * args)
330 {
331  vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
332  int is_long = va_arg (*args, int);
333  if (is_long && c->long_help)
334  s = format (s, "%s", c->long_help);
335  else if (c->short_help)
336  s = format (s, "%s", c->short_help);
337  else
338  s = format (s, "%v commands", c->path);
339  return s;
340 }
341 
342 static u8 *
343 format_vlib_cli_path (u8 * s, va_list * args)
344 {
345  u8 *path = va_arg (*args, u8 *);
346 
347  s = format (s, "%v", path);
348 
349  return s;
350 }
351 
352 static vlib_cli_command_t *
354 {
355  vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index);
357 
358  if (c->function)
359  vec_add1 (subs, c[0]);
360 
361  vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index);
362 
363  return subs;
364 }
365 
366 static int
367 vlib_cli_cmp_rule (void *a1, void *a2)
368 {
369  vlib_cli_sub_rule_t *r1 = a1;
370  vlib_cli_sub_rule_t *r2 = a2;
371 
372  return vec_cmp (r1->name, r2->name);
373 }
374 
375 static int
376 vlib_cli_cmp_command (void *a1, void *a2)
377 {
378  vlib_cli_command_t *c1 = a1;
379  vlib_cli_command_t *c2 = a2;
380 
381  return vec_cmp (c1->path, c2->path);
382 }
383 
384 static clib_error_t *
387  unformat_input_t * input,
388  uword parent_command_index)
389 {
390  vlib_cli_command_t *parent, *c;
391  clib_error_t *error = 0;
392  unformat_input_t sub_input;
393  u8 *string;
394  uword is_main_dispatch = cm == &vm->cli_main;
395 
396  parent = vec_elt_at_index (cm->commands, parent_command_index);
397  if (is_main_dispatch && unformat (input, "help"))
398  {
399  uword help_at_end_of_line, i;
400 
401  help_at_end_of_line =
403  while (1)
404  {
405  c = parent;
406  if (unformat_user
407  (input, unformat_vlib_cli_sub_command, vm, c, &parent))
408  ;
409 
410  else if (!(unformat_check_input (input) == UNFORMAT_END_OF_INPUT))
411  goto unknown;
412 
413  else
414  break;
415  }
416 
417  /* help SUB-COMMAND => long format help.
418  "help" at end of line: show all commands. */
419  if (!help_at_end_of_line)
421  /* is_long */ 1);
422 
423  else if (vec_len (c->sub_commands) == 0)
424  vlib_cli_output (vm, "%v: no sub-commands", c->path);
425 
426  else
427  {
428  vlib_cli_sub_rule_t *sr, *subs = 0;
430 
431  vec_foreach (sc, c->sub_commands)
432  {
433  vec_add2 (subs, sr, 1);
434  sr->name = sc->name;
435  sr->command_index = sc->index;
436  sr->rule_index = ~0;
437  }
438 
440 
441  for (i = 0; i < vec_len (subs); i++)
442  {
444 
445  d = vec_elt_at_index (cm->commands, subs[i].command_index);
447  (vm, " %-30v %U", subs[i].name,
448  format_vlib_cli_command_help, d, /* is_long */ 0);
449  }
450 
451  vec_free (subs);
452  }
453  }
454 
455  else if (is_main_dispatch
456  && (unformat (input, "choices") || unformat (input, "?")))
457  {
458  vlib_cli_command_t *sub, *subs;
459 
460  subs = all_subs (cm, 0, parent_command_index);
462  vec_foreach (sub, subs)
463  vlib_cli_output (vm, " %-40U %U",
465  format_vlib_cli_command_help, sub, /* is_long */ 0);
466  vec_free (subs);
467  }
468 
469  else if (unformat (input, "comment %v", &string))
470  {
471  vec_free (string);
472  }
473 
474  else if (unformat (input, "uncomment %U",
475  unformat_vlib_cli_sub_input, &sub_input))
476  {
477  error =
478  vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
479  parent_command_index);
480  unformat_free (&sub_input);
481  }
482  else if (unformat (input, "leak-check %U",
483  unformat_vlib_cli_sub_input, &sub_input))
484  {
485  u8 *leak_report;
487  {
488  void *oldheap;
490  clib_mem_trace (0);
491  clib_mem_set_heap (oldheap);
493  }
494  clib_mem_trace (1);
495  error =
496  vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
497  parent_command_index);
498  unformat_free (&sub_input);
499 
500  /* Otherwise, the clib_error_t shows up as a leak... */
501  if (error)
502  {
503  vlib_cli_output (vm, "%v", error->what);
504  clib_error_free (error);
505  error = 0;
506  }
507 
509  leak_report = format (0, "%U", format_mheap, clib_mem_get_heap (),
510  1 /* verbose, i.e. print leaks */ );
511  clib_mem_trace (0);
512  vlib_cli_output (vm, "%v", leak_report);
513  vec_free (leak_report);
514  }
515 
516  else
517  if (unformat_user (input, unformat_vlib_cli_sub_command, vm, parent, &c))
518  {
519  unformat_input_t *si;
520  uword has_sub_commands =
521  vec_len (c->sub_commands) + vec_len (c->sub_rules) > 0;
522 
523  si = input;
524  if (unformat_user (input, unformat_vlib_cli_sub_input, &sub_input))
525  si = &sub_input;
526 
527  if (has_sub_commands)
528  error = vlib_cli_dispatch_sub_commands (vm, cm, si, c - cm->commands);
529 
530  if (has_sub_commands && !error)
531  /* Found valid sub-command. */ ;
532 
533  else if (c->function)
534  {
535  clib_error_t *c_error;
536 
537  /* Skip white space for benefit of called function. */
539 
540  if (unformat (si, "?"))
541  {
542  vlib_cli_output (vm, " %-40U %U", format_vlib_cli_path, c->path, format_vlib_cli_command_help, c, /* is_long */
543  0);
544  }
545  else
546  {
548  {
549  /* *INDENT-OFF* */
550  ELOG_TYPE_DECLARE (e) =
551  {
552  .format = "cli-cmd: %s",
553  .format_args = "T4",
554  };
555  /* *INDENT-ON* */
556  struct
557  {
558  u32 c;
559  } *ed;
560  ed = ELOG_DATA (&vm->elog_main, e);
561  ed->c = elog_string (&vm->elog_main, "%v", c->path);
562  }
563 
564  if (!c->is_mp_safe)
566 
567  c->hit_counter++;
568  c_error = c->function (vm, si, c);
569 
570  if (!c->is_mp_safe)
572 
574  {
575  /* *INDENT-OFF* */
576  ELOG_TYPE_DECLARE (e) =
577  {
578  .format = "cli-cmd: %s %s",
579  .format_args = "T4T4",
580  };
581  /* *INDENT-ON* */
582  struct
583  {
584  u32 c, err;
585  } *ed;
586  ed = ELOG_DATA (&vm->elog_main, e);
587  ed->c = elog_string (&vm->elog_main, "%v", c->path);
588  if (c_error)
589  {
590  vec_add1 (c_error->what, 0);
591  ed->err =
592  elog_string (&vm->elog_main, (char *) c_error->what);
593  _vec_len (c_error->what) -= 1;
594  }
595  else
596  ed->err = elog_string (&vm->elog_main, "OK");
597  }
598 
599  if (c_error)
600  {
601  error =
602  clib_error_return (0, "%v: %v", c->path, c_error->what);
603  clib_error_free (c_error);
604  /* Free sub input. */
605  if (si != input)
606  unformat_free (si);
607 
608  return error;
609  }
610  }
611 
612  /* Free any previous error. */
613  clib_error_free (error);
614  }
615 
616  else if (!error)
617  error = clib_error_return (0, "%v: no sub-commands", c->path);
618 
619  /* Free sub input. */
620  if (si != input)
621  unformat_free (si);
622  }
623 
624  else
625  goto unknown;
626 
627  return error;
628 
629 unknown:
630  if (parent->path)
631  return clib_error_return (0, "%v: unknown input `%U'", parent->path,
632  format_unformat_error, input);
633  else
634  return clib_error_return (0, "unknown input `%U'", format_unformat_error,
635  input);
636 }
637 
638 
640  __attribute__ ((weak));
641 
642 void
644 {
645 }
646 
647 /* Process CLI input. */
648 int
650  unformat_input_t * input,
651  vlib_cli_output_function_t * function, uword function_arg)
652 {
654  clib_error_t *error;
655  vlib_cli_output_function_t *save_function;
656  uword save_function_arg;
657  int rv = 0;
658 
659  save_function = cp->output_function;
660  save_function_arg = cp->output_function_arg;
661 
662  cp->output_function = function;
663  cp->output_function_arg = function_arg;
664 
665  do
666  {
667  error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input,
668  /* parent */ 0);
669  }
670  while (!error && !unformat (input, "%U", unformat_eof));
671 
672  if (error)
673  {
674  vlib_cli_output (vm, "%v", error->what);
675  vlib_unix_error_report (vm, error);
676  /* clib_error_return is unfortunately often called with a '0'
677  return code */
678  rv = error->code != 0 ? error->code : -1;
679  clib_error_free (error);
680  }
681 
682  cp->output_function = save_function;
683  cp->output_function_arg = save_function_arg;
684  return rv;
685 }
686 
687 /* Output to current CLI connection. */
688 void
689 vlib_cli_output (vlib_main_t * vm, char *fmt, ...)
690 {
692  va_list va;
693  u8 *s;
694 
695  va_start (va, fmt);
696  s = va_format (0, fmt, &va);
697  va_end (va);
698 
699  /* Terminate with \n if not present. */
700  if (vec_len (s) > 0 && s[vec_len (s) - 1] != '\n')
701  vec_add1 (s, '\n');
702 
703  if ((!cp) || (!cp->output_function))
704  fformat (stdout, "%v", s);
705  else
706  cp->output_function (cp->output_function_arg, s, vec_len (s));
707 
708  vec_free (s);
709 }
710 
711 void *vl_msg_push_heap (void) __attribute__ ((weak));
712 void *
714 {
715  return 0;
716 }
717 
718 void vl_msg_pop_heap (void *oldheap) __attribute__ ((weak));
719 void
720 vl_msg_pop_heap (void *oldheap)
721 {
722 }
723 
724 void *vlib_stats_push_heap (void *) __attribute__ ((weak));
725 void *
726 vlib_stats_push_heap (void *notused)
727 {
728  return 0;
729 }
730 
731 static clib_error_t *
733  unformat_input_t * input, vlib_cli_command_t * cmd)
734 {
735  int verbose __attribute__ ((unused)) = 0;
736  int api_segment = 0, stats_segment = 0, main_heap = 0;
737  clib_error_t *error;
738  u32 index = 0;
740  uword was_enabled;
741 
742 
744  {
745  if (unformat (input, "verbose"))
746  verbose = 1;
747  else if (unformat (input, "api-segment"))
748  api_segment = 1;
749  else if (unformat (input, "stats-segment"))
750  stats_segment = 1;
751  else if (unformat (input, "main-heap"))
752  main_heap = 1;
753  else
754  {
755  error = clib_error_return (0, "unknown input `%U'",
756  format_unformat_error, input);
757  return error;
758  }
759  }
760 
761  if ((api_segment + stats_segment + main_heap) == 0)
762  return clib_error_return
763  (0, "Please supply one of api-segment, stats-segment or main-heap");
764 
765  if (api_segment)
766  {
767  void *oldheap = vl_msg_push_heap ();
768  was_enabled = clib_mem_trace_enable_disable (0);
769  u8 *s_in_svm =
770  format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
771  vl_msg_pop_heap (oldheap);
772  u8 *s = vec_dup (s_in_svm);
773 
774  oldheap = vl_msg_push_heap ();
775  vec_free (s_in_svm);
776  clib_mem_trace_enable_disable (was_enabled);
777  vl_msg_pop_heap (oldheap);
778  vlib_cli_output (vm, "API segment");
779  vlib_cli_output (vm, "%v", s);
780  vec_free (s);
781  }
782  if (stats_segment)
783  {
784  void *oldheap = vlib_stats_push_heap (0);
785  was_enabled = clib_mem_trace_enable_disable (0);
786  u8 *s_in_svm =
787  format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
788  if (oldheap)
789  clib_mem_set_heap (oldheap);
790  u8 *s = vec_dup (s_in_svm);
791 
792  oldheap = vlib_stats_push_heap (0);
793  vec_free (s_in_svm);
794  if (oldheap)
795  {
796  clib_mem_trace_enable_disable (was_enabled);
797  clib_mem_set_heap (oldheap);
798  }
799  vlib_cli_output (vm, "Stats segment");
800  vlib_cli_output (vm, "%v", s);
801  vec_free (s);
802  }
803 
804 #if USE_DLMALLOC == 0
805  /* *INDENT-OFF* */
807  ({
809  vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
810  vlib_worker_threads[index].name);
813  h->vm_alloc_size);
814  vlib_cli_output (vm, " %U\n", format_mheap, clib_per_cpu_mheaps[index],
815  verbose);
816  index++;
817  }));
818  /* *INDENT-ON* */
819 #else
820  {
821  if (main_heap)
822  {
823  /*
824  * Note: the foreach_vlib_main causes allocator traffic,
825  * so shut off tracing before we go there...
826  */
827  was_enabled = clib_mem_trace_enable_disable (0);
828 
829  /* *INDENT-OFF* */
831  ({
832  struct dlmallinfo mi;
833  void *mspace;
834  mspace = clib_per_cpu_mheaps[index];
835 
836  mi = mspace_mallinfo (mspace);
837  vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
838  vlib_worker_threads[index].name);
839  vlib_cli_output (vm, " %U\n", format_page_map,
841  mi.arena);
842  vlib_cli_output (vm, " %U\n", format_mheap,
843  clib_per_cpu_mheaps[index],
844  verbose);
845  index++;
846  }));
847  /* *INDENT-ON* */
848 
849  /* Restore the trace flag */
850  clib_mem_trace_enable_disable (was_enabled);
851  }
852  }
853 #endif /* USE_DLMALLOC */
854  return 0;
855 }
856 
857 /* *INDENT-OFF* */
858 VLIB_CLI_COMMAND (show_memory_usage_command, static) = {
859  .path = "show memory",
860  .short_help = "show memory [api-segment][stats-segment][verbose]",
861  .function = show_memory_usage,
862 };
863 /* *INDENT-ON* */
864 
865 static clib_error_t *
867  vlib_cli_command_t * cmd)
868 {
869 #define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c);
870  _("Model name", "%U", format_cpu_model_name);
871  _("Microarch model (family)", "%U", format_cpu_uarch);
872  _("Flags", "%U", format_cpu_flags);
873  _("Base frequency", "%.2f GHz",
874  ((f64) vm->clib_time.clocks_per_second) * 1e-9);
875 #undef _
876  return 0;
877 }
878 
879 /*?
880  * Displays various information about the CPU.
881  *
882  * @cliexpar
883  * @cliexstart{show cpu}
884  * Model name: Intel(R) Xeon(R) CPU E5-2667 v4 @ 3.20GHz
885  * Microarchitecture: Broadwell (Broadwell-EP/EX)
886  * Flags: sse3 ssse3 sse41 sse42 avx avx2 aes
887  * Base Frequency: 3.20 GHz
888  * @cliexend
889 ?*/
890 /* *INDENT-OFF* */
891 VLIB_CLI_COMMAND (show_cpu_command, static) = {
892  .path = "show cpu",
893  .short_help = "Show cpu information",
894  .function = show_cpu,
895 };
896 /* *INDENT-ON* */
897 
898 static clib_error_t *
900  unformat_input_t * input,
901  vlib_cli_command_t * cmd)
902 {
903  unformat_input_t _line_input, *line_input = &_line_input;
904  int enable = 1;
905  int api_segment = 0;
906  int stats_segment = 0;
907  int main_heap = 0;
908  void *oldheap;
909 
910  if (!unformat_user (input, unformat_line_input, line_input))
911  return 0;
912 
913  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
914  {
915  if (unformat (line_input, "%U", unformat_vlib_enable_disable, &enable))
916  ;
917  else if (unformat (line_input, "api-segment"))
918  api_segment = 1;
919  else if (unformat (line_input, "stats-segment"))
920  stats_segment = 1;
921  else if (unformat (line_input, "main-heap"))
922  main_heap = 1;
923  else
924  {
925  unformat_free (line_input);
926  return clib_error_return (0, "invalid input");
927  }
928  }
929  unformat_free (line_input);
930 
931  if ((api_segment + stats_segment + main_heap + (enable == 0)) == 0)
932  {
933  return clib_error_return
934  (0, "Need one of main-heap, stats-segment or api-segment");
935  }
936 
937  /* Turn off current trace, if any */
939  {
940  void *oldheap;
942  clib_mem_trace (0);
943  clib_mem_set_heap (oldheap);
945  }
946 
947  if (enable == 0)
948  return 0;
949 
950  /* API segment */
951  if (api_segment)
952  {
953  oldheap = vl_msg_push_heap ();
955  clib_mem_trace (1);
956  vl_msg_pop_heap (oldheap);
957 
958  }
959 
960  /* Stats segment */
961  if (stats_segment)
962  {
963  oldheap = vlib_stats_push_heap (0);
965  clib_mem_trace (stats_segment);
966  /* We don't want to call vlib_stats_pop_heap... */
967  if (oldheap)
968  clib_mem_set_heap (oldheap);
969  }
970 
971  /* main_heap */
972  if (main_heap)
973  {
975  clib_mem_trace (main_heap);
976  }
977 
978  return 0;
979 }
980 
981 /* *INDENT-OFF* */
982 VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = {
983  .path = "memory-trace",
984  .short_help = "memory-trace on|off [api-segment][stats-segment][main-heap]\n",
985  .function = enable_disable_memory_trace,
986 };
987 /* *INDENT-ON* */
988 
989 
990 static clib_error_t *
992  vlib_cli_command_t * cmd)
993 {
994 #if USE_DLMALLOC == 0
995  clib_error_t *error = 0;
996  void *heap;
997  mheap_t *mheap;
998 
999  if (unformat (input, "on"))
1000  {
1001  /* *INDENT-OFF* */
1003  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1004  mheap = mheap_header(heap);
1005  mheap->flags |= MHEAP_FLAG_VALIDATE;
1006  // Turn off small object cache because it delays detection of errors
1008  });
1009  /* *INDENT-ON* */
1010 
1011  }
1012  else if (unformat (input, "off"))
1013  {
1014  /* *INDENT-OFF* */
1016  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1017  mheap = mheap_header(heap);
1018  mheap->flags &= ~MHEAP_FLAG_VALIDATE;
1020  });
1021  /* *INDENT-ON* */
1022  }
1023  else if (unformat (input, "now"))
1024  {
1025  /* *INDENT-OFF* */
1027  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1028  mheap = mheap_header(heap);
1029  mheap_validate(heap);
1030  });
1031  /* *INDENT-ON* */
1032  vlib_cli_output (vm, "heap validation complete");
1033 
1034  }
1035  else
1036  {
1037  return clib_error_return (0, "unknown input `%U'",
1038  format_unformat_error, input);
1039  }
1040 
1041  return error;
1042 #else
1043  return clib_error_return (0, "unimplemented...");
1044 #endif /* USE_DLMALLOC */
1045 }
1046 
1047 /* *INDENT-OFF* */
1048 VLIB_CLI_COMMAND (cmd_test_heap_validate,static) = {
1049  .path = "test heap-validate",
1050  .short_help = "<on/off/now> validate heap on future allocs/frees or right now",
1051  .function = test_heap_validate,
1052 };
1053 /* *INDENT-ON* */
1054 
1055 static clib_error_t *
1057  vlib_cli_command_t * cmd)
1058 {
1060  clib_file_t *f;
1061 
1062  /* environ(7) does not indicate a header for this */
1063  extern char **environ;
1064 
1065  /* Close all known open files */
1066  /* *INDENT-OFF* */
1067  pool_foreach(f, fm->file_pool,
1068  ({
1069  if (f->file_descriptor > 2)
1070  close(f->file_descriptor);
1071  }));
1072  /* *INDENT-ON* */
1073 
1074  /* Exec ourself */
1075  execve (vm->name, (char **) vm->argv, environ);
1076 
1077  return 0;
1078 }
1079 
1080 /* *INDENT-OFF* */
1081 VLIB_CLI_COMMAND (restart_cmd,static) = {
1082  .path = "restart",
1083  .short_help = "restart process",
1084  .function = restart_cmd_fn,
1085 };
1086 /* *INDENT-ON* */
1087 
1088 #ifdef TEST_CODE
1089 /*
1090  * A trivial test harness to verify the per-process output_function
1091  * is working correcty.
1092  */
1093 
1094 static clib_error_t *
1095 sleep_ten_seconds (vlib_main_t * vm,
1096  unformat_input_t * input, vlib_cli_command_t * cmd)
1097 {
1098  u16 i;
1099  u16 my_id = rand ();
1100 
1101  vlib_cli_output (vm, "Starting 10 seconds sleep with id %u\n", my_id);
1102 
1103  for (i = 0; i < 10; i++)
1104  {
1106  vlib_cli_output (vm, "Iteration number %u, my id: %u\n", i, my_id);
1107  }
1108  vlib_cli_output (vm, "Done with sleep with id %u\n", my_id);
1109  return 0;
1110 }
1111 
1112 /* *INDENT-OFF* */
1113 VLIB_CLI_COMMAND (ping_command, static) = {
1114  .path = "test sleep",
1115  .function = sleep_ten_seconds,
1116  .short_help = "Sleep for 10 seconds",
1117 };
1118 /* *INDENT-ON* */
1119 #endif /* ifdef TEST_CODE */
1120 
1121 static uword
1122 vlib_cli_normalize_path (char *input, char **result)
1123 {
1124  char *i = input;
1125  char *s = 0;
1126  uword l = 0;
1127  uword index_of_last_space = ~0;
1128 
1129  while (*i != 0)
1130  {
1131  u8 c = *i++;
1132  /* Multiple white space -> single space. */
1133  switch (c)
1134  {
1135  case ' ':
1136  case '\t':
1137  case '\n':
1138  case '\r':
1139  if (l > 0 && s[l - 1] != ' ')
1140  {
1141  vec_add1 (s, ' ');
1142  l++;
1143  }
1144  break;
1145 
1146  default:
1147  if (l > 0 && s[l - 1] == ' ')
1148  index_of_last_space = vec_len (s);
1149  vec_add1 (s, c);
1150  l++;
1151  break;
1152  }
1153  }
1154 
1155  /* Remove any extra space at end. */
1156  if (l > 0 && s[l - 1] == ' ')
1157  _vec_len (s) -= 1;
1158 
1159  *result = s;
1160  return index_of_last_space;
1161 }
1162 
1165 {
1166  word i;
1167  for (i = vec_len (path) - 1; i >= 0; i--)
1168  {
1169  if (path[i] == ' ')
1170  return i;
1171  }
1172  return ~0;
1173 }
1174 
1175 static void
1176 add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
1177 {
1178  vlib_cli_command_t *p, *c;
1179  vlib_cli_sub_command_t *sub_c;
1180  u8 *sub_name;
1181  word i, l;
1182 
1183  p = vec_elt_at_index (cm->commands, parent_index);
1184  c = vec_elt_at_index (cm->commands, child_index);
1185 
1186  l = parent_path_len (c->path);
1187  if (l == ~0)
1188  sub_name = vec_dup ((u8 *) c->path);
1189  else
1190  {
1191  ASSERT (l + 1 < vec_len (c->path));
1192  sub_name = 0;
1193  vec_add (sub_name, c->path + l + 1, vec_len (c->path) - (l + 1));
1194  }
1195 
1196  if (sub_name[0] == '%')
1197  {
1198  uword *q;
1199  vlib_cli_sub_rule_t *sr;
1200 
1201  /* Remove %. */
1202  vec_delete (sub_name, 1, 0);
1203 
1204  if (!p->sub_rule_index_by_name)
1205  p->sub_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1206  sizeof (sub_name[0]),
1207  sizeof (uword));
1208  q = hash_get_mem (p->sub_rule_index_by_name, sub_name);
1209  if (q)
1210  {
1211  sr = vec_elt_at_index (p->sub_rules, q[0]);
1212  ASSERT (sr->command_index == child_index);
1213  return;
1214  }
1215 
1216  hash_set_mem (p->sub_rule_index_by_name, sub_name,
1217  vec_len (p->sub_rules));
1218  vec_add2 (p->sub_rules, sr, 1);
1219  sr->name = sub_name;
1220  sr->rule_index = sr - p->sub_rules;
1221  sr->command_index = child_index;
1222  return;
1223  }
1224 
1225  if (!p->sub_command_index_by_name)
1226  p->sub_command_index_by_name = hash_create_vec ( /* initial length */ 32,
1227  sizeof (c->path[0]),
1228  sizeof (uword));
1229 
1230  /* Check if sub-command has already been created. */
1231  if (hash_get_mem (p->sub_command_index_by_name, sub_name))
1232  {
1233  vec_free (sub_name);
1234  return;
1235  }
1236 
1237  vec_add2 (p->sub_commands, sub_c, 1);
1238  sub_c->index = child_index;
1239  sub_c->name = sub_name;
1241  sub_c - p->sub_commands);
1242 
1243  vec_validate (p->sub_command_positions, vec_len (sub_c->name) - 1);
1244  for (i = 0; i < vec_len (sub_c->name); i++)
1245  {
1246  int n;
1248 
1250 
1251  if (!pos->bitmaps)
1252  pos->min_char = sub_c->name[i];
1253 
1254  n = sub_c->name[i] - pos->min_char;
1255  if (n < 0)
1256  {
1257  pos->min_char = sub_c->name[i];
1258  vec_insert (pos->bitmaps, -n, 0);
1259  n = 0;
1260  }
1261 
1262  vec_validate (pos->bitmaps, n);
1263  pos->bitmaps[n] =
1264  clib_bitmap_ori (pos->bitmaps[n], sub_c - p->sub_commands);
1265  }
1266 }
1267 
1268 static void
1270 {
1271  uword p_len, pi, *p;
1272  char *p_path;
1273  vlib_cli_command_t *c, *parent;
1274 
1275  /* Root command (index 0) should have already been added. */
1276  ASSERT (vec_len (cm->commands) > 0);
1277 
1278  c = vec_elt_at_index (cm->commands, ci);
1279  p_len = parent_path_len (c->path);
1280 
1281  /* No space? Parent is root command. */
1282  if (p_len == ~0)
1283  {
1284  add_sub_command (cm, 0, ci);
1285  return;
1286  }
1287 
1288  p_path = 0;
1289  vec_add (p_path, c->path, p_len);
1290 
1291  p = hash_get_mem (cm->command_index_by_path, p_path);
1292 
1293  /* Parent exists? */
1294  if (!p)
1295  {
1296  /* Parent does not exist; create it. */
1297  vec_add2 (cm->commands, parent, 1);
1298  parent->path = p_path;
1299  hash_set_mem (cm->command_index_by_path, parent->path,
1300  parent - cm->commands);
1301  pi = parent - cm->commands;
1302  }
1303  else
1304  {
1305  pi = p[0];
1306  vec_free (p_path);
1307  }
1308 
1309  add_sub_command (cm, pi, ci);
1310 
1311  /* Create parent's parent. */
1312  if (!p)
1313  vlib_cli_make_parent (cm, pi);
1314 }
1315 
1318 {
1319  return (c->long_help == 0 && c->short_help == 0 && c->function == 0);
1320 }
1321 
1322 clib_error_t *
1324 {
1325  vlib_cli_main_t *cm = &vm->cli_main;
1326  clib_error_t *error = 0;
1327  uword ci, *p;
1328  char *normalized_path;
1329 
1330  if ((error = vlib_call_init_function (vm, vlib_cli_init)))
1331  return error;
1332 
1333  (void) vlib_cli_normalize_path (c->path, &normalized_path);
1334 
1335  if (!cm->command_index_by_path)
1336  cm->command_index_by_path = hash_create_vec ( /* initial length */ 32,
1337  sizeof (c->path[0]),
1338  sizeof (uword));
1339 
1340  /* See if command already exists with given path. */
1341  p = hash_get_mem (cm->command_index_by_path, normalized_path);
1342  if (p)
1343  {
1344  vlib_cli_command_t *d;
1345 
1346  ci = p[0];
1347  d = vec_elt_at_index (cm->commands, ci);
1348 
1349  /* If existing command was created via vlib_cli_make_parent
1350  replaced it with callers data. */
1351  if (vlib_cli_command_is_empty (d))
1352  {
1353  vlib_cli_command_t save = d[0];
1354 
1356 
1357  /* Copy callers fields. */
1358  d[0] = c[0];
1359 
1360  /* Save internal fields. */
1361  d->path = save.path;
1362  d->sub_commands = save.sub_commands;
1365  d->sub_rules = save.sub_rules;
1366  }
1367  else
1368  error =
1369  clib_error_return (0, "duplicate command name with path %v",
1370  normalized_path);
1371 
1372  vec_free (normalized_path);
1373  if (error)
1374  return error;
1375  }
1376  else
1377  {
1378  /* Command does not exist: create it. */
1379 
1380  /* Add root command (index 0). */
1381  if (vec_len (cm->commands) == 0)
1382  {
1383  /* Create command with index 0; path is empty string. */
1384  vec_resize (cm->commands, 1);
1385  }
1386 
1387  ci = vec_len (cm->commands);
1388  hash_set_mem (cm->command_index_by_path, normalized_path, ci);
1389  vec_add1 (cm->commands, c[0]);
1390 
1391  c = vec_elt_at_index (cm->commands, ci);
1392  c->path = normalized_path;
1393 
1394  /* Don't inherit from registration. */
1395  c->sub_commands = 0;
1397  c->sub_command_positions = 0;
1398  }
1399 
1400  vlib_cli_make_parent (cm, ci);
1401  return 0;
1402 }
1403 
1404 #if 0
1405 /* $$$ turn back on again someday, maybe */
1406 clib_error_t *
1408 {
1409  vlib_cli_main_t *cm = &vm->cli_main;
1411  clib_error_t *error = 0;
1412  u8 *r_name;
1413  uword *p;
1414 
1415  if (!cm->parse_rule_index_by_name)
1416  cm->parse_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1417  sizeof (r->name[0]),
1418  sizeof (uword));
1419 
1420  /* Make vector copy of name. */
1421  r_name = format (0, "%s", r_reg->name);
1422 
1423  if ((p = hash_get_mem (cm->parse_rule_index_by_name, r_name)))
1424  {
1425  vec_free (r_name);
1426  return clib_error_return (0, "duplicate parse rule name `%s'",
1427  r_reg->name);
1428  }
1429 
1430  vec_add2 (cm->parse_rules, r, 1);
1431  r[0] = r_reg[0];
1432  r->name = (char *) r_name;
1433  hash_set_mem (cm->parse_rule_index_by_name, r->name, r - cm->parse_rules);
1434 
1435  return error;
1436 }
1437 
1438 static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm,
1440  lo,
1442  hi)
1443  __attribute__ ((unused))
1444 {
1445  clib_error_t *error = 0;
1447 
1448  for (r = lo; r < hi; r = clib_elf_section_data_next (r, 0))
1449  {
1450  if (!r->name || strlen (r->name) == 0)
1451  {
1452  error = clib_error_return (0, "parse rule with no name");
1453  goto done;
1454  }
1455 
1456  error = vlib_cli_register_parse_rule (vm, r);
1457  if (error)
1458  goto done;
1459  }
1460 
1461 done:
1462  return error;
1463 }
1464 #endif
1465 
1466 static clib_error_t *
1468  unformat_input_t * input, vlib_cli_command_t * cmd)
1469 {
1470  unformat_input_t _line_input, *line_input = &_line_input;
1471  int enable = 1;
1472  int api = 0, cli = 0, barrier = 0, dispatch = 0, circuit = 0;
1473  u32 circuit_node_index;
1474 
1475  if (!unformat_user (input, unformat_line_input, line_input))
1476  goto print_status;
1477 
1478  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1479  {
1480  if (unformat (line_input, "api"))
1481  api = 1;
1482  else if (unformat (line_input, "dispatch"))
1483  dispatch = 1;
1484  else if (unformat (line_input, "circuit-node %U",
1485  unformat_vlib_node, vm, &circuit_node_index))
1486  circuit = 1;
1487  else if (unformat (line_input, "cli"))
1488  cli = 1;
1489  else if (unformat (line_input, "barrier"))
1490  barrier = 1;
1491  else if (unformat (line_input, "disable"))
1492  enable = 0;
1493  else if (unformat (line_input, "enable"))
1494  enable = 1;
1495  else
1496  break;
1497  }
1498  unformat_free (line_input);
1499 
1501  (api ? enable : vl_api_get_elog_trace_api_messages ());
1502  vm->elog_trace_cli_commands = cli ? enable : vm->elog_trace_cli_commands;
1503  vm->elog_trace_graph_dispatch = dispatch ?
1504  enable : vm->elog_trace_graph_dispatch;
1505  vm->elog_trace_graph_circuit = circuit ?
1506  enable : vm->elog_trace_graph_circuit;
1508  barrier ? enable : vlib_worker_threads->barrier_elog_enabled;
1509  vm->elog_trace_graph_circuit_node_index = circuit_node_index;
1510 
1511  /*
1512  * Set up start-of-buffer logic-analyzer trigger
1513  * for main loop event logs, which are fairly heavyweight.
1514  * See src/vlib/main/vlib_elog_main_loop_event(...), which
1515  * will fully disable the scheme when the elog buffer fills.
1516  */
1517  if (dispatch || circuit)
1518  {
1519  elog_main_t *em = &vm->elog_main;
1520 
1522  em->n_total_events + vec_len (em->event_ring);
1523  }
1524 
1525 
1526 print_status:
1527  vlib_cli_output (vm, "Current status:");
1528 
1530  (vm, " Event log API message trace: %s\n CLI command trace: %s",
1531  vl_api_get_elog_trace_api_messages ()? "on" : "off",
1532  vm->elog_trace_cli_commands ? "on" : "off");
1534  (vm, " Barrier sync trace: %s",
1535  vlib_worker_threads->barrier_elog_enabled ? "on" : "off");
1537  (vm, " Graph Dispatch: %s",
1538  vm->elog_trace_graph_dispatch ? "on" : "off");
1540  (vm, " Graph Circuit: %s",
1541  vm->elog_trace_graph_circuit ? "on" : "off");
1542  if (vm->elog_trace_graph_circuit)
1544  (vm, " node %U",
1546 
1547  return 0;
1548 }
1549 
1550 /*?
1551  * Control event logging of api, cli, and thread barrier events
1552  * With no arguments, displays the current trace status.
1553  * Name the event groups you wish to trace or stop tracing.
1554  *
1555  * @cliexpar
1556  * @clistart
1557  * elog trace api cli barrier
1558  * elog trace api cli barrier disable
1559  * elog trace dispatch
1560  * elog trace circuit-node ethernet-input
1561  * elog trace
1562  * @cliend
1563  * @cliexcmd{elog trace [api][cli][barrier][disable]}
1564 ?*/
1565 /* *INDENT-OFF* */
1566 VLIB_CLI_COMMAND (elog_trace_command, static) =
1567 {
1568  .path = "elog trace",
1569  .short_help = "elog trace [api][cli][barrier][dispatch]\n"
1570  "[circuit-node <name> e.g. ethernet-input][disable]",
1571  .function = elog_trace_command_fn,
1572 };
1573 /* *INDENT-ON* */
1574 
1575 static clib_error_t *
1577  unformat_input_t * input, vlib_cli_command_t * cmd)
1578 {
1579  vlib_process_suspend (vm, 30e-3);
1580  return 0;
1581 }
1582 
1583 /* *INDENT-OFF* */
1584 VLIB_CLI_COMMAND (suspend_command, static) =
1585 {
1586  .path = "suspend",
1587  .short_help = "suspend debug CLI for 30ms",
1588  .function = suspend_command_fn,
1589  .is_mp_safe = 1,
1590 };
1591 /* *INDENT-ON* */
1592 
1593 
1594 static int
1595 sort_cmds_by_path (void *a1, void *a2)
1596 {
1597  u32 *index1 = a1;
1598  u32 *index2 = a2;
1599  vlib_main_t *vm = vlib_get_main ();
1600  vlib_cli_main_t *cm = &vm->cli_main;
1601  vlib_cli_command_t *c1, *c2;
1602  int i, lmin;
1603 
1604  c1 = vec_elt_at_index (cm->commands, *index1);
1605  c2 = vec_elt_at_index (cm->commands, *index2);
1606 
1607  lmin = vec_len (c1->path);
1608  lmin = (vec_len (c2->path) >= lmin) ? lmin : vec_len (c2->path);
1609 
1610  for (i = 0; i < lmin; i++)
1611  {
1612  if (c1->path[i] < c2->path[i])
1613  return -1;
1614  else if (c1->path[i] > c2->path[i])
1615  return 1;
1616  }
1617 
1618  return 0;
1619 }
1620 
1621 typedef struct
1622 {
1630 
1631 static void
1633 {
1634  vlib_cli_command_t *parent;
1636  vlib_cli_walk_args_t _a, *a = &_a;
1638  int i;
1639 
1640  /* Copy args into this stack frame */
1641  *a = *aa;
1642  cm = a->cm;
1643 
1644  parent = vec_elt_at_index (cm->commands, a->parent_command_index);
1645 
1646  if (parent->function)
1647  {
1648  if (((a->show_mp_safe && parent->is_mp_safe)
1649  || (a->show_not_mp_safe && !parent->is_mp_safe))
1650  && (a->show_hit == 0 || parent->hit_counter))
1651  {
1653  }
1654 
1655  if (a->clear_hit)
1656  parent->hit_counter = 0;
1657  }
1658 
1659  for (i = 0; i < vec_len (parent->sub_commands); i++)
1660  {
1661  sub = vec_elt_at_index (parent->sub_commands, i);
1662  a->parent_command_index = sub->index;
1663  cli_recursive_walk (a);
1664  }
1665 }
1666 
1667 static u8 *
1668 format_mp_safe (u8 * s, va_list * args)
1669 {
1670  vlib_cli_main_t *cm = va_arg (*args, vlib_cli_main_t *);
1671  int show_mp_safe = va_arg (*args, int);
1672  int show_not_mp_safe = va_arg (*args, int);
1673  int show_hit = va_arg (*args, int);
1674  int clear_hit = va_arg (*args, int);
1676  vlib_cli_walk_args_t _a, *a = &_a;
1677  int i;
1678  char *format_string = "\n%v";
1679 
1680  if (show_hit)
1681  format_string = "\n%v: %u";
1682 
1684 
1685  a->cm = cm;
1686  a->parent_command_index = 0;
1687  a->show_mp_safe = show_mp_safe;
1688  a->show_not_mp_safe = show_not_mp_safe;
1689  a->show_hit = show_hit;
1690  a->clear_hit = clear_hit;
1691 
1692  cli_recursive_walk (a);
1693 
1695 
1696  for (i = 0; i < vec_len (cm->sort_vector); i++)
1697  {
1698  c = vec_elt_at_index (cm->commands, cm->sort_vector[i]);
1699  s = format (s, format_string, c->path, c->hit_counter);
1700  }
1701 
1702  return s;
1703 }
1704 
1705 
1706 static clib_error_t *
1708  unformat_input_t * input, vlib_cli_command_t * cmd)
1709 {
1710  int show_mp_safe = 0;
1711  int show_not_mp_safe = 0;
1712  int show_hit = 0;
1713  int clear_hit = 0;
1714 
1715  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1716  {
1717  if (unformat (input, "mp-safe"))
1718  show_mp_safe = 1;
1719  if (unformat (input, "not-mp-safe"))
1720  show_not_mp_safe = 1;
1721  else if (unformat (input, "hit"))
1722  show_hit = 1;
1723  else if (unformat (input, "clear-hit"))
1724  clear_hit = 1;
1725  else
1726  break;
1727  }
1728 
1729  /* default set: all cli commands */
1730  if (clear_hit == 0 && (show_mp_safe + show_not_mp_safe) == 0)
1731  show_mp_safe = show_not_mp_safe = 1;
1732 
1733  vlib_cli_output (vm, "%U", format_mp_safe, &vm->cli_main,
1734  show_mp_safe, show_not_mp_safe, show_hit, clear_hit);
1735  if (clear_hit)
1736  vlib_cli_output (vm, "hit counters cleared...");
1737 
1738  return 0;
1739 }
1740 
1741 /*?
1742  * Displays debug cli command information
1743  *
1744  * @cliexpar
1745  * @cliexstart{show cli [mp-safe][not-mp-safe][hit][clear-hit]}
1746  *
1747  * "show cli" displays the entire debug cli:
1748  *
1749  * abf attach
1750  * abf policy
1751  * adjacency counters
1752  * api trace
1753  * app ns
1754  * bfd key del
1755  * ... and so on ...
1756  *
1757  * "show cli mp-safe" displays mp-safe debug CLI commands:
1758  *
1759  * abf policy
1760  * binary-api
1761  * create vhost-user
1762  * exec
1763  * ip container
1764  * ip mroute
1765  * ip probe-neighbor
1766  * ip route
1767  * ip scan-neighbor
1768  * ip table
1769  * ip6 table
1770  *
1771  * "show cli not-mp-safe" displays debug CLI commands
1772  * which cause worker thread barrier synchronization
1773  *
1774  * "show cli hit" displays commands which have been executed. Qualify
1775  * as desired with "mp-safe" or "not-mp-safe".
1776  *
1777  * "show cli clear-hit" clears the per-command hit counters.
1778  * @cliexend
1779 ?*/
1780 
1781 /* *INDENT-OFF* */
1782 VLIB_CLI_COMMAND (show_cli_command, static) =
1783 {
1784  .path = "show cli",
1785  .short_help = "show cli [mp-safe][not-mp-safe][hit][clear-hit]",
1786  .function = show_cli_command_fn,
1787  .is_mp_safe = 1,
1788 };
1789 /* *INDENT-ON* */
1790 
1791 static clib_error_t *
1793 {
1794  vlib_cli_main_t *cm = &vm->cli_main;
1795  clib_error_t *error = 0;
1796  vlib_cli_command_t *cmd;
1797 
1798  cmd = cm->cli_command_registrations;
1799 
1800  while (cmd)
1801  {
1802  error = vlib_cli_register (vm, cmd);
1803  if (error)
1804  return error;
1805  cmd = cmd->next_cli_command;
1806  }
1807  return error;
1808 }
1809 
1811 
1812 /*
1813  * fd.io coding-style-patch-verification: ON
1814  *
1815  * Local Variables:
1816  * eval: (c-set-style "gnu")
1817  * End:
1818  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:440
uword output_function_arg
Definition: node.h:612
void * vlib_stats_push_heap(void *)
Definition: cli.c:726
void * clib_per_cpu_mheaps[CLIB_MAX_MHEAPS]
Definition: mem_dlmalloc.c:24
static clib_error_t * show_cpu(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:866
void * mspace
Definition: dlmalloc.h:1306
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:673
format_function_t format_vlib_node_name
Definition: node_funcs.h:1141
a
Definition: bitmap.h:538
uword vm_alloc_offset_from_header
unformat_function_t unformat_eof
Definition: format.h:293
static clib_error_t * show_cli_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1707
static uword unformat_get_input(unformat_input_t *input)
Definition: format.h:192
int elog_trace_cli_commands
Definition: main.h:197
u32 parent_command_index
Definition: cli.c:1624
vlib_cli_command_t * commands
Definition: cli.h:138
f64 clocks_per_second
Definition: time.h:53
format_function_t format_cpu_flags
Definition: cpu.h:391
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:561
int i
static uword parent_path_len(char *path)
Definition: cli.c:1164
static mheap_t * mheap_header(u8 *v)
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
uword * sub_rule_index_by_name
Definition: cli.h:121
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u8 * va_format(u8 *s, const char *fmt, va_list *va)
Definition: format.c:387
clib_time_t clib_time
Definition: main.h:87
vl_api_fib_path_t path
Definition: mfib_types.api:34
DLMALLOC_EXPORT struct dlmallinfo mspace_mallinfo(mspace msp)
vlib_cli_main_t cli_main
Definition: main.h:161
static vlib_cli_command_t * all_subs(vlib_cli_main_t *cm, vlib_cli_command_t *subs, u32 command_index)
Definition: cli.c:353
unsigned char u8
Definition: types.h:56
#define clib_bitmap_dup(v)
Duplicate a bitmap.
Definition: bitmap.h:87
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:204
clib_error_t * vlib_cli_register_parse_rule(struct vlib_main_t *vm, vlib_cli_parse_rule_t *c)
#define fm
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:599
clib_file_t * file_pool
Definition: file.h:88
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:422
static clib_error_t * test_heap_validate(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:991
i64 word
Definition: types.h:111
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
MALLINFO_FIELD_TYPE arena
Definition: dlmalloc.h:800
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
static uword clib_bitmap_is_zero(uword *ai)
predicate function; is an entire bitmap empty?
Definition: bitmap.h:57
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
u8 * format_page_map(u8 *s, va_list *args)
Definition: unix-formats.c:969
#define clib_error_return(e, args...)
Definition: error.h:99
void * vl_msg_push_heap(void)
Definition: cli.c:713
uword * command_index_by_path
Definition: cli.h:141
clib_file_main_t file_main
Definition: main.c:63
u32 command_index
Definition: cli.h:68
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:243
unsigned int u32
Definition: types.h:88
#define vlib_call_init_function(vm, x)
Definition: init.h:270
static void add_sub_command(vlib_cli_main_t *cm, uword parent_index, uword child_index)
Definition: cli.c:1176
static uword unformat_vlib_cli_sub_command(unformat_input_t *i, va_list *args)
Definition: cli.c:205
static int vlib_cli_cmp_strings(void *a1, void *a2)
Definition: cli.c:227
uword clib_mem_trace_enable_disable(uword enable)
Definition: mem_dlmalloc.c:444
static int vlib_cli_cmp_rule(void *a1, void *a2)
Definition: cli.c:367
unformat_function_t unformat_line_input
Definition: format.h:283
u8 * format_mheap(u8 *s, va_list *va)
Definition: mem_dlmalloc.c:357
char * name
Definition: main.h:140
vnet_crypto_main_t * cm
Definition: quic_crypto.c:41
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:37
static clib_error_t * enable_disable_memory_trace(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:899
#define clib_bitmap_foreach(i, ai, body)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
static vlib_cli_command_t * get_sub_command(vlib_cli_main_t *cm, vlib_cli_command_t *parent, u32 si)
Definition: cli.c:198
#define vec_insert(V, N, M)
Insert N vector elements starting at element M, initialize new elements to zero (no header...
Definition: vec.h:686
vlib_cli_command_function_t * function
Definition: cli.h:102
static uword clib_bitmap_first_set(uword *ai)
Return the lowest numbered set bit in a bitmap.
Definition: bitmap.h:385
static clib_error_t * elog_trace_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1467
u8 ** vlib_cli_get_possible_completions(u8 *str)
Definition: cli.c:236
vlib_cli_sub_rule_t * sub_rules
Definition: cli.h:124
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:376
#define ELOG_DATA(em, f)
Definition: elog.h:484
elog_event_t * event_ring
Vector of events (circular buffer).
Definition: elog.h:149
#define PREDICT_FALSE(x)
Definition: clib.h:111
#define always_inline
Definition: ipsec.h:28
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:806
static void unformat_put_input(unformat_input_t *input)
Definition: format.h:205
void vl_msg_pop_heap(void *oldheap)
Definition: cli.c:720
static clib_error_t * vlib_cli_dispatch_sub_commands(vlib_main_t *vm, vlib_cli_main_t *cm, unformat_input_t *input, uword parent_command_index)
Definition: cli.c:385
#define foreach_vlib_main(body)
Definition: threads.h:241
word fformat(FILE *f, char *fmt,...)
Definition: format.c:462
void unformat_init_vector(unformat_input_t *input, u8 *vector_string)
Definition: unformat.c:1037
The fine-grained event logger allows lightweight, thread-safe event logging at minimum cost...
vlib_cli_sub_command_t * sub_commands
Definition: cli.h:111
u8 ** argv
Definition: main.h:234
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
svmdb_client_t * c
static vlib_process_t * vlib_get_current_process(vlib_main_t *vm)
Definition: node_funcs.h:391
static u8 * format_mp_safe(u8 *s, va_list *args)
Definition: cli.c:1668
int elog_trace_graph_dispatch
Definition: main.h:198
int show_not_mp_safe
Definition: cli.c:1626
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
static void * clib_mem_set_heap(void *heap)
Definition: mem.h:283
static uword * clib_bitmap_andnot(uword *ai, uword *bi)
Logical operator across two bitmaps.
int vl_api_get_elog_trace_api_messages(void)
Definition: api_shared.c:1163
elog_main_t elog_main
Definition: main.h:193
static void cli_recursive_walk(vlib_cli_walk_args_t *aa)
Definition: cli.c:1632
uword ** bitmaps
Definition: cli.h:52
#define ELOG_TYPE_DECLARE(f)
Definition: elog.h:442
static u8 * format_vlib_cli_command_help(u8 *s, va_list *args)
Definition: cli.c:329
u32 n_total_events_disable_limit
When count reaches limit logging is disabled.
Definition: elog.h:139
static uword * vlib_cli_sub_command_match(vlib_cli_command_t *c, unformat_input_t *input)
Definition: cli.c:89
string name[64]
Definition: ip.api:44
static uword vlib_cli_command_is_empty(vlib_cli_command_t *c)
Definition: cli.c:1317
static void * clib_mem_get_heap(void)
Definition: mem.h:277
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:152
static int vlib_cli_cmp_command(void *a1, void *a2)
Definition: cli.c:376
#define clib_elf_section_data_next(a, extra)
Definition: elf_clib.h:57
static void vlib_cli_make_parent(vlib_cli_main_t *cm, uword ci)
Definition: cli.c:1269
#define ASSERT(truth)
static clib_error_t * vlib_cli_init(vlib_main_t *vm)
Definition: cli.c:1792
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:785
u32 hit_counter
Definition: cli.h:130
uword vm_alloc_size
char * long_help
Definition: cli.h:99
import vnet interface_types api
Definition: sample.api:20
uword is_mp_safe
Definition: cli.h:108
#define MHEAP_FLAG_VALIDATE
char * path
Definition: cli.h:95
#define clib_bitmap_free(v)
Free a bitmap.
Definition: bitmap.h:92
int vl_api_set_elog_trace_api_messages(int enable)
Definition: api_shared.c:1152
uword * sub_command_index_by_name
Definition: cli.h:114
u32 elog_trace_graph_circuit_node_index
Definition: main.h:200
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:922
int vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
Definition: cli.c:649
static uword pointer_to_uword(const void *p)
Definition: types.h:131
static clib_error_t * show_memory_usage(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:732
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
vl_api_ip4_address_t hi
Definition: arp.api:37
#define MHEAP_FLAG_SMALL_OBJECT_CACHE
static uword clib_bitmap_count_set_bits(uword *ai)
Return the number of set bits in a bitmap.
Definition: bitmap.h:462
static int sort_cmds_by_path(void *a1, void *a2)
Definition: cli.c:1595
struct vlib_cli_command_t * next_cli_command
Definition: cli.h:127
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:668
static void * current_traced_heap
Definition: cli.c:53
u32 elog_string(elog_main_t *em, char *fmt,...)
add a string to the event-log string table
Definition: elog.c:562
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
uword unformat_vlib_enable_disable(unformat_input_t *input, va_list *args)
Definition: format.c:116
uword unformat_vlib_cli_sub_input(unformat_input_t *i, va_list *args)
Definition: cli.c:162
u64 uword
Definition: types.h:112
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:983
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
format_function_t format_cpu_uarch
Definition: cpu.h:389
#define clib_error_free(e)
Definition: error.h:86
static clib_error_t * suspend_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1576
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1147
#define hash_get_mem(h, key)
Definition: hash.h:269
clib_error_t * vlib_cli_register(vlib_main_t *vm, vlib_cli_command_t *c)
Definition: cli.c:1323
vlib_cli_command_t * cli_command_registrations
Definition: cli.h:144
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
void vlib_unix_error_report(vlib_main_t *, clib_error_t *)
Definition: cli.c:643
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1496
void mheap_validate(void *v)
Definition: mheap.c:1378
static clib_error_t * restart_cmd_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1056
#define vec_foreach(var, vec)
Vector iterator.
Definition: file.h:51
vlib_cli_parse_position_t * sub_command_positions
Definition: cli.h:118
u32 n_total_events
Total number of events in buffer.
Definition: elog.h:135
static uword vlib_cli_normalize_path(char *input, char **result)
Definition: cli.c:1122
void() vlib_cli_output_function_t(uword arg, u8 *buffer, uword buffer_bytes)
Definition: cli.h:133
vlib_cli_output_function_t * output_function
Definition: node.h:611
u32 * sort_vector
Definition: cli.h:147
void clib_mem_trace(int enable)
Definition: mem_dlmalloc.c:423
char * short_help
Definition: cli.h:98
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
uword unformat_skip_white_space(unformat_input_t *input)
Definition: unformat.c:821
format_function_t format_cpu_model_name
Definition: cpu.h:390
DLMALLOC_EXPORT void * mspace_least_addr(mspace msp)
int elog_trace_graph_circuit
Definition: main.h:199
static uword * clib_bitmap_and(uword *ai, uword *bi)
Logical operator across two bitmaps.
static u8 * format_vlib_cli_path(u8 *s, va_list *args)
Definition: cli.c:343
vlib_cli_main_t * cm
Definition: cli.c:1623
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
u32 rule_index
Definition: cli.h:66
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171