X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Fcli.c;h=98d57c6ccb0547f4c1d55daa7d795c8f29534381;hb=b10561bbecb2870360a731b4696bff920150720d;hp=d7b2a4686d1cae581c131061cb6cb86dc1305450;hpb=c3a06556d1a4a63646d4cc7aa76274177a56c13f;p=vpp.git

diff --git a/src/vlib/cli.c b/src/vlib/cli.c
index d7b2a4686d1..98d57c6ccb0 100644
--- a/src/vlib/cli.c
+++ b/src/vlib/cli.c
@@ -38,43 +38,45 @@
  */
 
 #include <vlib/vlib.h>
+#include <vlib/stats/stats.h>
 #include <vlib/unix/unix.h>
+#include <vppinfra/callback.h>
 #include <vppinfra/cpu.h>
 #include <vppinfra/elog.h>
 #include <unistd.h>
 #include <ctype.h>
 
+/** \file src/vlib/cli.c Debug CLI Implementation
+ */
+
+int vl_api_set_elog_trace_api_messages (int enable);
+int vl_api_get_elog_trace_api_messages (void);
+
+static void *current_traced_heap;
+
 /* Root of all show commands. */
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (vlib_cli_show_command, static) = {
   .path = "show",
   .short_help = "Show commands",
 };
-/* *INDENT-ON* */
 
 /* Root of all clear commands. */
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (vlib_cli_clear_command, static) = {
   .path = "clear",
   .short_help = "Clear commands",
 };
-/* *INDENT-ON* */
 
 /* Root of all set commands. */
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (vlib_cli_set_command, static) = {
   .path = "set",
   .short_help = "Set commands",
 };
-/* *INDENT-ON* */
 
 /* Root of all test commands. */
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (vlib_cli_test_command, static) = {
   .path = "test",
   .short_help = "Test commands",
 };
-/* *INDENT-ON* */
 
 /* Returns bitmap of commands which match key. */
 static uword *
@@ -149,6 +151,64 @@ done:
   return match;
 }
 
+uword
+unformat_vlib_cli_line (unformat_input_t *i, va_list *va)
+{
+  unformat_input_t *result = va_arg (*va, unformat_input_t *);
+  u8 *line = 0;
+  uword c;
+  int skip;
+
+next_line:
+  skip = 0;
+
+  /* skip leading whitespace if any */
+  unformat_skip_white_space (i);
+
+  if (unformat_is_eof (i))
+    return 0;
+
+  while ((c = unformat_get_input (i)) != UNFORMAT_END_OF_INPUT)
+    {
+      if (c == '\\')
+	{
+	  c = unformat_get_input (i);
+
+	  if (c == '\n')
+	    {
+	      if (!skip)
+		vec_add1 (line, '\n');
+	      skip = 0;
+	      continue;
+	    }
+
+	  if (!skip)
+	    vec_add1 (line, '\\');
+
+	  if (c == UNFORMAT_END_OF_INPUT)
+	    break;
+
+	  if (!skip)
+	    vec_add1 (line, c);
+	  continue;
+	}
+
+      if (c == '#')
+	skip = 1;
+      else if (c == '\n')
+	break;
+
+      if (!skip)
+	vec_add1 (line, c);
+    }
+
+  if (line == 0)
+    goto next_line;
+
+  unformat_init_vector (result, line);
+  return 1;
+}
+
 /* Looks for string based sub-input formatted { SUB-INPUT }. */
 uword
 unformat_vlib_cli_sub_input (unformat_input_t * i, va_list * args)
@@ -196,35 +256,13 @@ get_sub_command (vlib_cli_main_t * cm, vlib_cli_command_t * parent, u32 si)
 static uword
 unformat_vlib_cli_sub_command (unformat_input_t * i, va_list * args)
 {
-  vlib_main_t *vm = va_arg (*args, vlib_main_t *);
+  vlib_main_t __clib_unused *vm = va_arg (*args, vlib_main_t *);
+  vlib_global_main_t *vgm = vlib_get_global_main ();
   vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
   vlib_cli_command_t **result = va_arg (*args, vlib_cli_command_t **);
-  vlib_cli_main_t *cm = &vm->cli_main;
+  vlib_cli_main_t *cm = &vgm->cli_main;
   uword *match_bitmap, is_unique, index;
 
-  {
-    vlib_cli_sub_rule_t *sr;
-    vlib_cli_parse_rule_t *r;
-    vec_foreach (sr, c->sub_rules)
-    {
-      void **d;
-      r = vec_elt_at_index (cm->parse_rules, sr->rule_index);
-      vec_add2 (cm->parse_rule_data, d, 1);
-      vec_reset_length (d[0]);
-      if (r->data_size)
-	d[0] = _vec_resize (d[0],
-			    /* length increment */ 1,
-			    r->data_size,
-			    /* header_bytes */ 0,
-			    /* data align */ sizeof (uword));
-      if (unformat_user (i, r->unformat_function, vm, d[0]))
-	{
-	  *result = vec_elt_at_index (cm->commands, sr->command_index);
-	  return 1;
-	}
-    }
-  }
-
   match_bitmap = vlib_cli_sub_command_match (c, i);
   is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
   index = ~0;
@@ -252,8 +290,8 @@ vlib_cli_get_possible_completions (u8 * str)
 {
   vlib_cli_command_t *c;
   vlib_cli_sub_command_t *sc;
-  vlib_main_t *vm = vlib_get_main ();
-  vlib_cli_main_t *vcm = &vm->cli_main;
+  vlib_global_main_t *vgm = vlib_get_global_main ();
+  vlib_cli_main_t *vcm = &vgm->cli_main;
   uword *match_bitmap = 0;
   uword index, is_unique, help_next_level;
   u8 **result = 0;
@@ -317,8 +355,7 @@ vlib_cli_get_possible_completions (u8 * str)
   /* if we have a space at the end of input, and a unique match,
    * autocomplete the next level of subcommands */
   help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]);
