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>
47 node_cmp (void *a1, void *a2)
49 vlib_node_t **n1 = a1;
50 vlib_node_t **n2 = a2;
52 return vec_cmp (n1[0]->name, n2[0]->name);
56 show_node_graph (vlib_main_t * vm,
57 unformat_input_t * input, vlib_cli_command_t * cmd)
59 vlib_node_main_t *nm = &vm->node_main;
63 vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, 0);
65 if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
67 n = vlib_get_node (vm, node_index);
68 vlib_cli_output (vm, "%U\n", format_vlib_node_graph, nm, n);
72 vlib_node_t **nodes = vec_dup (nm->nodes);
75 vec_sort_with_function (nodes, node_cmp);
77 for (i = 0; i < vec_len (nodes); i++)
78 vlib_cli_output (vm, "%U\n\n", format_vlib_node_graph, nm, nodes[i]);
87 VLIB_CLI_COMMAND (show_node_graph_command, static) = {
88 .path = "show vlib graph",
89 .short_help = "Show packet processing node graph",
90 .function = show_node_graph,
95 show_node_graphviz (vlib_main_t * vm,
96 unformat_input_t * input, vlib_cli_command_t * cmd)
98 clib_error_t *error = 0;
99 vlib_node_main_t *nm = &vm->node_main;
100 u8 *chroot_filename = 0;
102 vlib_node_t **nodes = 0;
105 if (!unformat_user (input, unformat_vlib_tmpfile, &chroot_filename))
112 open ((char *) chroot_filename, O_CREAT | O_TRUNC | O_WRONLY, 0664);
115 #define format__(vm__, fd__, ...) \
118 vlib_cli_output((vm__), ## __VA_ARGS__); \
122 fdformat((fd__), ## __VA_ARGS__); \
125 format__ (vm, fd, "%s", "digraph {\n");
127 nodes = vec_dup (nm->nodes);
128 vec_sort_with_function (nodes, node_cmp);
130 for (i = 0; i < vec_len (nodes); i++)
132 for (j = 0; j < vec_len (nodes[i]->next_nodes); j++)
136 if (nodes[i]->next_nodes[j] == VLIB_INVALID_NODE_INDEX)
139 x = vec_elt (nm->nodes, nodes[i]->next_nodes[j]);
140 format__ (vm, fd, " \"%v\" -> \"%v\"\n", nodes[i]->name, x->name);
144 format__ (vm, fd, "%s", "}");
149 "vlib graph dumped into `%s'. Run eg. `fdp -Tsvg -O %s'.",
150 chroot_filename, chroot_filename);
154 vec_free (chroot_filename);
162 VLIB_CLI_COMMAND (show_node_graphviz_command, static) = {
163 .path = "show vlib graphviz",
164 .short_help = "Dump packet processing node graph as a graphviz dotfile",
165 .function = show_node_graphviz,
170 format_vlib_node_state (u8 * s, va_list * va)
172 vlib_main_t *vm = va_arg (*va, vlib_main_t *);
173 vlib_node_t *n = va_arg (*va, vlib_node_t *);
177 if (n->type == VLIB_NODE_TYPE_PROCESS)
179 vlib_process_t *p = vlib_get_process_from_node (vm, n);
181 switch (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
182 | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
185 if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
189 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
193 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
194 state = "event wait";
197 case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
203 else if (n->type != VLIB_NODE_TYPE_INTERNAL)
206 if (n->state == VLIB_NODE_STATE_DISABLED)
208 else if (n->state == VLIB_NODE_STATE_INTERRUPT)
209 state = "interrupt wait";
212 return format (s, "%s", state);
216 format_vlib_node_stats (u8 * s, va_list * va)
218 vlib_main_t *vm = va_arg (*va, vlib_main_t *);
219 vlib_node_t *n = va_arg (*va, vlib_node_t *);
220 int max = va_arg (*va, int);
234 "%=30s%=17s%=16s%=16s%=16s%=16s",
235 "Name", "Max Node Clocks", "Vectors at Max",
236 "Max Clocks", "Avg Clocks", "Avg Vectors/Call");
239 "%=30s%=12s%=16s%=16s%=16s%=16s%=16s",
240 "Name", "State", "Calls", "Vectors", "Suspends",
241 "Clocks", "Vectors/Call");
245 indent = format_get_indent (s);
247 l = n->stats_total.clocks - n->stats_last_clear.clocks;
248 c = n->stats_total.calls - n->stats_last_clear.calls;
249 p = n->stats_total.vectors - n->stats_last_clear.vectors;
250 d = n->stats_total.suspends - n->stats_last_clear.suspends;
251 maxc = (f64) n->stats_total.max_clock;
252 maxn = n->stats_total.max_clock_n;
253 if (n->stats_total.max_clock_n)
254 maxcn = (f64) n->stats_total.max_clock / (f64) maxn;
258 /* Clocks per packet, per call or per suspend. */
261 x = (f64) l / (f64) p;
263 x = (f64) l / (f64) c;
265 x = (f64) l / (f64) d;
268 v = (double) p / (double) c;
272 if (n->type == VLIB_NODE_TYPE_PROCESS)
274 vlib_process_t *p = vlib_get_process_from_node (vm, n);
276 /* Show processes with events pending. This helps spot bugs where events are not
278 if (!clib_bitmap_is_zero (p->non_empty_event_type_bitmap))
279 misc_info = format (misc_info, "events pending, ");
284 s = format (s, "%-30v%=17.2e%=16d%=16.2e%=16.2e%=16.2e",
285 ns, maxc, maxn, maxcn, x, v);
287 s = format (s, "%-30v%=12U%16Ld%16Ld%16Ld%16.2e%16.2f", ns,
288 format_vlib_node_state, vm, n, c, p, d, x, v);
295 s = format (s, "\n%U%v", format_white_space, indent + 4, misc_info);
296 vec_free (misc_info);
302 static clib_error_t *
303 show_node_runtime (vlib_main_t * vm,
304 unformat_input_t * input, vlib_cli_command_t * cmd)
306 vlib_node_main_t *nm = &vm->node_main;
310 vlib_node_t ***node_dups = 0;
311 f64 *vectors_per_main_loop = 0;
312 f64 *last_vector_length_per_node = 0;
314 time_now = vlib_time_now (vm);
316 if (unformat (input, "%U", unformat_vlib_node, vm, &node_index))
318 n = vlib_get_node (vm, node_index);
319 vlib_node_sync_stats (vm, n);
320 vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, 0, 0);
321 vlib_cli_output (vm, "%U\n", format_vlib_node_stats, vm, n, 0);
328 u64 n_input, n_output, n_drop, n_punt;
329 u64 n_internal_vectors, n_internal_calls;
330 u64 n_clocks, l, v, c, d;
333 vlib_main_t **stat_vms = 0, *stat_vm;
335 /* Suppress nodes with zero calls since last clear */
336 if (unformat (input, "brief") || unformat (input, "b"))
338 if (unformat (input, "verbose") || unformat (input, "v"))
340 if (unformat (input, "max") || unformat (input, "m"))
343 for (i = 0; i < vec_len (vlib_mains); i++)
345 stat_vm = vlib_mains[i];
347 vec_add1 (stat_vms, stat_vm);
351 * Barrier sync across stats scraping.
352 * Otherwise, the counts will be grossly inaccurate.
354 vlib_worker_thread_barrier_sync (vm);
356 for (j = 0; j < vec_len (stat_vms); j++)
358 stat_vm = stat_vms[j];
359 nm = &stat_vm->node_main;
361 for (i = 0; i < vec_len (nm->nodes); i++)
364 vlib_node_sync_stats (stat_vm, n);
367 nodes = vec_dup (nm->nodes);
369 vec_add1 (node_dups, nodes);
370 vec_add1 (vectors_per_main_loop,
371 vlib_last_vectors_per_main_loop_as_f64 (stat_vm));
372 vec_add1 (last_vector_length_per_node,
373 vlib_last_vector_length_per_node (stat_vm));
375 vlib_worker_thread_barrier_release (vm);
378 for (j = 0; j < vec_len (stat_vms); j++)
380 stat_vm = stat_vms[j];
381 nodes = node_dups[j];
383 vec_sort_with_function (nodes, node_cmp);
385 n_input = n_output = n_drop = n_punt = n_clocks = 0;
386 n_internal_vectors = n_internal_calls = 0;
387 for (i = 0; i < vec_len (nodes); i++)
391 l = n->stats_total.clocks - n->stats_last_clear.clocks;
394 v = n->stats_total.vectors - n->stats_last_clear.vectors;
395 c = n->stats_total.calls - n->stats_last_clear.calls;
402 case VLIB_NODE_TYPE_INTERNAL:
403 n_output += (n->flags & VLIB_NODE_FLAG_IS_OUTPUT) ? v : 0;
404 n_drop += (n->flags & VLIB_NODE_FLAG_IS_DROP) ? v : 0;
405 n_punt += (n->flags & VLIB_NODE_FLAG_IS_PUNT) ? v : 0;
406 if (!(n->flags & VLIB_NODE_FLAG_IS_OUTPUT))
408 n_internal_vectors += v;
409 n_internal_calls += c;
411 if (n->flags & VLIB_NODE_FLAG_IS_HANDOFF)
415 case VLIB_NODE_TYPE_INPUT:
421 if (vec_len (vlib_mains) > 1)
423 vlib_worker_thread_t *w = vlib_worker_threads + j;
425 vlib_cli_output (vm, "---------------");
428 vlib_cli_output (vm, "Thread %d %s (lcore %u)", j, w->name,
431 vlib_cli_output (vm, "Thread %d %s", j, w->name);
434 dt = time_now - nm->time_last_runtime_stats_clear;
437 "Time %.1f, average vectors/node %.2f, last %d main loops %.2f per node %.2f"
438 "\n vector rates in %.4e, out %.4e, drop %.4e, punt %.4e",
440 (n_internal_calls > 0
441 ? (f64) n_internal_vectors / (f64) n_internal_calls
443 1 << VLIB_LOG2_MAIN_LOOPS_PER_STATS_UPDATE,
444 vectors_per_main_loop[j],
445 last_vector_length_per_node[j],
447 (f64) n_output / dt, (f64) n_drop / dt, (f64) n_punt / dt);
449 vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm, 0, max);
450 for (i = 0; i < vec_len (nodes); i++)
453 nodes[i]->stats_total.calls -
454 nodes[i]->stats_last_clear.calls;
456 nodes[i]->stats_total.suspends -
457 nodes[i]->stats_last_clear.suspends;
458 if (c || d || !brief)
460 vlib_cli_output (vm, "%U", format_vlib_node_stats, stat_vm,
467 vec_free (node_dups);
468 vec_free (vectors_per_main_loop);
469 vec_free (last_vector_length_per_node);
476 VLIB_CLI_COMMAND (show_node_runtime_command, static) = {
477 .path = "show runtime",
478 .short_help = "Show packet processing runtime",
479 .function = show_node_runtime,
484 static clib_error_t *
485 clear_node_runtime (vlib_main_t * vm,
486 unformat_input_t * input, vlib_cli_command_t * cmd)
488 vlib_node_main_t *nm;
491 vlib_main_t **stat_vms = 0, *stat_vm;
492 vlib_node_runtime_t *r;
494 for (i = 0; i < vec_len (vlib_mains); i++)
496 stat_vm = vlib_mains[i];
498 vec_add1 (stat_vms, stat_vm);
501 vlib_worker_thread_barrier_sync (vm);
503 for (j = 0; j < vec_len (stat_vms); j++)
505 stat_vm = stat_vms[j];
506 nm = &stat_vm->node_main;
508 for (i = 0; i < vec_len (nm->nodes); i++)
511 vlib_node_sync_stats (stat_vm, n);
512 n->stats_last_clear = n->stats_total;
514 r = vlib_node_get_runtime (stat_vm, n->index);
517 /* Note: input/output rates computed using vlib_global_main */
518 nm->time_last_runtime_stats_clear = vlib_time_now (vm);
521 vlib_worker_thread_barrier_release (vm);
529 VLIB_CLI_COMMAND (clear_node_runtime_command, static) = {
530 .path = "clear runtime",
531 .short_help = "Clear packet processing runtime statistics",
532 .function = clear_node_runtime,
536 static clib_error_t *
537 show_node (vlib_main_t * vm, unformat_input_t * input,
538 vlib_cli_command_t * cmd)
540 unformat_input_t _line_input, *line_input = &_line_input;
541 clib_error_t *error = 0;
542 vlib_node_main_t *nm = &vm->node_main;
545 u32 i, node_index = ~0;
547 u8 valid_node_name = 0;
549 if (!unformat_user (input, unformat_line_input, line_input))
552 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
554 if (unformat (line_input, "index %u", &node_index))
557 if (unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
559 else if (!valid_node_name)
560 error = clib_error_return (0, "unknown node name: '%U'",
561 format_unformat_error, line_input);
563 error = clib_error_return (0, "unknown input '%U'",
564 format_unformat_error, line_input);
567 unformat_free (line_input);
572 if (node_index >= vec_len (vm->node_main.nodes))
573 return clib_error_return (0, "please specify valid node");
575 n = vlib_get_node (vm, node_index);
576 vlib_node_sync_stats (vm, n);
580 case VLIB_NODE_TYPE_INTERNAL:
581 type_str = "internal";
583 case VLIB_NODE_TYPE_INPUT:
586 case VLIB_NODE_TYPE_PRE_INPUT:
587 type_str = "pre-input";
589 case VLIB_NODE_TYPE_PROCESS:
590 type_str = "process";
593 type_str = "unknown";
597 s = format (s, ", sibling-of %s", n->sibling_of);
599 vlib_cli_output (vm, "node %s, type %s, state %U, index %d%v\n",
600 n->name, type_str, format_vlib_node_state, vm, n,
602 vec_reset_length (s);
604 if (n->node_fn_registrations)
606 vlib_node_fn_registration_t *fnr = n->node_fn_registrations;
609 if (vec_len (s) == 0)
610 s = format (s, "\n %-15s %=8s %6s",
611 "Name", "Priority", "Active");
612 s = format (s, "\n %-15s %=8u %=6s", fnr->name, fnr->priority,
613 fnr->function == n->function ? "yes" : "");
614 fnr = fnr->next_registration;
618 s = format (s, "\n default only");
619 vlib_cli_output (vm, " node function variants:%v\n", s);
620 vec_reset_length (s);
622 for (i = 0; i < vec_len (n->next_nodes); i++)
625 if (n->next_nodes[i] == VLIB_INVALID_NODE_INDEX)
628 pn = vec_elt (nm->nodes, n->next_nodes[i]);
630 if (vec_len (s) == 0)
631 s = format (s, "\n %10s %10s %=30s %8s",
632 "next-index", "node-index", "Node", "Vectors");
634 s = format (s, "\n %=10u %=10u %-30v %=8llu", i, n->next_nodes[i],
635 pn->name, vec_elt (n->n_vectors_by_next_node, i));
638 if (vec_len (s) == 0)
639 s = format (s, "\n none");
640 vlib_cli_output (vm, "\n next nodes:%v\n", s);
641 vec_reset_length (s);
643 if (n->type == VLIB_NODE_TYPE_INTERNAL)
647 clib_bitmap_foreach (i, n->prev_node_bitmap, ({
648 vlib_node_t *pn = vlib_get_node (vm, i);
650 s = format (s, "\n ");
651 s2 = format (s2, "%v (%u)", pn->name, i);
652 s = format (s, "%-35v", s2);
653 vec_reset_length (s2);
657 if (vec_len (s) == 0)
658 s = format (s, "\n none");
659 vlib_cli_output (vm, "\n known previous nodes:%v\n", s);
660 vec_reset_length (s);
669 VLIB_CLI_COMMAND (show_node_command, static) = {
671 .short_help = "show node [index] <node-name | node-index>",
672 .function = show_node,
675 static clib_error_t *
676 set_node_fn(vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd)
678 unformat_input_t _line_input, *line_input = &_line_input;
681 clib_error_t *err = 0;
682 vlib_node_fn_registration_t *fnr;
685 if (!unformat_user (input, unformat_line_input, line_input))
688 if (!unformat (line_input, "%U", unformat_vlib_node, vm, &node_index))
690 err = clib_error_return (0, "please specify valid node name");
694 if (!unformat (line_input, "%s", &variant))
696 err = clib_error_return (0, "please specify node functional variant");
700 n = vlib_get_node (vm, node_index);
702 if (n->node_fn_registrations == 0)
704 err = clib_error_return (0, "node doesn't have functional variants");
708 fnr = n->node_fn_registrations;
709 vec_add1 (variant, 0);
713 if (!strncmp (fnr->name, (char *) variant, vec_len (variant) - 1))
717 n->function = fnr->function;
719 for (i = 0; i < vec_len (vlib_mains); i++)
721 vlib_node_runtime_t *nrt;
722 nrt = vlib_node_get_runtime (vlib_mains[i], n->index);
723 nrt->function = fnr->function;
727 fnr = fnr->next_registration;
730 err = clib_error_return (0, "node functional variant '%s' not found", variant);
734 unformat_free (line_input);
739 VLIB_CLI_COMMAND (set_node_fn_command, static) = {
740 .path = "set node function",
741 .short_help = "set node function <node-name> <variant-name>",
742 .function = set_node_fn,
746 /* Dummy function to get us linked in. */
748 vlib_node_cli_reference (void)
753 * fd.io coding-style-patch-verification: ON
756 * eval: (c-set-style "gnu")