src/vlibmemory/vlib_api_cli.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <fcntl.h>
  19 #include <unistd.h>
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22
  23 #include <vlibapi/api.h>
  24 #include <vlibmemory/api.h>
  25
  26 static clib_error_t *
  27 vl_api_show_histogram_command (vlib_main_t * vm,
  28                                unformat_input_t * input,
  29                                vlib_cli_command_t * cli_cmd)
  30 {
  31   u64 total_counts = 0;
  32   int i;
  33
  34   for (i = 0; i < SLEEP_N_BUCKETS; i++)
  35     {
  36       total_counts += vector_rate_histogram[i];
  37     }
  38
  39   if (total_counts == 0)
  40     {
  41       vlib_cli_output (vm, "No control-plane activity.");
  42       return 0;
  43     }
  44
  45 #define _(n)                                                    \
  46     do {                                                        \
  47         f64 percent;                                            \
  48         percent = ((f64) vector_rate_histogram[SLEEP_##n##_US]) \
  49             / (f64) total_counts;                               \
  50         percent *= 100.0;                                       \
  51         vlib_cli_output (vm, "Sleep %3d us: %llu, %.2f%%",n,    \
  52                          vector_rate_histogram[SLEEP_##n##_US], \
  53                          percent);                              \
  54     } while (0);
  55   foreach_histogram_bucket;
  56 #undef _
  57
  58   return 0;
  59 }
  60
  61 /*?
  62  * Display the binary api sleep-time histogram
  63 ?*/
  64 /* *INDENT-OFF* */
  65 VLIB_CLI_COMMAND (cli_show_api_histogram_command, static) =
  66 {
  67   .path = "show api histogram",
  68   .short_help = "show api histogram",
  69   .function = vl_api_show_histogram_command,
  70 };
  71 /* *INDENT-ON* */
  72
  73 static clib_error_t *
  74 vl_api_clear_histogram_command (vlib_main_t * vm,
  75                                 unformat_input_t * input,
  76                                 vlib_cli_command_t * cli_cmd)
  77 {
  78   int i;
  79
  80   for (i = 0; i < SLEEP_N_BUCKETS; i++)
  81     vector_rate_histogram[i] = 0;
  82   return 0;
  83 }
  84
  85 /*?
  86  * Clear the binary api sleep-time histogram
  87 ?*/
  88 /* *INDENT-OFF* */
  89 VLIB_CLI_COMMAND (cli_clear_api_histogram_command, static) =
  90 {
  91   .path = "clear api histogram",
  92   .short_help = "clear api histogram",
  93   .function = vl_api_clear_histogram_command,
  94 };
  95 /* *INDENT-ON* */
  96
  97 static clib_error_t *
  98 vl_api_client_command (vlib_main_t * vm,
  99                        unformat_input_t * input, vlib_cli_command_t * cli_cmd)
 100 {
 101   vl_api_registration_t **regpp, *regp;
 102   svm_queue_t *q;
 103   char *health;
 104   api_main_t *am = &api_main;
 105   u32 *confused_indices = 0;
 106
 107   if (!pool_elts (am->vl_clients))
 108     goto socket_clients;
 109   vlib_cli_output (vm, "Shared memory clients");
 110   vlib_cli_output (vm, "%20s %8s %14s %18s %s",
 111                    "Name", "PID", "Queue Length", "Queue VA", "Health");
 112
 113   /* *INDENT-OFF* */
 114   pool_foreach (regpp, am->vl_clients,
 115   ({
 116     regp = *regpp;
 117
 118     if (regp)
 119       {
 120         if (regp->unanswered_pings > 0)
 121           health = "questionable";
 122         else
 123           health = "OK";
 124
 125         q = regp->vl_input_queue;
 126
 127         vlib_cli_output (vm, "%20s %8d %14d 0x%016llx %s\n",
 128                          regp->name, q->consumer_pid, q->cursize,
 129                          q, health);
 130       }
 131     else
 132       {
 133         clib_warning ("NULL client registration index %d",
 134                       regpp - am->vl_clients);
 135         vec_add1 (confused_indices, regpp - am->vl_clients);
 136       }
 137   }));
 138   /* *INDENT-ON* */
 139
 140   /* This should "never happen," but if it does, fix it... */
 141   if (PREDICT_FALSE (vec_len (confused_indices) > 0))
 142     {
 143       int i;
 144       for (i = 0; i < vec_len (confused_indices); i++)
 145         {
 146           pool_put_index (am->vl_clients, confused_indices[i]);
 147         }
 148     }
 149   vec_free (confused_indices);
 150
 151   if (am->missing_clients)
 152     vlib_cli_output (vm, "%u messages with missing clients",
 153                      am->missing_clients);
 154 socket_clients:
 155   vl_sock_api_dump_clients (vm, am);
 156
 157   return 0;
 158 }
 159
 160 static clib_error_t *
 161 vl_api_status_command (vlib_main_t * vm,
 162                        unformat_input_t * input, vlib_cli_command_t * cli_cmd)
 163 {
 164   api_main_t *am = &api_main;
 165
 166   /* check if rx_trace and tx_trace are not null pointers */
 167   if (am->rx_trace == 0)
 168     {
 169       vlib_cli_output (vm, "RX Trace disabled\n");
 170     }
 171   else
 172     {
 173       if (am->rx_trace->enabled == 0)
 174         vlib_cli_output (vm, "RX Trace disabled\n");
 175       else
 176         vlib_cli_output (vm, "RX Trace enabled\n");
 177     }
 178
 179   if (am->tx_trace == 0)
 180     {
 181       vlib_cli_output (vm, "TX Trace disabled\n");
 182     }
 183   else
 184     {
 185       if (am->tx_trace->enabled == 0)
 186         vlib_cli_output (vm, "TX Trace disabled\n");
 187       else
 188         vlib_cli_output (vm, "TX Trace enabled\n");
 189     }
 190
 191   return 0;
 192 }
 193
 194 /* *INDENT-OFF* */
 195 VLIB_CLI_COMMAND (cli_show_api_command, static) =
 196 {
 197   .path = "show api",
 198   .short_help = "Show API information",
 199 };
 200 /* *INDENT-ON* */
 201
 202 /*?
 203  * Display current api client connections
 204 ?*/
 205 /* *INDENT-OFF* */
 206 VLIB_CLI_COMMAND (cli_show_api_clients_command, static) =
 207 {
 208   .path = "show api clients",
 209   .short_help = "Client information",
 210   .function = vl_api_client_command,
 211 };
 212 /* *INDENT-ON* */
 213
 214 /*?
 215  * Display the current api message tracing status
 216 ?*/
 217 /* *INDENT-OFF* */
 218 VLIB_CLI_COMMAND (cli_show_api_status_command, static) =
 219 {
 220   .path = "show api trace-status",
 221   .short_help = "Display API trace status",
 222   .function = vl_api_status_command,
 223 };
 224 /* *INDENT-ON* */
 225
 226 static clib_error_t *
 227 vl_api_message_table_command (vlib_main_t * vm,
 228                               unformat_input_t * input,
 229                               vlib_cli_command_t * cli_cmd)
 230 {
 231   api_main_t *am = &api_main;
 232   int i;
 233   int verbose = 0;
 234
 235   if (unformat (input, "verbose"))
 236     verbose = 1;
 237
 238
 239   if (verbose == 0)
 240     vlib_cli_output (vm, "%-4s %s", "ID", "Name");
 241   else
 242     vlib_cli_output (vm, "%-4s %-40s %6s %7s", "ID", "Name", "Bounce",
 243                      "MP-safe");
 244
 245   for (i = 1; i < vec_len (am->msg_names); i++)
 246     {
 247       if (verbose == 0)
 248         {
 249           vlib_cli_output (vm, "%-4d %s", i,
 250                            am->msg_names[i] ? am->msg_names[i] :
 251                            "  [no handler]");
 252         }
 253       else
 254         {
 255           vlib_cli_output (vm, "%-4d %-40s %6d %7d", i,
 256                            am->msg_names[i] ? am->msg_names[i] :
 257                            "  [no handler]", am->message_bounce[i],
 258                            am->is_mp_safe[i]);
 259         }
 260     }
 261
 262   return 0;
 263 }
 264
 265 /*?
 266  * Display the current api message decode tables
 267 ?*/
 268 /* *INDENT-OFF* */
 269 VLIB_CLI_COMMAND (cli_show_api_message_table_command, static) =
 270 {
 271   .path = "show api message-table",
 272   .short_help = "Message Table",
 273   .function = vl_api_message_table_command,
 274 };
 275 /* *INDENT-ON* */
 276
 277 static int
 278 range_compare (vl_api_msg_range_t * a0, vl_api_msg_range_t * a1)
 279 {
 280   int len0, len1, clen;
 281
 282   len0 = vec_len (a0->name);
 283   len1 = vec_len (a1->name);
 284   clen = len0 < len1 ? len0 : len1;
 285   return (strncmp ((char *) a0->name, (char *) a1->name, clen));
 286 }
 287
 288 static u8 *
 289 format_api_msg_range (u8 * s, va_list * args)
 290 {
 291   vl_api_msg_range_t *rp = va_arg (*args, vl_api_msg_range_t *);
 292
 293   if (rp == 0)
 294     s = format (s, "%-50s%9s%9s", "Name", "First-ID", "Last-ID");
 295   else
 296     s = format (s, "%-50s%9d%9d", rp->name, rp->first_msg_id,
 297                 rp->last_msg_id);
 298
 299   return s;
 300 }
 301
 302 static clib_error_t *
 303 vl_api_show_plugin_command (vlib_main_t * vm,
 304                             unformat_input_t * input,
 305                             vlib_cli_command_t * cli_cmd)
 306 {
 307   api_main_t *am = &api_main;
 308   vl_api_msg_range_t *rp = 0;
 309   int i;
 310
 311   if (vec_len (am->msg_ranges) == 0)
 312     {
 313       vlib_cli_output (vm, "No plugin API message ranges configured...");
 314       return 0;
 315     }
 316
 317   rp = vec_dup (am->msg_ranges);
 318
 319   vec_sort_with_function (rp, range_compare);
 320
 321   vlib_cli_output (vm, "Plugin API message ID ranges...\n");
 322   vlib_cli_output (vm, "%U", format_api_msg_range, 0 /* header */ );
 323
 324   for (i = 0; i < vec_len (rp); i++)
 325     vlib_cli_output (vm, "%U", format_api_msg_range, rp + i);
 326
 327   vec_free (rp);
 328
 329   return 0;
 330 }
 331
 332 /*?
 333  * Display the plugin binary API message range table
 334 ?*/
 335 /* *INDENT-OFF* */
 336 VLIB_CLI_COMMAND (cli_show_api_plugin_command, static) =
 337 {
 338   .path = "show api plugin",
 339   .short_help = "show api plugin",
 340   .function = vl_api_show_plugin_command,
 341 };
 342 /* *INDENT-ON* */
 343
 344 typedef enum
 345 {
 346   DUMP,
 347   CUSTOM_DUMP,
 348   REPLAY,
 349   INITIALIZERS,
 350 } vl_api_replay_t;
 351
 352 u8 *
 353 format_vl_msg_api_trace_status (u8 * s, va_list * args)
 354 {
 355   api_main_t *am = va_arg (*args, api_main_t *);
 356   vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
 357   vl_api_trace_t *tp;
 358   char *trace_name;
 359
 360   switch (which)
 361     {
 362     case VL_API_TRACE_TX:
 363       tp = am->tx_trace;
 364       trace_name = "TX trace";
 365       break;
 366
 367     case VL_API_TRACE_RX:
 368       tp = am->rx_trace;
 369       trace_name = "RX trace";
 370       break;
 371
 372     default:
 373       abort ();
 374     }
 375
 376   if (tp == 0)
 377     {
 378       s = format (s, "%s: not yet configured.\n", trace_name);
 379       return s;
 380     }
 381
 382   s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
 383               trace_name, vec_len (tp->traces), tp->nitems,
 384               tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
 385   return s;
 386 }
 387
 388 void vl_msg_api_custom_dump_configure (api_main_t * am)
 389   __attribute__ ((weak));
 390 void
 391 vl_msg_api_custom_dump_configure (api_main_t * am)
 392 {
 393 }
 394
 395 static void
 396 vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
 397                          u32 first_index, u32 last_index,
 398                          vl_api_replay_t which)
 399 {
 400   vl_api_trace_file_header_t *hp;
 401   int i, fd;
 402   struct stat statb;
 403   size_t file_size;
 404   u8 *msg;
 405   u8 endian_swap_needed = 0;
 406   api_main_t *am = &api_main;
 407   u8 *tmpbuf = 0;
 408   u32 nitems;
 409   void **saved_print_handlers = 0;
 410
 411   fd = open ((char *) filename, O_RDONLY);
 412
 413   if (fd < 0)
 414     {
 415       vlib_cli_output (vm, "Couldn't open %s\n", filename);
 416       return;
 417     }
 418
 419   if (fstat (fd, &statb) < 0)
 420     {
 421       vlib_cli_output (vm, "Couldn't stat %s\n", filename);
 422       close (fd);
 423       return;
 424     }
 425
 426   if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
 427     {
 428       vlib_cli_output (vm, "File not plausible: %s\n", filename);
 429       close (fd);
 430       return;
 431     }
 432
 433   file_size = statb.st_size;
 434   file_size = (file_size + 4095) & ~(4096);
 435
 436   hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
 437
 438   if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
 439     {
 440       vlib_cli_output (vm, "mmap failed: %s\n", filename);
 441       close (fd);
 442       return;
 443     }
 444   close (fd);
 445
 446   if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
 447       || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
 448     endian_swap_needed = 1;
 449
 450   if (endian_swap_needed)
 451     nitems = ntohl (hp->nitems);
 452   else
 453     nitems = hp->nitems;
 454
 455   if (last_index == (u32) ~ 0)
 456     {
 457       last_index = nitems - 1;
 458     }
 459
 460   if (first_index >= nitems || last_index >= nitems)
 461     {
 462       vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
 463                        first_index, last_index, nitems - 1);
 464       munmap (hp, file_size);
 465       return;
 466     }
 467   if (hp->wrapped)
 468     vlib_cli_output (vm,
 469                      "Note: wrapped/incomplete trace, results may vary\n");
 470
 471   if (which == CUSTOM_DUMP)
 472     {
 473       saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
 474       vl_msg_api_custom_dump_configure (am);
 475     }
 476
 477
 478   msg = (u8 *) (hp + 1);
 479
 480   for (i = 0; i < first_index; i++)
 481     {
 482       trace_cfg_t *cfgp;
 483       int size;
 484       u16 msg_id;
 485
 486       size = clib_host_to_net_u32 (*(u32 *) msg);
 487       msg += sizeof (u32);
 488
 489       if (clib_arch_is_little_endian)
 490         msg_id = ntohs (*((u16 *) msg));
 491       else
 492         msg_id = *((u16 *) msg);
 493
 494       cfgp = am->api_trace_cfg + msg_id;
 495       if (!cfgp)
 496         {
 497           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
 498           munmap (hp, file_size);
 499           return;
 500         }
 501       msg += size;
 502     }
 503
 504   if (which == REPLAY)
 505     am->replay_in_progress = 1;
 506
 507   for (; i <= last_index; i++)
 508     {
 509       trace_cfg_t *cfgp;
 510       u16 *msg_idp;
 511       u16 msg_id;
 512       int size;
 513
 514       if (which == DUMP)
 515         vlib_cli_output (vm, "---------- trace %d -----------\n", i);
 516
 517       size = clib_host_to_net_u32 (*(u32 *) msg);
 518       msg += sizeof (u32);
 519
 520       if (clib_arch_is_little_endian)
 521         msg_id = ntohs (*((u16 *) msg));
 522       else
 523         msg_id = *((u16 *) msg);
 524
 525       cfgp = am->api_trace_cfg + msg_id;
 526       if (!cfgp)
 527         {
 528           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
 529           munmap (hp, file_size);
 530           vec_free (tmpbuf);
 531           am->replay_in_progress = 0;
 532           return;
 533         }
 534
 535       /* Copy the buffer (from the read-only mmap'ed file) */
 536       vec_validate (tmpbuf, size - 1 + sizeof (uword));
 537       clib_memcpy (tmpbuf + sizeof (uword), msg, size);
 538       clib_memset (tmpbuf, 0xf, sizeof (uword));
 539
 540       /*
 541        * Endian swap if needed. All msg data is supposed to be
 542        * in network byte order. All msg handlers are supposed to
 543        * know that. The generic message dumpers don't know that.
 544        * One could fix apigen, I suppose.
 545        */
 546       if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
 547         {
 548           void (*endian_fp) (void *);
 549           if (msg_id >= vec_len (am->msg_endian_handlers)
 550               || (am->msg_endian_handlers[msg_id] == 0))
 551             {
 552               vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
 553               munmap (hp, file_size);
 554               vec_free (tmpbuf);
 555               am->replay_in_progress = 0;
 556               return;
 557             }
 558           endian_fp = am->msg_endian_handlers[msg_id];
 559           (*endian_fp) (tmpbuf + sizeof (uword));
 560         }
 561
 562       /* msg_id always in network byte order */
 563       if (clib_arch_is_little_endian)
 564         {
 565           msg_idp = (u16 *) (tmpbuf + sizeof (uword));
 566           *msg_idp = msg_id;
 567         }
 568
 569       switch (which)
 570         {
 571         case CUSTOM_DUMP:
 572         case DUMP:
 573           if (msg_id < vec_len (am->msg_print_handlers) &&
 574               am->msg_print_handlers[msg_id])
 575             {
 576               u8 *(*print_fp) (void *, void *);
 577
 578               print_fp = (void *) am->msg_print_handlers[msg_id];
 579               (*print_fp) (tmpbuf + sizeof (uword), vm);
 580             }
 581           else
 582             {
 583               vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
 584                                msg_id);
 585               break;
 586             }
 587           break;
 588
 589         case INITIALIZERS:
 590           if (msg_id < vec_len (am->msg_print_handlers) &&
 591               am->msg_print_handlers[msg_id])
 592             {
 593               u8 *s;
 594               int j;
 595               u8 *(*print_fp) (void *, void *);
 596
 597               print_fp = (void *) am->msg_print_handlers[msg_id];
 598
 599               vlib_cli_output (vm, "/*");
 600
 601               (*print_fp) (tmpbuf + sizeof (uword), vm);
 602               vlib_cli_output (vm, "*/\n");
 603
 604               s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
 605                           am->msg_names[msg_id], i,
 606                           am->api_trace_cfg[msg_id].size);
 607
 608               for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
 609                 {
 610                   if ((j & 7) == 0)
 611                     s = format (s, "\n    ");
 612                   s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
 613                 }
 614               s = format (s, "\n};\n%c", 0);
 615               vlib_cli_output (vm, (char *) s);
 616               vec_free (s);
 617             }
 618           break;
 619
 620         case REPLAY:
 621           if (msg_id < vec_len (am->msg_print_handlers) &&
 622               am->msg_print_handlers[msg_id] && cfgp->replay_enable)
 623             {
 624               void (*handler) (void *, vlib_main_t *);
 625
 626               handler = (void *) am->msg_handlers[msg_id];
 627
 628               if (!am->is_mp_safe[msg_id])
 629                 vl_msg_api_barrier_sync ();
 630               (*handler) (tmpbuf + sizeof (uword), vm);
 631               if (!am->is_mp_safe[msg_id])
 632                 vl_msg_api_barrier_release ();
 633             }
 634           else
 635             {
 636               if (cfgp->replay_enable)
 637                 vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
 638                                  msg_id);
 639               break;
 640             }
 641           break;
 642         }
 643
 644       _vec_len (tmpbuf) = 0;
 645       msg += size;
 646     }
 647
 648   if (saved_print_handlers)
 649     {
 650       clib_memcpy (am->msg_print_handlers, saved_print_handlers,
 651                    vec_len (am->msg_print_handlers) * sizeof (void *));
 652       vec_free (saved_print_handlers);
 653     }
 654
 655   munmap (hp, file_size);
 656   vec_free (tmpbuf);
 657   am->replay_in_progress = 0;
 658 }
 659
 660 static clib_error_t *
 661 api_trace_command_fn (vlib_main_t * vm,
 662                       unformat_input_t * input, vlib_cli_command_t * cmd)
 663 {
 664   u32 nitems = 256 << 10;
 665   api_main_t *am = &api_main;
 666   vl_api_trace_which_t which = VL_API_TRACE_RX;
 667   u8 *filename = 0;
 668   u8 *chroot_filename = 0;
 669   u32 first = 0;
 670   u32 last = (u32) ~ 0;
 671   FILE *fp;
 672   int rv;
 673
 674   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 675     {
 676       if (unformat (input, "on") || unformat (input, "enable"))
 677         {
 678           if (unformat (input, "nitems %d", &nitems))
 679             ;
 680           vl_msg_api_trace_configure (am, which, nitems);
 681           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
 682         }
 683       else if (unformat (input, "off"))
 684         {
 685           vl_msg_api_trace_onoff (am, which, 0);
 686         }
 687       else if (unformat (input, "save %s", &filename))
 688         {
 689           if (strstr ((char *) filename, "..")
 690               || index ((char *) filename, '/'))
 691             {
 692               vlib_cli_output (vm, "illegal characters in filename '%s'",
 693                                filename);
 694               goto out;
 695             }
 696
 697           chroot_filename = format (0, "/tmp/%s%c", filename, 0);
 698
 699           vec_free (filename);
 700
 701           fp = fopen ((char *) chroot_filename, "w");
 702           if (fp == NULL)
 703             {
 704               vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
 705               goto out;
 706             }
 707           rv = vl_msg_api_trace_save (am, which, fp);
 708           fclose (fp);
 709           if (rv == -1)
 710             vlib_cli_output (vm, "API Trace data not present\n");
 711           else if (rv == -2)
 712             vlib_cli_output (vm, "File for writing is closed\n");
 713           else if (rv == -10)
 714             vlib_cli_output (vm, "Error while writing header to file\n");
 715           else if (rv == -11)
 716             vlib_cli_output (vm, "Error while writing trace to file\n");
 717           else if (rv == -12)
 718             vlib_cli_output (vm,
 719                              "Error while writing end of buffer trace to file\n");
 720           else if (rv == -13)
 721             vlib_cli_output (vm,
 722                              "Error while writing start of buffer trace to file\n");
 723           else if (rv < 0)
 724             vlib_cli_output (vm, "Unknown error while saving: %d", rv);
 725           else
 726             vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
 727           goto out;
 728         }
 729       else if (unformat (input, "dump %s", &filename))
 730         {
 731           vl_msg_api_process_file (vm, filename, first, last, DUMP);
 732         }
 733       else if (unformat (input, "custom-dump %s", &filename))
 734         {
 735           vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
 736         }
 737       else if (unformat (input, "replay %s", &filename))
 738         {
 739           vl_msg_api_process_file (vm, filename, first, last, REPLAY);
 740         }
 741       else if (unformat (input, "initializers %s", &filename))
 742         {
 743           vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
 744         }
 745       else if (unformat (input, "tx"))
 746         {
 747           which = VL_API_TRACE_TX;
 748         }
 749       else if (unformat (input, "first %d", &first))
 750         {
 751           ;
 752         }
 753       else if (unformat (input, "last %d", &last))
 754         {
 755           ;
 756         }
 757       else if (unformat (input, "status"))
 758         {
 759           vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
 760                            am, which);
 761         }
 762       else if (unformat (input, "free"))
 763         {
 764           vl_msg_api_trace_onoff (am, which, 0);
 765           vl_msg_api_trace_free (am, which);
 766         }
 767       else if (unformat (input, "post-mortem-on"))
 768         vl_msg_api_post_mortem_dump_enable_disable (1 /* enable */ );
 769       else if (unformat (input, "post-mortem-off"))
 770         vl_msg_api_post_mortem_dump_enable_disable (0 /* enable */ );
 771       else
 772         return clib_error_return (0, "unknown input `%U'",
 773                                   format_unformat_error, input);
 774     }
 775 out:
 776   vec_free (filename);
 777   vec_free (chroot_filename);
 778   return 0;
 779 }
 780
 781 /*?
 782  * Display, replay, or save a binary API trace
 783 ?*/
 784
 785 /* *INDENT-OFF* */
 786 VLIB_CLI_COMMAND (api_trace_command, static) =
 787 {
 788   .path = "api trace",
 789   .short_help = "api trace [on|off][first <n>][last <n>][status][free]"
 790       "[post-mortem-on][dump|custom-dump|save|replay <file>]",
 791   .function = api_trace_command_fn,
 792 };
 793 /* *INDENT-ON* */
 794
 795 static clib_error_t *
 796 vl_api_trace_command (vlib_main_t * vm,
 797                       unformat_input_t * input, vlib_cli_command_t * cli_cmd)
 798 {
 799   u32 nitems = 1024;
 800   vl_api_trace_which_t which = VL_API_TRACE_RX;
 801   api_main_t *am = &api_main;
 802
 803   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 804     {
 805       if (unformat (input, "rx nitems %u", &nitems) || unformat (input, "rx"))
 806         goto configure;
 807       else if (unformat (input, "tx nitems %u", &nitems)
 808                || unformat (input, "tx"))
 809         {
 810           which = VL_API_TRACE_RX;
 811           goto configure;
 812         }
 813       else if (unformat (input, "on rx"))
 814         {
 815           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
 816         }
 817       else if (unformat (input, "on tx"))
 818         {
 819           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 1);
 820         }
 821       else if (unformat (input, "on"))
 822         {
 823           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
 824         }
 825       else if (unformat (input, "off"))
 826         {
 827           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
 828           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
 829         }
 830       else if (unformat (input, "free"))
 831         {
 832           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
 833           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
 834           vl_msg_api_trace_free (am, VL_API_TRACE_RX);
 835           vl_msg_api_trace_free (am, VL_API_TRACE_TX);
 836         }
 837       else if (unformat (input, "debug on"))
 838         {
 839           am->msg_print_flag = 1;
 840         }
 841       else if (unformat (input, "debug off"))
 842         {
 843           am->msg_print_flag = 0;
 844         }
 845       else
 846         return clib_error_return (0, "unknown input `%U'",
 847                                   format_unformat_error, input);
 848     }
 849   return 0;
 850
 851 configure:
 852   if (vl_msg_api_trace_configure (am, which, nitems))
 853     {
 854       vlib_cli_output (vm, "warning: trace configure error (%d, %d)",
 855                        which, nitems);
 856     }
 857
 858   return 0;
 859 }
 860
 861 /*?
 862  * Control the binary API trace mechanism
 863 ?*/
 864 /* *INDENT-OFF* */
 865 VLIB_CLI_COMMAND (trace, static) =
 866 {
 867   .path = "set api-trace",
 868   .short_help = "API trace [on][on tx][on rx][off][free][debug on][debug off]",
 869   .function = vl_api_trace_command,
 870 };
 871 /* *INDENT-ON* */
 872
 873 static clib_error_t *
 874 api_trace_config_fn (vlib_main_t * vm, unformat_input_t * input)
 875 {
 876   u32 nitems = 256 << 10;
 877   vl_api_trace_which_t which = VL_API_TRACE_RX;
 878   api_main_t *am = &api_main;
 879
 880   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 881     {
 882       if (unformat (input, "on") || unformat (input, "enable"))
 883         {
 884           if (unformat (input, "nitems %d", &nitems))
 885             ;
 886           vl_msg_api_trace_configure (am, which, nitems);
 887           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
 888           vl_msg_api_post_mortem_dump_enable_disable (1 /* enable */ );
 889         }
 890       else if (unformat (input, "save-api-table %s",
 891                          &am->save_msg_table_filename))
 892         ;
 893       else
 894         return clib_error_return (0, "unknown input `%U'",
 895                                   format_unformat_error, input);
 896     }
 897   return 0;
 898 }
 899
 900 /*?
 901  * This module has three configuration parameters:
 902  * "on" or "enable" - enables binary api tracing
 903  * "nitems <nnn>" - sets the size of the circular buffer to <nnn>
 904  * "save-api-table <filename>" - dumps the API message table to /tmp/<filename>
 905 ?*/
 906 VLIB_CONFIG_FUNCTION (api_trace_config_fn, "api-trace");
 907
 908 static clib_error_t *
 909 api_queue_config_fn (vlib_main_t * vm, unformat_input_t * input)
 910 {
 911   api_main_t *am = &api_main;
 912   u32 nitems;
 913
 914   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 915     {
 916       if (unformat (input, "length %d", &nitems) ||
 917           (unformat (input, "len %d", &nitems)))
 918         {
 919           if (nitems >= 1024)
 920             am->vlib_input_queue_length = nitems;
 921           else
 922             clib_warning ("vlib input queue length %d too small, ignored",
 923                           nitems);
 924         }
 925       else
 926         return clib_error_return (0, "unknown input `%U'",
 927                                   format_unformat_error, input);
 928     }
 929   return 0;
 930 }
 931
 932 VLIB_CONFIG_FUNCTION (api_queue_config_fn, "api-queue");
 933
 934 static u8 *
 935 extract_name (u8 * s)
 936 {
 937   u8 *rv;
 938
 939   rv = vec_dup (s);
 940
 941   while (vec_len (rv) && rv[vec_len (rv)] != '_')
 942     _vec_len (rv)--;
 943
 944   rv[vec_len (rv)] = 0;
 945
 946   return rv;
 947 }
 948
 949 static u8 *
 950 extract_crc (u8 * s)
 951 {
 952   int i;
 953   u8 *rv;
 954
 955   rv = vec_dup (s);
 956
 957   for (i = vec_len (rv) - 1; i >= 0; i--)
 958     {
 959       if (rv[i] == '_')
 960         {
 961           vec_delete (rv, i + 1, 0);
 962           break;
 963         }
 964     }
 965   return rv;
 966 }
 967
 968 typedef struct
 969 {
 970   u8 *name_and_crc;
 971   u8 *name;
 972   u8 *crc;
 973   u32 msg_index;
 974   int which;
 975 } msg_table_unserialize_t;
 976
 977 static int
 978 table_id_cmp (void *a1, void *a2)
 979 {
 980   msg_table_unserialize_t *n1 = a1;
 981   msg_table_unserialize_t *n2 = a2;
 982
 983   return (n1->msg_index - n2->msg_index);
 984 }
 985
 986 static int
 987 table_name_and_crc_cmp (void *a1, void *a2)
 988 {
 989   msg_table_unserialize_t *n1 = a1;
 990   msg_table_unserialize_t *n2 = a2;
 991
 992   return strcmp ((char *) n1->name_and_crc, (char *) n2->name_and_crc);
 993 }
 994
 995 static clib_error_t *
 996 dump_api_table_file_command_fn (vlib_main_t * vm,
 997                                 unformat_input_t * input,
 998                                 vlib_cli_command_t * cmd)
 999 {
1000   u8 *filename = 0;
1001   api_main_t *am = &api_main;
1002   serialize_main_t _sm, *sm = &_sm;
1003   clib_error_t *error;
1004   u32 nmsgs;
1005   u32 msg_index;
1006   u8 *name_and_crc;
1007   int compare_current = 0;
1008   int numeric_sort = 0;
1009   msg_table_unserialize_t *table = 0, *item;
1010   u32 i;
1011   u32 ndifferences = 0;
1012
1013   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1014     {
1015       if (unformat (input, "file %s", &filename))
1016         ;
1017       else if (unformat (input, "compare-current")
1018                || unformat (input, "compare"))
1019         compare_current = 1;
1020       else if (unformat (input, "numeric"))
1021         numeric_sort = 1;
1022       else
1023         return clib_error_return (0, "unknown input `%U'",
1024                                   format_unformat_error, input);
1025     }
1026
1027   if (numeric_sort && compare_current)
1028     return clib_error_return
1029       (0, "Comparison and numeric sorting are incompatible");
1030
1031   if (filename == 0)
1032     return clib_error_return (0, "File not specified");
1033
1034   /* Load the serialized message table from the table dump */
1035
1036   error = unserialize_open_clib_file (sm, (char *) filename);
1037
1038   if (error)
1039     return error;
1040
1041   unserialize_integer (sm, &nmsgs, sizeof (u32));
1042
1043   for (i = 0; i < nmsgs; i++)
1044     {
1045       msg_index = unserialize_likely_small_unsigned_integer (sm);
1046       unserialize_cstring (sm, (char **) &name_and_crc);
1047       vec_add2 (table, item, 1);
1048       item->msg_index = msg_index;
1049       item->name_and_crc = name_and_crc;
1050       item->name = extract_name (name_and_crc);
1051       item->crc = extract_crc (name_and_crc);
1052       item->which = 0;          /* file */
1053     }
1054   serialize_close (sm);
1055
1056   /* Compare with the current image? */
1057   if (compare_current)
1058     {
1059       /* Append the current message table */
1060       u8 *tblv = vl_api_serialize_message_table (am, 0);
1061
1062       serialize_open_vector (sm, tblv);
1063       unserialize_integer (sm, &nmsgs, sizeof (u32));
1064
1065       for (i = 0; i < nmsgs; i++)
1066         {
1067           msg_index = unserialize_likely_small_unsigned_integer (sm);
1068           unserialize_cstring (sm, (char **) &name_and_crc);
1069
1070           vec_add2 (table, item, 1);
1071           item->msg_index = msg_index;
1072           item->name_and_crc = name_and_crc;
1073           item->name = extract_name (name_and_crc);
1074           item->crc = extract_crc (name_and_crc);
1075           item->which = 1;      /* current_image */
1076         }
1077       vec_free (tblv);
1078     }
1079
1080   /* Sort the table. */
1081   if (numeric_sort)
1082     vec_sort_with_function (table, table_id_cmp);
1083   else
1084     vec_sort_with_function (table, table_name_and_crc_cmp);
1085
1086   if (compare_current)
1087     {
1088       u8 *dashes = 0;
1089       ndifferences = 0;
1090
1091       /*
1092        * In this case, the recovered table will have two entries per
1093        * API message. So, if entries i and i+1 match, the message definitions
1094        * are identical. Otherwise, the crc is different, or a message is
1095        * present in only one of the tables.
1096        */
1097       vlib_cli_output (vm, "%-60s | %s", "Message Name", "Result");
1098       vec_validate_init_empty (dashes, 60, '-');
1099       vec_terminate_c_string (dashes);
1100       vlib_cli_output (vm, "%60s-|-%s", dashes, "-----------------");
1101       vec_free (dashes);
1102       for (i = 0; i < vec_len (table);)
1103         {
1104           /* Last message lonely? */
1105           if (i == vec_len (table) - 1)
1106             {
1107               ndifferences++;
1108               goto last_unique;
1109             }
1110
1111           /* Identical pair? */
1112           if (!strncmp
1113               ((char *) table[i].name_and_crc,
1114                (char *) table[i + 1].name_and_crc,
1115                vec_len (table[i].name_and_crc)))
1116             {
1117               i += 2;
1118               continue;
1119             }
1120
1121           ndifferences++;
1122
1123           /* Only in one of two tables? */
1124           if (i + 1 == vec_len (table)
1125               || strcmp ((char *) table[i].name, (char *) table[i + 1].name))
1126             {
1127             last_unique:
1128               vlib_cli_output (vm, "%-60s | only in %s",
1129                                table[i].name, table[i].which ?
1130                                "image" : "file");
1131               i++;
1132               continue;
1133             }
1134           /* In both tables, but with different signatures */
1135           vlib_cli_output (vm, "%-60s | definition changed", table[i].name);
1136           i += 2;
1137         }
1138       if (ndifferences == 0)
1139         vlib_cli_output (vm, "No api message signature differences found.");
1140       else
1141         vlib_cli_output (vm, "\nFound %u api message signature differences",
1142                          ndifferences);
1143       goto cleanup;
1144     }
1145
1146   /* Dump the table, sorted as shown above */
1147   vlib_cli_output (vm, "%=60s %=8s %=10s", "Message name", "MsgID", "CRC");
1148
1149   for (i = 0; i < vec_len (table); i++)
1150     {
1151       item = table + i;
1152       vlib_cli_output (vm, "%-60s %8u %10s", item->name,
1153                        item->msg_index, item->crc);
1154     }
1155
1156 cleanup:
1157   for (i = 0; i < vec_len (table); i++)
1158     {
1159       vec_free (table[i].name_and_crc);
1160       vec_free (table[i].name);
1161       vec_free (table[i].crc);
1162     }
1163
1164   vec_free (table);
1165
1166   return 0;
1167 }
1168
1169 /*?
1170  * Displays a serialized API message decode table, sorted by message name
1171  *
1172  * @cliexpar
1173  * @cliexstart{show api dump file <filename>}
1174  *                                                Message name    MsgID        CRC
1175  * accept_session                                                    407   8e2a127e
1176  * accept_session_reply                                              408   67d8c22a
1177  * add_node_next                                                     549   e4202993
1178  * add_node_next_reply                                               550   e89d6eed
1179  * etc.
1180  * @cliexend
1181 ?*/
1182
1183 /*?
1184  * Compares a serialized API message decode table with the current image
1185  *
1186  * @cliexpar
1187  * @cliexstart{show api dump file <filename> compare}
1188  * ip_add_del_route                                             definition changed
1189  * ip_table_add_del                                             definition changed
1190  * l2_macs_event                                                only in image
1191  * vnet_ip4_fib_counters                                        only in file
1192  * vnet_ip4_nbr_counters                                        only in file
1193  * @cliexend
1194 ?*/
1195
1196 /*?
1197  * Display a serialized API message decode table, compare a saved
1198  * decode table with the current image, to establish API differences.
1199  *
1200 ?*/
1201 /* *INDENT-OFF* */
1202 VLIB_CLI_COMMAND (dump_api_table_file, static) =
1203 {
1204   .path = "show api dump",
1205   .short_help = "show api dump file <filename> [numeric | compare-current]",
1206   .function = dump_api_table_file_command_fn,
1207 };
1208
1209 /* *INDENT-ON* */
1210 /*
1211  * fd.io coding-style-patch-verification: ON
1212  *
1213  * Local Variables:
1214  * eval: (c-set-style "gnu")
1215  * End:
1216  */