-  /* *INDENT-OFF* */
-  clib_bitmap_foreach(index, match_bitmap, {
+  clib_bitmap_foreach (index, match_bitmap) {
     if (help_next_level && is_unique) {
 	c = get_sub_command (vcm, c, index);
 	vec_foreach (sc, c->sub_commands) {
@@ -328,8 +365,7 @@ vlib_cli_get_possible_completions (u8 * str)
     }
     sc = &c->sub_commands[index];
     vec_add1(result, (u8*) sc->name);
-  });
-  /* *INDENT-ON* */
+  }
 
 done:
   clib_bitmap_free (match_bitmap);
@@ -354,50 +390,12 @@ format_vlib_cli_command_help (u8 * s, va_list * args)
   return s;
 }
 
-static u8 *
-format_vlib_cli_parse_rule_name (u8 * s, va_list * args)
-{
-  vlib_cli_parse_rule_t *r = va_arg (*args, vlib_cli_parse_rule_t *);
-  return format (s, "<%U>", format_c_identifier, r->name);
-}
-
 static u8 *
 format_vlib_cli_path (u8 * s, va_list * args)
 {
   u8 *path = va_arg (*args, u8 *);
-  int i, in_rule;
-  in_rule = 0;
-  for (i = 0; i < vec_len (path); i++)
-    {
-      switch (path[i])
-	{
-	case '%':
-	  in_rule = 1;
-	  vec_add1 (s, '<');	/* start of <RULE> */
-	  break;
 
-	case '_':
-	  /* _ -> space in rules. */
-	  vec_add1 (s, in_rule ? ' ' : '_');
-	  break;
-
-	case ' ':
-	  if (in_rule)
-	    {
-	      vec_add1 (s, '>');	/* end of <RULE> */
-	      in_rule = 0;
-	    }
-	  vec_add1 (s, ' ');
-	  break;
-
-	default:
-	  vec_add1 (s, path[i]);
-	  break;
-	}
-    }
-
-  if (in_rule)
-    vec_add1 (s, '>');		/* terminate <RULE> */
+  s = format (s, "%v", path);
 
   return s;
 }
@@ -407,13 +405,10 @@ all_subs (vlib_cli_main_t * cm, vlib_cli_command_t * subs, u32 command_index)
 {
   vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index);
   vlib_cli_sub_command_t *sc;
-  vlib_cli_sub_rule_t *sr;
 
   if (c->function)
     vec_add1 (subs, c[0]);
 
-  vec_foreach (sr, c->sub_rules)
-    subs = all_subs (cm, subs, sr->command_index);
   vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index);
 
   return subs;
