FD.io VPP  v21.06-1-gbb7418cf9
Vector Packet Processing
node_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  * node_cli.c: node CLI
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 <sys/types.h>
41 #include <sys/stat.h>
42 #include <fcntl.h>
43 #include <vlib/vlib.h>
44 #include <vlib/threads.h>
45 #include <math.h>
46 
47 static int
48 node_cmp (void *a1, void *a2)
49 {
50  vlib_node_t **n1 = a1;
51  vlib_node_t **n2 = a2;
52 
53  return vec_cmp (n1[0]->name, n2[0]->name);
54 }
55 
56 static clib_error_t *
58  unformat_input_t * input, vlib_cli_command_t * cmd)
59 {
61  vlib_node_t *n;
63 
64  vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, 0);
65 
66  if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
67  {
68  n = vlib_get_node (vm, node_index);
69  vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, n);
70  }
71  else
72  {
73  vlib_node_t **nodes = vec_dup (nm->nodes);
74  uword i;
75 
77 
78  for (i = 0; i < vec_len (nodes); i++)
79  vlib_cli_output (vm, "%U\n\n", format_vlib_node_graph, nm, nodes[i]);
80 
81  vec_free (nodes);
82  }
83 
84  return 0;
85 }
86 
87 /* *INDENT-OFF* */
88 VLIB_CLI_COMMAND (show_node_graph_command, static) = {
89  .path = "show vlib graph",
90  .short_help = "Show packet processing node graph",
91  .function = show_node_graph,
92 };
93 /* *INDENT-ON* */
94 
95 static clib_error_t *
97  unformat_input_t * input, vlib_cli_command_t * cmd)
98 {
99  clib_error_t *error = 0;
100  vlib_node_main_t *nm = &vm->node_main;
101  vlib_node_t **nodes = nm->nodes;
102  u8 *chroot_filename = 0;
103  int fd;
104  uword *active = 0;
105  u32 i, j;
106  unformat_input_t _line_input, *line_input = &_line_input;
107  u8 filter = 0, calls_filter = 0, vectors_filter = 0, both = 0;
108 
109  fd = -1;
110  /* Get a line of input. */
111  if (unformat_user (input, unformat_line_input, line_input))
112  {
113  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
114  {
115  if (unformat (line_input, "filter"))
116  filter = 1;
117  else if (unformat (line_input, "calls") && filter)
118  calls_filter = 1;
119  else if (unformat (line_input, "vectors") && filter)
120  vectors_filter = 1;
121  else if (unformat (line_input, "file %U", unformat_vlib_tmpfile,
122  &chroot_filename))
123  {
124  fd = open ((char *) chroot_filename,
125  O_CREAT | O_TRUNC | O_WRONLY, 0664);
126  }
127  else
128  return clib_error_return (0, "unknown input `%U'",
129  format_unformat_error, input);
130  }
131  unformat_free (line_input);
132  }
133 
134  /*both is set to true if calls_filter and vectors_filter are, or neither */
135  both = filter & (!(calls_filter ^ vectors_filter));
136 
137 #define format__(vm__, fd__, ...) \
138  if ((fd) < 0) \
139  { \
140  vlib_cli_output((vm__), ## __VA_ARGS__); \
141  } \
142  else \
143  { \
144  fdformat((fd__), ## __VA_ARGS__); \
145  }
146 
147  format__ (vm, fd, "%s", "digraph {\n");
148 
149  clib_bitmap_alloc (active, vec_len (nodes));
150  clib_bitmap_set_region (active, 0, 1, vec_len (nodes));
151  if (filter)
152  {
153  /*Adding the legend to the dot file*/
154  format__ (vm, fd, "%s",
155  " rankdir=\"LR\"\n nodesep=2\n subgraph cluster_legend {\n "
156  " label=\"Legend\"\n style=\"solid\"\n labelloc = b\n "
157  " subgraph cluster_colors {\n label=\"Packets/Call\"\n "
158  " style=\"solid\"\n labelloc = b\n");
159  format__ (vm, fd, "%s",
160  " 0 [label=\"No packet\", fixedsize=true shape=circle "
161  "width=2 fontsize=17]\n"
162  " 1 [label=\"1-32\", fillcolor=1 style=filled "
163  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
164  "fontsize=17]\n"
165  " 2 [label=\"33-64\", fillcolor=2 style=filled "
166  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
167  "fontsize=17]\n"
168  " 3 [label=\"65-96\", fillcolor=3 style=filled "
169  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
170  "fontsize=17]\n"
171  " 4 [label=\"97-128\", fillcolor=4 style=filled "
172  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
173  "fontsize=17]\n"
174  " 5 [label=\"129-160\", fillcolor=5 style=filled "
175  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
176  "fontsize=17]\n"
177  " 6 [label=\"161-192\", fillcolor=6 style=filled "
178  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
179  "fontsize=17]\n"
180  " 7 [label=\"193-224\", fillcolor=7 style=filled "
181  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
182  "fontsize=17]\n"
183  " 8 [label=\"224+\", fillcolor=8 style=filled "
184  "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
185  "fontsize=17]\n");
186  format__ (vm, fd, "%s",
187  " 0 -> 1 -> 2 -> 3 -> 4 [style=\"invis\",weight =100]\n "
188  " 5 -> 6 -> 7 -> 8 [style=\"invis\",weight =100]\n }\n "
189  " subgraph cluster_size {\n label=\"Cycles/Packet\"\n "
190  " style=\"solid\"\n labelloc = b\n");
191  format__ (
192  vm, fd, "%s",
193  " a[label=\"0\",fixedsize=true shape=circle width=1] \n"
194  " b[label=\"10\",fixedsize=true shape=circle width=2 "
195  "fontsize=17]\n"
196  " c[label=\"100\",fixedsize=true shape=circle width=3 "
197  "fontsize=20]\n"
198  " d[label=\"1000\",fixedsize=true shape=circle width=4 "
199  "fontsize=23]\n"
200  " a -> b -> c -> d [style=\"invis\",weight =100]\n }\n }\n");
201 
203  for (j = 0; j < vec_len (nm->nodes); j++)
204  {
205  vlib_node_t *n;
206  n = nm->nodes[j];
207  vlib_node_sync_stats (vm, n);
208  }
209 
210  /* Updating the stats for multithreaded use cases.
211  * We need to dup the nodes to sum the stats from all threads.*/
212  nodes = vec_dup (nm->nodes);
213  for (i = 1; i < vlib_get_n_threads (); i++)
214  {
215  vlib_node_main_t *nm_clone;
216  vlib_main_t *vm_clone;
218  vlib_node_t *n;
219 
220  vm_clone = vlib_get_main_by_index (i);
221  nm_clone = &vm_clone->node_main;
222 
223  for (j = 0; j < vec_len (nm_clone->nodes); j++)
224  {
225  n = nm_clone->nodes[j];
226 
227  rt = vlib_node_get_runtime (vm_clone, n->index);
228  /* Sync the stats directly in the duplicated node.*/
229  vlib_node_runtime_sync_stats_node (nodes[j], rt, 0, 0, 0);
230  }
231  }
233 
234  for (i = 0; i < vec_len (nodes); i++)
235  {
236  u64 p, c, l;
237  c = nodes[i]->stats_total.calls - nodes[i]->stats_last_clear.calls;
238  p =
239  nodes[i]->stats_total.vectors - nodes[i]->stats_last_clear.vectors;
240  l = nodes[i]->stats_total.clocks - nodes[i]->stats_last_clear.clocks;
241 
242  if ((both && c > 0 && p > 0) || (calls_filter && c > 0) ||
243  (vectors_filter && p > 0))
244  {
245  format__ (vm, fd, " \"%v\" [shape=circle", nodes[i]->name);
246  /*Changing the size and the font of nodes that receive packets*/
247  if (p > 0)
248  {
249  f64 x = (f64) l / (f64) p;
250  f64 size_ratio = (1 + log10 (x + 1));
251  format__ (vm, fd, " width=%.2f fontsize=%.2f fixedsize=true",
252  size_ratio, 11 + 3 * size_ratio);
253  /*Coloring nodes that are indeed called*/
254  if (c > 0)
255  {
256  u64 color = ((p - 1) / (32 * c)) + 1;
257  color = clib_min (color, 8);
258  format__ (
259  vm, fd,
260  " fillcolor=%u style=filled colorscheme=ylorrd8",
261  color);
262  }
263  }
264  format__ (vm, fd, "]\n");
265  }
266  else
267  {
268  clib_bitmap_set (active, i, 0);
269  }
270  }
271  }
272 
273  clib_bitmap_foreach (i, active)
274  {
275  for (j = 0; j < vec_len (nodes[i]->next_nodes); j++)
276  {
277  if (nodes[i]->next_nodes[j] == VLIB_INVALID_NODE_INDEX)
278  continue;
279 
280  if (!filter || clib_bitmap_get (active, nodes[i]->next_nodes[j]))
281  {
282  format__ (vm, fd, " \"%v\" -> \"%v\"\n", nodes[i]->name,
283  nodes[nodes[i]->next_nodes[j]]->name);
284  }
285  }
286  }
287 
288  format__ (vm, fd, "}\n");
289 
290  if (fd >= 0)
291  {
292  /*Dumping all the nodes saturates dot capacities to render a directed
293  * graph. In this case, prefer using he fdp command to generate an
294  * undirected graph. */
295  const char *soft = filter ? "dot" : "fdp";
297  vm, "vlib graph dumped into `%s'. Run eg. `%s -Tsvg -O %s'.",
298  chroot_filename, soft, chroot_filename);
299  }
300 
301  clib_bitmap_free (active);
302  vec_free (chroot_filename);
303  if (filter)
304  vec_free (nodes);
305  if (fd >= 0)
306  close (fd);
307  return error;
308 }
309 
310 /*?
311  * Dump dot files data to draw a graph of all the nodes.
312  * If the argument 'filter' is provided, only the active nodes (since the last
313  * "clear run" comand) are selected and they are scaled and colored according
314  * to their utilization. You can choose to filter nodes that are called,
315  * nodes that receive vectors or both (default).
316  * The 'file' option allows to save data in a temp file.
317  *
318  * @cliexpar
319  * @clistart
320  * show vlib graphviz
321  * show vlib graphviz filter file tmpfile
322  * show vlib graphviz filter calls file tmpfile
323  * @cliend
324  * @cliexcmd{show vlib graphviz [filter][calls][vectors][file <filename>]}
325 ?*/
326 /* *INDENT-OFF* */
327 VLIB_CLI_COMMAND (show_node_graphviz_command, static) = {
328  .path = "show vlib graphviz",
329  .short_help = "Dump packet processing node graph as a graphviz dotfile",
330  .function = show_node_graphviz,
331  .is_mp_safe = 1,
332 };
333 /* *INDENT-ON* */
334 
335 static u8 *
336 format_vlib_node_state (u8 * s, va_list * va)
337 {
338  vlib_main_t *vm = va_arg (*va, vlib_main_t *);
339  vlib_node_t *n = va_arg (*va, vlib_node_t *);
340  char *state;
341 
342  state = "active";
343  if (n->type == VLIB_NODE_TYPE_PROCESS)
344  {
346 
349  {
350  default:
351  if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
352  state = "done";
353  break;
354 
356  state = "time wait";
357  break;
358 
360  state = "event wait";
361  break;
362 
364  state =
365  "any wait";
366  break;
367  }
368  }
369  else if (n->type != VLIB_NODE_TYPE_INTERNAL)
370  {
371  state = "polling";
372  if (n->state == VLIB_NODE_STATE_DISABLED)
373  state = "disabled";
374  else if (n->state == VLIB_NODE_STATE_INTERRUPT)
375  state = "interrupt wait";
376  }
377 
378  return format (s, "%s", state);
379 }
380 
381 static u8 *
382 format_vlib_node_stats (u8 * s, va_list * va)
383 {
384  vlib_main_t *vm = va_arg (*va, vlib_main_t *);
385  vlib_node_t *n = va_arg (*va, vlib_node_t *);
386  int max = va_arg (*va, int);
387  f64 v;
388  u8 *ns;
389  u8 *misc_info = 0;
390  u64 c, p, l, d;
391  f64 x;
392  f64 maxc, maxcn;
393  u32 maxn;
394  u32 indent;
395 
396  if (!n)
397  {
398  if (max)
399  s = format (s,
400  "%=30s%=17s%=16s%=16s%=16s%=16s",
401  "Name", "Max Node Clocks", "Vectors at Max",
402  "Max Clocks", "Avg Clocks", "Avg Vectors/Call");
403  else
404  s = format (s,
405  "%=30s%=12s%=16s%=16s%=16s%=16s%=16s",
406  "Name", "State", "Calls", "Vectors", "Suspends",
407  "Clocks", "Vectors/Call");
408  return s;
409  }
410 
411  indent = format_get_indent (s);
412 
417  maxc = (f64) n->stats_total.max_clock;
418  maxn = n->stats_total.max_clock_n;
420  maxcn = (f64) n->stats_total.max_clock / (f64) maxn;
421  else
422  maxcn = 0.0;
423 
424  /* Clocks per packet, per call or per suspend. */
425  x = 0;
426  if (p > 0)
427  x = (f64) l / (f64) p;
428  else if (c > 0)
429  x = (f64) l / (f64) c;
430  else if (d > 0)
431  x = (f64) l / (f64) d;
432 
433  if (c > 0)
434  v = (double) p / (double) c;
435  else
436  v = 0;
437 
438  if (n->type == VLIB_NODE_TYPE_PROCESS)
439  {
441 
442  /* Show processes with events pending. This helps spot bugs where events are not
443  being handled. */
445  misc_info = format (misc_info, "events pending, ");
446  }
447  ns = n->name;
448 
449  if (max)
450  s = format (s, "%-30v%=17.2e%=16d%=16.2e%=16.2e%=16.2e",
451  ns, maxc, maxn, maxcn, x, v);
452  else
453  s = format (s, "%-30v%=12U%16Ld%16Ld%16Ld%16.2e%16.2f", ns,
454  format_vlib_node_state, vm, n, c, p, d, x, v);
455 
456  if (ns != n->name)
457  vec_free (ns);
458 
459  if (misc_info)
460  {
461  s = format (s, "\n%U%v", format_white_space, indent + 4, misc_info);
462  vec_free (misc_info);
463  }
464 
465  return s;
466 }
467 
468 f64 vlib_get_stat_segment_update_rate (void) __attribute__ ((weak));
469 f64
471 {
472  return 1e70;
473 }
474 
475 static clib_error_t *
477  unformat_input_t * input, vlib_cli_command_t * cmd)
478 {
479  vlib_node_main_t *nm = &vm->node_main;
480  vlib_node_t *n;
481  f64 time_now;
482  u32 node_index;
483  vlib_node_t ***node_dups = 0;
484  f64 *internal_node_vector_rates = 0;
485 
486  time_now = vlib_time_now (vm);
487 
488  if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
489  {
490  n = vlib_get_node (vm, node_index);
491  vlib_node_sync_stats (vm, n);
492  vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, 0, 0);
493  vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, n, 0);
494  }
495  else
496  {
497  vlib_node_t **nodes;
498  uword i, j;
499  f64 dt;
500  u64 n_input, n_output, n_drop, n_punt;
501  u64 n_internal_vectors, n_internal_calls;
502  u64 n_clocks, l, v, c, d;
503  int brief = 1;
504  int summary = 0;
505  int max = 0;
506  vlib_main_t **stat_vms = 0, *stat_vm;
507 
508  /* Suppress nodes with zero calls since last clear */
509  if (unformat (input, "brief") || unformat (input, "b"))
510  brief = 1;
511  if (unformat (input, "verbose") || unformat (input, "v"))
512  brief = 0;
513  if (unformat (input, "max") || unformat (input, "m"))
514  max = 1;
515  if (unformat (input, "summary") || unformat (input, "sum")
516  || unformat (input, "su"))
517  summary = 1;
518 
519  for (i = 0; i < vlib_get_n_threads (); i++)
520  {
521  stat_vm = vlib_get_main_by_index (i);
522  if (stat_vm)
523  vec_add1 (stat_vms, stat_vm);
524  }
525 
526  /*
527  * Barrier sync across stats scraping.
528  * Otherwise, the counts will be grossly inaccurate.
529  */
531 
532  for (j = 0; j < vec_len (stat_vms); j++)
533  {
534  stat_vm = stat_vms[j];
535  nm = &stat_vm->node_main;
536 
537  for (i = 0; i < vec_len (nm->nodes); i++)
538  {
539  n = nm->nodes[i];
540  vlib_node_sync_stats (stat_vm, n);
541  }
542 
543  nodes = vec_dup (nm->nodes);
544 
545  vec_add1 (node_dups, nodes);
546  vec_add1 (internal_node_vector_rates,
548  }
550 
551 
552  for (j = 0; j < vec_len (stat_vms); j++)
553  {
554  stat_vm = stat_vms[j];
555  nodes = node_dups[j];
556 
558 
559  n_input = n_output = n_drop = n_punt = n_clocks = 0;
560  n_internal_vectors = n_internal_calls = 0;
561  for (i = 0; i < vec_len (nodes); i++)
562  {
563  n = nodes[i];
564 
566  n_clocks += l;
567 
570 
571  switch (n->type)
572  {
573  default:
574  continue;
575 
577  n_output += (n->flags & VLIB_NODE_FLAG_IS_OUTPUT) ? v : 0;
578  n_drop += (n->flags & VLIB_NODE_FLAG_IS_DROP) ? v : 0;
579  n_punt += (n->flags & VLIB_NODE_FLAG_IS_PUNT) ? v : 0;
580  if (!(n->flags & VLIB_NODE_FLAG_IS_OUTPUT))
581  {
582  n_internal_vectors += v;
583  n_internal_calls += c;
584  }
586  n_input += v;
587  break;
588 
590  n_input += v;
591  break;
592  }
593  }
594 
595  if (vlib_get_n_threads () > 1)
596  {
598  if (j > 0)
599  vlib_cli_output (vm, "---------------");
600 
601  if (w->cpu_id > -1)
602  vlib_cli_output (vm, "Thread %d %s (lcore %u)", j, w->name,
603  w->cpu_id);
604  else
605  vlib_cli_output (vm, "Thread %d %s", j, w->name);
606  }
607 
608  dt = time_now - nm->time_last_runtime_stats_clear;
610  (vm,
611  "Time %.1f, %f sec internal node vector rate %.2f loops/sec %.2f\n"
612  " vector rates in %.4e, out %.4e, drop %.4e, punt %.4e",
613  dt,
615  internal_node_vector_rates[j],
616  stat_vm->loops_per_second,
617  (f64) n_input / dt,
618  (f64) n_output / dt, (f64) n_drop / dt, (f64) n_punt / dt);
619 
620  if (summary == 0)
621  {
622  vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm,
623  0, max);
624  for (i = 0; i < vec_len (nodes); i++)
625  {
626  c =
627  nodes[i]->stats_total.calls -
628  nodes[i]->stats_last_clear.calls;
629  d =
630  nodes[i]->stats_total.suspends -
631  nodes[i]->stats_last_clear.suspends;
632  if (c || d || !brief)
633  {
635  stat_vm, nodes[i], max);
636  }
637  }
638  }
639  vec_free (nodes);
640  }
641  vec_free (stat_vms);
642  vec_free (node_dups);
643  vec_free (internal_node_vector_rates);
644  }
645 
646  return 0;
647 }
648 
649 /* *INDENT-OFF* */
650 VLIB_CLI_COMMAND (show_node_runtime_command, static) = {
651  .path = "show runtime",
652  .short_help = "Show packet processing runtime",
653  .function = show_node_runtime,
654  .is_mp_safe = 1,
655 };
656 /* *INDENT-ON* */
657 
658 static clib_error_t *
660  unformat_input_t * input, vlib_cli_command_t * cmd)
661 {
663  vlib_node_t *n;
664  int i, j;
665  vlib_main_t **stat_vms = 0, *stat_vm;
667 
668  for (i = 0; i < vlib_get_n_threads (); i++)
669  {
670  stat_vm = vlib_get_main_by_index (i);
671  if (stat_vm)
672  vec_add1 (stat_vms, stat_vm);
673  }
674 
676 
677  for (j = 0; j < vec_len (stat_vms); j++)
678  {
679  stat_vm = stat_vms[j];
680  nm = &stat_vm->node_main;
681 
682  for (i = 0; i < vec_len (nm->nodes); i++)
683  {
684  n = nm->nodes[i];
685  vlib_node_sync_stats (stat_vm, n);
687 
688  r = vlib_node_get_runtime (stat_vm, n->index);
689  r->max_clock = 0;
690  }
691  /* Note: input/output rates computed using vlib_global_main */
693  }
694 
696 
697  vec_free (stat_vms);
698 
699  return 0;
700 }
701 
702 /* *INDENT-OFF* */
703 VLIB_CLI_COMMAND (clear_node_runtime_command, static) = {
704  .path = "clear runtime",
705  .short_help = "Clear packet processing runtime statistics",
706  .function = clear_node_runtime,
707 };
708 /* *INDENT-ON* */
709 
710 static clib_error_t *
712  vlib_cli_command_t * cmd)
713 {
714  unformat_input_t _line_input, *line_input = &_line_input;
715  clib_error_t *error = 0;
716  vlib_node_main_t *nm = &vm->node_main;
717  vlib_node_t *n;
718  u8 *s = 0, *s2 = 0;
719  u32 i, node_index = ~0, verbose = 0;
720  char *type_str;
721  u8 valid_node_name = 0;
722  u64 cl, ca, v;
723 
724  if (!unformat_user (input, unformat_line_input, line_input))
725  return 0;
726 
727  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
728  {
729  if (unformat (line_input, "index %u", &node_index))
730  ;
731  else if (unformat (line_input, "verbose"))
732  verbose = 1;
733  else
734  if (unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
735  valid_node_name = 1;
736  else if (!valid_node_name)
737  error = clib_error_return (0, "unknown node name: '%U'",
738  format_unformat_error, line_input);
739  else
740  error = clib_error_return (0, "unknown input '%U'",
741  format_unformat_error, line_input);
742 
743  if (error)
744  break;
745  }
746 
747  unformat_free (line_input);
748 
749  if (error)
750  return error;
751 
752  if (node_index >= vec_len (vm->node_main.nodes))
753  return clib_error_return (0, "please specify valid node");
754 
755  n = vlib_get_node (vm, node_index);
756  vlib_node_sync_stats (vm, n);
757 
758  switch (n->type)
759  {
761  type_str = "internal";
762  break;
764  type_str = "input";
765  break;
767  type_str = "pre-input";
768  break;
770  type_str = "process";
771  break;
772  default:
773  type_str = "unknown";
774  }
775 
776  if (n->sibling_of)
777  s = format (s, ", sibling-of %s", n->sibling_of);
778 
779  vlib_cli_output (vm, "node %v, type %s, state %U, index %d%v\n",
780  n->name, type_str, format_vlib_node_state, vm, n,
781  n->index, s);
782  vec_reset_length (s);
783 
784  if (n->node_fn_registrations)
785  {
788  while (fnr)
789  {
790  v = vec_elt_at_index (vm->node_main.variants, fnr->march_variant);
791  if (vec_len (s) == 0)
792  s = format (s, "\n %-15s %=8s %6s %s", "Name", "Priority",
793  "Active", "Description");
794  s = format (s, "\n %-15s %8d %=6s %s", v->suffix, v->priority,
795  fnr->function == n->function ? "yes" : "", v->desc);
796  fnr = fnr->next_registration;
797  }
798  }
799  else
800  s = format (s, "\n default only");
801  vlib_cli_output (vm, " node function variants:%v\n", s);
802  vec_reset_length (s);
803 
804  for (i = 0; i < vec_len (n->next_nodes); i++)
805  {
806  vlib_node_t *pn;
807  if (n->next_nodes[i] == VLIB_INVALID_NODE_INDEX)
808  continue;
809 
810  pn = vec_elt (nm->nodes, n->next_nodes[i]);
811 
812  if (vec_len (s) == 0)
813  s = format (s, "\n %10s %10s %=30s %8s",
814  "next-index", "node-index", "Node", "Vectors");
815 
816  s = format (s, "\n %=10u %=10u %=30v %=8llu", i, n->next_nodes[i],
817  pn->name, vec_elt (n->n_vectors_by_next_node, i));
818  }
819 
820  if (vec_len (s) == 0)
821  s = format (s, "\n none");
822  vlib_cli_output (vm, "\n next nodes:%v\n", s);
823  vec_reset_length (s);
824 
825  if (n->type == VLIB_NODE_TYPE_INTERNAL)
826  {
827  int j = 0;
828  /* *INDENT-OFF* */
830  vlib_node_t *pn = vlib_get_node (vm, i);
831  if (j++ % 3 == 0)
832  s = format (s, "\n ");
833  s2 = format (s2, "%v (%u)", pn->name, i);
834  s = format (s, "%-35v", s2);
835  vec_reset_length (s2);
836  }
837  /* *INDENT-ON* */
838 
839  if (vec_len (s) == 0)
840  s = format (s, "\n none");
841  vlib_cli_output (vm, "\n known previous nodes:%v\n", s);
842  vec_reset_length (s);
843  vec_free (s2);
844  }
845 
846  if (!verbose)
847  goto done;
848 
849  s = format (s, "\n%8s %=12s %=12s %=12s %=12s %=12s\n", "Thread", "Calls",
850  "Clocks", "Vectors", "Max Clock", "Max Vectors");
851  for (i = 0; i < vlib_get_n_threads (); i++)
852  {
853  n = vlib_get_node (vlib_get_main_by_index (i), node_index);
855 
859 
860  s = format (s, "%=8u %=12lu %=12lu %=12lu %=12u %=12u\n", i, ca, cl, v,
862  }
863 
864  vlib_cli_output (vm, "%v", s);
865 
866 done:
867 
868  vec_free (s);
869  return 0;
870 }
871 
872 /* *INDENT-OFF* */
873 VLIB_CLI_COMMAND (show_node_command, static) = {
874  .path = "show node",
875  .short_help = "show node [index] <node-name | node-index>",
876  .function = show_node,
877 };
878 
879 static clib_error_t *
881 {
882  unformat_input_t _line_input, *line_input = &_line_input;
883  u32 node_index, march_variant;
884  vlib_node_t *n;
885  clib_error_t *err = 0;
886 
887  if (!unformat_user (input, unformat_line_input, line_input))
888  return 0;
889 
890  if (!unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
891  {
892  err = clib_error_return (0, "please specify valid node name");
893  goto done;
894  }
895 
896  if (!unformat (line_input, "%U", unformat_vlib_node_variant, &march_variant))
897  {
898  err = clib_error_return (0, "please specify node function variant");
899  goto done;
900  }
901 
902  n = vlib_get_node (vm, node_index);
903 
904  if (n->node_fn_registrations == 0)
905  {
906  err = clib_error_return (0, "node doesn't have function variants");
907  goto done;
908  }
909 
910  if (vlib_node_set_march_variant (vm, node_index, march_variant))
911  {
913  v = vec_elt_at_index (vm->node_main.variants, march_variant);
914  err = clib_error_return (0, "node function variant '%s' not found",
915  v->suffix);
916  goto done;
917  }
918 
919 
920 done:
921  unformat_free (line_input);
922  return err;
923 }
924 
925 /* *INDENT-OFF* */
926 VLIB_CLI_COMMAND (set_node_fn_command, static) = {
927  .path = "set node function",
928  .short_help = "set node function <node-name> <variant-name>",
929  .function = set_node_fn,
930 };
931 /* *INDENT-ON* */
932 
933 /* Dummy function to get us linked in. */
934 void
936 {
937 }
938 
939 /*
940  * fd.io coding-style-patch-verification: ON
941  *
942  * Local Variables:
943  * eval: (c-set-style "gnu")
944  * End:
945  */
u32 * next_nodes
Definition: node.h:326
f64 vlib_get_stat_segment_update_rate(void)
Definition: node_cli.c:470
u32 max_clock
Maximum clock cycle for an invocation.
Definition: node.h:465
vnet_interface_output_runtime_t * rt
#define clib_min(x, y)
Definition: clib.h:342
vlib_node_fn_variant_t * variants
Definition: node.h:737
vnet_hw_if_output_node_runtime_t * r
static uword * clib_bitmap_set_region(uword *bitmap, uword i, uword value, uword n_bits)
Definition: bitmap.h:317
static clib_error_t * show_node_graphviz(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:96
unsigned long u64
Definition: types.h:89
u32 index
Definition: node.h:270
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:325
#define clib_bitmap_foreach(i, ai)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
u16 flags
Definition: node.h:279
static int node_cmp(void *a1, void *a2)
Definition: node_cli.c:48
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:607
#define VLIB_NODE_FLAG_IS_PUNT
Definition: node.h:288
static uword * clib_bitmap_set(uword *ai, uword i, uword value)
Sets the ith bit of a bitmap to new_value Removes trailing zeros from the bitmap. ...
Definition: bitmap.h:167
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
static u32 format_get_indent(u8 *s)
Definition: format.h:72
string name[64]
Definition: fib.api:25
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
double f64
Definition: types.h:142
u8 state
Definition: node.h:300
vlib_node_function_t * function
Definition: node.h:251
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:194
unsigned int u32
Definition: types.h:88
vlib_node_stats_t stats_last_clear
Definition: node.h:264
if(node->flags &VLIB_NODE_FLAG_TRACE) vnet_interface_output_trace(vm
static clib_error_t * show_node_runtime(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:476
uword unformat_vlib_tmpfile(unformat_input_t *input, va_list *args)
Definition: format.c:192
#define VLIB_INVALID_NODE_INDEX
Definition: node.h:366
static uword clib_bitmap_is_zero(uword *ai)
predicate function; is an entire bitmap empty?
Definition: bitmap.h:57
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
vlib_node_t ** nodes
Definition: node.h:669
description fragment has unexpected format
Definition: map.api:433
char * sibling_of
Definition: node.h:329
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
Definition: error.h:99
struct _vlib_node_fn_registration vlib_node_fn_registration_t
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
Definition: node.h:552
static clib_error_t * show_node(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:711
#define VLIB_PROCESS_IS_RUNNING
Definition: node.h:558
unformat_function_t unformat_vlib_node_variant
Definition: node.h:221
u64 max_clock_n
Definition: node.h:228
unformat_function_t unformat_line_input
Definition: format.h:275
static u8 * format_vlib_node_stats(u8 *s, va_list *va)
Definition: node_cli.c:382
Definition: cJSON.c:88
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:35
vlib_node_stats_t stats_total
Definition: node.h:260
f64 time_last_runtime_stats_clear
Definition: node.h:731
struct _unformat_input_t unformat_input_t
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:444
static clib_error_t * set_node_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:880
u64 * n_vectors_by_next_node
Definition: node.h:335
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
u8 * name
Definition: node.h:254
#define clib_bitmap_alloc(v, n_bits)
Allocate a bitmap with the supplied number of bits.
Definition: bitmap.h:109
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
svmdb_client_t * c
int vlib_node_set_march_variant(vlib_main_t *vm, u32 node_index, clib_march_variant_type_t march_variant)
Definition: node.c:823
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
#define format__(vm__, fd__,...)
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:395
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:116
static u8 * format_vlib_node_state(u8 *s, va_list *va)
Definition: node_cli.c:336
static uword clib_bitmap_get(uword *ai, uword i)
Gets the ith bit value from a bitmap.
Definition: bitmap.h:197
vlib_node_fn_registration_t * node_fn_registrations
Definition: node.h:363
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
static clib_error_t * clear_node_runtime(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:659
void vlib_node_cli_reference(void)
Definition: node_cli.c:935
#define clib_bitmap_free(v)
Free a bitmap.
Definition: bitmap.h:92
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:1034
static u32 vlib_get_n_threads()
Definition: global_funcs.h:23
uword * prev_node_bitmap
Definition: node.h:343
void vlib_node_sync_stats(vlib_main_t *vm, vlib_node_t *n)
Definition: main.c:610
#define vec_elt(v, i)
Get vector value at index i.
#define VLIB_NODE_FLAG_IS_HANDOFF
Definition: node.h:289
static vlib_main_t * vlib_get_main_by_index(u32 thread_index)
Definition: global_funcs.h:29
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vlib_node_main_t node_main
Definition: main.h:171
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:1098
static void unformat_free(unformat_input_t *i)
Definition: format.h:155
static clib_error_t * show_node_graph(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:57
node node_index
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1241
#define VLIB_NODE_FLAG_IS_DROP
Definition: node.h:287
u16 flags
Definition: node.h:551
void vlib_node_runtime_sync_stats_node(vlib_node_t *n, vlib_node_runtime_t *r, uword n_calls, uword n_vectors, uword n_clocks)
Definition: main.c:574
vlib_node_type_t type
Definition: node.h:267
static vlib_process_t * vlib_get_process_from_node(vlib_main_t *vm, vlib_node_t *node)
Definition: node_funcs.h:265
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1386
nat44_ei_main_t * nm
vl_api_dhcp_client_state_t state
Definition: dhcp.api:201
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:86
#define VLIB_NODE_FLAG_IS_OUTPUT
Definition: node.h:286
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
Definition: node.h:553
static f64 vlib_internal_node_vector_rate(vlib_main_t *vm)
Definition: main.h:394
format_function_t format_vlib_node_graph
Definition: node_funcs.h:1234
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
uword * non_empty_event_type_bitmap
Definition: node.h:572