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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * node_cli.c: node CLI
18 * Copyright (c) 2008 Eliot Dresselhaus
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:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
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.
40 #include <sys/types.h>
43 #include <vlib/vlib.h>
44 #include <vlib/threads.h>
48 node_cmp (void *a1, void *a2)
50 vlib_node_t **n1 = a1;
51 vlib_node_t **n2 = a2;
53 return vec_cmp (n1[0]->name, n2[0]->name);
57 show_node_graph (vlib_main_t * vm,
58 unformat_input_t * input, vlib_cli_command_t * cmd)
60 vlib_node_main_t *nm = &vm->node_main;
64 vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, 0);
66 if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
68 n = vlib_get_node (vm, node_index);
69 vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, n);
73 vlib_node_t **nodes = vec_dup (nm->nodes);
76 vec_sort_with_function (nodes, node_cmp);
78 for (i = 0; i < vec_len (nodes); i++)
79 vlib_cli_output (vm, "%U\n\n", format_vlib_node_graph, nm, nodes[i]);
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,
96 show_node_graphviz (vlib_main_t * vm,
97 unformat_input_t * input, vlib_cli_command_t * cmd)
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;
106 unformat_input_t _line_input, *line_input = &_line_input;
107 u8 filter = 0, calls_filter = 0, vectors_filter = 0, both = 0;
110 /* Get a line of input. */
111 if (unformat_user (input, unformat_line_input, line_input))
113 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
115 if (unformat (line_input, "filter"))
117 else if (unformat (line_input, "calls") && filter)
119 else if (unformat (line_input, "vectors") && filter)
121 else if (unformat (line_input, "file %U", unformat_vlib_tmpfile,
124 fd = open ((char *) chroot_filename,
125 O_CREAT | O_TRUNC | O_WRONLY, 0664);
128 return clib_error_return (0, "unknown input `%U'",
129 format_unformat_error, input);
131 unformat_free (line_input);
134 /*both is set to true if calls_filter and vectors_filter are, or neither */
135 both = filter & (!(calls_filter ^ vectors_filter));
137 #define format__(vm__, fd__, ...) \
140 vlib_cli_output((vm__), ## __VA_ARGS__); \
144 fdformat((fd__), ## __VA_ARGS__); \
147 format__ (vm, fd, "%s", "digraph {\n");
149 clib_bitmap_alloc (active, vec_len (nodes));
150 clib_bitmap_set_region (active, 0, 1, vec_len (nodes));
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 "
165 " 2 [label=\"33-64\", fillcolor=2 style=filled "
166 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
168 " 3 [label=\"65-96\", fillcolor=3 style=filled "
169 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
171 " 4 [label=\"97-128\", fillcolor=4 style=filled "
172 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
174 " 5 [label=\"129-160\", fillcolor=5 style=filled "
175 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
177 " 6 [label=\"161-192\", fillcolor=6 style=filled "
178 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
180 " 7 [label=\"193-224\", fillcolor=7 style=filled "
181 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
183 " 8 [label=\"224+\", fillcolor=8 style=filled "
184 "colorscheme=ylorrd8 fixedsize=true shape=circle width=2 "
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");
193 " a[label=\"0\",fixedsize=true shape=circle width=1] \n"
194 " b[label=\"10\",fixedsize=true shape=circle width=2 "
196 " c[label=\"100\",fixedsize=true shape=circle width=3 "
198 " d[label=\"1000\",fixedsize=true shape=circle width=4 "
200 " a -> b -> c -> d [style=\"invis\",weight =100]\n }\n }\n");
202 vlib_worker_thread_barrier_sync (vm);
203 for (j = 0; j < vec_len (nm->nodes); j++)
207 vlib_node_sync_stats (vm, n);
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++)
215 vlib_node_main_t *nm_clone;
216 vlib_main_t *vm_clone;
217 vlib_node_runtime_t *rt;
220 vm_clone = vlib_get_main_by_index (i);
221 nm_clone = &vm_clone->node_main;
223 for (j = 0; j < vec_len (nm_clone->nodes); j++)
225 n = nm_clone->nodes[j];
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);
232 vlib_worker_thread_barrier_release (vm);
234 for (i = 0; i < vec_len (nodes); i++)
237 c = nodes[i]->stats_total.calls - nodes[i]->stats_last_clear.calls;
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;
242 if ((both && c > 0 && p > 0) || (calls_filter && c > 0) ||
243 (vectors_filter && p > 0))
245 format__ (vm, fd, " \"%v\" [shape=circle", nodes[i]->name);
246 /*Changing the size and the font of nodes that receive packets*/
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*/
256 u64 color = ((p - 1) / (32 * c)) + 1;
257 color = clib_min (color, 8);
260 " fillcolor=%u style=filled colorscheme=ylorrd8",
264 format__ (vm, fd, "]\n");
268 clib_bitmap_set (active, i, 0);
273 clib_bitmap_foreach (i, active)
275 for (j = 0; j < vec_len (nodes[i]->next_nodes); j++)
277 if (nodes[i]->next_nodes[j] == VLIB_INVALID_NODE_INDEX)
280 if (!filter || clib_bitmap_get (active, nodes[i]->next_nodes[j]))
282 format__ (vm, fd, " \"%v\" -> \"%v\"\n", nodes[i]->name,
283 nodes[nodes[i]->next_nodes[j]]->name);
288 format__ (vm, fd, "}\n");
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);
301 clib_bitmap_free (active);
302 vec_free (chroot_filename);
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.
321 * show vlib graphviz filter file tmpfile
322 * show vlib graphviz filter calls file tmpfile
324 * @cliexcmd{show vlib graphviz [filter][calls][vectors][file <filename>]}
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,
336 format_vlib_node_state (u8 * s, va_list * va)
338 vlib_main_t *vm = va_arg (*va, vlib_main_t *);
339 vlib_node_t *n = va_arg (*va, vlib_node_t *);
343 if (n->type == VLIB_NODE_TYPE_PROCESS)
345 vlib_process_t *p = vlib_get_process_from_node (vm, n);
347 switch (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
348 | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
351 if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
355 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
359 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
360 state = "event wait";
363 case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
369 else if (n->type != VLIB_NODE_TYPE_INTERNAL)
372 if (n->state == VLIB_NODE_STATE_DISABLED)
374 else if (n->state == VLIB_NODE_STATE_INTERRUPT)
375 state = "interrupt wait";
378 return format (s, "%s", state);
382 format_vlib_node_stats (u8 * s, va_list * va)
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);
400 "%=30s%=17s%=16s%=16s%=16s%=16s",
401 "Name", "Max Node Clocks", "Vectors at Max",
402 "Max Clocks", "Avg Clocks", "Avg Vectors/Call");
405 "%=30s%=12s%=16s%=16s%=16s%=16s%=16s",
406 "Name", "State", "Calls", "Vectors", "Suspends",
407 "Clocks", "Vectors/Call");
411 indent = format_get_indent (s);
413 l = n->stats_total.clocks - n->stats_last_clear.clocks;
414 c = n->stats_total.calls - n->stats_last_clear.calls;
415 p = n->stats_total.vectors - n->stats_last_clear.vectors;
416 d = n->stats_total.suspends - n->stats_last_clear.suspends;
417 maxc = (f64) n->stats_total.max_clock;
418 maxn = n->stats_total.max_clock_n;
419 if (n->stats_total.max_clock_n)
420 maxcn = (f64) n->stats_total.max_clock / (f64) maxn;
424 /* Clocks per packet, per call or per suspend. */
427 x = (f64) l / (f64) p;
429 x = (f64) l / (f64) c;
431 x = (f64) l / (f64) d;
434 v = (double) p / (double) c;
438 if (n->type == VLIB_NODE_TYPE_PROCESS)
440 vlib_process_t *p = vlib_get_process_from_node (vm, n);
442 /* Show processes with events pending. This helps spot bugs where events are not
444 if (!clib_bitmap_is_zero (p->non_empty_event_type_bitmap))
445 misc_info = format (misc_info, "events pending, ");
450 s = format (s, "%-30v%=17.2e%=16d%=16.2e%=16.2e%=16.2e",
451 ns, maxc, maxn, maxcn, x, v);
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);
461 s = format (s, "\n%U%v", format_white_space, indent + 4, misc_info);
462 vec_free (misc_info);
468 f64 vlib_get_stat_segment_update_rate (void) __attribute__ ((weak));
470 vlib_get_stat_segment_update_rate (void)
475 static clib_error_t *
476 show_node_runtime (vlib_main_t * vm,
477 unformat_input_t * input, vlib_cli_command_t * cmd)
479 vlib_node_main_t *nm = &vm->node_main;
483 vlib_node_t ***node_dups = 0;
484 f64 *internal_node_vector_rates = 0;
486 time_now = vlib_time_now (vm);
488 if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
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);
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;
506 vlib_main_t **stat_vms = 0, *stat_vm;
508 /* Suppress nodes with zero calls since last clear */
509 if (unformat (input, "brief") || unformat (input, "b"))
511 if (unformat (input, "verbose") || unformat (input, "v"))
513 if (unformat (input, "max") || unformat (input, "m"))
515 if (unformat (input, "summary") || unformat (input, "sum")
516 || unformat (input, "su"))
519 for (i = 0; i < vlib_get_n_threads (); i++)
521 stat_vm = vlib_get_main_by_index (i);
523 vec_add1 (stat_vms, stat_vm);
527 * Barrier sync across stats scraping.
528 * Otherwise, the counts will be grossly inaccurate.
530 vlib_worker_thread_barrier_sync (vm);
532 for (j = 0; j < vec_len (stat_vms); j++)
534 stat_vm = stat_vms[j];
535 nm = &stat_vm->node_main;
537 for (i = 0; i < vec_len (nm->nodes); i++)
540 vlib_node_sync_stats (stat_vm, n);
543 nodes = vec_dup (nm->nodes);
545 vec_add1 (node_dups, nodes);
546 vec_add1 (internal_node_vector_rates,
547 vlib_internal_node_vector_rate (stat_vm));
549 vlib_worker_thread_barrier_release (vm);
552 for (j = 0; j < vec_len (stat_vms); j++)
554 stat_vm = stat_vms[j];
555 nodes = node_dups[j];
557 vec_sort_with_function (nodes, node_cmp);
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++)
565 l = n->stats_total.clocks - n->stats_last_clear.clocks;
568 v = n->stats_total.vectors - n->stats_last_clear.vectors;
569 c = n->stats_total.calls - n->stats_last_clear.calls;
576 case VLIB_NODE_TYPE_INTERNAL:
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))
582 n_internal_vectors += v;
583 n_internal_calls += c;
585 if (n->flags & VLIB_NODE_FLAG_IS_HANDOFF)
589 case VLIB_NODE_TYPE_INPUT:
595 if (vlib_get_n_threads () > 1)
597 vlib_worker_thread_t *w = vlib_worker_threads + j;
599 vlib_cli_output (vm, "---------------");
602 vlib_cli_output (vm, "Thread %d %s (lcore %u)", j, w->name,
605 vlib_cli_output (vm, "Thread %d %s", j, w->name);
608 dt = time_now - nm->time_last_runtime_stats_clear;
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",
614 vlib_get_stat_segment_update_rate (),
615 internal_node_vector_rates[j],
616 stat_vm->loops_per_second,
618 (f64) n_output / dt, (f64) n_drop / dt, (f64) n_punt / dt);
622 vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm,
624 for (i = 0; i < vec_len (nodes); i++)
627 nodes[i]->stats_total.calls -
628 nodes[i]->stats_last_clear.calls;
630 nodes[i]->stats_total.suspends -
631 nodes[i]->stats_last_clear.suspends;
632 if (c || d || !brief)
634 vlib_cli_output (vm, "%U", format_vlib_node_stats,
635 stat_vm, nodes[i], max);
642 vec_free (node_dups);
643 vec_free (internal_node_vector_rates);
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,
658 static clib_error_t *
659 clear_node_runtime (vlib_main_t * vm,
660 unformat_input_t * input, vlib_cli_command_t * cmd)
662 vlib_node_main_t *nm;
665 vlib_main_t **stat_vms = 0, *stat_vm;
666 vlib_node_runtime_t *r;
668 for (i = 0; i < vlib_get_n_threads (); i++)
670 stat_vm = vlib_get_main_by_index (i);
672 vec_add1 (stat_vms, stat_vm);
675 vlib_worker_thread_barrier_sync (vm);
677 for (j = 0; j < vec_len (stat_vms); j++)
679 stat_vm = stat_vms[j];
680 nm = &stat_vm->node_main;
682 for (i = 0; i < vec_len (nm->nodes); i++)
685 vlib_node_sync_stats (stat_vm, n);
686 n->stats_last_clear = n->stats_total;
688 r = vlib_node_get_runtime (stat_vm, n->index);
691 /* Note: input/output rates computed using vlib_global_main */
692 nm->time_last_runtime_stats_clear = vlib_time_now (vm);
695 vlib_worker_thread_barrier_release (vm);
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,
710 static clib_error_t *
711 show_node (vlib_main_t * vm, unformat_input_t * input,
712 vlib_cli_command_t * cmd)
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;
719 u32 i, node_index = ~0, verbose = 0;
721 u8 valid_node_name = 0;
724 if (!unformat_user (input, unformat_line_input, line_input))
727 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
729 if (unformat (line_input, "index %u", &node_index))
731 else if (unformat (line_input, "verbose"))
734 if (unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
736 else if (!valid_node_name)
737 error = clib_error_return (0, "unknown node name: '%U'",
738 format_unformat_error, line_input);
740 error = clib_error_return (0, "unknown input '%U'",
741 format_unformat_error, line_input);
747 unformat_free (line_input);
752 if (node_index >= vec_len (vm->node_main.nodes))
753 return clib_error_return (0, "please specify valid node");
755 n = vlib_get_node (vm, node_index);
756 vlib_node_sync_stats (vm, n);
760 case VLIB_NODE_TYPE_INTERNAL:
761 type_str = "internal";
763 case VLIB_NODE_TYPE_INPUT:
766 case VLIB_NODE_TYPE_PRE_INPUT:
767 type_str = "pre-input";
769 case VLIB_NODE_TYPE_PROCESS:
770 type_str = "process";
773 type_str = "unknown";
777 s = format (s, ", sibling-of %s", n->sibling_of);
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,
782 vec_reset_length (s);
784 if (n->node_fn_registrations)
786 vlib_node_fn_registration_t *fnr = n->node_fn_registrations;
787 vlib_node_fn_variant_t *v;
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;
800 s = format (s, "\n default only");
801 vlib_cli_output (vm, " node function variants:%v\n", s);
802 vec_reset_length (s);
804 for (i = 0; i < vec_len (n->next_nodes); i++)
807 if (n->next_nodes[i] == VLIB_INVALID_NODE_INDEX)
810 pn = vec_elt (nm->nodes, n->next_nodes[i]);
812 if (vec_len (s) == 0)
813 s = format (s, "\n %10s %10s %=30s %8s",
814 "next-index", "node-index", "Node", "Vectors");
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));
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);
825 if (n->type == VLIB_NODE_TYPE_INTERNAL)
829 clib_bitmap_foreach (i, n->prev_node_bitmap) {
830 vlib_node_t *pn = vlib_get_node (vm, i);
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);
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);
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++)
853 n = vlib_get_node (vlib_get_main_by_index (i), node_index);
854 vlib_node_sync_stats (vlib_get_main_by_index (i), n);
856 cl = n->stats_total.clocks - n->stats_last_clear.clocks;
857 ca = n->stats_total.calls - n->stats_last_clear.calls;
858 v = n->stats_total.vectors - n->stats_last_clear.vectors;
860 s = format (s, "%=8u %=12lu %=12lu %=12lu %=12u %=12u\n", i, ca, cl, v,
861 n->stats_total.max_clock, n->stats_total.max_clock_n);
864 vlib_cli_output (vm, "%v", s);
873 VLIB_CLI_COMMAND (show_node_command, static) = {
875 .short_help = "show node [index] <node-name | node-index>",
876 .function = show_node,
879 static clib_error_t *
880 set_node_fn(vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd)
882 unformat_input_t _line_input, *line_input = &_line_input;
883 u32 node_index, march_variant;
885 clib_error_t *err = 0;
887 if (!unformat_user (input, unformat_line_input, line_input))
890 if (!unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
892 err = clib_error_return (0, "please specify valid node name");
896 if (!unformat (line_input, "%U", unformat_vlib_node_variant, &march_variant))
898 err = clib_error_return (0, "please specify node function variant");
902 n = vlib_get_node (vm, node_index);
904 if (n->node_fn_registrations == 0)
906 err = clib_error_return (0, "node doesn't have function variants");
910 if (vlib_node_set_march_variant (vm, node_index, march_variant))
912 vlib_node_fn_variant_t *v;
913 v = vec_elt_at_index (vm->node_main.variants, march_variant);
914 err = clib_error_return (0, "node function variant '%s' not found",
921 unformat_free (line_input);
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,
933 /* Dummy function to get us linked in. */
935 vlib_node_cli_reference (void)
940 * fd.io coding-style-patch-verification: ON
943 * eval: (c-set-style "gnu")