@@ -443,11 +438,12 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 				unformat_input_t * input,
 				uword parent_command_index)
 {
+  vlib_global_main_t *vgm = vlib_get_global_main ();
   vlib_cli_command_t *parent, *c;
   clib_error_t *error = 0;
   unformat_input_t sub_input;
   u8 *string;
-  uword is_main_dispatch = cm == &vm->cli_main;
+  uword is_main_dispatch = cm == &vgm->cli_main;
 
   parent = vec_elt_at_index (cm->commands, parent_command_index);
   if (is_main_dispatch && unformat (input, "help"))
@@ -476,17 +472,14 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 	vlib_cli_output (vm, "%U", format_vlib_cli_command_help, c,
 			 /* is_long */ 1);
 
-      else if (vec_len (c->sub_commands) + vec_len (c->sub_rules) == 0)
+      else if (vec_len (c->sub_commands) == 0)
 	vlib_cli_output (vm, "%v: no sub-commands", c->path);
 
       else
 	{
+	  vlib_cli_sub_rule_t *sr, *subs = 0;
 	  vlib_cli_sub_command_t *sc;
-	  vlib_cli_sub_rule_t *sr, *subs;
 
-	  subs = vec_dup (c->sub_rules);
-
-	  /* Add in rules if any. */
 	  vec_foreach (sc, c->sub_commands)
 	  {
 	    vec_add2 (subs, sr, 1);
@@ -500,25 +493,11 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 	  for (i = 0; i < vec_len (subs); i++)
 	    {
 	      vlib_cli_command_t *d;
-	      vlib_cli_parse_rule_t *r;
 
 	      d = vec_elt_at_index (cm->commands, subs[i].command_index);
-	      r =
-		subs[i].rule_index != ~0 ? vec_elt_at_index (cm->parse_rules,
-							     subs
-							     [i].rule_index) :
-		0;
-
-	      if (r)
-		vlib_cli_output
-		  (vm, "  %-30U %U",
-		   format_vlib_cli_parse_rule_name, r,
-		   format_vlib_cli_command_help, d, /* is_long */ 0);
-	      else
-		vlib_cli_output
-		  (vm, "  %-30v %U",
-		   subs[i].name,
-		   format_vlib_cli_command_help, d, /* is_long */ 0);
+	      vlib_cli_output
+		(vm, "  %-30v %U", subs[i].name,
+		 format_vlib_cli_command_help, d, /* is_long */ 0);
 	    }
 
 	  vec_free (subs);
@@ -544,6 +523,23 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
       vec_free (string);
     }
 
+  else if (unformat (input, "vpplog %v", &string))
+    {
+      int i;
+      /*
+       * Delete leading whitespace, so "vpplog { this and that }"
+       * and "vpplog this" line up nicely.
+       */
+      for (i = 0; i < vec_len (string); i++)
+	if (string[i] != ' ')
+	  break;
+      if (i > 0)
+	vec_delete (string, i, 0);
+
+      vlib_log_notice (cm->log, "CLI: %v", string);
+      vec_free (string);
+    }
+
   else if (unformat (input, "uncomment %U",
 		     unformat_vlib_cli_sub_input, &sub_input))
     {
@@ -552,6 +548,39 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 					parent_command_index);
       unformat_free (&sub_input);
     }
+  else if (unformat (input, "leak-check %U",
+		     unformat_vlib_cli_sub_input, &sub_input))
+    {
+      u8 *leak_report;
+      if (current_traced_heap)
+	{
+	  void *oldheap;
+	  oldheap = clib_mem_set_heap (current_traced_heap);
+	  clib_mem_trace (0);
+	  clib_mem_set_heap (oldheap);
+	  current_traced_heap = 0;
+	}
+      clib_mem_trace (1);
+      error =
+	vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
+					parent_command_index);
+      unformat_free (&sub_input);
+
+      /* Otherwise, the clib_error_t shows up as a leak... */
+      if (error)
+	{
+	  vlib_cli_output (vm, "%v", error->what);
+	  clib_error_free (error);
+	  error = 0;
+	}
+
+      (void) clib_mem_trace_enable_disable (0);
+      leak_report = format (0, "%U", format_clib_mem_heap, 0,
+			    1 /* verbose, i.e. print leaks */ );
+      clib_mem_trace (0);
+      vlib_cli_output (vm, "%v", leak_report);
+      vec_free (leak_report);
+    }
 
   else
     if (unformat_user (input, unformat_vlib_cli_sub_command, vm, parent, &c))
@@ -586,53 +615,56 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 	    {
 	      if (PREDICT_FALSE (vm->elog_trace_cli_commands))
 		{
-                  /* *INDENT-OFF* */
                   ELOG_TYPE_DECLARE (e) =
                     {
                       .format = "cli-cmd: %s",
                       .format_args = "T4",
                     };
-                  /* *INDENT-ON* */
 		  struct
 		  {
 		    u32 c;
 		  } *ed;
-		  ed = ELOG_DATA (&vm->elog_main, e);
-		  ed->c = elog_global_id_for_msg_name (c->path);
+		  ed = ELOG_DATA (vlib_get_elog_main (), e);
+		  ed->c = elog_string (vlib_get_elog_main (), "%v", c->path);
 		}
 
 	      if (!c->is_mp_safe)
 		vlib_worker_thread_barrier_sync (vm);
+	      if (PREDICT_FALSE (vec_len (cm->perf_counter_cbs) != 0))
+		clib_call_callbacks (cm->perf_counter_cbs, cm,
+				     c - cm->commands, 0 /* before */ );
 
+	      c->hit_counter++;
 	      c_error = c->function (vm, si, c);
 
+	      if (PREDICT_FALSE (vec_len (cm->perf_counter_cbs) != 0))
+		clib_call_callbacks (cm->perf_counter_cbs, cm,
+				     c - cm->commands, 1 /* after */ );
 	      if (!c->is_mp_safe)
 		vlib_worker_thread_barrier_release (vm);
 
 	      if (PREDICT_FALSE (vm->elog_trace_cli_commands))
 		{
-                  /* *INDENT-OFF* */
                   ELOG_TYPE_DECLARE (e) =
                     {
                       .format = "cli-cmd: %s %s",
                       .format_args = "T4T4",
                     };
-                  /* *INDENT-ON* */
 		  struct
 		  {
 		    u32 c, err;
 		  } *ed;
-		  ed = ELOG_DATA (&vm->elog_main, e);
-		  ed->c = elog_global_id_for_msg_name (c->path);
+		  ed = ELOG_DATA (vlib_get_elog_main (), e);
+		  ed->c = elog_string (vlib_get_elog_main (), "%v", c->path);
 		  if (c_error)
 		    {
 		      vec_add1 (c_error->what, 0);
-		      ed->err = elog_global_id_for_msg_name
-			((const char *) c_error->what);
-		      _vec_len (c_error->what) -= 1;
+		      ed->err = elog_string (vlib_get_elog_main (),
+					     (char *) c_error->what);
+		      vec_dec_len (c_error->what, 1);
 		    }
 		  else
-		    ed->err = elog_global_id_for_msg_name ("OK");
+		    ed->err = elog_string (vlib_get_elog_main (), "OK");
 		}
 
 	      if (c_error)
@@ -684,16 +716,17 @@ vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error)
 }
 
 /* Process CLI input. */
