+static clib_error_t *
+elog_trace_command_fn (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+ unformat_input_t _line_input, *line_input = &_line_input;
+ int enable = 1;
+ int api = 0, cli = 0, barrier = 0, dispatch = 0, circuit = 0;
+ u32 circuit_node_index;
+
+ if (!unformat_user (input, unformat_line_input, line_input))
+ goto print_status;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (line_input, "api"))
+ api = 1;
+ else if (unformat (line_input, "dispatch"))
+ dispatch = 1;
+ else if (unformat (line_input, "circuit-node %U",
+ unformat_vlib_node, vm, &circuit_node_index))
+ circuit = 1;
+ else if (unformat (line_input, "cli"))
+ cli = 1;
+ else if (unformat (line_input, "barrier"))
+ barrier = 1;
+ else if (unformat (line_input, "disable"))
+ enable = 0;
+ else if (unformat (line_input, "enable"))
+ enable = 1;
+ else
+ break;
+ }
+ unformat_free (line_input);
+
+ vl_api_set_elog_trace_api_messages
+ (api ? enable : vl_api_get_elog_trace_api_messages ());
+ vm->elog_trace_cli_commands = cli ? enable : vm->elog_trace_cli_commands;
+ vm->elog_trace_graph_dispatch = dispatch ?
+ enable : vm->elog_trace_graph_dispatch;
+ vm->elog_trace_graph_circuit = circuit ?
+ enable : vm->elog_trace_graph_circuit;
+ vlib_worker_threads->barrier_elog_enabled =
+ barrier ? enable : vlib_worker_threads->barrier_elog_enabled;
+ vm->elog_trace_graph_circuit_node_index = circuit_node_index;
+
+ /*
+ * Set up start-of-buffer logic-analyzer trigger
+ * for main loop event logs, which are fairly heavyweight.
+ * See src/vlib/main/vlib_elog_main_loop_event(...), which
+ * will fully disable the scheme when the elog buffer fills.
+ */
+ if (dispatch || circuit)
+ {
+ elog_main_t *em = &vm->elog_main;
+
+ em->n_total_events_disable_limit =
+ em->n_total_events + vec_len (em->event_ring);
+ }
+
+
+print_status:
+ vlib_cli_output (vm, "Current status:");
+
+ vlib_cli_output
+ (vm, " Event log API message trace: %s\n CLI command trace: %s",
+ vl_api_get_elog_trace_api_messages ()? "on" : "off",
+ vm->elog_trace_cli_commands ? "on" : "off");
+ vlib_cli_output
+ (vm, " Barrier sync trace: %s",
+ vlib_worker_threads->barrier_elog_enabled ? "on" : "off");
+ vlib_cli_output
+ (vm, " Graph Dispatch: %s",
+ vm->elog_trace_graph_dispatch ? "on" : "off");
+ vlib_cli_output
+ (vm, " Graph Circuit: %s",
+ vm->elog_trace_graph_circuit ? "on" : "off");
+ if (vm->elog_trace_graph_circuit)
+ vlib_cli_output
+ (vm, " node %U",
+ format_vlib_node_name, vm, vm->elog_trace_graph_circuit_node_index);
+
+ return 0;
+}
+
+/*?
+ * Control event logging of api, cli, and thread barrier events
+ * With no arguments, displays the current trace status.
+ * Name the event groups you wish to trace or stop tracing.
+ *
+ * @cliexpar
+ * @clistart
+ * elog trace api cli barrier
+ * elog trace api cli barrier disable
+ * elog trace dispatch
+ * elog trace circuit-node ethernet-input
+ * elog trace
+ * @cliend
+ * @cliexcmd{elog trace [api][cli][barrier][disable]}
+?*/
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (elog_trace_command, static) =
+{
+ .path = "elog trace",
+ .short_help = "elog trace [api][cli][barrier][dispatch]\n"
+ "[circuit-node <name> e.g. ethernet-input][disable]",
+ .function = elog_trace_command_fn,
+};
+/* *INDENT-ON* */
+
+static clib_error_t *
+suspend_command_fn (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+ vlib_process_suspend (vm, 30e-3);
+ return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (suspend_command, static) =
+{
+ .path = "suspend",
+ .short_help = "suspend debug CLI for 30ms",
+ .function = suspend_command_fn,
+ .is_mp_safe = 1,
+};
+/* *INDENT-ON* */
+
+
+static int
+sort_cmds_by_path (void *a1, void *a2)
+{
+ u32 *index1 = a1;
+ u32 *index2 = a2;
+ vlib_main_t *vm = vlib_get_main ();
+ vlib_cli_main_t *cm = &vm->cli_main;
+ vlib_cli_command_t *c1, *c2;
+ int i, lmin;
+
+ c1 = vec_elt_at_index (cm->commands, *index1);
+ c2 = vec_elt_at_index (cm->commands, *index2);
+
+ lmin = vec_len (c1->path);
+ lmin = (vec_len (c2->path) >= lmin) ? lmin : vec_len (c2->path);
+
+ for (i = 0; i < lmin; i++)
+ {
+ if (c1->path[i] < c2->path[i])
+ return -1;
+ else if (c1->path[i] > c2->path[i])
+ return 1;
+ }
+
+ return 0;
+}
+
+typedef struct
+{
+ vlib_cli_main_t *cm;
+ u32 parent_command_index;
+ int show_mp_safe;
+ int show_not_mp_safe;
+ int show_hit;
+ int clear_hit;
+} vlib_cli_walk_args_t;
+
+static void
+cli_recursive_walk (vlib_cli_walk_args_t * aa)
+{
+ vlib_cli_command_t *parent;
+ vlib_cli_sub_command_t *sub;
+ vlib_cli_walk_args_t _a, *a = &_a;
+ vlib_cli_main_t *cm;
+ int i;
+
+ /* Copy args into this stack frame */
+ *a = *aa;
+ cm = a->cm;
+
+ parent = vec_elt_at_index (cm->commands, a->parent_command_index);
+
+ if (parent->function)
+ {
+ if (((a->show_mp_safe && parent->is_mp_safe)
+ || (a->show_not_mp_safe && !parent->is_mp_safe))
+ && (a->show_hit == 0 || parent->hit_counter))
+ {
+ vec_add1 (cm->sort_vector, a->parent_command_index);
+ }
+
+ if (a->clear_hit)
+ parent->hit_counter = 0;
+ }
+
+ for (i = 0; i < vec_len (parent->sub_commands); i++)
+ {
+ sub = vec_elt_at_index (parent->sub_commands, i);
+ a->parent_command_index = sub->index;
+ cli_recursive_walk (a);
+ }
+}
+
+static u8 *
+format_mp_safe (u8 * s, va_list * args)
+{
+ vlib_cli_main_t *cm = va_arg (*args, vlib_cli_main_t *);
+ int show_mp_safe = va_arg (*args, int);
+ int show_not_mp_safe = va_arg (*args, int);
+ int show_hit = va_arg (*args, int);
+ int clear_hit = va_arg (*args, int);
+ vlib_cli_command_t *c;
+ vlib_cli_walk_args_t _a, *a = &_a;
+ int i;
+ char *format_string = "\n%v";
+
+ if (show_hit)
+ format_string = "\n%v: %u";
+
+ vec_reset_length (cm->sort_vector);
+
+ a->cm = cm;
+ a->parent_command_index = 0;
+ a->show_mp_safe = show_mp_safe;
+ a->show_not_mp_safe = show_not_mp_safe;
+ a->show_hit = show_hit;
+ a->clear_hit = clear_hit;
+
+ cli_recursive_walk (a);
+
+ vec_sort_with_function (cm->sort_vector, sort_cmds_by_path);
+
+ for (i = 0; i < vec_len (cm->sort_vector); i++)
+ {
+ c = vec_elt_at_index (cm->commands, cm->sort_vector[i]);
+ s = format (s, format_string, c->path, c->hit_counter);
+ }
+
+ return s;
+}
+
+
+static clib_error_t *
+show_cli_command_fn (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
+{
+ int show_mp_safe = 0;
+ int show_not_mp_safe = 0;
+ int show_hit = 0;
+ int clear_hit = 0;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "mp-safe"))
+ show_mp_safe = 1;
+ if (unformat (input, "not-mp-safe"))
+ show_not_mp_safe = 1;
+ else if (unformat (input, "hit"))
+ show_hit = 1;
+ else if (unformat (input, "clear-hit"))
+ clear_hit = 1;
+ else
+ break;
+ }
+
+ /* default set: all cli commands */
+ if (clear_hit == 0 && (show_mp_safe + show_not_mp_safe) == 0)
+ show_mp_safe = show_not_mp_safe = 1;
+
+ vlib_cli_output (vm, "%U", format_mp_safe, &vm->cli_main,
+ show_mp_safe, show_not_mp_safe, show_hit, clear_hit);
+ if (clear_hit)
+ vlib_cli_output (vm, "hit counters cleared...");
+
+ return 0;
+}
+
+/*?
+ * Displays debug cli command information
+ *
+ * @cliexpar
+ * @cliexstart{show cli [mp-safe][not-mp-safe][hit][clear-hit]}
+ *
+ * "show cli" displays the entire debug cli:
+ *
+ * abf attach
+ * abf policy
+ * adjacency counters
+ * api trace
+ * app ns
+ * bfd key del
+ * ... and so on ...
+ *
+ * "show cli mp-safe" displays mp-safe debug CLI commands:
+ *
+ * abf policy
+ * binary-api
+ * create vhost-user
+ * exec
+ * ip container
+ * ip mroute
+ * ip probe-neighbor
+ * ip route
+ * ip scan-neighbor
+ * ip table
+ * ip6 table
+ *
+ * "show cli not-mp-safe" displays debug CLI commands
+ * which cause worker thread barrier synchronization
+ *
+ * "show cli hit" displays commands which have been executed. Qualify
+ * as desired with "mp-safe" or "not-mp-safe".
+ *
+ * "show cli clear-hit" clears the per-command hit counters.
+ * @cliexend
+?*/
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (show_cli_command, static) =
+{
+ .path = "show cli",
+ .short_help = "show cli [mp-safe][not-mp-safe][hit][clear-hit]",
+ .function = show_cli_command_fn,
+ .is_mp_safe = 1,
+};
+/* *INDENT-ON* */
+