FD.io VPP  v19.01.3-6-g70449b9b9
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 <vlib/vlib.h>
41 #include <vlib/threads.h>
42 
43 static int
44 node_cmp (void *a1, void *a2)
45 {
46  vlib_node_t **n1 = a1;
47  vlib_node_t **n2 = a2;
48 
49  return vec_cmp (n1[0]->name, n2[0]->name);
50 }
51 
52 static clib_error_t *
54  unformat_input_t * input, vlib_cli_command_t * cmd)
55 {
56  vlib_node_main_t *nm = &vm->node_main;
57  vlib_node_t *n;
58  u32 node_index;
59 
60  vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, 0);
61 
62  if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
63  {
64  n = vlib_get_node (vm, node_index);
65  vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, n);
66  }
67  else
68  {
69  vlib_node_t **nodes = vec_dup (nm->nodes);
70  uword i;
71 
73 
74  for (i = 0; i < vec_len (nodes); i++)
75  vlib_cli_output (vm, "%U\n\n", format_vlib_node_graph, nm, nodes[i]);
76 
77  vec_free (nodes);
78  }
79 
80  return 0;
81 }
82 
83 /* *INDENT-OFF* */
84 VLIB_CLI_COMMAND (show_node_graph_command, static) = {
85  .path = "show vlib graph",
86  .short_help = "Show packet processing node graph",
87  .function = show_node_graph,
88 };
89 /* *INDENT-ON* */
90 
91 static u8 *
92 format_vlib_node_state (u8 * s, va_list * va)
93 {
94  vlib_main_t *vm = va_arg (*va, vlib_main_t *);
95  vlib_node_t *n = va_arg (*va, vlib_node_t *);
96  char *state;
97 
98  state = "active";
99  if (n->type == VLIB_NODE_TYPE_PROCESS)
100  {
102 
105  {
106  default:
107  if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
108  state = "done";
109  break;
110 
112  state = "time wait";
113  break;
114 
116  state = "event wait";
117  break;
118 
120  state =
121  "any wait";
122  break;
123  }
124  }
125  else if (n->type != VLIB_NODE_TYPE_INTERNAL)
126  {
127  state = "polling";
128  if (n->state == VLIB_NODE_STATE_DISABLED)
129  state = "disabled";
130  else if (n->state == VLIB_NODE_STATE_INTERRUPT)
131  state = "interrupt wait";
132  }
133 
134  return format (s, "%s", state);
135 }
136 
137 static u8 *
138 format_vlib_node_stats (u8 * s, va_list * va)
139 {
140  vlib_main_t *vm = va_arg (*va, vlib_main_t *);
141  vlib_node_t *n = va_arg (*va, vlib_node_t *);
142  int max = va_arg (*va, int);
143  f64 v;
144  u8 *ns;
145  u8 *misc_info = 0;
146  u64 c, p, l, d;
147  f64 x;
148  f64 maxc, maxcn;
149  u32 maxn;
150  u32 indent;
151  u64 pmc_ticks;
152  f64 pmc_ticks_per_packet;
153 
154  if (!n)
155  {
156  if (max)
157  s = format (s,
158  "%=30s%=17s%=16s%=16s%=16s%=16s",
159  "Name", "Max Node Clocks", "Vectors at Max",
160  "Max Clocks", "Avg Clocks", "Avg Vectors/Call");
161  else
162  s = format (s,
163  "%=30s%=12s%=16s%=16s%=16s%=16s%=16s",
164  "Name", "State", "Calls", "Vectors", "Suspends",
165  "Clocks", "Vectors/Call");
166  if (vm->perf_counter_id)
167  s = format (s, "%=16s", "Perf Ticks");
168 
169  return s;
170  }
171 
172  indent = format_get_indent (s);
173 
178  maxc = (f64) n->stats_total.max_clock;
179  maxn = n->stats_total.max_clock_n;
180  if (n->stats_total.max_clock_n)
181  maxcn = (f64) n->stats_total.max_clock / (f64) maxn;
182  else
183  maxcn = 0.0;
184 
185  pmc_ticks = n->stats_total.perf_counter_ticks -
187  if (p > 0)
188  pmc_ticks_per_packet = (f64) pmc_ticks / (f64) p;
189  else
190  pmc_ticks_per_packet = 0.0;
191 
192  /* Clocks per packet, per call or per suspend. */
193  x = 0;
194  if (p > 0)
195  x = (f64) l / (f64) p;
196  else if (c > 0)
197  x = (f64) l / (f64) c;
198  else if (d > 0)
199  x = (f64) l / (f64) d;
200 
201  if (c > 0)
202  v = (double) p / (double) c;
203  else
204  v = 0;
205 
206  if (n->type == VLIB_NODE_TYPE_PROCESS)
207  {
209 
210  /* Show processes with events pending. This helps spot bugs where events are not
211  being handled. */
213  misc_info = format (misc_info, "events pending, ");
214  }
215  ns = n->name;
216 
217  if (max)
218  s = format (s, "%-30v%=17.2e%=16d%=16.2e%=16.2e%=16.2e",
219  ns, maxc, maxn, maxcn, x, v);
220  else
221  s = format (s, "%-30v%=12U%16Ld%16Ld%16Ld%16.2e%16.2f", ns,
222  format_vlib_node_state, vm, n, c, p, d, x, v);
223 
224  if (pmc_ticks_per_packet > 0.0)
225  s = format (s, "%16.2e", pmc_ticks_per_packet);
226 
227  if (ns != n->name)
228  vec_free (ns);
229 
230  if (misc_info)
231  {
232  s = format (s, "\n%U%v", format_white_space, indent + 4, misc_info);
233  vec_free (misc_info);
234  }
235 
236  return s;
237 }
238 
239 static clib_error_t *
241  unformat_input_t * input, vlib_cli_command_t * cmd)
242 {
243  vlib_node_main_t *nm = &vm->node_main;
244  vlib_node_t *n;
245  f64 time_now;
246  u32 node_index;
247  vlib_node_t ***node_dups = 0;
248  f64 *vectors_per_main_loop = 0;
249  f64 *last_vector_length_per_node = 0;
250 
251  time_now = vlib_time_now (vm);
252 
253  if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
254  {
255  n = vlib_get_node (vm, node_index);
256  vlib_node_sync_stats (vm, n);
257  vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, 0, 0);
258  vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, n, 0);
259  }
260  else
261  {
262  vlib_node_t **nodes;
263  uword i, j;
264  f64 dt;
265  u64 n_input, n_output, n_drop, n_punt;
266  u64 n_internal_vectors, n_internal_calls;
267  u64 n_clocks, l, v, c, d;
268  int brief = 1;
269  int max = 0;
270  vlib_main_t **stat_vms = 0, *stat_vm;
271 
272  /* Suppress nodes with zero calls since last clear */
273  if (unformat (input, "brief") || unformat (input, "b"))
274  brief = 1;
275  if (unformat (input, "verbose") || unformat (input, "v"))
276  brief = 0;
277  if (unformat (input, "max") || unformat (input, "m"))
278  max = 1;
279 
280  for (i = 0; i < vec_len (vlib_mains); i++)
281  {
282  stat_vm = vlib_mains[i];
283  if (stat_vm)
284  vec_add1 (stat_vms, stat_vm);
285  }
286 
287  /*
288  * Barrier sync across stats scraping.
289  * Otherwise, the counts will be grossly inaccurate.
290  */
292 
293  for (j = 0; j < vec_len (stat_vms); j++)
294  {
295  stat_vm = stat_vms[j];
296  nm = &stat_vm->node_main;
297 
298  for (i = 0; i < vec_len (nm->nodes); i++)
299  {
300  n = nm->nodes[i];
301  vlib_node_sync_stats (stat_vm, n);
302  }
303 
304  nodes = vec_dup (nm->nodes);
305 
306  vec_add1 (node_dups, nodes);
307  vec_add1 (vectors_per_main_loop,
309  vec_add1 (last_vector_length_per_node,
311  }
313 
314 
315  for (j = 0; j < vec_len (stat_vms); j++)
316  {
317  stat_vm = stat_vms[j];
318  nodes = node_dups[j];
319 
321 
322  n_input = n_output = n_drop = n_punt = n_clocks = 0;
323  n_internal_vectors = n_internal_calls = 0;
324  for (i = 0; i < vec_len (nodes); i++)
325  {
326  n = nodes[i];
327 
329  n_clocks += l;
330 
333 
334  switch (n->type)
335  {
336  default:
337  continue;
338 
340  n_output += (n->flags & VLIB_NODE_FLAG_IS_OUTPUT) ? v : 0;
341  n_drop += (n->flags & VLIB_NODE_FLAG_IS_DROP) ? v : 0;
342  n_punt += (n->flags & VLIB_NODE_FLAG_IS_PUNT) ? v : 0;
343  if (!(n->flags & VLIB_NODE_FLAG_IS_OUTPUT))
344  {
345  n_internal_vectors += v;
346  n_internal_calls += c;
347  }
349  n_input += v;
350  break;
351 
353  n_input += v;
354  break;
355  }
356  }
357 
358  if (vec_len (vlib_mains) > 1)
359  {
361  if (j > 0)
362  vlib_cli_output (vm, "---------------");
363 
364  if (w->cpu_id > -1)
365  vlib_cli_output (vm, "Thread %d %s (lcore %u)", j, w->name,
366  w->cpu_id);
367  else
368  vlib_cli_output (vm, "Thread %d %s", j, w->name);
369  }
370 
371  dt = time_now - nm->time_last_runtime_stats_clear;
373  (vm,
374  "Time %.1f, average vectors/node %.2f, last %d main loops %.2f per node %.2f"
375  "\n vector rates in %.4e, out %.4e, drop %.4e, punt %.4e",
376  dt,
377  (n_internal_calls > 0
378  ? (f64) n_internal_vectors / (f64) n_internal_calls
379  : 0),
381  vectors_per_main_loop[j],
382  last_vector_length_per_node[j],
383  (f64) n_input / dt,
384  (f64) n_output / dt, (f64) n_drop / dt, (f64) n_punt / dt);
385 
386  vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm, 0, max);
387  for (i = 0; i < vec_len (nodes); i++)
388  {
389  c =
390  nodes[i]->stats_total.calls -
391  nodes[i]->stats_last_clear.calls;
392  d =
393  nodes[i]->stats_total.suspends -
394  nodes[i]->stats_last_clear.suspends;
395  if (c || d || !brief)
396  {
397  vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm,
398  nodes[i], max);
399  }
400  }
401  vec_free (nodes);
402  }
403  vec_free (stat_vms);
404  vec_free (node_dups);
405  vec_free (vectors_per_main_loop);
406  vec_free (last_vector_length_per_node);
407  }
408 
409  return 0;
410 }
411 
412 /* *INDENT-OFF* */
413 VLIB_CLI_COMMAND (show_node_runtime_command, static) = {
414  .path = "show runtime",
415  .short_help = "Show packet processing runtime",
416  .function = show_node_runtime,
417  .is_mp_safe = 1,
418 };
419 /* *INDENT-ON* */
420 
421 static clib_error_t *
423  unformat_input_t * input, vlib_cli_command_t * cmd)
424 {
425  vlib_node_main_t *nm;
426  vlib_node_t *n;
427  int i, j;
428  vlib_main_t **stat_vms = 0, *stat_vm;
430 
431  for (i = 0; i < vec_len (vlib_mains); i++)
432  {
433  stat_vm = vlib_mains[i];
434  if (stat_vm)
435  vec_add1 (stat_vms, stat_vm);
436  }
437 
439 
440  for (j = 0; j < vec_len (stat_vms); j++)
441  {
442  stat_vm = stat_vms[j];
443  nm = &stat_vm->node_main;
444 
445  for (i = 0; i < vec_len (nm->nodes); i++)
446  {
447  n = nm->nodes[i];
448  vlib_node_sync_stats (stat_vm, n);
450 
451  r = vlib_node_get_runtime (stat_vm, n->index);
452  r->max_clock = 0;
453  }
454  /* Note: input/output rates computed using vlib_global_main */
456  }
457 
459 
460  vec_free (stat_vms);
461 
462  return 0;
463 }
464 
465 /* *INDENT-OFF* */
466 VLIB_CLI_COMMAND (clear_node_runtime_command, static) = {
467  .path = "clear runtime",
468  .short_help = "Clear packet processing runtime statistics",
469  .function = clear_node_runtime,
470 };
471 /* *INDENT-ON* */
472 
473 static clib_error_t *
475  vlib_cli_command_t * cmd)
476 {
477  unformat_input_t _line_input, *line_input = &_line_input;
478  clib_error_t *error = 0;
479  vlib_node_main_t *nm = &vm->node_main;
480  vlib_node_t *n;
481  u8 *s = 0, *s2 = 0;
482  u32 i, node_index = ~0;
483  char *type_str;
484  u8 valid_node_name = 0;
485 
486  if (!unformat_user (input, unformat_line_input, line_input))
487  return 0;
488 
489  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
490  {
491  if (unformat (line_input, "index %u", &node_index))
492  ;
493  else
494  if (unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
495  valid_node_name = 1;
496  else if (!valid_node_name)
497  error = clib_error_return (0, "unknown node name: '%U'",
498  format_unformat_error, line_input);
499  else
500  error = clib_error_return (0, "unknown input '%U'",
501  format_unformat_error, line_input);
502  }
503 
504  unformat_free (line_input);
505 
506  if (error)
507  return error;
508 
509  if (node_index >= vec_len (vm->node_main.nodes))
510  return clib_error_return (0, "please specify valid node");
511 
512  n = vlib_get_node (vm, node_index);
513  vlib_node_sync_stats (vm, n);
514 
515  switch (n->type)
516  {
518  type_str = "internal";
519  break;
521  type_str = "input";
522  break;
524  type_str = "pre-input";
525  break;
527  type_str = "process";
528  break;
529  default:
530  type_str = "unknown";
531  }
532 
533  if (n->sibling_of)
534  s = format (s, ", sibling-of %s", n->sibling_of);
535 
536  vlib_cli_output (vm, "node %s, type %s, state %U, index %d%v\n",
537  n->name, type_str, format_vlib_node_state, vm, n,
538  n->index, s);
539  vec_reset_length (s);
540 
541  if (n->node_fn_registrations)
542  {
544  while (fnr)
545  {
546  if (vec_len (s) == 0)
547  s = format (s, "\n %-15s %=8s %6s",
548  "Name", "Priority", "Active");
549  s = format (s, "\n %-15s %=8u %=6s", fnr->name, fnr->priority,
550  fnr->function == n->function ? "yes" : "");
551  fnr = fnr->next_registration;
552  }
553  }
554  else
555  s = format (s, "\n default only");
556  vlib_cli_output (vm, " node function variants:%v\n", s);
557  vec_reset_length (s);
558 
559  for (i = 0; i < vec_len (n->next_nodes); i++)
560  {
561  vlib_node_t *pn;
562  if (n->next_nodes[i] == VLIB_INVALID_NODE_INDEX)
563  continue;
564 
565  pn = vec_elt (nm->nodes, n->next_nodes[i]);
566 
567  if (vec_len (s) == 0)
568  s = format (s, "\n %10s %10s %=30s %8s",
569  "next-index", "node-index", "Node", "Vectors");
570 
571  s = format (s, "\n %=10u %=10u %-30v %=8llu", i, n->next_nodes[i],
572  pn->name, vec_elt (n->n_vectors_by_next_node, i));
573  }
574 
575  if (vec_len (s) == 0)
576  s = format (s, "\n none");
577  vlib_cli_output (vm, "\n next nodes:%v\n", s);
578  vec_reset_length (s);
579 
580  if (n->type == VLIB_NODE_TYPE_INTERNAL)
581  {
582  int j = 0;
583  /* *INDENT-OFF* */
585  vlib_node_t *pn = vlib_get_node (vm, i);
586  if (j++ % 3 == 0)
587  s = format (s, "\n ");
588  s2 = format (s2, "%v (%u)", pn->name, i);
589  s = format (s, "%-35v", s2);
590  vec_reset_length (s2);
591  }));
592  /* *INDENT-ON* */
593 
594  if (vec_len (s) == 0)
595  s = format (s, "\n none");
596  vlib_cli_output (vm, "\n known previous nodes:%v\n", s);
597  vec_reset_length (s);
598  }
599 
600  vec_free (s);
601  vec_free (s2);
602  return 0;
603 }
604 
605 /* *INDENT-OFF* */
606 VLIB_CLI_COMMAND (show_node_command, static) = {
607  .path = "show node",
608  .short_help = "show node [index] <node-name | node-index>",
609  .function = show_node,
610 };
611 
612 static clib_error_t *
614 {
615  unformat_input_t _line_input, *line_input = &_line_input;
616  u32 node_index;
617  vlib_node_t *n;
618  clib_error_t *err = 0;
620  u8 *variant = 0;
621 
622  if (!unformat_user (input, unformat_line_input, line_input))
623  return 0;
624 
625  if (!unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
626  {
627  err = clib_error_return (0, "please specify valid node name");
628  goto done;
629  }
630 
631  if (!unformat (line_input, "%s", &variant))
632  {
633  err = clib_error_return (0, "please specify node functional variant");
634  goto done;
635  }
636 
637  n = vlib_get_node (vm, node_index);
638 
639  if (n->node_fn_registrations == 0)
640  {
641  err = clib_error_return (0, "node doesn't have functional variants");
642  goto done;
643  }
644 
645  fnr = n->node_fn_registrations;
646  vec_add1 (variant, 0);
647 
648  while (fnr)
649  {
650  if (!strncmp (fnr->name, (char *) variant, vec_len (variant) - 1))
651  {
652  int i;
653 
654  n->function = fnr->function;
655 
656  for (i = 0; i < vec_len (vlib_mains); i++)
657  {
658  vlib_node_runtime_t *nrt;
659  nrt = vlib_node_get_runtime (vlib_mains[i], n->index);
660  nrt->function = fnr->function;
661  }
662  goto done;
663  }
664  fnr = fnr->next_registration;
665  }
666 
667  err = clib_error_return (0, "node functional variant '%s' not found", variant);
668 
669 done:
670  vec_free (variant);
671  unformat_free (line_input);
672  return err;
673 }
674 
675 /* *INDENT-OFF* */
676 VLIB_CLI_COMMAND (set_node_fn_command, static) = {
677  .path = "set node function",
678  .short_help = "set node function <node-name> <variant-name>",
679  .function = set_node_fn,
680 };
681 /* *INDENT-ON* */
682 
683 /* Dummy function to get us linked in. */
684 void
686 {
687 }
688 
689 /*
690  * fd.io coding-style-patch-verification: ON
691  *
692  * Local Variables:
693  * eval: (c-set-style "gnu")
694  * End:
695  */
u32 * next_nodes
Definition: node.h:358
static f64 vlib_last_vectors_per_main_loop_as_f64(vlib_main_t *vm)
Definition: main.h:314
u32 max_clock
Maximum clock cycle for an invocation.
Definition: node.h:501
unsigned long u64
Definition: types.h:89
u32 index
Definition: node.h:304
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:232
u16 flags
Definition: node.h:313
static int node_cmp(void *a1, void *a2)
Definition: node_cli.c:44
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:525
#define VLIB_NODE_FLAG_IS_PUNT
Definition: node.h:322
int i
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
static u32 format_get_indent(u8 *s)
Definition: format.h:72
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
vlib_main_t ** vlib_mains
Definition: buffer.c:310
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:332
vlib_node_function_t * function
Definition: node.h:285
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:204
static f64 vlib_last_vector_length_per_node(vlib_main_t *vm)
Definition: main.h:323
vlib_node_stats_t stats_last_clear
Definition: node.h:298
static clib_error_t * show_node_runtime(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:240
vlib_node_function_t * function
Node function to call.
Definition: node.h:491
#define VLIB_INVALID_NODE_INDEX
Definition: node.h:398
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:113
vlib_node_t ** nodes
Definition: node.h:721
#define VLIB_LOG2_MAIN_LOOPS_PER_STATS_UPDATE
Definition: main.h:95
char * sibling_of
Definition: node.h:361
#define clib_error_return(e, args...)
Definition: error.h:99
u64 perf_counter_ticks
Definition: node.h:261
struct _vlib_node_fn_registration vlib_node_fn_registration_t
vhost_vring_state_t state
Definition: vhost_user.h:120
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
Definition: node.h:590
unsigned int u32
Definition: types.h:88
static clib_error_t * show_node(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:474
#define VLIB_PROCESS_IS_RUNNING
Definition: node.h:596
u64 max_clock_n
Definition: node.h:260
unformat_function_t unformat_line_input
Definition: format.h:282
static u8 * format_vlib_node_stats(u8 *s, va_list *va)
Definition: node_cli.c:138
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:36
#define clib_bitmap_foreach(i, ai, body)
Macro to iterate across set bits in a bitmap.
Definition: bitmap.h:361
vlib_node_stats_t stats_total
Definition: node.h:294
f64 time_last_runtime_stats_clear
Definition: node.h:783
struct _unformat_input_t unformat_input_t
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
static clib_error_t * set_node_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:613
u64 * n_vectors_by_next_node
Definition: node.h:367
u8 name[64]
Definition: memclnt.api:152
int perf_counter_id
Definition: main.h:91
u8 * name
Definition: node.h:288
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
svmdb_client_t * c
vlib_main_t * vm
Definition: buffer.c:301
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
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:89
static u8 * format_vlib_node_state(u8 *s, va_list *va)
Definition: node_cli.c:92
vlib_node_fn_registration_t * node_fn_registrations
Definition: node.h:395
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
static clib_error_t * clear_node_runtime(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:422
void vlib_node_cli_reference(void)
Definition: node_cli.c:685
#define vec_cmp(v1, v2)
Compare two vectors (only applicable to vectors of signed numbers).
Definition: vec.h:923
uword * prev_node_bitmap
Definition: node.h:375
void vlib_node_sync_stats(vlib_main_t *vm, vlib_node_t *n)
Definition: main.c:577
#define vec_elt(v, i)
Get vector value at index i.
#define VLIB_NODE_FLAG_IS_HANDOFF
Definition: node.h:323
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vlib_node_main_t node_main
Definition: main.h:129
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:984
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
static clib_error_t * show_node_graph(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: node_cli.c:53
unformat_function_t unformat_vlib_node
Definition: node_funcs.h:1147
#define VLIB_NODE_FLAG_IS_DROP
Definition: node.h:321
u16 flags
Definition: node.h:589
vlib_node_type_t type
Definition: node.h:301
static vlib_process_t * vlib_get_process_from_node(vlib_main_t *vm, vlib_node_t *node)
Definition: node_funcs.h:208
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:1470
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
#define VLIB_NODE_FLAG_IS_OUTPUT
Definition: node.h:320
#define VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
Definition: node.h:591
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
format_function_t format_vlib_node_graph
Definition: node_funcs.h:1140
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
uword * non_empty_event_type_bitmap
Definition: node.h:610