-void
+int
 vlib_cli_input (vlib_main_t * vm,
 		unformat_input_t * input,
 		vlib_cli_output_function_t * function, uword function_arg)
 {
+  vlib_global_main_t *vgm = vlib_get_global_main ();
   vlib_process_t *cp = vlib_get_current_process (vm);
-  vlib_cli_main_t *cm = &vm->cli_main;
   clib_error_t *error;
   vlib_cli_output_function_t *save_function;
   uword save_function_arg;
+  int rv = 0;
 
   save_function = cp->output_function;
   save_function_arg = cp->output_function_arg;
@@ -703,9 +736,8 @@ vlib_cli_input (vlib_main_t * vm,
 
   do
     {
-      vec_reset_length (cm->parse_rule_data);
-      error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input,	/* parent */
-					      0);
+      error = vlib_cli_dispatch_sub_commands (vm, &vgm->cli_main, input,
+					      /* parent */ 0);
     }
   while (!error && !unformat (input, "%U", unformat_eof));
 
@@ -713,11 +745,15 @@ vlib_cli_input (vlib_main_t * vm,
     {
       vlib_cli_output (vm, "%v", error->what);
       vlib_unix_error_report (vm, error);
+      /* clib_error_return is unfortunately often called with a '0'
+         return code */
+      rv = error->code != 0 ? error->code : -1;
       clib_error_free (error);
     }
 
   cp->output_function = save_function;
   cp->output_function_arg = save_function_arg;
+  return rv;
 }
 
 /* Output to current CLI connection. */
@@ -732,6 +768,11 @@ vlib_cli_output (vlib_main_t * vm, char *fmt, ...)
   s = va_format (0, fmt, &va);
   va_end (va);
 
+  /* some format functions might return 0
+   * e.g. show int addr */
+  if (NULL == s)
+    return;
+
   /* Terminate with \n if not present. */
   if (vec_len (s) > 0 && s[vec_len (s) - 1] != '\n')
     vec_add1 (s, '\n');
@@ -745,15 +786,32 @@ vlib_cli_output (vlib_main_t * vm, char *fmt, ...)
 }
 
 void *vl_msg_push_heap (void) __attribute__ ((weak));
+void *
+vl_msg_push_heap (void)
+{
+  return 0;
+}
+
 void vl_msg_pop_heap (void *oldheap) __attribute__ ((weak));
