FD.io VPP  v19.04-6-g6f05f72
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 /* Root of all show commands. */
48 /* *INDENT-OFF* */
49 VLIB_CLI_COMMAND (vlib_cli_show_command, static) = {
50  .path = "show",
51  .short_help = "Show commands",
52 };
53 /* *INDENT-ON* */
54 
55 /* Root of all clear commands. */
56 /* *INDENT-OFF* */
57 VLIB_CLI_COMMAND (vlib_cli_clear_command, static) = {
58  .path = "clear",
59  .short_help = "Clear commands",
60 };
61 /* *INDENT-ON* */
62 
63 /* Root of all set commands. */
64 /* *INDENT-OFF* */
65 VLIB_CLI_COMMAND (vlib_cli_set_command, static) = {
66  .path = "set",
67  .short_help = "Set commands",
68 };
69 /* *INDENT-ON* */
70 
71 /* Root of all test commands. */
72 /* *INDENT-OFF* */
73 VLIB_CLI_COMMAND (vlib_cli_test_command, static) = {
74  .path = "test",
75  .short_help = "Test commands",
76 };
77 /* *INDENT-ON* */
78 
79 /* Returns bitmap of commands which match key. */
80 static uword *
82 {
83  int i, n;
84  uword *match = 0;
86 
88 
89  for (i = 0;; i++)
90  {
91  uword k;
92 
93  k = unformat_get_input (input);
94  switch (k)
95  {
96  case 'a' ... 'z':
97  case 'A' ... 'Z':
98  case '0' ... '9':
99  case '-':
100  case '_':
101  break;
102 
103  case ' ':
104  case '\t':
105  case '\r':
106  case '\n':
108  /* White space or end of input removes any non-white
109  matches that were before possible. */
110  if (i < vec_len (c->sub_command_positions)
111  && clib_bitmap_count_set_bits (match) > 1)
112  {
114  for (n = 0; n < vec_len (p->bitmaps); n++)
115  match = clib_bitmap_andnot (match, p->bitmaps[n]);
116  }
117  goto done;
118 
119  default:
120  unformat_put_input (input);
121  goto done;
122  }
123 
124  if (i >= vec_len (c->sub_command_positions))
125  {
126  no_match:
127  clib_bitmap_free (match);
128  return 0;
129  }
130 
132  if (vec_len (p->bitmaps) == 0)
133  goto no_match;
134 
135  n = k - p->min_char;
136  if (n < 0 || n >= vec_len (p->bitmaps))
137  goto no_match;
138 
139  if (i == 0)
140  match = clib_bitmap_dup (p->bitmaps[n]);
141  else
142  match = clib_bitmap_and (match, p->bitmaps[n]);
143 
144  if (clib_bitmap_is_zero (match))
145  goto no_match;
146  }
147 
148 done:
149  return match;
150 }
151 
152 /* Looks for string based sub-input formatted { SUB-INPUT }. */
153 uword
155 {
156  unformat_input_t *sub_input = va_arg (*args, unformat_input_t *);
157  u8 *s;
158  uword c;
159 
160  while (1)
161  {
162  c = unformat_get_input (i);
163  switch (c)
164  {
165  case ' ':
166  case '\t':
167  case '\n':
168  case '\r':
169  case '\f':
170  break;
171 
172  case '{':
173  default:
174  /* Put back paren. */
175  if (c != UNFORMAT_END_OF_INPUT)
176  unformat_put_input (i);
177 
178  if (c == '{' && unformat (i, "%v", &s))
179  {
180  unformat_init_vector (sub_input, s);
181  return 1;
182  }
183  return 0;
184  }
185  }
186  return 0;
187 }
188 
189 static vlib_cli_command_t *
191 {
193  return vec_elt_at_index (cm->commands, s->index);
194 }
195 
196 static uword
198 {
199  vlib_main_t *vm = va_arg (*args, vlib_main_t *);
200  vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
201  vlib_cli_command_t **result = va_arg (*args, vlib_cli_command_t **);
202  vlib_cli_main_t *cm = &vm->cli_main;
203  uword *match_bitmap, is_unique, index;
204 
205  {
208  vec_foreach (sr, c->sub_rules)
209  {
210  void **d;
211  r = vec_elt_at_index (cm->parse_rules, sr->rule_index);
212  vec_add2 (cm->parse_rule_data, d, 1);
213  vec_reset_length (d[0]);
214  if (r->data_size)
215  d[0] = _vec_resize (d[0],
216  /* length increment */ 1,
217  r->data_size,
218  /* header_bytes */ 0,
219  /* data align */ sizeof (uword));
220  if (unformat_user (i, r->unformat_function, vm, d[0]))
221  {
222  *result = vec_elt_at_index (cm->commands, sr->command_index);
223  return 1;
224  }
225  }
226  }
227 
228  match_bitmap = vlib_cli_sub_command_match (c, i);
229  is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
230  index = ~0;
231  if (is_unique)
232  {
233  index = clib_bitmap_first_set (match_bitmap);
234  *result = get_sub_command (cm, c, index);
235  }
236  clib_bitmap_free (match_bitmap);
237 
238  return is_unique;
239 }
240 
241 static int
242 vlib_cli_cmp_strings (void *a1, void *a2)
243 {
244  u8 *c1 = *(u8 **) a1;
245  u8 *c2 = *(u8 **) a2;
246 
247  return vec_cmp (c1, c2);
248 }
249 
250 u8 **
252 {
255  vlib_main_t *vm = vlib_get_main ();
256  vlib_cli_main_t *vcm = &vm->cli_main;
257  uword *match_bitmap = 0;
258  uword index, is_unique, help_next_level;
259  u8 **result = 0;
260  unformat_input_t input;
261  unformat_init_vector (&input, vec_dup (str));
262  c = vec_elt_at_index (vcm->commands, 0);
263 
264  /* remove trailing whitespace, except for one of them */
265  while (vec_len (input.buffer) >= 2 &&
266  isspace (input.buffer[vec_len (input.buffer) - 1]) &&
267  isspace (input.buffer[vec_len (input.buffer) - 2]))
268  {
269  vec_del1 (input.buffer, vec_len (input.buffer) - 1);
270  }
271 
272  /* if input is empty, directly return list of root commands */
273  if (vec_len (input.buffer) == 0 ||
274  (vec_len (input.buffer) == 1 && isspace (input.buffer[0])))
275  {
276  vec_foreach (sc, c->sub_commands)
277  {
278  vec_add1 (result, (u8 *) sc->name);
279  }
280  goto done;
281  }
282 
283  /* add a trailing '?' so that vlib_cli_sub_command_match can find
284  * all commands starting with the input string */
285  vec_add1 (input.buffer, '?');
286 
287  while (1)
288  {
289  match_bitmap = vlib_cli_sub_command_match (c, &input);
290  /* no match: return no result */
291  if (match_bitmap == 0)
292  {
293  goto done;
294  }
295  is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
296  /* unique match: try to step one subcommand level further */
297  if (is_unique)
298  {
299  /* stop if no more input */
300  if (input.index >= vec_len (input.buffer) - 1)
301  {
302  break;
303  }
304 
305  index = clib_bitmap_first_set (match_bitmap);
306  c = get_sub_command (vcm, c, index);
307  clib_bitmap_free (match_bitmap);
308  continue;
309  }
310  /* multiple matches: stop here, return all matches */
311  break;
312  }
313 
314  /* remove trailing '?' */
315  vec_del1 (input.buffer, vec_len (input.buffer) - 1);
316 
317  /* if we have a space at the end of input, and a unique match,
318  * autocomplete the next level of subcommands */
319  help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]);
320  /* *INDENT-OFF* */
321  clib_bitmap_foreach(index, match_bitmap, {
322  if (help_next_level && is_unique) {
323  c = get_sub_command (vcm, c, index);
324  vec_foreach (sc, c->sub_commands) {
325  vec_add1 (result, (u8*) sc->name);
326  }
327  goto done; /* break doesn't work in this macro-loop */
328  }
329  sc = &c->sub_commands[index];
330  vec_add1(result, (u8*) sc->name);
331  });
332  /* *INDENT-ON* */
333 
334 done:
335  clib_bitmap_free (match_bitmap);
336  unformat_free (&input);
337 
338  if (result)
340  return result;
341 }
342 
343 static u8 *
344 format_vlib_cli_command_help (u8 * s, va_list * args)
345 {
346  vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
347  int is_long = va_arg (*args, int);
348  if (is_long && c->long_help)
349  s = format (s, "%s", c->long_help);
350  else if (c->short_help)
351  s = format (s, "%s", c->short_help);
352  else
353  s = format (s, "%v commands", c->path);
354  return s;
355 }
356 
357 static u8 *
358 format_vlib_cli_parse_rule_name (u8 * s, va_list * args)
359 {
360  vlib_cli_parse_rule_t *r = va_arg (*args, vlib_cli_parse_rule_t *);
361  return format (s, "<%U>", format_c_identifier, r->name);
362 }
363 
364 static u8 *
365 format_vlib_cli_path (u8 * s, va_list * args)
366 {
367  u8 *path = va_arg (*args, u8 *);
368  int i, in_rule;
369  in_rule = 0;
370  for (i = 0; i < vec_len (path); i++)
371  {
372  switch (path[i])
373  {
374  case '%':
375  in_rule = 1;
376  vec_add1 (s, '<'); /* start of <RULE> */
377  break;
378 
379  case '_':
380  /* _ -> space in rules. */
381  vec_add1 (s, in_rule ? ' ' : '_');
382  break;
383 
384  case ' ':
385  if (in_rule)
386  {
387  vec_add1 (s, '>'); /* end of <RULE> */
388  in_rule = 0;
389  }
390  vec_add1 (s, ' ');
391  break;
392 
393  default:
394  vec_add1 (s, path[i]);
395  break;
396  }
397  }
398 
399  if (in_rule)
400  vec_add1 (s, '>'); /* terminate <RULE> */
401 
402  return s;
403 }
404 
405 static vlib_cli_command_t *
406 all_subs (vlib_cli_main_t * cm, vlib_cli_command_t * subs, u32 command_index)
407 {
408  vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index);
411 
412  if (c->function)
413  vec_add1 (subs, c[0]);
414 
415  vec_foreach (sr, c->sub_rules)
416  subs = all_subs (cm, subs, sr->command_index);
417  vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index);
418 
419  return subs;
420 }
421 
422 static int
423 vlib_cli_cmp_rule (void *a1, void *a2)
424 {
425  vlib_cli_sub_rule_t *r1 = a1;
426  vlib_cli_sub_rule_t *r2 = a2;
427 
428  return vec_cmp (r1->name, r2->name);
429 }
430 
431 static int
432 vlib_cli_cmp_command (void *a1, void *a2)
433 {
434  vlib_cli_command_t *c1 = a1;
435  vlib_cli_command_t *c2 = a2;
436 
437  return vec_cmp (c1->path, c2->path);
438 }
439 
440 static clib_error_t *
442  vlib_cli_main_t * cm,
443  unformat_input_t * input,
444  uword parent_command_index)
445 {
446  vlib_cli_command_t *parent, *c;
447  clib_error_t *error = 0;
448  unformat_input_t sub_input;
449  u8 *string;
450  uword is_main_dispatch = cm == &vm->cli_main;
451 
452  parent = vec_elt_at_index (cm->commands, parent_command_index);
453  if (is_main_dispatch && unformat (input, "help"))
454  {
455  uword help_at_end_of_line, i;
456 
457  help_at_end_of_line =
459  while (1)
460  {
461  c = parent;
462  if (unformat_user
463  (input, unformat_vlib_cli_sub_command, vm, c, &parent))
464  ;
465 
466  else if (!(unformat_check_input (input) == UNFORMAT_END_OF_INPUT))
467  goto unknown;
468 
469  else
470  break;
471  }
472 
473  /* help SUB-COMMAND => long format help.
474  "help" at end of line: show all commands. */
475  if (!help_at_end_of_line)
477  /* is_long */ 1);
478 
479  else if (vec_len (c->sub_commands) + vec_len (c->sub_rules) == 0)
480  vlib_cli_output (vm, "%v: no sub-commands", c->path);
481 
482  else
483  {
485  vlib_cli_sub_rule_t *sr, *subs;
486 
487  subs = vec_dup (c->sub_rules);
488 
489  /* Add in rules if any. */
490  vec_foreach (sc, c->sub_commands)
491  {
492  vec_add2 (subs, sr, 1);
493  sr->name = sc->name;
494  sr->command_index = sc->index;
495  sr->rule_index = ~0;
496  }
497 
499 
500  for (i = 0; i < vec_len (subs); i++)
501  {
504 
505  d = vec_elt_at_index (cm->commands, subs[i].command_index);
506  r =
507  subs[i].rule_index != ~0 ? vec_elt_at_index (cm->parse_rules,
508  subs
509  [i].rule_index) :
510  0;
511 
512  if (r)
514  (vm, " %-30U %U",
516  format_vlib_cli_command_help, d, /* is_long */ 0);
517  else
519  (vm, " %-30v %U",
520  subs[i].name,
521  format_vlib_cli_command_help, d, /* is_long */ 0);
522  }
523 
524  vec_free (subs);
525  }
526  }
527 
528  else if (is_main_dispatch
529  && (unformat (input, "choices") || unformat (input, "?")))
530  {
531  vlib_cli_command_t *sub, *subs;
532 
533  subs = all_subs (cm, 0, parent_command_index);
535  vec_foreach (sub, subs)
536  vlib_cli_output (vm, " %-40U %U",
538  format_vlib_cli_command_help, sub, /* is_long */ 0);
539  vec_free (subs);
540  }
541 
542  else if (unformat (input, "comment %v", &string))
543  {
544  vec_free (string);
545  }
546 
547  else if (unformat (input, "uncomment %U",
548  unformat_vlib_cli_sub_input, &sub_input))
549  {
550  error =
551  vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
552  parent_command_index);
553  unformat_free (&sub_input);
554  }
555 
556  else
557  if (unformat_user (input, unformat_vlib_cli_sub_command, vm, parent, &c))
558  {
559  unformat_input_t *si;
560  uword has_sub_commands =
561  vec_len (c->sub_commands) + vec_len (c->sub_rules) > 0;
562 
563  si = input;
564  if (unformat_user (input, unformat_vlib_cli_sub_input, &sub_input))
565  si = &sub_input;
566 
567  if (has_sub_commands)
568  error = vlib_cli_dispatch_sub_commands (vm, cm, si, c - cm->commands);
569 
570  if (has_sub_commands && !error)
571  /* Found valid sub-command. */ ;
572 
573  else if (c->function)
574  {
575  clib_error_t *c_error;
576 
577  /* Skip white space for benefit of called function. */
579 
580  if (unformat (si, "?"))
581  {
582  vlib_cli_output (vm, " %-40U %U", format_vlib_cli_path, c->path, format_vlib_cli_command_help, c, /* is_long */
583  0);
584  }
585  else
586  {
588  {
589  /* *INDENT-OFF* */
590  ELOG_TYPE_DECLARE (e) =
591  {
592  .format = "cli-cmd: %s",
593  .format_args = "T4",
594  };
595  /* *INDENT-ON* */
596  struct
597  {
598  u32 c;
599  } *ed;
600  ed = ELOG_DATA (&vm->elog_main, e);
601  ed->c = elog_global_id_for_msg_name (c->path);
602  }
603 
604  if (!c->is_mp_safe)
606 
607  c_error = c->function (vm, si, c);
608 
609  if (!c->is_mp_safe)
611 
613  {
614  /* *INDENT-OFF* */
615  ELOG_TYPE_DECLARE (e) =
616  {
617  .format = "cli-cmd: %s %s",
618  .format_args = "T4T4",
619  };
620  /* *INDENT-ON* */
621  struct
622  {
623  u32 c, err;
624  } *ed;
625  ed = ELOG_DATA (&vm->elog_main, e);
626  ed->c = elog_global_id_for_msg_name (c->path);
627  if (c_error)
628  {
629  vec_add1 (c_error->what, 0);
631  ((const char *) c_error->what);
632  _vec_len (c_error->what) -= 1;
633  }
634  else
635  ed->err = elog_global_id_for_msg_name ("OK");
636  }
637 
638  if (c_error)
639  {
640  error =
641  clib_error_return (0, "%v: %v", c->path, c_error->what);
642  clib_error_free (c_error);
643  /* Free sub input. */
644  if (si != input)
645  unformat_free (si);
646 
647  return error;
648  }
649  }
650 
651  /* Free any previous error. */
652  clib_error_free (error);
653  }
654 
655  else if (!error)
656  error = clib_error_return (0, "%v: no sub-commands", c->path);
657 
658  /* Free sub input. */
659  if (si != input)
660  unformat_free (si);
661  }
662 
663  else
664  goto unknown;
665 
666  return error;
667 
668 unknown:
669  if (parent->path)
670  return clib_error_return (0, "%v: unknown input `%U'", parent->path,
671  format_unformat_error, input);
672  else
673  return clib_error_return (0, "unknown input `%U'", format_unformat_error,
674  input);
675 }
676 
677 
679  __attribute__ ((weak));
680 
681 void
683 {
684 }
685 
686 /* Process CLI input. */
687 void
689  unformat_input_t * input,
690  vlib_cli_output_function_t * function, uword function_arg)
691 {
693  vlib_cli_main_t *cm = &vm->cli_main;
694  clib_error_t *error;
695  vlib_cli_output_function_t *save_function;
696  uword save_function_arg;
697 
698  save_function = cp->output_function;
699  save_function_arg = cp->output_function_arg;
700 
701  cp->output_function = function;
702  cp->output_function_arg = function_arg;
703 
704  do
705  {
707  error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input, /* parent */
708  0);
709  }
710  while (!error && !unformat (input, "%U", unformat_eof));
711 
712  if (error)
713  {
714  vlib_cli_output (vm, "%v", error->what);
715  vlib_unix_error_report (vm, error);
716  clib_error_free (error);
717  }
718 
719  cp->output_function = save_function;
720  cp->output_function_arg = save_function_arg;
721 }
722 
723 /* Output to current CLI connection. */
724 void
725 vlib_cli_output (vlib_main_t * vm, char *fmt, ...)
726 {
728  va_list va;
729  u8 *s;
730 
731  va_start (va, fmt);
732  s = va_format (0, fmt, &va);
733  va_end (va);
734 
735  /* Terminate with \n if not present. */
736  if (vec_len (s) > 0 && s[vec_len (s) - 1] != '\n')
737  vec_add1 (s, '\n');
738 
739  if ((!cp) || (!cp->output_function))
740  fformat (stdout, "%v", s);
741  else
742  cp->output_function (cp->output_function_arg, s, vec_len (s));
743 
744  vec_free (s);
745 }
746 
747 void *vl_msg_push_heap (void) __attribute__ ((weak));
748 void vl_msg_pop_heap (void *oldheap) __attribute__ ((weak));
749 
750 static clib_error_t *
752  unformat_input_t * input, vlib_cli_command_t * cmd)
753 {
754  int verbose __attribute__ ((unused)) = 0, api_segment = 0;
755  clib_error_t *error;
756  u32 index = 0;
757 
759  {
760  if (unformat (input, "verbose"))
761  verbose = 1;
762  else if (unformat (input, "api-segment"))
763  api_segment = 1;
764  else
765  {
766  error = clib_error_return (0, "unknown input `%U'",
767  format_unformat_error, input);
768  return error;
769  }
770  }
771 
772  if (api_segment)
773  {
774  void *oldheap = vl_msg_push_heap ();
775  u8 *s_in_svm =
776  format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
777  vl_msg_pop_heap (oldheap);
778  u8 *s = vec_dup (s_in_svm);
779 
780  oldheap = vl_msg_push_heap ();
781  vec_free (s_in_svm);
782  vl_msg_pop_heap (oldheap);
783  vlib_cli_output (vm, "API segment start:");
784  vlib_cli_output (vm, "%v", s);
785  vlib_cli_output (vm, "API segment end:");
786  vec_free (s);
787  }
788 
789 #if USE_DLMALLOC == 0
790  /* *INDENT-OFF* */
792  ({
794  vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
795  vlib_worker_threads[index].name);
798  h->vm_alloc_size);
799  vlib_cli_output (vm, " %U\n", format_mheap, clib_per_cpu_mheaps[index],
800  verbose);
801  index++;
802  }));
803  /* *INDENT-ON* */
804 #else
805  {
807  uword was_enabled;
808 
809  /*
810  * Note: the foreach_vlib_main cause allocator traffic,
811  * so shut off tracing before we go there...
812  */
813  was_enabled = clib_mem_trace_enable_disable (0);
814 
815  /* *INDENT-OFF* */
817  ({
818  struct dlmallinfo mi;
819  void *mspace;
820  mspace = clib_per_cpu_mheaps[index];
821 
822  mi = mspace_mallinfo (mspace);
823  vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
824  vlib_worker_threads[index].name);
825  vlib_cli_output (vm, " %U\n", format_page_map,
827  mi.arena);
828  vlib_cli_output (vm, " %U\n", format_mheap, clib_per_cpu_mheaps[index],
829  verbose);
830  index++;
831  }));
832  /* *INDENT-ON* */
833 
834  /* Restore the trace flag */
835  clib_mem_trace_enable_disable (was_enabled);
836  }
837 #endif /* USE_DLMALLOC */
838  return 0;
839 }
840 
841 /* *INDENT-OFF* */
842 VLIB_CLI_COMMAND (show_memory_usage_command, static) = {
843  .path = "show memory",
844  .short_help = "[verbose | api-segment] Show current memory usage",
845  .function = show_memory_usage,
846 };
847 /* *INDENT-ON* */
848 
849 static clib_error_t *
851  vlib_cli_command_t * cmd)
852 {
853 #define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c);
854  _("Model name", "%U", format_cpu_model_name);
855  _("Microarch model (family)", "%U", format_cpu_uarch);
856  _("Flags", "%U", format_cpu_flags);
857  _("Base frequency", "%.2f GHz",
858  ((f64) vm->clib_time.clocks_per_second) * 1e-9);
859 #undef _
860  return 0;
861 }
862 
863 /*?
864  * Displays various information about the CPU.
865  *
866  * @cliexpar
867  * @cliexstart{show cpu}
868  * Model name: Intel(R) Xeon(R) CPU E5-2667 v4 @ 3.20GHz
869  * Microarchitecture: Broadwell (Broadwell-EP/EX)
870  * Flags: sse3 ssse3 sse41 sse42 avx avx2 aes
871  * Base Frequency: 3.20 GHz
872  * @cliexend
873 ?*/
874 /* *INDENT-OFF* */
875 VLIB_CLI_COMMAND (show_cpu_command, static) = {
876  .path = "show cpu",
877  .short_help = "Show cpu information",
878  .function = show_cpu,
879 };
880 
881 /* *INDENT-ON* */
882 
883 static clib_error_t *
885  unformat_input_t * input,
886  vlib_cli_command_t * cmd)
887 {
888  unformat_input_t _line_input, *line_input = &_line_input;
889  int enable;
890  int api_segment = 0;
891  void *oldheap;
892 
893 
894  if (!unformat_user (input, unformat_line_input, line_input))
895  return 0;
896 
897  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
898  {
899  if (unformat (line_input, "%U", unformat_vlib_enable_disable, &enable))
900  ;
901  else if (unformat (line_input, "api-segment"))
902  api_segment = 1;
903  else
904  {
905  unformat_free (line_input);
906  return clib_error_return (0, "invalid input");
907  }
908  }
909  unformat_free (line_input);
910 
911  if (api_segment)
912  oldheap = vl_msg_push_heap ();
913  clib_mem_trace (enable);
914  if (api_segment)
915  vl_msg_pop_heap (oldheap);
916 
917  return 0;
918 }
919 
920 /* *INDENT-OFF* */
921 VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = {
922  .path = "memory-trace",
923  .short_help = "on|off [api-segment] Enable/disable memory allocation trace",
924  .function = enable_disable_memory_trace,
925 };
926 /* *INDENT-ON* */
927 
928 
929 static clib_error_t *
931  vlib_cli_command_t * cmd)
932 {
933 #if USE_DLMALLOC == 0
934  clib_error_t *error = 0;
935  void *heap;
936  mheap_t *mheap;
937 
938  if (unformat (input, "on"))
939  {
940  /* *INDENT-OFF* */
942  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
943  mheap = mheap_header(heap);
944  mheap->flags |= MHEAP_FLAG_VALIDATE;
945  // Turn off small object cache because it delays detection of errors
947  });
948  /* *INDENT-ON* */
949 
950  }
951  else if (unformat (input, "off"))
952  {
953  /* *INDENT-OFF* */
955  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
956  mheap = mheap_header(heap);
957  mheap->flags &= ~MHEAP_FLAG_VALIDATE;
959  });
960  /* *INDENT-ON* */
961  }
962  else if (unformat (input, "now"))
963  {
964  /* *INDENT-OFF* */
966  heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
967  mheap = mheap_header(heap);
968  mheap_validate(heap);
969  });
970  /* *INDENT-ON* */
971  vlib_cli_output (vm, "heap validation complete");
972 
973  }
974  else
975  {
976  return clib_error_return (0, "unknown input `%U'",
977  format_unformat_error, input);
978  }
979 
980  return error;
981 #else
982  return clib_error_return (0, "unimplemented...");
983 #endif /* USE_DLMALLOC */
984 }
985 
986 /* *INDENT-OFF* */
987 VLIB_CLI_COMMAND (cmd_test_heap_validate,static) = {
988  .path = "test heap-validate",
989  .short_help = "<on/off/now> validate heap on future allocs/frees or right now",
990  .function = test_heap_validate,
991 };
992 /* *INDENT-ON* */
993 
994 static clib_error_t *
996  vlib_cli_command_t * cmd)
997 {
999  clib_file_t *f;
1000 
1001  /* environ(7) does not indicate a header for this */
1002  extern char **environ;
1003 
1004  /* Close all known open files */
1005  /* *INDENT-OFF* */
1006  pool_foreach(f, fm->file_pool,
1007  ({
1008  if (f->file_descriptor > 2)
1009  close(f->file_descriptor);
1010  }));
1011  /* *INDENT-ON* */
1012 
1013  /* Exec ourself */
1014  execve (vm->name, (char **) vm->argv, environ);
1015 
1016  return 0;
1017 }
1018 
1019 /* *INDENT-OFF* */
1020 VLIB_CLI_COMMAND (restart_cmd,static) = {
1021  .path = "restart",
1022  .short_help = "restart process",
1023  .function = restart_cmd_fn,
1024 };
1025 /* *INDENT-ON* */
1026 
1027 #ifdef TEST_CODE
1028 /*
1029  * A trivial test harness to verify the per-process output_function
1030  * is working correcty.
1031  */
1032 
1033 static clib_error_t *
1034 sleep_ten_seconds (vlib_main_t * vm,
1035  unformat_input_t * input, vlib_cli_command_t * cmd)
1036 {
1037  u16 i;
1038  u16 my_id = rand ();
1039 
1040  vlib_cli_output (vm, "Starting 10 seconds sleep with id %u\n", my_id);
1041 
1042  for (i = 0; i < 10; i++)
1043  {
1045  vlib_cli_output (vm, "Iteration number %u, my id: %u\n", i, my_id);
1046  }
1047  vlib_cli_output (vm, "Done with sleep with id %u\n", my_id);
1048  return 0;
1049 }
1050 
1051 /* *INDENT-OFF* */
1052 VLIB_CLI_COMMAND (ping_command, static) = {
1053  .path = "test sleep",
1054  .function = sleep_ten_seconds,
1055  .short_help = "Sleep for 10 seconds",
1056 };
1057 /* *INDENT-ON* */
1058 #endif /* ifdef TEST_CODE */
1059 
1060 static uword
1061 vlib_cli_normalize_path (char *input, char **result)
1062 {
1063  char *i = input;
1064  char *s = 0;
1065  uword l = 0;
1066  uword index_of_last_space = ~0;
1067 
1068  while (*i != 0)
1069  {
1070  u8 c = *i++;
1071  /* Multiple white space -> single space. */
1072  switch (c)
1073  {
1074  case ' ':
1075  case '\t':
1076  case '\n':
1077  case '\r':
1078  if (l > 0 && s[l - 1] != ' ')
1079  {
1080  vec_add1 (s, ' ');
1081  l++;
1082  }
1083  break;
1084 
1085  default:
1086  if (l > 0 && s[l - 1] == ' ')
1087  index_of_last_space = vec_len (s);
1088  vec_add1 (s, c);
1089  l++;
1090  break;
1091  }
1092  }
1093 
1094  /* Remove any extra space at end. */
1095  if (l > 0 && s[l - 1] == ' ')
1096  _vec_len (s) -= 1;
1097 
1098  *result = s;
1099  return index_of_last_space;
1100 }
1101 
1103 parent_path_len (char *path)
1104 {
1105  word i;
1106  for (i = vec_len (path) - 1; i >= 0; i--)
1107  {
1108  if (path[i] == ' ')
1109  return i;
1110  }
1111  return ~0;
1112 }
1113 
1114 static void
1115 add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
1116 {
1117  vlib_cli_command_t *p, *c;
1118  vlib_cli_sub_command_t *sub_c;
1119  u8 *sub_name;
1120  word i, l;
1121 
1122  p = vec_elt_at_index (cm->commands, parent_index);
1123  c = vec_elt_at_index (cm->commands, child_index);
1124 
1125  l = parent_path_len (c->path);
1126  if (l == ~0)
1127  sub_name = vec_dup ((u8 *) c->path);
1128  else
1129  {
1130  ASSERT (l + 1 < vec_len (c->path));
1131  sub_name = 0;
1132  vec_add (sub_name, c->path + l + 1, vec_len (c->path) - (l + 1));
1133  }
1134 
1135  if (sub_name[0] == '%')
1136  {
1137  uword *q;
1138  vlib_cli_sub_rule_t *sr;
1139 
1140  /* Remove %. */
1141  vec_delete (sub_name, 1, 0);
1142 
1143  if (!p->sub_rule_index_by_name)
1144  p->sub_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1145  sizeof (sub_name[0]),
1146  sizeof (uword));
1147  q = hash_get_mem (p->sub_rule_index_by_name, sub_name);
1148  if (q)
1149  {
1150  sr = vec_elt_at_index (p->sub_rules, q[0]);
1151  ASSERT (sr->command_index == child_index);
1152  return;
1153  }
1154 
1155  q = hash_get_mem (cm->parse_rule_index_by_name, sub_name);
1156  if (!q)
1157  {
1158  clib_error ("reference to unknown rule `%%%v' in path `%v'",
1159  sub_name, c->path);
1160  return;
1161  }
1162 
1163  hash_set_mem (p->sub_rule_index_by_name, sub_name,
1164  vec_len (p->sub_rules));
1165  vec_add2 (p->sub_rules, sr, 1);
1166  sr->name = sub_name;
1167  sr->rule_index = q[0];
1168  sr->command_index = child_index;
1169  return;
1170  }
1171 
1172  if (!p->sub_command_index_by_name)
1173  p->sub_command_index_by_name = hash_create_vec ( /* initial length */ 32,
1174  sizeof (c->path[0]),
1175  sizeof (uword));
1176 
1177  /* Check if sub-command has already been created. */
1178  if (hash_get_mem (p->sub_command_index_by_name, sub_name))
1179  {
1180  vec_free (sub_name);
1181  return;
1182  }
1183 
1184  vec_add2 (p->sub_commands, sub_c, 1);
1185  sub_c->index = child_index;
1186  sub_c->name = sub_name;
1188  sub_c - p->sub_commands);
1189 
1190  vec_validate (p->sub_command_positions, vec_len (sub_c->name) - 1);
1191  for (i = 0; i < vec_len (sub_c->name); i++)
1192  {
1193  int n;
1195 
1197 
1198  if (!pos->bitmaps)
1199  pos->min_char = sub_c->name[i];
1200 
1201  n = sub_c->name[i] - pos->min_char;
1202  if (n < 0)
1203  {
1204  pos->min_char = sub_c->name[i];
1205  vec_insert (pos->bitmaps, -n, 0);
1206  n = 0;
1207  }
1208 
1209  vec_validate (pos->bitmaps, n);
1210  pos->bitmaps[n] =
1211  clib_bitmap_ori (pos->bitmaps[n], sub_c - p->sub_commands);
1212  }
1213 }
1214 
1215 static void
1217 {
1218  uword p_len, pi, *p;
1219  char *p_path;
1220  vlib_cli_command_t *c, *parent;
1221 
1222  /* Root command (index 0) should have already been added. */
1223  ASSERT (vec_len (cm->commands) > 0);
1224 
1225  c = vec_elt_at_index (cm->commands, ci);
1226  p_len = parent_path_len (c->path);
1227 
1228  /* No space? Parent is root command. */
1229  if (p_len == ~0)
1230  {
1231  add_sub_command (cm, 0, ci);
1232  return;
1233  }
1234 
1235  p_path = 0;
1236  vec_add (p_path, c->path, p_len);
1237 
1238  p = hash_get_mem (cm->command_index_by_path, p_path);
1239 
1240  /* Parent exists? */
1241  if (!p)
1242  {
1243  /* Parent does not exist; create it. */
1244  vec_add2 (cm->commands, parent, 1);
1245  parent->path = p_path;
1246  hash_set_mem (cm->command_index_by_path, parent->path,
1247  parent - cm->commands);
1248  pi = parent - cm->commands;
1249  }
1250  else
1251  {
1252  pi = p[0];
1253  vec_free (p_path);
1254  }
1255 
1256  add_sub_command (cm, pi, ci);
1257 
1258  /* Create parent's parent. */
1259  if (!p)
1260  vlib_cli_make_parent (cm, pi);
1261 }
1262 
1265 {
1266  return (c->long_help == 0 && c->short_help == 0 && c->function == 0);
1267 }
1268 
1269 clib_error_t *
1271 {
1272  vlib_cli_main_t *cm = &vm->cli_main;
1273  clib_error_t *error = 0;
1274  uword ci, *p;
1275  char *normalized_path;
1276 
1277  if ((error = vlib_call_init_function (vm, vlib_cli_init)))
1278  return error;
1279 
1280  (void) vlib_cli_normalize_path (c->path, &normalized_path);
1281 
1282  if (!cm->command_index_by_path)
1283  cm->command_index_by_path = hash_create_vec ( /* initial length */ 32,
1284  sizeof (c->path[0]),
1285  sizeof (uword));
1286 
1287  /* See if command already exists with given path. */
1288  p = hash_get_mem (cm->command_index_by_path, normalized_path);
1289  if (p)
1290  {
1291  vlib_cli_command_t *d;
1292 
1293  ci = p[0];
1294  d = vec_elt_at_index (cm->commands, ci);
1295 
1296  /* If existing command was created via vlib_cli_make_parent
1297  replaced it with callers data. */
1298  if (vlib_cli_command_is_empty (d))
1299  {
1300  vlib_cli_command_t save = d[0];
1301 
1303 
1304  /* Copy callers fields. */
1305  d[0] = c[0];
1306 
1307  /* Save internal fields. */
1308  d->path = save.path;
1309  d->sub_commands = save.sub_commands;
1312  d->sub_rules = save.sub_rules;
1313  }
1314  else
1315  error =
1316  clib_error_return (0, "duplicate command name with path %v",
1317  normalized_path);
1318 
1319  vec_free (normalized_path);
1320  if (error)
1321  return error;
1322  }
1323  else
1324  {
1325  /* Command does not exist: create it. */
1326 
1327  /* Add root command (index 0). */
1328  if (vec_len (cm->commands) == 0)
1329  {
1330  /* Create command with index 0; path is empty string. */
1331  vec_resize (cm->commands, 1);
1332  }
1333 
1334  ci = vec_len (cm->commands);
1335  hash_set_mem (cm->command_index_by_path, normalized_path, ci);
1336  vec_add1 (cm->commands, c[0]);
1337 
1338  c = vec_elt_at_index (cm->commands, ci);
1339  c->path = normalized_path;
1340 
1341  /* Don't inherit from registration. */
1342  c->sub_commands = 0;
1344  c->sub_command_positions = 0;
1345  }
1346 
1347  vlib_cli_make_parent (cm, ci);
1348  return 0;
1349 }
1350 
1351 clib_error_t *
1353 {
1354  vlib_cli_main_t *cm = &vm->cli_main;
1356  clib_error_t *error = 0;
1357  u8 *r_name;
1358  uword *p;
1359 
1360  if (!cm->parse_rule_index_by_name)
1361  cm->parse_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1362  sizeof (r->name[0]),
1363  sizeof (uword));
1364 
1365  /* Make vector copy of name. */
1366  r_name = format (0, "%s", r_reg->name);
1367 
1368  if ((p = hash_get_mem (cm->parse_rule_index_by_name, r_name)))
1369  {
1370  vec_free (r_name);
1371  return clib_error_return (0, "duplicate parse rule name `%s'",
1372  r_reg->name);
1373  }
1374 
1375  vec_add2 (cm->parse_rules, r, 1);
1376  r[0] = r_reg[0];
1377  r->name = (char *) r_name;
1379 
1380  return error;
1381 }
1382 
1383 #if 0
1384 /* $$$ turn back on again someday, maybe */
1385 static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm,
1387  lo,
1389  hi)
1390  __attribute__ ((unused))
1391 {
1392  clib_error_t *error = 0;
1394 
1395  for (r = lo; r < hi; r = clib_elf_section_data_next (r, 0))
1396  {
1397  if (!r->name || strlen (r->name) == 0)
1398  {
1399  error = clib_error_return (0, "parse rule with no name");
1400  goto done;
1401  }
1402 
1403  error = vlib_cli_register_parse_rule (vm, r);
1404  if (error)
1405  goto done;
1406  }
1407 
1408 done:
1409  return error;
1410 }
1411 #endif
1412 
1413 static int
1414 cli_path_compare (void *a1, void *a2)
1415 {
1416  u8 **s1 = a1;
1417  u8 **s2 = a2;
1418 
1419  if ((vec_len (*s1) < vec_len (*s2)) &&
1420  memcmp ((char *) *s1, (char *) *s2, vec_len (*s1)) == 0)
1421  return -1;
1422 
1423 
1424  if ((vec_len (*s1) > vec_len (*s2)) &&
1425  memcmp ((char *) *s1, (char *) *s2, vec_len (*s2)) == 0)
1426  return 1;
1427 
1428  return vec_cmp (*s1, *s2);
1429 }
1430 
1431 static clib_error_t *
1433  vlib_cli_command_t * cmd)
1434 {
1435  vlib_cli_main_t *cm = &vm->cli_main;
1436  vlib_cli_command_t *cli;
1437  u8 **paths = 0, **s;
1438 
1439  /* *INDENT-OFF* */
1440  vec_foreach (cli, cm->commands)
1441  if (vec_len (cli->path) > 0)
1442  vec_add1 (paths, (u8 *) cli->path);
1443 
1445 
1446  vec_foreach (s, paths)
1447  vlib_cli_output (vm, "%v", *s);
1448  /* *INDENT-ON* */
1449 
1450  vec_free (paths);
1451  return 0;
1452 }
1453 
1454 /* *INDENT-OFF* */
1455 VLIB_CLI_COMMAND (show_cli_command, static) = {
1456  .path = "show cli",
1457  .short_help = "Show cli commands",
1458  .function = show_cli_cmd_fn,
1459 };
1460 /* *INDENT-ON* */
1461 
1462 static clib_error_t *
1464  unformat_input_t * input, vlib_cli_command_t * cmd)
1465 {
1466  unformat_input_t _line_input, *line_input = &_line_input;
1467  int enable = 1;
1468  int api = 0, cli = 0, barrier = 0, dispatch = 0, circuit = 0;
1469  u32 circuit_node_index;
1470 
1471  if (!unformat_user (input, unformat_line_input, line_input))
1472  goto print_status;
1473 
1474  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1475  {
1476  if (unformat (line_input, "api"))
1477  api = 1;
1478  else if (unformat (line_input, "dispatch"))
1479  dispatch = 1;
1480  else if (unformat (line_input, "circuit-node %U",
1481  unformat_vlib_node, vm, &circuit_node_index))
1482  circuit = 1;
1483  else if (unformat (line_input, "cli"))
1484  cli = 1;
1485  else if (unformat (line_input, "barrier"))
1486  barrier = 1;
1487  else if (unformat (line_input, "disable"))
1488  enable = 0;
1489  else if (unformat (line_input, "enable"))
1490  enable = 1;
1491  else
1492  break;
1493  }
1494  unformat_free (line_input);
1495 
1496  vm->elog_trace_api_messages = api ? enable : vm->elog_trace_api_messages;
1497  vm->elog_trace_cli_commands = cli ? enable : vm->elog_trace_cli_commands;
1498  vm->elog_trace_graph_dispatch = dispatch ?
1499  enable : vm->elog_trace_graph_dispatch;
1500  vm->elog_trace_graph_circuit = circuit ?
1501  enable : vm->elog_trace_graph_circuit;
1503  barrier ? enable : vlib_worker_threads->barrier_elog_enabled;
1504  vm->elog_trace_graph_circuit_node_index = circuit_node_index;
1505 
1506  /*
1507  * Set up start-of-buffer logic-analyzer trigger
1508  * for main loop event logs, which are fairly heavyweight.
1509  * See src/vlib/main/vlib_elog_main_loop_event(...), which
1510  * will fully disable the scheme when the elog buffer fills.
1511  */
1512  if (dispatch || circuit)
1513  {
1514  elog_main_t *em = &vm->elog_main;
1515 
1517  em->n_total_events + vec_len (em->event_ring);
1518  }
1519 
1520 
1521 print_status:
1522  vlib_cli_output (vm, "Current status:");
1523 
1525  (vm, " Event log API message trace: %s\n CLI command trace: %s",
1526  vm->elog_trace_api_messages ? "on" : "off",
1527  vm->elog_trace_cli_commands ? "on" : "off");
1529  (vm, " Barrier sync trace: %s",
1530  vlib_worker_threads->barrier_elog_enabled ? "on" : "off");
1532  (vm, " Graph Dispatch: %s",
1533  vm->elog_trace_graph_dispatch ? "on" : "off");
1535  (vm, " Graph Circuit: %s",
1536  vm->elog_trace_graph_circuit ? "on" : "off");
1537  if (vm->elog_trace_graph_circuit)
1539  (vm, " node %U",
1541 
1542  return 0;
1543 }
1544 
1545 /*?
1546  * Control event logging of api, cli, and thread barrier events
1547  * With no arguments, displays the current trace status.
1548  * Name the event groups you wish to trace or stop tracing.
1549  *
1550  * @cliexpar
1551  * @clistart
1552  * elog trace api cli barrier
1553  * elog trace api cli barrier disable
1554  * elog trace dispatch
1555  * elog trace circuit-node ethernet-input
1556  * elog trace
1557  * @cliend
1558  * @cliexcmd{elog trace [api][cli][barrier][disable]}
1559 ?*/
1560 /* *INDENT-OFF* */
1561 VLIB_CLI_COMMAND (elog_trace_command, static) =
1562 {
1563  .path = "elog trace",
1564  .short_help = "elog trace [api][cli][barrier][dispatch]\n"
1565  "[circuit-node <name> e.g. ethernet-input][disable]",
1566  .function = elog_trace_command_fn,
1567 };
1568 /* *INDENT-ON* */
1569 
1570 static clib_error_t *
1572 {
1573  vlib_cli_main_t *cm = &vm->cli_main;
1574  clib_error_t *error = 0;
1575  vlib_cli_command_t *cmd;
1576 
1577  cmd = cm->cli_command_registrations;
1578 
1579  while (cmd)
1580  {
1581  error = vlib_cli_register (vm, cmd);
1582  if (error)
1583  return error;
1584  cmd = cmd->next_cli_command;
1585  }
1586  return error;
1587 }
1588 
1590 
1591 /*
1592  * fd.io coding-style-patch-verification: ON
1593  *
1594  * Local Variables:
1595  * eval: (c-set-style "gnu")
1596  * End:
1597  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
import vnet fib fib_types api
Definition: bier.api:22
uword output_function_arg
Definition: node.h:611
vmrglw vmrglh hi
unformat_function_t * unformat_function
Definition: cli.h:80
void * clib_per_cpu_mheaps[CLIB_MAX_MHEAPS]
Definition: mem_dlmalloc.c:23
static clib_error_t * show_cpu(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:850
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:703
format_function_t format_vlib_node_name
Definition: node_funcs.h:1171
void vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
Definition: cli.c:688
uword data_size
Definition: cli.h:78
uword vm_alloc_offset_from_header
unformat_function_t unformat_eof
Definition: format.h:292
static u8 * format_vlib_cli_parse_rule_name(u8 *s, va_list *args)
Definition: cli.c:358
static uword unformat_get_input(unformat_input_t *input)
Definition: format.h:191
int elog_trace_cli_commands
Definition: main.h:176
#define clib_error(format, args...)
Definition: error.h:62
vlib_cli_command_t * commands
Definition: cli.h:136
f64 clocks_per_second
Definition: time.h:53
int elog_trace_api_messages
Definition: main.h:175
format_function_t format_cpu_flags
Definition: cpu.h:390
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
static uword parent_path_len(char *path)
Definition: cli.c:1103
static mheap_t * mheap_header(u8 *v)
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
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:72
DLMALLOC_EXPORT struct dlmallinfo mspace_mallinfo(mspace msp)
vlib_cli_main_t cli_main
Definition: main.h:138
static vlib_cli_command_t * all_subs(vlib_cli_main_t *cm, vlib_cli_command_t *subs, u32 command_index)
Definition: cli.c:406
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
#define fm
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:598
clib_file_t * file_pool
Definition: file.h:88
static clib_error_t * test_heap_validate(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:930
i64 word
Definition: types.h:111
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
MALLINFO_FIELD_TYPE arena
Definition: dlmalloc.h:800
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
#define always_inline
Definition: clib.h:98
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: api_shared.c:967
uword * command_index_by_path
Definition: cli.h:139
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:242
unsigned int u32
Definition: types.h:88
#define vlib_call_init_function(vm, x)
Definition: init.h:260
static void add_sub_command(vlib_cli_main_t *cm, uword parent_index, uword child_index)
Definition: cli.c:1115
static uword unformat_vlib_cli_sub_command(unformat_input_t *i, va_list *args)
Definition: cli.c:197
static int vlib_cli_cmp_strings(void *a1, void *a2)
Definition: cli.c:242
static int vlib_cli_cmp_rule(void *a1, void *a2)
Definition: cli.c:423
unformat_function_t unformat_line_input
Definition: format.h:282
u8 * format_c_identifier(u8 *s, va_list *va)
Definition: std-formats.c:258
u8 * format_mheap(u8 *s, va_list *va)
Definition: mem_dlmalloc.c:354
char * name
Definition: main.h:117
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:36
vlib_cli_parse_rule_t * parse_rules
Definition: cli.h:142
static clib_error_t * enable_disable_memory_trace(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:884
#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:190
#define vec_insert(V, N, M)
Insert N vector elements starting at element M, initialize new elements to zero (no header...
Definition: vec.h:685
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:1463
clib_error_t * vlib_cli_register_parse_rule(vlib_main_t *vm, vlib_cli_parse_rule_t *r_reg)
Definition: cli.c:1352
u8 ** vlib_cli_get_possible_completions(u8 *str)
Definition: cli.c:251
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
static int cli_path_compare(void *a1, void *a2)
Definition: cli.c:1414
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
#define ELOG_DATA(em, f)
Definition: elog.h:481
elog_event_t * event_ring
Vector of events (circular buffer).
Definition: elog.h:148
#define PREDICT_FALSE(x)
Definition: clib.h:111
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:804
static void unformat_put_input(unformat_input_t *input)
Definition: format.h:204
void vl_msg_pop_heap(void *oldheap)
Definition: api_shared.c:975
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:441
u32 elog_global_id_for_msg_name(const char *msg_name)
Definition: threads.c:47
#define foreach_vlib_main(body)
Definition: threads.h:235
u8 name[64]
Definition: memclnt.api:152
word fformat(FILE *f, char *fmt,...)
Definition: format.c:462
void unformat_init_vector(unformat_input_t *input, u8 *vector_string)
Definition: unformat.c:1031
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:213
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
svmdb_client_t * c
static vlib_process_t * vlib_get_current_process(vlib_main_t *vm)
Definition: node_funcs.h:421
int elog_trace_graph_dispatch
Definition: main.h:177
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
static uword * clib_bitmap_andnot(uword *ai, uword *bi)
Logical operator across two bitmaps.
elog_main_t elog_main
Definition: main.h:172
uword ** bitmaps
Definition: cli.h:52
#define ELOG_TYPE_DECLARE(f)
Definition: elog.h:439
static u8 * format_vlib_cli_command_help(u8 *s, va_list *args)
Definition: cli.c:344
u32 n_total_events_disable_limit
When count reaches limit logging is disabled.
Definition: elog.h:138
static uword * vlib_cli_sub_command_match(vlib_cli_command_t *c, unformat_input_t *input)
Definition: cli.c:81
static uword vlib_cli_command_is_empty(vlib_cli_command_t *c)
Definition: cli.c:1264
static void * clib_mem_get_heap(void)
Definition: mem.h:255
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
static int vlib_cli_cmp_command(void *a1, void *a2)
Definition: cli.c:432
#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:1216
#define ASSERT(truth)
static clib_error_t * vlib_cli_init(vlib_main_t *vm)
Definition: cli.c:1571
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:784
uword clib_mem_trace_enable_disable(uword enable)
Definition: mem_dlmalloc.c:413
uword * parse_rule_index_by_name
Definition: cli.h:145
void( vlib_cli_output_function_t)(uword arg, u8 *buffer, uword buffer_bytes)
Definition: cli.h:131
uword vm_alloc_size
char * long_help
Definition: cli.h:99
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
uword * sub_command_index_by_name
Definition: cli.h:114
u32 elog_trace_graph_circuit_node_index
Definition: main.h:179
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:919
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:751
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
#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
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
#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:154
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:980
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
void ** parse_rule_data
Definition: cli.h:148
format_function_t format_cpu_uarch
Definition: cpu.h:388
#define clib_error_free(e)
Definition: error.h:86
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1177
#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:1270
vlib_cli_command_t * cli_command_registrations
Definition: cli.h:151
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:682
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1487
static struct st_util_session_cache_t sc
Definition: quic.c:395
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:995
#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:134
static uword vlib_cli_normalize_path(char *input, char **result)
Definition: cli.c:1061
vlib_cli_output_function_t * output_function
Definition: node.h:610
void clib_mem_trace(int enable)
Definition: mem_dlmalloc.c:404
static clib_error_t * show_cli_cmd_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cli.c:1432
char * short_help
Definition: cli.h:98
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:725
uword unformat_skip_white_space(unformat_input_t *input)
Definition: unformat.c:815
format_function_t format_cpu_model_name
Definition: cpu.h:389
DLMALLOC_EXPORT void * mspace_least_addr(mspace msp)
int elog_trace_graph_circuit
Definition: main.h:178
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:365
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
u32 rule_index
Definition: cli.h:66
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170