src/vlib/cli.c

   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  * cli.c: command line interface
  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/unix/unix.h>
  42 #include <vppinfra/cpu.h>
  43 #include <vppinfra/elog.h>
  44 #include <unistd.h>
  45 #include <ctype.h>
  46
  47 /** \file src/vlib/cli.c Debug CLI Implementation
  48  */
  49
  50 int vl_api_set_elog_trace_api_messages (int enable);
  51 int vl_api_get_elog_trace_api_messages (void);
  52
  53 static void *current_traced_heap;
  54
  55 /* Root of all show commands. */
  56 /* *INDENT-OFF* */
  57 VLIB_CLI_COMMAND (vlib_cli_show_command, static) = {
  58   .path = "show",
  59   .short_help = "Show commands",
  60 };
  61 /* *INDENT-ON* */
  62
  63 /* Root of all clear commands. */
  64 /* *INDENT-OFF* */
  65 VLIB_CLI_COMMAND (vlib_cli_clear_command, static) = {
  66   .path = "clear",
  67   .short_help = "Clear commands",
  68 };
  69 /* *INDENT-ON* */
  70
  71 /* Root of all set commands. */
  72 /* *INDENT-OFF* */
  73 VLIB_CLI_COMMAND (vlib_cli_set_command, static) = {
  74   .path = "set",
  75   .short_help = "Set commands",
  76 };
  77 /* *INDENT-ON* */
  78
  79 /* Root of all test commands. */
  80 /* *INDENT-OFF* */
  81 VLIB_CLI_COMMAND (vlib_cli_test_command, static) = {
  82   .path = "test",
  83   .short_help = "Test commands",
  84 };
  85 /* *INDENT-ON* */
  86
  87 /* Returns bitmap of commands which match key. */
  88 static uword *
  89 vlib_cli_sub_command_match (vlib_cli_command_t * c, unformat_input_t * input)
  90 {
  91   int i, n;
  92   uword *match = 0;
  93   vlib_cli_parse_position_t *p;
  94
  95   unformat_skip_white_space (input);
  96
  97   for (i = 0;; i++)
  98     {
  99       uword k;
 100
 101       k = unformat_get_input (input);
 102       switch (k)
 103         {
 104         case 'a' ... 'z':
 105         case 'A' ... 'Z':
 106         case '0' ... '9':
 107         case '-':
 108         case '_':
 109           break;
 110
 111         case ' ':
 112         case '\t':
 113         case '\r':
 114         case '\n':
 115         case UNFORMAT_END_OF_INPUT:
 116           /* White space or end of input removes any non-white
 117              matches that were before possible. */
 118           if (i < vec_len (c->sub_command_positions)
 119               && clib_bitmap_count_set_bits (match) > 1)
 120             {
 121               p = vec_elt_at_index (c->sub_command_positions, i);
 122               for (n = 0; n < vec_len (p->bitmaps); n++)
 123                 match = clib_bitmap_andnot (match, p->bitmaps[n]);
 124             }
 125           goto done;
 126
 127         default:
 128           unformat_put_input (input);
 129           goto done;
 130         }
 131
 132       if (i >= vec_len (c->sub_command_positions))
 133         {
 134         no_match:
 135           clib_bitmap_free (match);
 136           return 0;
 137         }
 138
 139       p = vec_elt_at_index (c->sub_command_positions, i);
 140       if (vec_len (p->bitmaps) == 0)
 141         goto no_match;
 142
 143       n = k - p->min_char;
 144       if (n < 0 || n >= vec_len (p->bitmaps))
 145         goto no_match;
 146
 147       if (i == 0)
 148         match = clib_bitmap_dup (p->bitmaps[n]);
 149       else
 150         match = clib_bitmap_and (match, p->bitmaps[n]);
 151
 152       if (clib_bitmap_is_zero (match))
 153         goto no_match;
 154     }
 155
 156 done:
 157   return match;
 158 }
 159
 160 /* Looks for string based sub-input formatted { SUB-INPUT }. */
 161 uword
 162 unformat_vlib_cli_sub_input (unformat_input_t * i, va_list * args)
 163 {
 164   unformat_input_t *sub_input = va_arg (*args, unformat_input_t *);
 165   u8 *s;
 166   uword c;
 167
 168   while (1)
 169     {
 170       c = unformat_get_input (i);
 171       switch (c)
 172         {
 173         case ' ':
 174         case '\t':
 175         case '\n':
 176         case '\r':
 177         case '\f':
 178           break;
 179
 180         case '{':
 181         default:
 182           /* Put back paren. */
 183           if (c != UNFORMAT_END_OF_INPUT)
 184             unformat_put_input (i);
 185
 186           if (c == '{' && unformat (i, "%v", &s))
 187             {
 188               unformat_init_vector (sub_input, s);
 189               return 1;
 190             }
 191           return 0;
 192         }
 193     }
 194   return 0;
 195 }
 196
 197 static vlib_cli_command_t *
 198 get_sub_command (vlib_cli_main_t * cm, vlib_cli_command_t * parent, u32 si)
 199 {
 200   vlib_cli_sub_command_t *s = vec_elt_at_index (parent->sub_commands, si);
 201   return vec_elt_at_index (cm->commands, s->index);
 202 }
 203
 204 static uword
 205 unformat_vlib_cli_sub_command (unformat_input_t * i, va_list * args)
 206 {
 207   vlib_main_t *vm = va_arg (*args, vlib_main_t *);
 208   vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
 209   vlib_cli_command_t **result = va_arg (*args, vlib_cli_command_t **);
 210   vlib_cli_main_t *cm = &vm->cli_main;
 211   uword *match_bitmap, is_unique, index;
 212
 213   match_bitmap = vlib_cli_sub_command_match (c, i);
 214   is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
 215   index = ~0;
 216   if (is_unique)
 217     {
 218       index = clib_bitmap_first_set (match_bitmap);
 219       *result = get_sub_command (cm, c, index);
 220     }
 221   clib_bitmap_free (match_bitmap);
 222
 223   return is_unique;
 224 }
 225
 226 static int
 227 vlib_cli_cmp_strings (void *a1, void *a2)
 228 {
 229   u8 *c1 = *(u8 **) a1;
 230   u8 *c2 = *(u8 **) a2;
 231
 232   return vec_cmp (c1, c2);
 233 }
 234
 235 u8 **
 236 vlib_cli_get_possible_completions (u8 * str)
 237 {
 238   vlib_cli_command_t *c;
 239   vlib_cli_sub_command_t *sc;
 240   vlib_main_t *vm = vlib_get_main ();
 241   vlib_cli_main_t *vcm = &vm->cli_main;
 242   uword *match_bitmap = 0;
 243   uword index, is_unique, help_next_level;
 244   u8 **result = 0;
 245   unformat_input_t input;
 246   unformat_init_vector (&input, vec_dup (str));
 247   c = vec_elt_at_index (vcm->commands, 0);
 248
 249   /* remove trailing whitespace, except for one of them */
 250   while (vec_len (input.buffer) >= 2 &&
 251          isspace (input.buffer[vec_len (input.buffer) - 1]) &&
 252          isspace (input.buffer[vec_len (input.buffer) - 2]))
 253     {
 254       vec_del1 (input.buffer, vec_len (input.buffer) - 1);
 255     }
 256
 257   /* if input is empty, directly return list of root commands */
 258   if (vec_len (input.buffer) == 0 ||
 259       (vec_len (input.buffer) == 1 && isspace (input.buffer[0])))
 260     {
 261       vec_foreach (sc, c->sub_commands)
 262       {
 263         vec_add1 (result, (u8 *) sc->name);
 264       }
 265       goto done;
 266     }
 267
 268   /* add a trailing '?' so that vlib_cli_sub_command_match can find
 269    * all commands starting with the input string */
 270   vec_add1 (input.buffer, '?');
 271
 272   while (1)
 273     {
 274       match_bitmap = vlib_cli_sub_command_match (c, &input);
 275       /* no match: return no result */
 276       if (match_bitmap == 0)
 277         {
 278           goto done;
 279         }
 280       is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1;
 281       /* unique match: try to step one subcommand level further */
 282       if (is_unique)
 283         {
 284           /* stop if no more input */
 285           if (input.index >= vec_len (input.buffer) - 1)
 286             {
 287               break;
 288             }
 289
 290           index = clib_bitmap_first_set (match_bitmap);
 291           c = get_sub_command (vcm, c, index);
 292           clib_bitmap_free (match_bitmap);
 293           continue;
 294         }
 295       /* multiple matches: stop here, return all matches */
 296       break;
 297     }
 298
 299   /* remove trailing '?' */
 300   vec_del1 (input.buffer, vec_len (input.buffer) - 1);
 301
 302   /* if we have a space at the end of input, and a unique match,
 303    * autocomplete the next level of subcommands */
 304   help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]);
 305   /* *INDENT-OFF* */
 306   clib_bitmap_foreach(index, match_bitmap, {
 307     if (help_next_level && is_unique) {
 308         c = get_sub_command (vcm, c, index);
 309         vec_foreach (sc, c->sub_commands) {
 310           vec_add1 (result, (u8*) sc->name);
 311         }
 312         goto done; /* break doesn't work in this macro-loop */
 313     }
 314     sc = &c->sub_commands[index];
 315     vec_add1(result, (u8*) sc->name);
 316   });
 317   /* *INDENT-ON* */
 318
 319 done:
 320   clib_bitmap_free (match_bitmap);
 321   unformat_free (&input);
 322
 323   if (result)
 324     vec_sort_with_function (result, vlib_cli_cmp_strings);
 325   return result;
 326 }
 327
 328 static u8 *
 329 format_vlib_cli_command_help (u8 * s, va_list * args)
 330 {
 331   vlib_cli_command_t *c = va_arg (*args, vlib_cli_command_t *);
 332   int is_long = va_arg (*args, int);
 333   if (is_long && c->long_help)
 334     s = format (s, "%s", c->long_help);
 335   else if (c->short_help)
 336     s = format (s, "%s", c->short_help);
 337   else
 338     s = format (s, "%v commands", c->path);
 339   return s;
 340 }
 341
 342 static u8 *
 343 format_vlib_cli_path (u8 * s, va_list * args)
 344 {
 345   u8 *path = va_arg (*args, u8 *);
 346
 347   s = format (s, "%v", path);
 348
 349   return s;
 350 }
 351
 352 static vlib_cli_command_t *
 353 all_subs (vlib_cli_main_t * cm, vlib_cli_command_t * subs, u32 command_index)
 354 {
 355   vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index);
 356   vlib_cli_sub_command_t *sc;
 357
 358   if (c->function)
 359     vec_add1 (subs, c[0]);
 360
 361   vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index);
 362
 363   return subs;
 364 }
 365
 366 static int
 367 vlib_cli_cmp_rule (void *a1, void *a2)
 368 {
 369   vlib_cli_sub_rule_t *r1 = a1;
 370   vlib_cli_sub_rule_t *r2 = a2;
 371
 372   return vec_cmp (r1->name, r2->name);
 373 }
 374
 375 static int
 376 vlib_cli_cmp_command (void *a1, void *a2)
 377 {
 378   vlib_cli_command_t *c1 = a1;
 379   vlib_cli_command_t *c2 = a2;
 380
 381   return vec_cmp (c1->path, c2->path);
 382 }
 383
 384 static clib_error_t *
 385 vlib_cli_dispatch_sub_commands (vlib_main_t * vm,
 386                                 vlib_cli_main_t * cm,
 387                                 unformat_input_t * input,
 388                                 uword parent_command_index)
 389 {
 390   vlib_cli_command_t *parent, *c;
 391   clib_error_t *error = 0;
 392   unformat_input_t sub_input;
 393   u8 *string;
 394   uword is_main_dispatch = cm == &vm->cli_main;
 395
 396   parent = vec_elt_at_index (cm->commands, parent_command_index);
 397   if (is_main_dispatch && unformat (input, "help"))
 398     {
 399       uword help_at_end_of_line, i;
 400
 401       help_at_end_of_line =
 402         unformat_check_input (input) == UNFORMAT_END_OF_INPUT;
 403       while (1)
 404         {
 405           c = parent;
 406           if (unformat_user
 407               (input, unformat_vlib_cli_sub_command, vm, c, &parent))
 408             ;
 409
 410           else if (!(unformat_check_input (input) == UNFORMAT_END_OF_INPUT))
 411             goto unknown;
 412
 413           else
 414             break;
 415         }
 416
 417       /* help SUB-COMMAND => long format help.
 418          "help" at end of line: show all commands. */
 419       if (!help_at_end_of_line)
 420         vlib_cli_output (vm, "%U", format_vlib_cli_command_help, c,
 421                          /* is_long */ 1);
 422
 423       else if (vec_len (c->sub_commands) == 0)
 424         vlib_cli_output (vm, "%v: no sub-commands", c->path);
 425
 426       else
 427         {
 428           vlib_cli_sub_rule_t *sr, *subs = 0;
 429           vlib_cli_sub_command_t *sc;
 430
 431           vec_foreach (sc, c->sub_commands)
 432           {
 433             vec_add2 (subs, sr, 1);
 434             sr->name = sc->name;
 435             sr->command_index = sc->index;
 436             sr->rule_index = ~0;
 437           }
 438
 439           vec_sort_with_function (subs, vlib_cli_cmp_rule);
 440
 441           for (i = 0; i < vec_len (subs); i++)
 442             {
 443               vlib_cli_command_t *d;
 444
 445               d = vec_elt_at_index (cm->commands, subs[i].command_index);
 446               vlib_cli_output
 447                 (vm, "  %-30v %U", subs[i].name,
 448                  format_vlib_cli_command_help, d, /* is_long */ 0);
 449             }
 450
 451           vec_free (subs);
 452         }
 453     }
 454
 455   else if (is_main_dispatch
 456            && (unformat (input, "choices") || unformat (input, "?")))
 457     {
 458       vlib_cli_command_t *sub, *subs;
 459
 460       subs = all_subs (cm, 0, parent_command_index);
 461       vec_sort_with_function (subs, vlib_cli_cmp_command);
 462       vec_foreach (sub, subs)
 463         vlib_cli_output (vm, "  %-40U %U",
 464                          format_vlib_cli_path, sub->path,
 465                          format_vlib_cli_command_help, sub, /* is_long */ 0);
 466       vec_free (subs);
 467     }
 468
 469   else if (unformat (input, "comment %v", &string))
 470     {
 471       vec_free (string);
 472     }
 473
 474   else if (unformat (input, "uncomment %U",
 475                      unformat_vlib_cli_sub_input, &sub_input))
 476     {
 477       error =
 478         vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
 479                                         parent_command_index);
 480       unformat_free (&sub_input);
 481     }
 482   else if (unformat (input, "leak-check %U",
 483                      unformat_vlib_cli_sub_input, &sub_input))
 484     {
 485       u8 *leak_report;
 486       if (current_traced_heap)
 487         {
 488           void *oldheap;
 489           oldheap = clib_mem_set_heap (current_traced_heap);
 490           clib_mem_trace (0);
 491           clib_mem_set_heap (oldheap);
 492           current_traced_heap = 0;
 493         }
 494       clib_mem_trace (1);
 495       error =
 496         vlib_cli_dispatch_sub_commands (vm, cm, &sub_input,
 497                                         parent_command_index);
 498       unformat_free (&sub_input);
 499
 500       /* Otherwise, the clib_error_t shows up as a leak... */
 501       if (error)
 502         {
 503           vlib_cli_output (vm, "%v", error->what);
 504           clib_error_free (error);
 505           error = 0;
 506         }
 507
 508       (void) clib_mem_trace_enable_disable (0);
 509       leak_report = format (0, "%U", format_mheap, clib_mem_get_heap (),
 510                             1 /* verbose, i.e. print leaks */ );
 511       clib_mem_trace (0);
 512       vlib_cli_output (vm, "%v", leak_report);
 513       vec_free (leak_report);
 514     }
 515
 516   else
 517     if (unformat_user (input, unformat_vlib_cli_sub_command, vm, parent, &c))
 518     {
 519       unformat_input_t *si;
 520       uword has_sub_commands =
 521         vec_len (c->sub_commands) + vec_len (c->sub_rules) > 0;
 522
 523       si = input;
 524       if (unformat_user (input, unformat_vlib_cli_sub_input, &sub_input))
 525         si = &sub_input;
 526
 527       if (has_sub_commands)
 528         error = vlib_cli_dispatch_sub_commands (vm, cm, si, c - cm->commands);
 529
 530       if (has_sub_commands && !error)
 531         /* Found valid sub-command. */ ;
 532
 533       else if (c->function)
 534         {
 535           clib_error_t *c_error;
 536
 537           /* Skip white space for benefit of called function. */
 538           unformat_skip_white_space (si);
 539
 540           if (unformat (si, "?"))
 541             {
 542               vlib_cli_output (vm, "  %-40U %U", format_vlib_cli_path, c->path, format_vlib_cli_command_help, c,        /* is_long */
 543                                0);
 544             }
 545           else
 546             {
 547               if (PREDICT_FALSE (vm->elog_trace_cli_commands))
 548                 {
 549                   /* *INDENT-OFF* */
 550                   ELOG_TYPE_DECLARE (e) =
 551                     {
 552                       .format = "cli-cmd: %s",
 553                       .format_args = "T4",
 554                     };
 555                   /* *INDENT-ON* */
 556                   struct
 557                   {
 558                     u32 c;
 559                   } *ed;
 560                   ed = ELOG_DATA (&vm->elog_main, e);
 561                   ed->c = elog_string (&vm->elog_main, "%v", c->path);
 562                 }
 563
 564               if (!c->is_mp_safe)
 565                 vlib_worker_thread_barrier_sync (vm);
 566
 567               c->hit_counter++;
 568               c_error = c->function (vm, si, c);
 569
 570               if (!c->is_mp_safe)
 571                 vlib_worker_thread_barrier_release (vm);
 572
 573               if (PREDICT_FALSE (vm->elog_trace_cli_commands))
 574                 {
 575                   /* *INDENT-OFF* */
 576                   ELOG_TYPE_DECLARE (e) =
 577                     {
 578                       .format = "cli-cmd: %s %s",
 579                       .format_args = "T4T4",
 580                     };
 581                   /* *INDENT-ON* */
 582                   struct
 583                   {
 584                     u32 c, err;
 585                   } *ed;
 586                   ed = ELOG_DATA (&vm->elog_main, e);
 587                   ed->c = elog_string (&vm->elog_main, "%v", c->path);
 588                   if (c_error)
 589                     {
 590                       vec_add1 (c_error->what, 0);
 591                       ed->err =
 592                         elog_string (&vm->elog_main, (char *) c_error->what);
 593                       _vec_len (c_error->what) -= 1;
 594                     }
 595                   else
 596                     ed->err = elog_string (&vm->elog_main, "OK");
 597                 }
 598
 599               if (c_error)
 600                 {
 601                   error =
 602                     clib_error_return (0, "%v: %v", c->path, c_error->what);
 603                   clib_error_free (c_error);
 604                   /* Free sub input. */
 605                   if (si != input)
 606                     unformat_free (si);
 607
 608                   return error;
 609                 }
 610             }
 611
 612           /* Free any previous error. */
 613           clib_error_free (error);
 614         }
 615
 616       else if (!error)
 617         error = clib_error_return (0, "%v: no sub-commands", c->path);
 618
 619       /* Free sub input. */
 620       if (si != input)
 621         unformat_free (si);
 622     }
 623
 624   else
 625     goto unknown;
 626
 627   return error;
 628
 629 unknown:
 630   if (parent->path)
 631     return clib_error_return (0, "%v: unknown input `%U'", parent->path,
 632                               format_unformat_error, input);
 633   else
 634     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
 635                               input);
 636 }
 637
 638
 639 void vlib_unix_error_report (vlib_main_t *, clib_error_t *)
 640   __attribute__ ((weak));
 641
 642 void
 643 vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error)
 644 {
 645 }
 646
 647 /* Process CLI input. */
 648 int
 649 vlib_cli_input (vlib_main_t * vm,
 650                 unformat_input_t * input,
 651                 vlib_cli_output_function_t * function, uword function_arg)
 652 {
 653   vlib_process_t *cp = vlib_get_current_process (vm);
 654   clib_error_t *error;
 655   vlib_cli_output_function_t *save_function;
 656   uword save_function_arg;
 657   int rv = 0;
 658
 659   save_function = cp->output_function;
 660   save_function_arg = cp->output_function_arg;
 661
 662   cp->output_function = function;
 663   cp->output_function_arg = function_arg;
 664
 665   do
 666     {
 667       error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input,
 668                                               /* parent */ 0);
 669     }
 670   while (!error && !unformat (input, "%U", unformat_eof));
 671
 672   if (error)
 673     {
 674       vlib_cli_output (vm, "%v", error->what);
 675       vlib_unix_error_report (vm, error);
 676       /* clib_error_return is unfortunately often called with a '0'
 677          return code */
 678       rv = error->code != 0 ? error->code : -1;
 679       clib_error_free (error);
 680     }
 681
 682   cp->output_function = save_function;
 683   cp->output_function_arg = save_function_arg;
 684   return rv;
 685 }
 686
 687 /* Output to current CLI connection. */
 688 void
 689 vlib_cli_output (vlib_main_t * vm, char *fmt, ...)
 690 {
 691   vlib_process_t *cp = vlib_get_current_process (vm);
 692   va_list va;
 693   u8 *s;
 694
 695   va_start (va, fmt);
 696   s = va_format (0, fmt, &va);
 697   va_end (va);
 698
 699   /* Terminate with \n if not present. */
 700   if (vec_len (s) > 0 && s[vec_len (s) - 1] != '\n')
 701     vec_add1 (s, '\n');
 702
 703   if ((!cp) || (!cp->output_function))
 704     fformat (stdout, "%v", s);
 705   else
 706     cp->output_function (cp->output_function_arg, s, vec_len (s));
 707
 708   vec_free (s);
 709 }
 710
 711 void *vl_msg_push_heap (void) __attribute__ ((weak));
 712 void *
 713 vl_msg_push_heap (void)
 714 {
 715   return 0;
 716 }
 717
 718 void vl_msg_pop_heap (void *oldheap) __attribute__ ((weak));
 719 void
 720 vl_msg_pop_heap (void *oldheap)
 721 {
 722 }
 723
 724 void *vlib_stats_push_heap (void *) __attribute__ ((weak));
 725 void *
 726 vlib_stats_push_heap (void *notused)
 727 {
 728   return 0;
 729 }
 730
 731 static clib_error_t *
 732 show_memory_usage (vlib_main_t * vm,
 733                    unformat_input_t * input, vlib_cli_command_t * cmd)
 734 {
 735   int verbose __attribute__ ((unused)) = 0;
 736   int api_segment = 0, stats_segment = 0, main_heap = 0, numa_heaps = 0;
 737   clib_error_t *error;
 738   u32 index = 0;
 739   int i;
 740   uword clib_mem_trace_enable_disable (uword enable);
 741   uword was_enabled;
 742
 743
 744   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 745     {
 746       if (unformat (input, "verbose"))
 747         verbose = 1;
 748       else if (unformat (input, "api-segment"))
 749         api_segment = 1;
 750       else if (unformat (input, "stats-segment"))
 751         stats_segment = 1;
 752       else if (unformat (input, "main-heap"))
 753         main_heap = 1;
 754       else if (unformat (input, "numa-heaps"))
 755         numa_heaps = 1;
 756       else
 757         {
 758           error = clib_error_return (0, "unknown input `%U'",
 759                                      format_unformat_error, input);
 760           return error;
 761         }
 762     }
 763
 764   if ((api_segment + stats_segment + main_heap + numa_heaps) == 0)
 765     return clib_error_return
 766       (0, "Need one of api-segment, stats-segment, main-heap or numa-heaps");
 767
 768   if (api_segment)
 769     {
 770       void *oldheap = vl_msg_push_heap ();
 771       was_enabled = clib_mem_trace_enable_disable (0);
 772       u8 *s_in_svm =
 773         format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
 774       vl_msg_pop_heap (oldheap);
 775       u8 *s = vec_dup (s_in_svm);
 776
 777       oldheap = vl_msg_push_heap ();
 778       vec_free (s_in_svm);
 779       clib_mem_trace_enable_disable (was_enabled);
 780       vl_msg_pop_heap (oldheap);
 781       vlib_cli_output (vm, "API segment");
 782       vlib_cli_output (vm, "%v", s);
 783       vec_free (s);
 784     }
 785   if (stats_segment)
 786     {
 787       void *oldheap = vlib_stats_push_heap (0);
 788       was_enabled = clib_mem_trace_enable_disable (0);
 789       u8 *s_in_svm =
 790         format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1);
 791       if (oldheap)
 792         clib_mem_set_heap (oldheap);
 793       u8 *s = vec_dup (s_in_svm);
 794
 795       oldheap = vlib_stats_push_heap (0);
 796       vec_free (s_in_svm);
 797       if (oldheap)
 798         {
 799           clib_mem_trace_enable_disable (was_enabled);
 800           clib_mem_set_heap (oldheap);
 801         }
 802       vlib_cli_output (vm, "Stats segment");
 803       vlib_cli_output (vm, "%v", s);
 804       vec_free (s);
 805     }
 806
 807
 808 #if USE_DLMALLOC == 0
 809   /* *INDENT-OFF* */
 810   foreach_vlib_main (
 811   ({
 812       mheap_t *h = mheap_header (clib_per_cpu_mheaps[index]);
 813       vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
 814                        vlib_worker_threads[index].name);
 815       vlib_cli_output (vm, "  %U\n", format_page_map, pointer_to_uword (h) -
 816                        h->vm_alloc_offset_from_header,
 817                        h->vm_alloc_size);
 818       vlib_cli_output (vm, "  %U\n", format_mheap, clib_per_cpu_mheaps[index],
 819                        verbose);
 820       index++;
 821   }));
 822   /* *INDENT-ON* */
 823 #else
 824   {
 825     if (main_heap)
 826       {
 827         /*
 828          * Note: the foreach_vlib_main causes allocator traffic,
 829          * so shut off tracing before we go there...
 830          */
 831         was_enabled = clib_mem_trace_enable_disable (0);
 832
 833         /* *INDENT-OFF* */
 834         foreach_vlib_main (
 835         ({
 836           struct dlmallinfo mi;
 837           void *mspace;
 838           mspace = clib_per_cpu_mheaps[index];
 839
 840           mi = mspace_mallinfo (mspace);
 841           vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index,
 842                            vlib_worker_threads[index].name);
 843           vlib_cli_output (vm, "  %U\n", format_page_map,
 844                            pointer_to_uword (mspace_least_addr(mspace)),
 845                            mi.arena);
 846           vlib_cli_output (vm, "  %U\n", format_mheap,
 847                            clib_per_cpu_mheaps[index],
 848                            verbose);
 849           index++;
 850         }));
 851         /* *INDENT-ON* */
 852
 853         /* Restore the trace flag */
 854         clib_mem_trace_enable_disable (was_enabled);
 855       }
 856     if (numa_heaps)
 857       {
 858         struct dlmallinfo mi;
 859         void *mspace;
 860
 861         for (i = 0; i < ARRAY_LEN (clib_per_numa_mheaps); i++)
 862           {
 863             if (clib_per_numa_mheaps[i] == 0)
 864               continue;
 865             if (clib_per_numa_mheaps[i] == clib_per_cpu_mheaps[i])
 866               {
 867                 vlib_cli_output (vm, "Numa %d uses the main heap...", i);
 868                 continue;
 869               }
 870             was_enabled = clib_mem_trace_enable_disable (0);
 871             mspace = clib_per_numa_mheaps[i];
 872
 873             mi = mspace_mallinfo (mspace);
 874             vlib_cli_output (vm, "Numa %d:", i);
 875             vlib_cli_output (vm, "  %U\n", format_page_map,
 876                              pointer_to_uword (mspace_least_addr (mspace)),
 877                              mi.arena);
 878             vlib_cli_output (vm, "  %U\n", format_mheap,
 879                              clib_per_numa_mheaps[index], verbose);
 880           }
 881       }
 882   }
 883 #endif /* USE_DLMALLOC */
 884   return 0;
 885 }
 886
 887 /* *INDENT-OFF* */
 888 VLIB_CLI_COMMAND (show_memory_usage_command, static) = {
 889   .path = "show memory",
 890   .short_help = "show memory [api-segment][stats-segment][verbose]\n"
 891   "            [numa-heaps]",
 892   .function = show_memory_usage,
 893 };
 894 /* *INDENT-ON* */
 895
 896 static clib_error_t *
 897 show_cpu (vlib_main_t * vm, unformat_input_t * input,
 898           vlib_cli_command_t * cmd)
 899 {
 900 #define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c);
 901   _("Model name", "%U", format_cpu_model_name);
 902   _("Microarch model (family)", "%U", format_cpu_uarch);
 903   _("Flags", "%U", format_cpu_flags);
 904   _("Base frequency", "%.2f GHz",
 905     ((f64) vm->clib_time.clocks_per_second) * 1e-9);
 906 #undef _
 907   return 0;
 908 }
 909
 910 /*?
 911  * Displays various information about the CPU.
 912  *
 913  * @cliexpar
 914  * @cliexstart{show cpu}
 915  * Model name:               Intel(R) Xeon(R) CPU E5-2667 v4 @ 3.20GHz
 916  * Microarchitecture:        Broadwell (Broadwell-EP/EX)
 917  * Flags:                    sse3 ssse3 sse41 sse42 avx avx2 aes
 918  * Base Frequency:           3.20 GHz
 919  * @cliexend
 920 ?*/
 921 /* *INDENT-OFF* */
 922 VLIB_CLI_COMMAND (show_cpu_command, static) = {
 923   .path = "show cpu",
 924   .short_help = "Show cpu information",
 925   .function = show_cpu,
 926 };
 927 /* *INDENT-ON* */
 928
 929 static clib_error_t *
 930 enable_disable_memory_trace (vlib_main_t * vm,
 931                              unformat_input_t * input,
 932                              vlib_cli_command_t * cmd)
 933 {
 934   unformat_input_t _line_input, *line_input = &_line_input;
 935   int enable = 1;
 936   int api_segment = 0;
 937   int stats_segment = 0;
 938   int main_heap = 0;
 939   u32 numa_id = ~0;
 940   void *oldheap;
 941
 942   if (!unformat_user (input, unformat_line_input, line_input))
 943     return 0;
 944
 945   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 946     {
 947       if (unformat (line_input, "%U", unformat_vlib_enable_disable, &enable))
 948         ;
 949       else if (unformat (line_input, "api-segment"))
 950         api_segment = 1;
 951       else if (unformat (line_input, "stats-segment"))
 952         stats_segment = 1;
 953       else if (unformat (line_input, "main-heap"))
 954         main_heap = 1;
 955       else if (unformat (line_input, "numa-heap %d", &numa_id))
 956         ;
 957       else
 958         {
 959           unformat_free (line_input);
 960           return clib_error_return (0, "invalid input");
 961         }
 962     }
 963   unformat_free (line_input);
 964
 965   if ((api_segment + stats_segment + main_heap + (enable == 0)
 966        + (numa_id != ~0)) == 0)
 967     {
 968       return clib_error_return
 969         (0, "Need one of main-heap, stats-segment, api-segment,\n"
 970          "numa-heap <nn> or disable");
 971     }
 972
 973   /* Turn off current trace, if any */
 974   if (current_traced_heap)
 975     {
 976       void *oldheap;
 977       oldheap = clib_mem_set_heap (current_traced_heap);
 978       clib_mem_trace (0);
 979       clib_mem_set_heap (oldheap);
 980       current_traced_heap = 0;
 981     }
 982
 983   if (enable == 0)
 984     return 0;
 985
 986   /* API segment */
 987   if (api_segment)
 988     {
 989       oldheap = vl_msg_push_heap ();
 990       current_traced_heap = clib_mem_get_heap ();
 991       clib_mem_trace (1);
 992       vl_msg_pop_heap (oldheap);
 993
 994     }
 995
 996   /* Stats segment */
 997   if (stats_segment)
 998     {
 999       oldheap = vlib_stats_push_heap (0);
1000       current_traced_heap = clib_mem_get_heap ();
1001       clib_mem_trace (stats_segment);
1002       /* We don't want to call vlib_stats_pop_heap... */
1003       if (oldheap)
1004         clib_mem_set_heap (oldheap);
1005     }
1006
1007   /* main_heap */
1008   if (main_heap)
1009     {
1010       current_traced_heap = clib_mem_get_heap ();
1011       clib_mem_trace (main_heap);
1012     }
1013
1014   if (numa_id != ~0)
1015     {
1016       if (numa_id >= ARRAY_LEN (clib_per_numa_mheaps))
1017         return clib_error_return (0, "Numa %d out of range", numa_id);
1018       if (clib_per_numa_mheaps[numa_id] == 0)
1019         return clib_error_return (0, "Numa %d heap not active", numa_id);
1020
1021       if (clib_per_numa_mheaps[numa_id] == clib_mem_get_heap ())
1022         return clib_error_return (0, "Numa %d uses the main heap...",
1023                                   numa_id);
1024       current_traced_heap = clib_per_numa_mheaps[numa_id];
1025       oldheap = clib_mem_set_heap (current_traced_heap);
1026       clib_mem_trace (1);
1027       clib_mem_set_heap (oldheap);
1028     }
1029
1030
1031   return 0;
1032 }
1033
1034 /* *INDENT-OFF* */
1035 VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = {
1036   .path = "memory-trace",
1037   .short_help = "memory-trace on|off [api-segment][stats-segment][main-heap]\n"
1038   "                   [numa-heap <numa-id>]\n",
1039   .function = enable_disable_memory_trace,
1040 };
1041 /* *INDENT-ON* */
1042
1043
1044 static clib_error_t *
1045 test_heap_validate (vlib_main_t * vm, unformat_input_t * input,
1046                     vlib_cli_command_t * cmd)
1047 {
1048 #if USE_DLMALLOC == 0
1049   clib_error_t *error = 0;
1050   void *heap;
1051   mheap_t *mheap;
1052
1053   if (unformat (input, "on"))
1054     {
1055         /* *INDENT-OFF* */
1056         foreach_vlib_main({
1057           heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1058           mheap = mheap_header(heap);
1059           mheap->flags |= MHEAP_FLAG_VALIDATE;
1060           // Turn off small object cache because it delays detection of errors
1061           mheap->flags &= ~MHEAP_FLAG_SMALL_OBJECT_CACHE;
1062         });
1063         /* *INDENT-ON* */
1064
1065     }
1066   else if (unformat (input, "off"))
1067     {
1068         /* *INDENT-OFF* */
1069         foreach_vlib_main({
1070           heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1071           mheap = mheap_header(heap);
1072           mheap->flags &= ~MHEAP_FLAG_VALIDATE;
1073           mheap->flags |= MHEAP_FLAG_SMALL_OBJECT_CACHE;
1074         });
1075         /* *INDENT-ON* */
1076     }
1077   else if (unformat (input, "now"))
1078     {
1079         /* *INDENT-OFF* */
1080         foreach_vlib_main({
1081           heap = clib_per_cpu_mheaps[this_vlib_main->thread_index];
1082           mheap = mheap_header(heap);
1083           mheap_validate(heap);
1084         });
1085         /* *INDENT-ON* */
1086       vlib_cli_output (vm, "heap validation complete");
1087
1088     }
1089   else
1090     {
1091       return clib_error_return (0, "unknown input `%U'",
1092                                 format_unformat_error, input);
1093     }
1094
1095   return error;
1096 #else
1097   return clib_error_return (0, "unimplemented...");
1098 #endif /* USE_DLMALLOC */
1099 }
1100
1101 /* *INDENT-OFF* */
1102 VLIB_CLI_COMMAND (cmd_test_heap_validate,static) = {
1103     .path = "test heap-validate",
1104     .short_help = "<on/off/now> validate heap on future allocs/frees or right now",
1105     .function = test_heap_validate,
1106 };
1107 /* *INDENT-ON* */
1108
1109 static clib_error_t *
1110 restart_cmd_fn (vlib_main_t * vm, unformat_input_t * input,
1111                 vlib_cli_command_t * cmd)
1112 {
1113   clib_file_main_t *fm = &file_main;
1114   clib_file_t *f;
1115
1116   /* environ(7) does not indicate a header for this */
1117   extern char **environ;
1118
1119   /* Close all known open files */
1120   /* *INDENT-OFF* */
1121   pool_foreach(f, fm->file_pool,
1122     ({
1123       if (f->file_descriptor > 2)
1124         close(f->file_descriptor);
1125     }));
1126   /* *INDENT-ON* */
1127
1128   /* Exec ourself */
1129   execve (vm->name, (char **) vm->argv, environ);
1130
1131   return 0;
1132 }
1133
1134 /* *INDENT-OFF* */
1135 VLIB_CLI_COMMAND (restart_cmd,static) = {
1136     .path = "restart",
1137     .short_help = "restart process",
1138     .function = restart_cmd_fn,
1139 };
1140 /* *INDENT-ON* */
1141
1142 #ifdef TEST_CODE
1143 /*
1144  * A trivial test harness to verify the per-process output_function
1145  * is working correcty.
1146  */
1147
1148 static clib_error_t *
1149 sleep_ten_seconds (vlib_main_t * vm,
1150                    unformat_input_t * input, vlib_cli_command_t * cmd)
1151 {
1152   u16 i;
1153   u16 my_id = rand ();
1154
1155   vlib_cli_output (vm, "Starting 10 seconds sleep with id %u\n", my_id);
1156
1157   for (i = 0; i < 10; i++)
1158     {
1159       vlib_process_wait_for_event_or_clock (vm, 1.0);
1160       vlib_cli_output (vm, "Iteration number %u, my id: %u\n", i, my_id);
1161     }
1162   vlib_cli_output (vm, "Done with sleep with id %u\n", my_id);
1163   return 0;
1164 }
1165
1166 /* *INDENT-OFF* */
1167 VLIB_CLI_COMMAND (ping_command, static) = {
1168   .path = "test sleep",
1169   .function = sleep_ten_seconds,
1170   .short_help = "Sleep for 10 seconds",
1171 };
1172 /* *INDENT-ON* */
1173 #endif /* ifdef TEST_CODE */
1174
1175 static uword
1176 vlib_cli_normalize_path (char *input, char **result)
1177 {
1178   char *i = input;
1179   char *s = 0;
1180   uword l = 0;
1181   uword index_of_last_space = ~0;
1182
1183   while (*i != 0)
1184     {
1185       u8 c = *i++;
1186       /* Multiple white space -> single space. */
1187       switch (c)
1188         {
1189         case ' ':
1190         case '\t':
1191         case '\n':
1192         case '\r':
1193           if (l > 0 && s[l - 1] != ' ')
1194             {
1195               vec_add1 (s, ' ');
1196               l++;
1197             }
1198           break;
1199
1200         default:
1201           if (l > 0 && s[l - 1] == ' ')
1202             index_of_last_space = vec_len (s);
1203           vec_add1 (s, c);
1204           l++;
1205           break;
1206         }
1207     }
1208
1209   /* Remove any extra space at end. */
1210   if (l > 0 && s[l - 1] == ' ')
1211     _vec_len (s) -= 1;
1212
1213   *result = s;
1214   return index_of_last_space;
1215 }
1216
1217 always_inline uword
1218 parent_path_len (char *path)
1219 {
1220   word i;
1221   for (i = vec_len (path) - 1; i >= 0; i--)
1222     {
1223       if (path[i] == ' ')
1224         return i;
1225     }
1226   return ~0;
1227 }
1228
1229 static void
1230 add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index)
1231 {
1232   vlib_cli_command_t *p, *c;
1233   vlib_cli_sub_command_t *sub_c;
1234   u8 *sub_name;
1235   word i, l;
1236
1237   p = vec_elt_at_index (cm->commands, parent_index);
1238   c = vec_elt_at_index (cm->commands, child_index);
1239
1240   l = parent_path_len (c->path);
1241   if (l == ~0)
1242     sub_name = vec_dup ((u8 *) c->path);
1243   else
1244     {
1245       ASSERT (l + 1 < vec_len (c->path));
1246       sub_name = 0;
1247       vec_add (sub_name, c->path + l + 1, vec_len (c->path) - (l + 1));
1248     }
1249
1250   if (sub_name[0] == '%')
1251     {
1252       uword *q;
1253       vlib_cli_sub_rule_t *sr;
1254
1255       /* Remove %. */
1256       vec_delete (sub_name, 1, 0);
1257
1258       if (!p->sub_rule_index_by_name)
1259         p->sub_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1260                                                      sizeof (sub_name[0]),
1261                                                      sizeof (uword));
1262       q = hash_get_mem (p->sub_rule_index_by_name, sub_name);
1263       if (q)
1264         {
1265           sr = vec_elt_at_index (p->sub_rules, q[0]);
1266           ASSERT (sr->command_index == child_index);
1267           return;
1268         }
1269
1270       hash_set_mem (p->sub_rule_index_by_name, sub_name,
1271                     vec_len (p->sub_rules));
1272       vec_add2 (p->sub_rules, sr, 1);
1273       sr->name = sub_name;
1274       sr->rule_index = sr - p->sub_rules;
1275       sr->command_index = child_index;
1276       return;
1277     }
1278
1279   if (!p->sub_command_index_by_name)
1280     p->sub_command_index_by_name = hash_create_vec ( /* initial length */ 32,
1281                                                     sizeof (c->path[0]),
1282                                                     sizeof (uword));
1283
1284   /* Check if sub-command has already been created. */
1285   if (hash_get_mem (p->sub_command_index_by_name, sub_name))
1286     {
1287       vec_free (sub_name);
1288       return;
1289     }
1290
1291   vec_add2 (p->sub_commands, sub_c, 1);
1292   sub_c->index = child_index;
1293   sub_c->name = sub_name;
1294   hash_set_mem (p->sub_command_index_by_name, sub_c->name,
1295                 sub_c - p->sub_commands);
1296
1297   vec_validate (p->sub_command_positions, vec_len (sub_c->name) - 1);
1298   for (i = 0; i < vec_len (sub_c->name); i++)
1299     {
1300       int n;
1301       vlib_cli_parse_position_t *pos;
1302
1303       pos = vec_elt_at_index (p->sub_command_positions, i);
1304
1305       if (!pos->bitmaps)
1306         pos->min_char = sub_c->name[i];
1307
1308       n = sub_c->name[i] - pos->min_char;
1309       if (n < 0)
1310         {
1311           pos->min_char = sub_c->name[i];
1312           vec_insert (pos->bitmaps, -n, 0);
1313           n = 0;
1314         }
1315
1316       vec_validate (pos->bitmaps, n);
1317       pos->bitmaps[n] =
1318         clib_bitmap_ori (pos->bitmaps[n], sub_c - p->sub_commands);
1319     }
1320 }
1321
1322 static void
1323 vlib_cli_make_parent (vlib_cli_main_t * cm, uword ci)
1324 {
1325   uword p_len, pi, *p;
1326   char *p_path;
1327   vlib_cli_command_t *c, *parent;
1328
1329   /* Root command (index 0) should have already been added. */
1330   ASSERT (vec_len (cm->commands) > 0);
1331
1332   c = vec_elt_at_index (cm->commands, ci);
1333   p_len = parent_path_len (c->path);
1334
1335   /* No space?  Parent is root command. */
1336   if (p_len == ~0)
1337     {
1338       add_sub_command (cm, 0, ci);
1339       return;
1340     }
1341
1342   p_path = 0;
1343   vec_add (p_path, c->path, p_len);
1344
1345   p = hash_get_mem (cm->command_index_by_path, p_path);
1346
1347   /* Parent exists? */
1348   if (!p)
1349     {
1350       /* Parent does not exist; create it. */
1351       vec_add2 (cm->commands, parent, 1);
1352       parent->path = p_path;
1353       hash_set_mem (cm->command_index_by_path, parent->path,
1354                     parent - cm->commands);
1355       pi = parent - cm->commands;
1356     }
1357   else
1358     {
1359       pi = p[0];
1360       vec_free (p_path);
1361     }
1362
1363   add_sub_command (cm, pi, ci);
1364
1365   /* Create parent's parent. */
1366   if (!p)
1367     vlib_cli_make_parent (cm, pi);
1368 }
1369
1370 always_inline uword
1371 vlib_cli_command_is_empty (vlib_cli_command_t * c)
1372 {
1373   return (c->long_help == 0 && c->short_help == 0 && c->function == 0);
1374 }
1375
1376 clib_error_t *
1377 vlib_cli_register (vlib_main_t * vm, vlib_cli_command_t * c)
1378 {
1379   vlib_cli_main_t *cm = &vm->cli_main;
1380   clib_error_t *error = 0;
1381   uword ci, *p;
1382   char *normalized_path;
1383
1384   if ((error = vlib_call_init_function (vm, vlib_cli_init)))
1385     return error;
1386
1387   (void) vlib_cli_normalize_path (c->path, &normalized_path);
1388
1389   if (!cm->command_index_by_path)
1390     cm->command_index_by_path = hash_create_vec ( /* initial length */ 32,
1391                                                  sizeof (c->path[0]),
1392                                                  sizeof (uword));
1393
1394   /* See if command already exists with given path. */
1395   p = hash_get_mem (cm->command_index_by_path, normalized_path);
1396   if (p)
1397     {
1398       vlib_cli_command_t *d;
1399
1400       ci = p[0];
1401       d = vec_elt_at_index (cm->commands, ci);
1402
1403       /* If existing command was created via vlib_cli_make_parent
1404          replaced it with callers data. */
1405       if (vlib_cli_command_is_empty (d))
1406         {
1407           vlib_cli_command_t save = d[0];
1408
1409           ASSERT (!vlib_cli_command_is_empty (c));
1410
1411           /* Copy callers fields. */
1412           d[0] = c[0];
1413
1414           /* Save internal fields. */
1415           d->path = save.path;
1416           d->sub_commands = save.sub_commands;
1417           d->sub_command_index_by_name = save.sub_command_index_by_name;
1418           d->sub_command_positions = save.sub_command_positions;
1419           d->sub_rules = save.sub_rules;
1420         }
1421       else
1422         error =
1423           clib_error_return (0, "duplicate command name with path %v",
1424                              normalized_path);
1425
1426       vec_free (normalized_path);
1427       if (error)
1428         return error;
1429     }
1430   else
1431     {
1432       /* Command does not exist: create it. */
1433
1434       /* Add root command (index 0). */
1435       if (vec_len (cm->commands) == 0)
1436         {
1437           /* Create command with index 0; path is empty string. */
1438           vec_resize (cm->commands, 1);
1439         }
1440
1441       ci = vec_len (cm->commands);
1442       hash_set_mem (cm->command_index_by_path, normalized_path, ci);
1443       vec_add1 (cm->commands, c[0]);
1444
1445       c = vec_elt_at_index (cm->commands, ci);
1446       c->path = normalized_path;
1447
1448       /* Don't inherit from registration. */
1449       c->sub_commands = 0;
1450       c->sub_command_index_by_name = 0;
1451       c->sub_command_positions = 0;
1452     }
1453
1454   vlib_cli_make_parent (cm, ci);
1455   return 0;
1456 }
1457
1458 #if 0
1459 /* $$$ turn back on again someday, maybe */
1460 clib_error_t *
1461 vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg)
1462 {
1463   vlib_cli_main_t *cm = &vm->cli_main;
1464   vlib_cli_parse_rule_t *r;
1465   clib_error_t *error = 0;
1466   u8 *r_name;
1467   uword *p;
1468
1469   if (!cm->parse_rule_index_by_name)
1470     cm->parse_rule_index_by_name = hash_create_vec ( /* initial length */ 32,
1471                                                     sizeof (r->name[0]),
1472                                                     sizeof (uword));
1473
1474   /* Make vector copy of name. */
1475   r_name = format (0, "%s", r_reg->name);
1476
1477   if ((p = hash_get_mem (cm->parse_rule_index_by_name, r_name)))
1478     {
1479       vec_free (r_name);
1480       return clib_error_return (0, "duplicate parse rule name `%s'",
1481                                 r_reg->name);
1482     }
1483
1484   vec_add2 (cm->parse_rules, r, 1);
1485   r[0] = r_reg[0];
1486   r->name = (char *) r_name;
1487   hash_set_mem (cm->parse_rule_index_by_name, r->name, r - cm->parse_rules);
1488
1489   return error;
1490 }
1491
1492 static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm,
1493                                                     vlib_cli_parse_rule_t *
1494                                                     lo,
1495                                                     vlib_cli_parse_rule_t *
1496                                                     hi)
1497   __attribute__ ((unused))
1498 {
1499   clib_error_t *error = 0;
1500   vlib_cli_parse_rule_t *r;
1501
1502   for (r = lo; r < hi; r = clib_elf_section_data_next (r, 0))
1503     {
1504       if (!r->name || strlen (r->name) == 0)
1505         {
1506           error = clib_error_return (0, "parse rule with no name");
1507           goto done;
1508         }
1509
1510       error = vlib_cli_register_parse_rule (vm, r);
1511       if (error)
1512         goto done;
1513     }
1514
1515 done:
1516   return error;
1517 }
1518 #endif
1519
1520 static clib_error_t *
1521 elog_trace_command_fn (vlib_main_t * vm,
1522                        unformat_input_t * input, vlib_cli_command_t * cmd)
1523 {
1524   unformat_input_t _line_input, *line_input = &_line_input;
1525   int enable = 1;
1526   int api = 0, cli = 0, barrier = 0, dispatch = 0, circuit = 0;
1527   u32 circuit_node_index;
1528
1529   if (!unformat_user (input, unformat_line_input, line_input))
1530     goto print_status;
1531
1532   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
1533     {
1534       if (unformat (line_input, "api"))
1535         api = 1;
1536       else if (unformat (line_input, "dispatch"))
1537         dispatch = 1;
1538       else if (unformat (line_input, "circuit-node %U",
1539                          unformat_vlib_node, vm, &circuit_node_index))
1540         circuit = 1;
1541       else if (unformat (line_input, "cli"))
1542         cli = 1;
1543       else if (unformat (line_input, "barrier"))
1544         barrier = 1;
1545       else if (unformat (line_input, "disable"))
1546         enable = 0;
1547       else if (unformat (line_input, "enable"))
1548         enable = 1;
1549       else
1550         break;
1551     }
1552   unformat_free (line_input);
1553
1554   vl_api_set_elog_trace_api_messages
1555     (api ? enable : vl_api_get_elog_trace_api_messages ());
1556   vm->elog_trace_cli_commands = cli ? enable : vm->elog_trace_cli_commands;
1557   vm->elog_trace_graph_dispatch = dispatch ?
1558     enable : vm->elog_trace_graph_dispatch;
1559   vm->elog_trace_graph_circuit = circuit ?
1560     enable : vm->elog_trace_graph_circuit;
1561   vlib_worker_threads->barrier_elog_enabled =
1562     barrier ? enable : vlib_worker_threads->barrier_elog_enabled;
1563   vm->elog_trace_graph_circuit_node_index = circuit_node_index;
1564
1565   /*
1566    * Set up start-of-buffer logic-analyzer trigger
1567    * for main loop event logs, which are fairly heavyweight.
1568    * See src/vlib/main/vlib_elog_main_loop_event(...), which
1569    * will fully disable the scheme when the elog buffer fills.
1570    */
1571   if (dispatch || circuit)
1572     {
1573       elog_main_t *em = &vm->elog_main;
1574
1575       em->n_total_events_disable_limit =
1576         em->n_total_events + vec_len (em->event_ring);
1577     }
1578
1579
1580 print_status:
1581   vlib_cli_output (vm, "Current status:");
1582
1583   vlib_cli_output
1584     (vm, "    Event log API message trace: %s\n    CLI command trace: %s",
1585      vl_api_get_elog_trace_api_messages ()? "on" : "off",
1586      vm->elog_trace_cli_commands ? "on" : "off");
1587   vlib_cli_output
1588     (vm, "    Barrier sync trace: %s",
1589      vlib_worker_threads->barrier_elog_enabled ? "on" : "off");
1590   vlib_cli_output
1591     (vm, "    Graph Dispatch: %s",
1592      vm->elog_trace_graph_dispatch ? "on" : "off");
1593   vlib_cli_output
1594     (vm, "    Graph Circuit: %s",
1595      vm->elog_trace_graph_circuit ? "on" : "off");
1596   if (vm->elog_trace_graph_circuit)
1597     vlib_cli_output
1598       (vm, "                   node %U",
1599        format_vlib_node_name, vm, vm->elog_trace_graph_circuit_node_index);
1600
1601   return 0;
1602 }
1603
1604 /*?
1605  * Control event logging of api, cli, and thread barrier events
1606  * With no arguments, displays the current trace status.
1607  * Name the event groups you wish to trace or stop tracing.
1608  *
1609  * @cliexpar
1610  * @clistart
1611  * elog trace api cli barrier
1612  * elog trace api cli barrier disable
1613  * elog trace dispatch
1614  * elog trace circuit-node ethernet-input
1615  * elog trace
1616  * @cliend
1617  * @cliexcmd{elog trace [api][cli][barrier][disable]}
1618 ?*/
1619 /* *INDENT-OFF* */
1620 VLIB_CLI_COMMAND (elog_trace_command, static) =
1621 {
1622   .path = "elog trace",
1623   .short_help = "elog trace [api][cli][barrier][dispatch]\n"
1624   "[circuit-node <name> e.g. ethernet-input][disable]",
1625   .function = elog_trace_command_fn,
1626 };
1627 /* *INDENT-ON* */
1628
1629 static clib_error_t *
1630 suspend_command_fn (vlib_main_t * vm,
1631                     unformat_input_t * input, vlib_cli_command_t * cmd)
1632 {
1633   vlib_process_suspend (vm, 30e-3);
1634   return 0;
1635 }
1636
1637 /* *INDENT-OFF* */
1638 VLIB_CLI_COMMAND (suspend_command, static) =
1639 {
1640   .path = "suspend",
1641   .short_help = "suspend debug CLI for 30ms",
1642   .function = suspend_command_fn,
1643   .is_mp_safe = 1,
1644 };
1645 /* *INDENT-ON* */
1646
1647
1648 static int
1649 sort_cmds_by_path (void *a1, void *a2)
1650 {
1651   u32 *index1 = a1;
1652   u32 *index2 = a2;
1653   vlib_main_t *vm = vlib_get_main ();
1654   vlib_cli_main_t *cm = &vm->cli_main;
1655   vlib_cli_command_t *c1, *c2;
1656   int i, lmin;
1657
1658   c1 = vec_elt_at_index (cm->commands, *index1);
1659   c2 = vec_elt_at_index (cm->commands, *index2);
1660
1661   lmin = vec_len (c1->path);
1662   lmin = (vec_len (c2->path) >= lmin) ? lmin : vec_len (c2->path);
1663
1664   for (i = 0; i < lmin; i++)
1665     {
1666       if (c1->path[i] < c2->path[i])
1667         return -1;
1668       else if (c1->path[i] > c2->path[i])
1669         return 1;
1670     }
1671
1672   return 0;
1673 }
1674
1675 typedef struct
1676 {
1677   vlib_cli_main_t *cm;
1678   u32 parent_command_index;
1679   int show_mp_safe;
1680   int show_not_mp_safe;
1681   int show_hit;
1682   int clear_hit;
1683 } vlib_cli_walk_args_t;
1684
1685 static void
1686 cli_recursive_walk (vlib_cli_walk_args_t * aa)
1687 {
1688   vlib_cli_command_t *parent;
1689   vlib_cli_sub_command_t *sub;
1690   vlib_cli_walk_args_t _a, *a = &_a;
1691   vlib_cli_main_t *cm;
1692   int i;
1693
1694   /* Copy args into this stack frame */
1695   *a = *aa;
1696   cm = a->cm;
1697
1698   parent = vec_elt_at_index (cm->commands, a->parent_command_index);
1699
1700   if (parent->function)
1701     {
1702       if (((a->show_mp_safe && parent->is_mp_safe)
1703            || (a->show_not_mp_safe && !parent->is_mp_safe))
1704           && (a->show_hit == 0 || parent->hit_counter))
1705         {
1706           vec_add1 (cm->sort_vector, a->parent_command_index);
1707         }
1708
1709       if (a->clear_hit)
1710         parent->hit_counter = 0;
1711     }
1712
1713   for (i = 0; i < vec_len (parent->sub_commands); i++)
1714     {
1715       sub = vec_elt_at_index (parent->sub_commands, i);
1716       a->parent_command_index = sub->index;
1717       cli_recursive_walk (a);
1718     }
1719 }
1720
1721 static u8 *
1722 format_mp_safe (u8 * s, va_list * args)
1723 {
1724   vlib_cli_main_t *cm = va_arg (*args, vlib_cli_main_t *);
1725   int show_mp_safe = va_arg (*args, int);
1726   int show_not_mp_safe = va_arg (*args, int);
1727   int show_hit = va_arg (*args, int);
1728   int clear_hit = va_arg (*args, int);
1729   vlib_cli_command_t *c;
1730   vlib_cli_walk_args_t _a, *a = &_a;
1731   int i;
1732   char *format_string = "\n%v";
1733
1734   if (show_hit)
1735     format_string = "\n%v: %u";
1736
1737   vec_reset_length (cm->sort_vector);
1738
1739   a->cm = cm;
1740   a->parent_command_index = 0;
1741   a->show_mp_safe = show_mp_safe;
1742   a->show_not_mp_safe = show_not_mp_safe;
1743   a->show_hit = show_hit;
1744   a->clear_hit = clear_hit;
1745
1746   cli_recursive_walk (a);
1747
1748   vec_sort_with_function (cm->sort_vector, sort_cmds_by_path);
1749
1750   for (i = 0; i < vec_len (cm->sort_vector); i++)
1751     {
1752       c = vec_elt_at_index (cm->commands, cm->sort_vector[i]);
1753       s = format (s, format_string, c->path, c->hit_counter);
1754     }
1755
1756   return s;
1757 }
1758
1759
1760 static clib_error_t *
1761 show_cli_command_fn (vlib_main_t * vm,
1762                      unformat_input_t * input, vlib_cli_command_t * cmd)
1763 {
1764   int show_mp_safe = 0;
1765   int show_not_mp_safe = 0;
1766   int show_hit = 0;
1767   int clear_hit = 0;
1768
1769   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1770     {
1771       if (unformat (input, "mp-safe"))
1772         show_mp_safe = 1;
1773       if (unformat (input, "not-mp-safe"))
1774         show_not_mp_safe = 1;
1775       else if (unformat (input, "hit"))
1776         show_hit = 1;
1777       else if (unformat (input, "clear-hit"))
1778         clear_hit = 1;
1779       else
1780         break;
1781     }
1782
1783   /* default set: all cli commands */
1784   if (clear_hit == 0 && (show_mp_safe + show_not_mp_safe) == 0)
1785     show_mp_safe = show_not_mp_safe = 1;
1786
1787   vlib_cli_output (vm, "%U", format_mp_safe, &vm->cli_main,
1788                    show_mp_safe, show_not_mp_safe, show_hit, clear_hit);
1789   if (clear_hit)
1790     vlib_cli_output (vm, "hit counters cleared...");
1791
1792   return 0;
1793 }
1794
1795 /*?
1796  * Displays debug cli command information
1797  *
1798  * @cliexpar
1799  * @cliexstart{show cli [mp-safe][not-mp-safe][hit][clear-hit]}
1800  *
1801  * "show cli" displays the entire debug cli:
1802  *
1803  * abf attach
1804  * abf policy
1805  * adjacency counters
1806  * api trace
1807  * app ns
1808  * bfd key del
1809  * ... and so on ...
1810  *
1811  * "show cli mp-safe" displays mp-safe debug CLI commands:
1812  *
1813  * abf policy
1814  * binary-api
1815  * create vhost-user
1816  * exec
1817  * ip container
1818  * ip mroute
1819  * ip probe-neighbor
1820  * ip route
1821  * ip scan-neighbor
1822  * ip table
1823  * ip6 table
1824  *
1825  * "show cli not-mp-safe" displays debug CLI commands
1826  * which cause worker thread barrier synchronization
1827  *
1828  * "show cli hit" displays commands which have been executed. Qualify
1829  * as desired with "mp-safe" or "not-mp-safe".
1830  *
1831  * "show cli clear-hit" clears the per-command hit counters.
1832  * @cliexend
1833 ?*/
1834
1835 /* *INDENT-OFF* */
1836 VLIB_CLI_COMMAND (show_cli_command, static) =
1837 {
1838   .path = "show cli",
1839   .short_help = "show cli [mp-safe][not-mp-safe][hit][clear-hit]",
1840   .function = show_cli_command_fn,
1841   .is_mp_safe = 1,
1842 };
1843 /* *INDENT-ON* */
1844
1845 static clib_error_t *
1846 vlib_cli_init (vlib_main_t * vm)
1847 {
1848   vlib_cli_main_t *cm = &vm->cli_main;
1849   clib_error_t *error = 0;
1850   vlib_cli_command_t *cmd;
1851
1852   cmd = cm->cli_command_registrations;
1853
1854   while (cmd)
1855     {
1856       error = vlib_cli_register (vm, cmd);
1857       if (error)
1858         return error;
1859       cmd = cmd->next_cli_command;
1860     }
1861   return error;
1862 }
1863
1864 VLIB_INIT_FUNCTION (vlib_cli_init);
1865
1866 /*
1867  * fd.io coding-style-patch-verification: ON
1868  *
1869  * Local Variables:
1870  * eval: (c-set-style "gnu")
1871  * End:
1872  */