+void
+vl_msg_pop_heap (void *oldheap)
+{
+}
 
 static clib_error_t *
 show_memory_usage (vlib_main_t * vm,
 		   unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  int verbose __attribute__ ((unused)) = 0, api_segment = 0;
+  clib_mem_main_t *mm = &clib_mem_main;
+  int verbose __attribute__ ((unused)) = 0;
+  int api_segment = 0, stats_segment = 0, main_heap = 0, numa_heaps = 0;
+  int map = 0;
   clib_error_t *error;
   u32 index = 0;
+  int i;
+  uword clib_mem_trace_enable_disable (uword enable);
+  uword was_enabled;
+
 
   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
     {
@@ -761,6 +819,14 @@ show_memory_usage (vlib_main_t * vm,
 	verbose = 1;
       else if (unformat (input, "api-segment"))
 	api_segment = 1;
+      else if (unformat (input, "stats-segment"))
+	stats_segment = 1;
+      else if (unformat (input, "main-heap"))
+	main_heap = 1;
+      else if (unformat (input, "numa-heaps"))
+	numa_heaps = 1;
+      else if (unformat (input, "map"))
+	map = 1;
       else
 	{
 	  error = clib_error_return (0, "unknown input `%U'",
@@ -769,82 +835,140 @@ show_memory_usage (vlib_main_t * vm,
 	}
     }
 
+  if ((api_segment + stats_segment + main_heap + numa_heaps + map) == 0)
+    return clib_error_return
+      (0, "Need one of api-segment, stats-segment, main-heap, numa-heaps "
+       "or map");
+
   if (api_segment)
     {
       void *oldheap = vl_msg_push_heap ();
-      u8 *s_in_svm =
-	format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
+      was_enabled = clib_mem_trace_enable_disable (0);
+      u8 *s_in_svm = format (0, "%U\n", format_clib_mem_heap, 0, 1);
       vl_msg_pop_heap (oldheap);
       u8 *s = vec_dup (s_in_svm);
 
       oldheap = vl_msg_push_heap ();
       vec_free (s_in_svm);
+      clib_mem_trace_enable_disable (was_enabled);
       vl_msg_pop_heap (oldheap);
-      vlib_cli_output (vm, "API segment start:");
+      vlib_cli_output (vm, "API segment");
       vlib_cli_output (vm, "%v", s);
-      vlib_cli_output (vm, "API segment end:");
       vec_free (s);
     }
+  if (stats_segment)
+    {
+      void *oldheap = vlib_stats_set_heap ();
+      was_enabled = clib_mem_trace_enable_disable (0);
+      u8 *s_in_svm = format (0, "%U\n", format_clib_mem_heap, 0, 1);
+      if (oldheap)
+	clib_mem_set_heap (oldheap);
+      u8 *s = vec_dup (s_in_svm);
+
+      oldheap = vlib_stats_set_heap ();
+      vec_free (s_in_svm);
+      if (oldheap)
+	{
+	  clib_mem_trace_enable_disable (was_enabled);
+	  clib_mem_set_heap (oldheap);
+	}
+      vlib_cli_output (vm, "Stats segment");
+      vlib_cli_output (vm, "%v", s);
+      vec_free (s);
+    }
+
 
-#if USE_DLMALLOC == 0
-  /* *INDENT-OFF* */
-  foreach_vlib_main (
-  ({
-      mheap_t *h = mheap_header (clib_per_cpu_mheaps[index]);
-      vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
-		       vlib_worker_threads[index].name);
-      vlib_cli_output (vm, "  %U\n", format_page_map, pointer_to_uword (h) -
-		       h->vm_alloc_offset_from_header,
-		       h->vm_alloc_size);
-      vlib_cli_output (vm, "  %U\n", format_mheap, clib_per_cpu_mheaps[index],
-                       verbose);
-      index++;
-  }));
-  /* *INDENT-ON* */
-#else
   {
-    uword clib_mem_trace_enable_disable (uword enable);
-    uword was_enabled;
-
-    /*
-     * Note: the foreach_vlib_main cause allocator traffic,
-     * so shut off tracing before we go there...
-     */
-    was_enabled = clib_mem_trace_enable_disable (0);
-
-    /* *INDENT-OFF* */
-    foreach_vlib_main (
-    ({
-      struct dlmallinfo mi;
-      void *mspace;
-      mspace = clib_per_cpu_mheaps[index];
-
-      mi = mspace_mallinfo (mspace);
-      vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
-		       vlib_worker_threads[index].name);
-      vlib_cli_output (vm, "  %U\n", format_page_map,
-                       pointer_to_uword (mspace_least_addr(mspace)),
-                       mi.arena);
-      vlib_cli_output (vm, "  %U\n", format_mheap, clib_per_cpu_mheaps[index],
-                       verbose);
-      index++;
-    }));
-    /* *INDENT-ON* */
-
-    /* Restore the trace flag */
-    clib_mem_trace_enable_disable (was_enabled);
+    if (main_heap)
+      {
+	/*
+	 * Note: the foreach_vlib_main causes allocator traffic,
+	 * so shut off tracing before we go there...
+	 */
+	was_enabled = clib_mem_trace_enable_disable (0);
+
+	foreach_vlib_main ()
+	  {
+	    vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n" : "", index,
+			     vlib_worker_threads[index].name);
+	    vlib_cli_output (vm, "  %U\n", format_clib_mem_heap,
+			     mm->per_cpu_mheaps[index], verbose);
+	    index++;
+	  }
+
+	/* Restore the trace flag */
+	clib_mem_trace_enable_disable (was_enabled);
+      }
+    if (numa_heaps)
+      {
+	for (i = 0; i < ARRAY_LEN (mm->per_numa_mheaps); i++)
+	  {
+	    if (mm->per_numa_mheaps[i] == 0)
+	      continue;
+	    if (mm->per_numa_mheaps[i] == mm->per_cpu_mheaps[i])
+	      {
+		vlib_cli_output (vm, "Numa %d uses the main heap...", i);
+		continue;
+	      }
+	    was_enabled = clib_mem_trace_enable_disable (0);
+
+	    vlib_cli_output (vm, "Numa %d:", i);
+	    vlib_cli_output (vm, "  %U\n", format_clib_mem_heap,
+			     mm->per_numa_mheaps[index], verbose);
+	  }
+      }
+    if (map)
+      {
+	clib_mem_page_stats_t stats = { };
+	clib_mem_vm_map_hdr_t *hdr = 0;
+	u8 *s = 0;
+	int numa = -1;
+
+	s = format (s, "\n%-16s%7s%5s%7s%7s",
+		    "StartAddr", "size", "FD", "PageSz", "Pages");
+	while ((numa = vlib_mem_get_next_numa_node (numa)) != -1)
+	  s = format (s, " Numa%u", numa);
+	s = format (s, " NotMap");
+	s = format (s, " Name");
+	vlib_cli_output (vm, "%v", s);
+	vec_reset_length (s);
+
+	while ((hdr = clib_mem_vm_get_next_map_hdr (hdr)))
+	  {
+	    clib_mem_get_page_stats ((void *) hdr->base_addr,
+				     hdr->log2_page_sz, hdr->num_pages,
+				     &stats);
+	    s = format (s, "%016lx%7U",
+			hdr->base_addr, format_memory_size,
+			hdr->num_pages << hdr->log2_page_sz);
+
+	    if (hdr->fd != -1)
+	      s = format (s, "%5d", hdr->fd);
+	    else
+	      s = format (s, "%5s", " ");
+
+	    s = format (s, "%7U%7lu",
+			format_log2_page_size, hdr->log2_page_sz,
+			hdr->num_pages);
+	    while ((numa = vlib_mem_get_next_numa_node (numa)) != -1)
+	      s = format (s, "%6lu", stats.per_numa[numa]);
+	    s = format (s, "%7lu", stats.not_mapped);
+	    s = format (s, " %s", hdr->name);
+	    vlib_cli_output (vm, "%v", s);
+	    vec_reset_length (s);
+	  }
+	vec_free (s);
+      }
   }
-#endif /* USE_DLMALLOC */
   return 0;
 }
 
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_memory_usage_command, static) = {
   .path = "show memory",
-  .short_help = "[verbose | api-segment] Show current memory usage",
+  .short_help = "show memory [api-segment][stats-segment][verbose]\n"
+		"            [numa-heaps][map][main-heap]",
   .function = show_memory_usage,
 };
-/* *INDENT-ON* */
 
 static clib_error_t *
 show_cpu (vlib_main_t * vm, unformat_input_t * input,
@@ -852,7 +976,7 @@ show_cpu (vlib_main_t * vm, unformat_input_t * input,
 {
 #define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c);
   _("Model name", "%U", format_cpu_model_name);
-  _("Microarchitecture", "%U", format_cpu_uarch);
+  _("Microarch model (family)", "%U", format_cpu_uarch);
   _("Flags", "%U", format_cpu_flags);
   _("Base frequency", "%.2f GHz",
     ((f64) vm->clib_time.clocks_per_second) * 1e-9);
@@ -871,26 +995,26 @@ show_cpu (vlib_main_t * vm, unformat_input_t * input,
  * Base Frequency:           3.20 GHz
  * @cliexend
 ?*/
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_cpu_command, static) = {
   .path = "show cpu",
   .short_help = "Show cpu information",
   .function = show_cpu,
 };
 
-/* *INDENT-ON* */
-
 static clib_error_t *
 enable_disable_memory_trace (vlib_main_t * vm,
 			     unformat_input_t * input,
 			     vlib_cli_command_t * cmd)
 {
+  clib_mem_main_t *mm = &clib_mem_main;
   unformat_input_t _line_input, *line_input = &_line_input;
-  int enable;
+  int enable = 1;
   int api_segment = 0;
+  int stats_segment = 0;
+  int main_heap = 0;
+  u32 numa_id = ~0;
   void *oldheap;
 
-
   if (!unformat_user (input, unformat_line_input, line_input))
     return 0;
 
@@ -900,6 +1024,12 @@ enable_disable_memory_trace (vlib_main_t * vm,
 	;
       else if (unformat (line_input, "api-segment"))
 	api_segment = 1;
+      else if (unformat (line_input, "stats-segment"))
+	stats_segment = 1;
+      else if (unformat (line_input, "main-heap"))
+	main_heap = 1;
+      else if (unformat (line_input, "numa-heap %d", &numa_id))
+	;
       else
 	{
 	  unformat_free (line_input);
@@ -908,93 +1038,87 @@ enable_disable_memory_trace (vlib_main_t * vm,
     }
   unformat_free (line_input);
 
-  if (api_segment)
-    oldheap = vl_msg_push_heap ();
-  clib_mem_trace (enable);
-  if (api_segment)
-    vl_msg_pop_heap (oldheap);
-
-  return 0;
-}
-
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = {
-  .path = "memory-trace",
-  .short_help = "on|off [api-segment] Enable/disable memory allocation trace",
-  .function = enable_disable_memory_trace,
-};
-/* *INDENT-ON* */
+  if ((api_segment + stats_segment + main_heap + (enable == 0)
+       + (numa_id != ~0)) == 0)
+    {
+      return clib_error_return
+	(0, "Need one of main-heap, stats-segment, api-segment,\n"
+	 "numa-heap <nn> or disable");
+    }
 
+  /* Turn off current trace, if any */
+  if (current_traced_heap)
+    {
+      void *oldheap;
+      oldheap = clib_mem_set_heap (current_traced_heap);
+      clib_mem_trace (0);
+      clib_mem_set_heap (oldheap);
+      current_traced_heap = 0;
+    }
 
-static clib_error_t *
-test_heap_validate (vlib_main_t * vm, unformat_input_t * input,
-		    vlib_cli_command_t * cmd)
-{
-#if USE_DLMALLOC == 0
-  clib_error_t *error = 0;
-  void *heap;
-  mheap_t *mheap;
+  if (enable == 0)
+    return 0;
 
-  if (unformat (input, "on"))
+  /* API segment */
+  if (api_segment)
     {
-        /* *INDENT-OFF* */
-        foreach_vlib_main({
-          heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
-          mheap = mheap_header(heap);
-          mheap->flags |= MHEAP_FLAG_VALIDATE;
-          // Turn off small object cache because it delays detection of errors
-          mheap->flags &= ~MHEAP_FLAG_SMALL_OBJECT_CACHE;
-        });
-        /* *INDENT-ON* */
+      oldheap = vl_msg_push_heap ();
+      current_traced_heap = clib_mem_get_heap ();
+      clib_mem_trace (1);
+      vl_msg_pop_heap (oldheap);
 
     }
-  else if (unformat (input, "off"))
+
+  /* Stats segment */
+  if (stats_segment)
     {
-        /* *INDENT-OFF* */
-        foreach_vlib_main({
-          heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
-          mheap = mheap_header(heap);
-          mheap->flags &= ~MHEAP_FLAG_VALIDATE;
-          mheap->flags |= MHEAP_FLAG_SMALL_OBJECT_CACHE;
-        });
-        /* *INDENT-ON* */
+      oldheap = vlib_stats_set_heap ();
+      current_traced_heap = clib_mem_get_heap ();
+      clib_mem_trace (stats_segment);
+      /* We don't want to call vlib_stats_pop_heap... */
+      if (oldheap)
+	clib_mem_set_heap (oldheap);
     }
-  else if (unformat (input, "now"))
-    {
-        /* *INDENT-OFF* */
-        foreach_vlib_main({
-          heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
-          mheap = mheap_header(heap);
-          mheap_validate(heap);
-        });
-        /* *INDENT-ON* */
-      vlib_cli_output (vm, "heap validation complete");
 
+  /* main_heap */
+  if (main_heap)
+    {
+      current_traced_heap = clib_mem_get_heap ();
+      clib_mem_trace (main_heap);
     }
-  else
+
+  if (numa_id != ~0)
     {
-      return clib_error_return (0, "unknown input `%U'",
-				format_unformat_error, input);
+      if (numa_id >= ARRAY_LEN (mm->per_numa_mheaps))
+	return clib_error_return (0, "Numa %d out of range", numa_id);
+      if (mm->per_numa_mheaps[numa_id] == 0)
+	return clib_error_return (0, "Numa %d heap not active", numa_id);
+
+      if (mm->per_numa_mheaps[numa_id] == clib_mem_get_heap ())
+	return clib_error_return (0, "Numa %d uses the main heap...",
+				  numa_id);
+      current_traced_heap = mm->per_numa_mheaps[numa_id];
+      oldheap = clib_mem_set_heap (current_traced_heap);
+      clib_mem_trace (1);
+      clib_mem_set_heap (oldheap);
     }
 
-  return error;
-#else
-  return clib_error_return (0, "unimplemented...");
-#endif /* USE_DLMALLOC */
+
+  return 0;
 }
 
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (cmd_test_heap_validate,static) = {
-    .path = "test heap-validate",
-    .short_help = "<on/off/now> validate heap on future allocs/frees or right now",
-    .function = test_heap_validate,
+VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = {
+  .path = "memory-trace",
+  .short_help = "memory-trace on|off [api-segment][stats-segment][main-heap]\n"
+  "                   [numa-heap <numa-id>]\n",
+  .function = enable_disable_memory_trace,
 };
-/* *INDENT-ON* */
 
 static clib_error_t *
 restart_cmd_fn (vlib_main_t * vm, unformat_input_t * input,
 		vlib_cli_command_t * cmd)
 {
+  vlib_global_main_t *vgm = vlib_get_global_main ();
   clib_file_main_t *fm = &file_main;
   clib_file_t *f;
 
@@ -1002,27 +1126,23 @@ restart_cmd_fn (vlib_main_t * vm, unformat_input_t * input,
   extern char **environ;
 
   /* Close all known open files */
-  /* *INDENT-OFF* */
-  pool_foreach(f, fm->file_pool,
-    ({
+  pool_foreach (f, fm->file_pool)
+     {
       if (f->file_descriptor > 2)
         close(f->file_descriptor);
-    }));
-  /* *INDENT-ON* */
+    }
 
   /* Exec ourself */
-  execve (vm->name, (char **) vm->argv, environ);
+  execve (vgm->name, (char **) vgm->argv, environ);
 
   return 0;
 }
 
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (restart_cmd,static) = {
     .path = "restart",
     .short_help = "restart process",
     .function = restart_cmd_fn,
 };
-/* *INDENT-ON* */
 
 #ifdef TEST_CODE
 /*
@@ -1048,13 +1168,11 @@ sleep_ten_seconds (vlib_main_t * vm,
   return 0;
 }
 
-/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (ping_command, static) = {
   .path = "test sleep",
   .function = sleep_ten_seconds,
   .short_help = "Sleep for 10 seconds",
 };
-/* *INDENT-ON* */
 #endif /* ifdef TEST_CODE */
 
 static uword
@@ -1093,7 +1211,7 @@ vlib_cli_normalize_path (char *input, char **result)
 
   /* Remove any extra space at end. */
   if (l > 0 && s[l - 1] == ' ')
-    _vec_len (s) -= 1;
+    vec_dec_len (s, 1);
 
   *result = s;
   return index_of_last_space;
@@ -1132,6 +1250,9 @@ add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
       vec_add (sub_name, c->path + l + 1, vec_len (c->path) - (l + 1));
     }
 
+  /* "Can't happen," check mainly to shut up coverity */
+  ALWAYS_ASSERT (sub_name != 0);
+
   if (sub_name[0] == '%')
     {
       uword *q;
@@ -1152,19 +1273,11 @@ add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
 	  return;
 	}
 
-      q = hash_get_mem (cm->parse_rule_index_by_name, sub_name);
-      if (!q)
-	{
-	  clib_error ("reference to unknown rule `%%%v' in path `%v'",
-		      sub_name, c->path);
-	  return;
-	}
-
       hash_set_mem (p->sub_rule_index_by_name, sub_name,
 		    vec_len (p->sub_rules));
       vec_add2 (p->sub_rules, sr, 1);
       sr->name = sub_name;
-      sr->rule_index = q[0];
+      sr->rule_index = sr - p->sub_rules;
       sr->command_index = child_index;
       return;
     }
@@ -1269,7 +1382,8 @@ vlib_cli_command_is_empty (vlib_cli_command_t * c)
 clib_error_t *
 vlib_cli_register (vlib_main_t * vm, vlib_cli_command_t * c)
 {
-  vlib_cli_main_t *cm = &vm->cli_main;
+  vlib_global_main_t *vgm = vlib_get_global_main ();
+  vlib_cli_main_t *cm = &vgm->cli_main;
   clib_error_t *error = 0;
   uword ci, *p;
   char *normalized_path;
@@ -1348,6 +1462,8 @@ vlib_cli_register (vlib_main_t * vm, vlib_cli_command_t * c)
   return 0;
 }
 
+#if 0
+/* $$$ turn back on again someday, maybe */
 clib_error_t *
 vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg)
 {
@@ -1380,8 +1496,6 @@ vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg)
   return error;
 }
 
-#if 0
-/* $$$ turn back on again someday, maybe */
 static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm,
 						    vlib_cli_parse_rule_t *
 						    lo,
@@ -1410,62 +1524,15 @@ done:
 }
 #endif
 
-static int
-cli_path_compare (void *a1, void *a2)
-{
-  u8 **s1 = a1;
-  u8 **s2 = a2;
-
-  if ((vec_len (*s1) < vec_len (*s2)) &&
-      memcmp ((char *) *s1, (char *) *s2, vec_len (*s1)) == 0)
-    return -1;
-
-
-  if ((vec_len (*s1) > vec_len (*s2)) &&
-      memcmp ((char *) *s1, (char *) *s2, vec_len (*s2)) == 0)
-    return 1;
-
-  return vec_cmp (*s1, *s2);
-}
-
-static clib_error_t *
-show_cli_cmd_fn (vlib_main_t * vm, unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
-{
-  vlib_cli_main_t *cm = &vm->cli_main;
-  vlib_cli_command_t *cli;
-  u8 **paths = 0, **s;
-
-  /* *INDENT-OFF* */
-  vec_foreach (cli, cm->commands)
-    if (vec_len (cli->path) > 0)
-      vec_add1 (paths, (u8 *) cli->path);
-
-  vec_sort_with_function (paths, cli_path_compare);
-
-  vec_foreach (s, paths)
-    vlib_cli_output (vm, "%v", *s);
-  /* *INDENT-ON* */
-
-  vec_free (paths);
-  return 0;
-}
-
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (show_cli_command, static) = {
-  .path = "show cli",
-  .short_help = "Show cli commands",
-  .function = show_cli_cmd_fn,
-};
-/* *INDENT-ON* */
-
 static clib_error_t *
-elog_trace_command_fn (vlib_main_t * vm,
-		       unformat_input_t * input, vlib_cli_command_t * cmd)
+event_logger_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;
+  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;
@@ -1474,6 +1541,11 @@ elog_trace_command_fn (vlib_main_t * vm,
     {
       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"))
@@ -1487,21 +1559,52 @@ elog_trace_command_fn (vlib_main_t * vm,
     }
   unformat_free (line_input);
 
-  vm->elog_trace_api_messages = api ? enable : vm->elog_trace_api_messages;
+  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 = &vlib_global_main.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",
-     vm->elog_trace_api_messages ? "on" : "off",
+     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;
 }
@@ -1513,25 +1616,239 @@ print_status:
  *
  * @cliexpar
  * @clistart
- * elog trace api cli barrier
- * elog trace api cli barrier disable
- * elog trace
+ * event-logger trace api cli barrier
+ * event-logger trace api cli barrier disable
+ * event-logger trace dispatch
+ * event-logger trace circuit-node ethernet-input
  * @cliend
- * @cliexcmd{elog trace [api][cli][barrier][disable]}
+ * @cliexcmd{event-logger trace [api][cli][barrier][disable]}
 ?*/
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (elog_trace_command, static) =
+VLIB_CLI_COMMAND (event_logger_trace_command, static) =
 {
-  .path = "elog trace",
-  .short_help = "elog trace [api][cli][barrier][disable]",
-  .function = elog_trace_command_fn,
+  .path = "event-logger trace",
+  .short_help = "event-logger trace [api][cli][barrier][dispatch]\n"
+  "[circuit-node <name> e.g. ethernet-input][disable]",
+  .function = event_logger_trace_command_fn,
+};
+
+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;
+}
+
+VLIB_CLI_COMMAND (suspend_command, static) =
+{
+  .path = "suspend",
+  .short_help = "suspend debug CLI for 30ms",
+  .function = suspend_command_fn,
+  .is_mp_safe = 1,
+};
+
+
+static int
+sort_cmds_by_path (void *a1, void *a2)
+{
+  u32 *index1 = a1;
+  u32 *index2 = a2;
+  vlib_global_main_t *vgm = vlib_get_global_main ();
+  vlib_cli_main_t *cm = &vgm->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)
+{
+  vlib_global_main_t *vgm = vlib_get_global_main ();
+  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, &vgm->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
+?*/
+
+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* */
 
 static clib_error_t *
 vlib_cli_init (vlib_main_t * vm)
 {
-  vlib_cli_main_t *cm = &vm->cli_main;
+  vlib_global_main_t *vgm = vlib_get_global_main ();
+  vlib_cli_main_t *cm = &vgm->cli_main;
   clib_error_t *error = 0;
   vlib_cli_command_t *cmd;
 
@@ -1544,6 +1861,9 @@ vlib_cli_init (vlib_main_t * vm)
 	return error;
       cmd = cmd->next_cli_command;
     }
+
+  cm->log = vlib_log_register_class_rate_limit (
+    "cli", "log", 0x7FFFFFFF /* aka no rate limit */);
   return error;
 }