vlib-api/vlibapi/api_shared.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api_shared.c - API message handling, common code for both clients
   4  * and the vlib process itself.
   5  *
   6  *
   7  * Copyright (c) 2009 Cisco and/or its affiliates.
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at:
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *------------------------------------------------------------------
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stddef.h>
  25 #include <string.h>
  26 #include <sys/types.h>
  27 #include <sys/mman.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <vppinfra/format.h>
  32 #include <vppinfra/byte_order.h>
  33 #include <vppinfra/error.h>
  34 #include <vlib/vlib.h>
  35 #include <vlib/unix/unix.h>
  36 #include <vlibapi/api.h>
  37 #include <vppinfra/elog.h>
  38
  39 api_main_t api_main;
  40
  41 void vl_msg_api_barrier_sync (void) __attribute__ ((weak));
  42 void
  43 vl_msg_api_barrier_sync (void)
  44 {
  45 }
  46
  47 void vl_msg_api_barrier_release (void) __attribute__ ((weak));
  48 void
  49 vl_msg_api_barrier_release (void)
  50 {
  51 }
  52
  53 void
  54 vl_msg_api_increment_missing_client_counter (void)
  55 {
  56   api_main_t *am = &api_main;
  57   am->missing_clients++;
  58 }
  59
  60 typedef enum
  61 {
  62   DUMP,
  63   CUSTOM_DUMP,
  64   REPLAY,
  65   INITIALIZERS,
  66 } vl_api_replay_t;
  67
  68 int
  69 vl_msg_api_rx_trace_enabled (api_main_t * am)
  70 {
  71   return (am->rx_trace && am->rx_trace->enabled);
  72 }
  73
  74 int
  75 vl_msg_api_tx_trace_enabled (api_main_t * am)
  76 {
  77   return (am->tx_trace && am->tx_trace->enabled);
  78 }
  79
  80 /*
  81  * vl_msg_api_trace
  82  */
  83 void
  84 vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
  85 {
  86   u8 **this_trace;
  87   u8 **old_trace;
  88   u8 *msg_copy;
  89   u32 length;
  90   trace_cfg_t *cfgp;
  91   u16 msg_id = ntohs (*((u16 *) msg));
  92   msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
  93
  94   cfgp = am->api_trace_cfg + msg_id;
  95
  96   if (!cfgp || !cfgp->trace_enable)
  97     return;
  98
  99   msg_copy = 0;
 100
 101   if (tp->nitems == 0)
 102     {
 103       clib_warning ("tp->nitems is 0");
 104       return;
 105     }
 106
 107   if (vec_len (tp->traces) < tp->nitems)
 108     {
 109       vec_add1 (tp->traces, 0);
 110       this_trace = tp->traces + vec_len (tp->traces) - 1;
 111     }
 112   else
 113     {
 114       tp->wrapped = 1;
 115       old_trace = tp->traces + tp->curindex++;
 116       if (tp->curindex == tp->nitems)
 117         tp->curindex = 0;
 118       vec_free (*old_trace);
 119       this_trace = old_trace;
 120     }
 121
 122   length = clib_net_to_host_u32 (header->data_len);
 123
 124   vec_validate (msg_copy, length - 1);
 125   clib_memcpy (msg_copy, msg, length);
 126   *this_trace = msg_copy;
 127 }
 128
 129 int
 130 vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
 131                         int onoff)
 132 {
 133   vl_api_trace_t *tp;
 134   int rv;
 135
 136   switch (which)
 137     {
 138     case VL_API_TRACE_TX:
 139       tp = am->tx_trace;
 140       if (tp == 0)
 141         {
 142           vl_msg_api_trace_configure (am, which, 1024);
 143           tp = am->tx_trace;
 144         }
 145       break;
 146
 147     case VL_API_TRACE_RX:
 148       tp = am->rx_trace;
 149       if (tp == 0)
 150         {
 151           vl_msg_api_trace_configure (am, which, 1024);
 152           tp = am->rx_trace;
 153         }
 154       break;
 155
 156     default:
 157       /* duh? */
 158       return -1;
 159     }
 160
 161   /* Configured? */
 162   if (tp == 0 || tp->nitems == 0)
 163     return -1;
 164
 165   rv = tp->enabled;
 166   tp->enabled = onoff;
 167
 168   return rv;
 169 }
 170
 171 int
 172 vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 173 {
 174   vl_api_trace_t *tp;
 175   int i;
 176
 177   switch (which)
 178     {
 179     case VL_API_TRACE_TX:
 180       tp = am->tx_trace;
 181       break;
 182
 183     case VL_API_TRACE_RX:
 184       tp = am->rx_trace;
 185       break;
 186
 187     default:
 188       /* duh? */
 189       return -1;
 190     }
 191
 192   /* Configured? */
 193   if (!tp || tp->nitems == 0)
 194     return -1;
 195
 196   tp->curindex = 0;
 197   tp->wrapped = 0;
 198
 199   for (i = 0; i < vec_len (tp->traces); i++)
 200     {
 201       vec_free (tp->traces[i]);
 202     }
 203   vec_free (tp->traces);
 204
 205   return 0;
 206 }
 207
 208 int
 209 vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
 210 {
 211   vl_api_trace_t *tp;
 212   vl_api_trace_file_header_t fh;
 213   int i;
 214   u8 *msg;
 215
 216   switch (which)
 217     {
 218     case VL_API_TRACE_TX:
 219       tp = am->tx_trace;
 220       break;
 221
 222     case VL_API_TRACE_RX:
 223       tp = am->rx_trace;
 224       break;
 225
 226     default:
 227       /* duh? */
 228       return -1;
 229     }
 230
 231   /* Configured, data present? */
 232   if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
 233     return -1;
 234
 235   /* "Dare to be stupid" check */
 236   if (fp == 0)
 237     {
 238       return -2;
 239     }
 240
 241   /* Write the file header */
 242   fh.nitems = vec_len (tp->traces);
 243   fh.endian = tp->endian;
 244   fh.wrapped = tp->wrapped;
 245
 246   if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
 247     {
 248       return (-10);
 249     }
 250
 251   /* No-wrap case */
 252   if (tp->wrapped == 0)
 253     {
 254       /*
 255        * Note: vec_len return 0 when fed a NULL pointer.
 256        * Unfortunately, the static analysis tool doesn't
 257        * figure it out, hence the suppressed warnings.
 258        * What a great use of my time.
 259        */
 260       for (i = 0; i < vec_len (tp->traces); i++)
 261         {
 262           u32 msg_length;
 263           /*sa_ignore NO_NULL_CHK */
 264           msg = tp->traces[i];
 265           /*
 266            * This retarded check required to pass
 267            * [sic] SA-checking.
 268            */
 269           if (!msg)
 270             continue;
 271
 272           msg_length = clib_host_to_net_u32 (vec_len (msg));
 273           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 274               != sizeof (msg_length))
 275             {
 276               return (-14);
 277             }
 278           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 279             {
 280               return (-11);
 281             }
 282         }
 283     }
 284   else
 285     {
 286       /* Wrap case: write oldest -> end of buffer */
 287       for (i = tp->curindex; i < vec_len (tp->traces); i++)
 288         {
 289           u32 msg_length;
 290           msg = tp->traces[i];
 291           /*
 292            * This retarded check required to pass
 293            * [sic] SA-checking
 294            */
 295           if (!msg)
 296             continue;
 297
 298           msg_length = clib_host_to_net_u32 (vec_len (msg));
 299           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 300               != sizeof (msg_length))
 301             {
 302               return (-14);
 303             }
 304
 305           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 306             {
 307               return (-12);
 308             }
 309         }
 310       /* write beginning of buffer -> oldest-1 */
 311       for (i = 0; i < tp->curindex; i++)
 312         {
 313           u32 msg_length;
 314           /*sa_ignore NO_NULL_CHK */
 315           msg = tp->traces[i];
 316           /*
 317            * This retarded check required to pass
 318            * [sic] SA-checking
 319            */
 320           if (!msg)
 321             continue;
 322
 323           msg_length = clib_host_to_net_u32 (vec_len (msg));
 324           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 325               != sizeof (msg_length))
 326             {
 327               return (-14);
 328             }
 329
 330           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 331             {
 332               return (-13);
 333             }
 334         }
 335     }
 336   return 0;
 337 }
 338
 339 int
 340 vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
 341                             u32 nitems)
 342 {
 343   vl_api_trace_t *tp;
 344   int was_on = 0;
 345
 346   switch (which)
 347     {
 348     case VL_API_TRACE_TX:
 349       tp = am->tx_trace;
 350       if (tp == 0)
 351         {
 352           vec_validate (am->tx_trace, 0);
 353           tp = am->tx_trace;
 354         }
 355       break;
 356
 357     case VL_API_TRACE_RX:
 358       tp = am->rx_trace;
 359       if (tp == 0)
 360         {
 361           vec_validate (am->rx_trace, 0);
 362           tp = am->rx_trace;
 363         }
 364
 365       break;
 366
 367     default:
 368       return -1;
 369
 370     }
 371
 372   if (tp->enabled)
 373     {
 374       was_on = vl_msg_api_trace_onoff (am, which, 0);
 375     }
 376   if (tp->traces)
 377     {
 378       vl_msg_api_trace_free (am, which);
 379     }
 380
 381   memset (tp, 0, sizeof (*tp));
 382
 383   if (clib_arch_is_big_endian)
 384     {
 385       tp->endian = VL_API_BIG_ENDIAN;
 386     }
 387   else
 388     {
 389       tp->endian = VL_API_LITTLE_ENDIAN;
 390     }
 391
 392   tp->nitems = nitems;
 393   if (was_on)
 394     {
 395       (void) vl_msg_api_trace_onoff (am, which, was_on);
 396     }
 397   return 0;
 398 }
 399
 400 always_inline void
 401 msg_handler_internal (api_main_t * am,
 402                       void *the_msg, int trace_it, int do_it, int free_it)
 403 {
 404   u16 id = ntohs (*((u16 *) the_msg));
 405   u8 *(*print_fp) (void *, void *);
 406
 407   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 408     {
 409       if (trace_it)
 410         vl_msg_api_trace (am, am->rx_trace, the_msg);
 411
 412       if (am->msg_print_flag)
 413         {
 414           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 415           print_fp = (void *) am->msg_print_handlers[id];
 416           if (print_fp == 0)
 417             {
 418               fformat (stdout, "  [no registered print fn]\n");
 419             }
 420           else
 421             {
 422               (*print_fp) (the_msg, stdout);
 423             }
 424         }
 425
 426       if (do_it)
 427         {
 428           if (!am->is_mp_safe[id])
 429             vl_msg_api_barrier_sync ();
 430           (*am->msg_handlers[id]) (the_msg);
 431           if (!am->is_mp_safe[id])
 432             vl_msg_api_barrier_release ();
 433         }
 434     }
 435   else
 436     {
 437       clib_warning ("no handler for msg id %d", id);
 438     }
 439
 440   if (free_it)
 441     vl_msg_api_free (the_msg);
 442 }
 443
 444 /* set to 1 if you want before/after message handler event logging */
 445 #define ELOG_API_MESSAGE_HANDLERS 0
 446
 447 #if ELOG_API_MESSAGE_HANDLERS > 0
 448 static u32
 449 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 450 {
 451   uword *p, r;
 452   static uword *h;
 453   u8 *name_copy;
 454
 455   if (!h)
 456     h = hash_create_string (0, sizeof (uword));
 457
 458   p = hash_get_mem (h, msg_name);
 459   if (p)
 460     return p[0];
 461   r = elog_string (&vm->elog_main, "%s", msg_name);
 462
 463   name_copy = format (0, "%s%c", msg_name, 0);
 464
 465   hash_set_mem (h, name_copy, r);
 466
 467   return r;
 468 }
 469 #endif
 470
 471 /* This is only to be called from a vlib/vnet app */
 472 void
 473 vl_msg_api_handler_with_vm_node (api_main_t * am,
 474                                  void *the_msg, vlib_main_t * vm,
 475                                  vlib_node_runtime_t * node)
 476 {
 477   u16 id = ntohs (*((u16 *) the_msg));
 478   u8 *(*handler) (void *, void *, void *);
 479
 480 #if ELOG_API_MESSAGE_HANDLERS > 0
 481   {
 482     /* *INDENT-OFF* */
 483     ELOG_TYPE_DECLARE (e) =
 484       {
 485         .format = "api-msg: %s",
 486         .format_args = "T4",
 487       };
 488     /* *INDENT-ON* */
 489     struct
 490     {
 491       u32 c;
 492     } *ed;
 493     ed = ELOG_DATA (&vm->elog_main, e);
 494     if (id < vec_len (am->msg_names))
 495       ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
 496     else
 497       ed->c = elog_id_for_msg_name (vm, "BOGUS");
 498   }
 499 #endif
 500
 501   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 502     {
 503       handler = (void *) am->msg_handlers[id];
 504
 505       if (am->rx_trace && am->rx_trace->enabled)
 506         vl_msg_api_trace (am, am->rx_trace, the_msg);
 507
 508       if (!am->is_mp_safe[id])
 509         vl_msg_api_barrier_sync ();
 510       (*handler) (the_msg, vm, node);
 511       if (!am->is_mp_safe[id])
 512         vl_msg_api_barrier_release ();
 513     }
 514   else
 515     {
 516       clib_warning ("no hander for msg id %d", id);
 517     }
 518
 519   /*
 520    * Special-case, so we can e.g. bounce messages off the vnet
 521    * main thread without copying them...
 522    */
 523   if (!(am->message_bounce[id]))
 524     vl_msg_api_free (the_msg);
 525
 526 #if ELOG_API_MESSAGE_HANDLERS > 0
 527   {
 528   /* *INDENT-OFF* */
 529   ELOG_TYPE_DECLARE (e) = {
 530     .format = "api-msg-done: %s",
 531     .format_args = "T4",
 532   };
 533   /* *INDENT-ON* */
 534
 535     struct
 536     {
 537       u32 c;
 538     } *ed;
 539     ed = ELOG_DATA (&vm->elog_main, e);
 540     if (id < vec_len (am->msg_names))
 541       ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
 542     else
 543       ed->c = elog_id_for_msg_name (vm, "BOGUS");
 544   }
 545 #endif
 546 }
 547
 548 void
 549 vl_msg_api_handler (void *the_msg)
 550 {
 551   api_main_t *am = &api_main;
 552
 553   msg_handler_internal (am, the_msg,
 554                         (am->rx_trace
 555                          && am->rx_trace->enabled) /* trace_it */ ,
 556                         1 /* do_it */ , 1 /* free_it */ );
 557 }
 558
 559 void
 560 vl_msg_api_handler_no_free (void *the_msg)
 561 {
 562   api_main_t *am = &api_main;
 563   msg_handler_internal (am, the_msg,
 564                         (am->rx_trace
 565                          && am->rx_trace->enabled) /* trace_it */ ,
 566                         1 /* do_it */ , 0 /* free_it */ );
 567 }
 568
 569 void
 570 vl_msg_api_handler_no_trace_no_free (void *the_msg)
 571 {
 572   api_main_t *am = &api_main;
 573   msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
 574                         0 /* free_it */ );
 575 }
 576
 577 /*
 578  * Add a trace record to the API message trace buffer, if
 579  * API message tracing is enabled. Handy for adding sufficient
 580  * data to the trace to reproduce autonomous state, as opposed to
 581  * state downloaded via control-plane API messages. Example: the NAT
 582  * application creates database entries based on packet traffic, not
 583  * control-plane messages.
 584  *
 585  */
 586 void
 587 vl_msg_api_trace_only (void *the_msg)
 588 {
 589   api_main_t *am = &api_main;
 590
 591   msg_handler_internal (am, the_msg,
 592                         (am->rx_trace
 593                          && am->rx_trace->enabled) /* trace_it */ ,
 594                         0 /* do_it */ , 0 /* free_it */ );
 595 }
 596
 597 void
 598 vl_msg_api_cleanup_handler (void *the_msg)
 599 {
 600   api_main_t *am = &api_main;
 601   u16 id = ntohs (*((u16 *) the_msg));
 602
 603   if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
 604     {
 605       clib_warning ("_vl_msg_id too large: %d\n", id);
 606       return;
 607     }
 608   if (am->msg_cleanup_handlers[id])
 609     (*am->msg_cleanup_handlers[id]) (the_msg);
 610
 611   vl_msg_api_free (the_msg);
 612 }
 613
 614 /*
 615  * vl_msg_api_replay_handler
 616  */
 617 void
 618 vl_msg_api_replay_handler (void *the_msg)
 619 {
 620   api_main_t *am = &api_main;
 621
 622   u16 id = ntohs (*((u16 *) the_msg));
 623
 624   if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
 625     {
 626       clib_warning ("_vl_msg_id too large: %d\n", id);
 627       return;
 628     }
 629   /* do NOT trace the message... */
 630   if (am->msg_handlers[id])
 631     (*am->msg_handlers[id]) (the_msg);
 632   /* do NOT free the message buffer... */
 633 }
 634
 635 /*
 636  * vl_msg_api_socket_handler
 637  */
 638 void
 639 vl_msg_api_socket_handler (void *the_msg)
 640 {
 641   api_main_t *am = &api_main;
 642
 643   msg_handler_internal (am, the_msg,
 644                         (am->rx_trace
 645                          && am->rx_trace->enabled) /* trace_it */ ,
 646                         1 /* do_it */ , 0 /* free_it */ );
 647 }
 648
 649 #define foreach_msg_api_vector                  \
 650 _(msg_names)                                    \
 651 _(msg_handlers)                                 \
 652 _(msg_cleanup_handlers)                         \
 653 _(msg_endian_handlers)                          \
 654 _(msg_print_handlers)                           \
 655 _(api_trace_cfg)                                \
 656 _(message_bounce)                               \
 657 _(is_mp_safe)
 658
 659 void
 660 vl_msg_api_config (vl_msg_api_msg_config_t * c)
 661 {
 662   api_main_t *am = &api_main;
 663
 664   ASSERT (c->id > 0);
 665
 666 #define _(a) vec_validate (am->a, c->id);
 667   foreach_msg_api_vector;
 668 #undef _
 669
 670   am->msg_names[c->id] = c->name;
 671   am->msg_handlers[c->id] = c->handler;
 672   am->msg_cleanup_handlers[c->id] = c->cleanup;
 673   am->msg_endian_handlers[c->id] = c->endian;
 674   am->msg_print_handlers[c->id] = c->print;
 675   am->message_bounce[c->id] = c->message_bounce;
 676   am->is_mp_safe[c->id] = c->is_mp_safe;
 677
 678   am->api_trace_cfg[c->id].size = c->size;
 679   am->api_trace_cfg[c->id].trace_enable = c->traced;
 680   am->api_trace_cfg[c->id].replay_enable = c->replay;
 681 }
 682
 683 /*
 684  * vl_msg_api_set_handlers
 685  * preserve the old API for a while
 686  */
 687 void
 688 vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
 689                          void *endian, void *print, int size, int traced)
 690 {
 691   vl_msg_api_msg_config_t cfg;
 692   vl_msg_api_msg_config_t *c = &cfg;
 693
 694   c->id = id;
 695   c->name = name;
 696   c->handler = handler;
 697   c->cleanup = cleanup;
 698   c->endian = endian;
 699   c->print = print;
 700   c->traced = traced;
 701   c->replay = 1;
 702   c->message_bounce = 0;
 703   c->is_mp_safe = 0;
 704   vl_msg_api_config (c);
 705 }
 706
 707 void
 708 vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
 709 {
 710   api_main_t *am = &api_main;
 711   ASSERT (msg_id > 0);
 712
 713   vec_validate (am->msg_cleanup_handlers, msg_id);
 714   am->msg_cleanup_handlers[msg_id] = fp;
 715 }
 716
 717 void
 718 vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
 719 {
 720   uword msg;
 721
 722   while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
 723     vl_msg_api_handler ((void *) msg);
 724 }
 725
 726 vl_api_trace_t *
 727 vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
 728 {
 729   switch (which)
 730     {
 731     case VL_API_TRACE_RX:
 732       return am->rx_trace;
 733     case VL_API_TRACE_TX:
 734       return am->tx_trace;
 735     default:
 736       return 0;
 737     }
 738 }
 739
 740 void
 741 vl_noop_handler (void *mp)
 742 {
 743 }
 744
 745 clib_error_t *
 746 vl_api_init (vlib_main_t * vm)
 747 {
 748   static u8 once;
 749   api_main_t *am = &api_main;
 750
 751   if (once)
 752     return 0;
 753
 754   once = 1;
 755
 756   am->region_name = "/unset";
 757   /*
 758    * Eventually passed to fchown, -1 => "current user"
 759    * instead of 0 => "root". A very fine disctinction at best.
 760    */
 761   if (am->api_uid == 0)
 762     am->api_uid = -1;
 763   if (am->api_gid == 0)
 764     am->api_gid = -1;
 765
 766   return (0);
 767 }
 768
 769 void vl_msg_api_custom_dump_configure (api_main_t * am)
 770   __attribute__ ((weak));
 771 void
 772 vl_msg_api_custom_dump_configure (api_main_t * am)
 773 {
 774 }
 775
 776 VLIB_INIT_FUNCTION (vl_api_init);
 777
 778 static void
 779 vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
 780                          u32 first_index, u32 last_index,
 781                          vl_api_replay_t which)
 782 {
 783   vl_api_trace_file_header_t *hp;
 784   int i, fd;
 785   struct stat statb;
 786   size_t file_size;
 787   u8 *msg;
 788   u8 endian_swap_needed = 0;
 789   api_main_t *am = &api_main;
 790   u8 *tmpbuf = 0;
 791   u32 nitems;
 792   void **saved_print_handlers = 0;
 793
 794   fd = open ((char *) filename, O_RDONLY);
 795
 796   if (fd < 0)
 797     {
 798       vlib_cli_output (vm, "Couldn't open %s\n", filename);
 799       return;
 800     }
 801
 802   if (fstat (fd, &statb) < 0)
 803     {
 804       vlib_cli_output (vm, "Couldn't stat %s\n", filename);
 805       close (fd);
 806       return;
 807     }
 808
 809   if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
 810     {
 811       vlib_cli_output (vm, "File not plausible: %s\n", filename);
 812       close (fd);
 813       return;
 814     }
 815
 816   file_size = statb.st_size;
 817   file_size = (file_size + 4095) & ~(4096);
 818
 819   hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
 820
 821   if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
 822     {
 823       vlib_cli_output (vm, "mmap failed: %s\n", filename);
 824       close (fd);
 825       return;
 826     }
 827   close (fd);
 828
 829   if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
 830       || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
 831     endian_swap_needed = 1;
 832
 833   if (endian_swap_needed)
 834     nitems = ntohl (hp->nitems);
 835   else
 836     nitems = hp->nitems;
 837
 838   if (last_index == (u32) ~ 0)
 839     {
 840       last_index = nitems - 1;
 841     }
 842
 843   if (first_index >= nitems || last_index >= nitems)
 844     {
 845       vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
 846                        first_index, last_index, nitems - 1);
 847       munmap (hp, file_size);
 848       return;
 849     }
 850   if (hp->wrapped)
 851     vlib_cli_output (vm,
 852                      "Note: wrapped/incomplete trace, results may vary\n");
 853
 854   if (which == CUSTOM_DUMP)
 855     {
 856       saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
 857       vl_msg_api_custom_dump_configure (am);
 858     }
 859
 860
 861   msg = (u8 *) (hp + 1);
 862
 863   for (i = 0; i < first_index; i++)
 864     {
 865       trace_cfg_t *cfgp;
 866       int size;
 867       u16 msg_id;
 868
 869       size = clib_host_to_net_u32 (*(u32 *) msg);
 870       msg += sizeof (u32);
 871
 872       if (clib_arch_is_little_endian)
 873         msg_id = ntohs (*((u16 *) msg));
 874       else
 875         msg_id = *((u16 *) msg);
 876
 877       cfgp = am->api_trace_cfg + msg_id;
 878       if (!cfgp)
 879         {
 880           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
 881           munmap (hp, file_size);
 882           return;
 883         }
 884       msg += size;
 885     }
 886
 887   for (; i <= last_index; i++)
 888     {
 889       trace_cfg_t *cfgp;
 890       u16 *msg_idp;
 891       u16 msg_id;
 892       int size;
 893
 894       if (which == DUMP)
 895         vlib_cli_output (vm, "---------- trace %d -----------\n", i);
 896
 897       size = clib_host_to_net_u32 (*(u32 *) msg);
 898       msg += sizeof (u32);
 899
 900       if (clib_arch_is_little_endian)
 901         msg_id = ntohs (*((u16 *) msg));
 902       else
 903         msg_id = *((u16 *) msg);
 904
 905       cfgp = am->api_trace_cfg + msg_id;
 906       if (!cfgp)
 907         {
 908           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
 909           munmap (hp, file_size);
 910           vec_free (tmpbuf);
 911           return;
 912         }
 913
 914       /* Copy the buffer (from the read-only mmap'ed file) */
 915       vec_validate (tmpbuf, size - 1 + sizeof (uword));
 916       clib_memcpy (tmpbuf + sizeof (uword), msg, size);
 917       memset (tmpbuf, 0xf, sizeof (uword));
 918
 919       /*
 920        * Endian swap if needed. All msg data is supposed to be
 921        * in network byte order. All msg handlers are supposed to
 922        * know that. The generic message dumpers don't know that.
 923        * One could fix apigen, I suppose.
 924        */
 925       if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
 926         {
 927           void (*endian_fp) (void *);
 928           if (msg_id >= vec_len (am->msg_endian_handlers)
 929               || (am->msg_endian_handlers[msg_id] == 0))
 930             {
 931               vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
 932               munmap (hp, file_size);
 933               vec_free (tmpbuf);
 934               return;
 935             }
 936           endian_fp = am->msg_endian_handlers[msg_id];
 937           (*endian_fp) (tmpbuf + sizeof (uword));
 938         }
 939
 940       /* msg_id always in network byte order */
 941       if (clib_arch_is_little_endian)
 942         {
 943           msg_idp = (u16 *) (tmpbuf + sizeof (uword));
 944           *msg_idp = msg_id;
 945         }
 946
 947       switch (which)
 948         {
 949         case CUSTOM_DUMP:
 950         case DUMP:
 951           if (msg_id < vec_len (am->msg_print_handlers) &&
 952               am->msg_print_handlers[msg_id])
 953             {
 954               u8 *(*print_fp) (void *, void *);
 955
 956               print_fp = (void *) am->msg_print_handlers[msg_id];
 957               (*print_fp) (tmpbuf + sizeof (uword), vm);
 958             }
 959           else
 960             {
 961               vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
 962                                msg_id);
 963               break;
 964             }
 965           break;
 966
 967         case INITIALIZERS:
 968           if (msg_id < vec_len (am->msg_print_handlers) &&
 969               am->msg_print_handlers[msg_id])
 970             {
 971               u8 *s;
 972               int j;
 973               u8 *(*print_fp) (void *, void *);
 974
 975               print_fp = (void *) am->msg_print_handlers[msg_id];
 976
 977               vlib_cli_output (vm, "/*");
 978
 979               (*print_fp) (tmpbuf + sizeof (uword), vm);
 980               vlib_cli_output (vm, "*/\n");
 981
 982               s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
 983                           am->msg_names[msg_id], i,
 984                           am->api_trace_cfg[msg_id].size);
 985
 986               for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
 987                 {
 988                   if ((j & 7) == 0)
 989                     s = format (s, "\n    ");
 990                   s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
 991                 }
 992               s = format (s, "\n};\n%c", 0);
 993               vlib_cli_output (vm, (char *) s);
 994               vec_free (s);
 995             }
 996           break;
 997
 998         case REPLAY:
 999           if (msg_id < vec_len (am->msg_print_handlers) &&
1000               am->msg_print_handlers[msg_id] && cfgp->replay_enable)
1001             {
1002               void (*handler) (void *);
1003
1004               handler = (void *) am->msg_handlers[msg_id];
1005
1006               if (!am->is_mp_safe[msg_id])
1007                 vl_msg_api_barrier_sync ();
1008               (*handler) (tmpbuf + sizeof (uword));
1009               if (!am->is_mp_safe[msg_id])
1010                 vl_msg_api_barrier_release ();
1011             }
1012           else
1013             {
1014               if (cfgp->replay_enable)
1015                 vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
1016                                  msg_id);
1017               break;
1018             }
1019           break;
1020         }
1021
1022       _vec_len (tmpbuf) = 0;
1023       msg += size;
1024     }
1025
1026   if (saved_print_handlers)
1027     {
1028       clib_memcpy (am->msg_print_handlers, saved_print_handlers,
1029                    vec_len (am->msg_print_handlers) * sizeof (void *));
1030       vec_free (saved_print_handlers);
1031     }
1032
1033   munmap (hp, file_size);
1034   vec_free (tmpbuf);
1035 }
1036
1037 u8 *
1038 format_vl_msg_api_trace_status (u8 * s, va_list * args)
1039 {
1040   api_main_t *am = va_arg (*args, api_main_t *);
1041   vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
1042   vl_api_trace_t *tp;
1043   char *trace_name;
1044
1045   switch (which)
1046     {
1047     case VL_API_TRACE_TX:
1048       tp = am->tx_trace;
1049       trace_name = "TX trace";
1050       break;
1051
1052     case VL_API_TRACE_RX:
1053       tp = am->rx_trace;
1054       trace_name = "RX trace";
1055       break;
1056
1057     default:
1058       abort ();
1059     }
1060
1061   if (tp == 0)
1062     {
1063       s = format (s, "%s: not yet configured.\n", trace_name);
1064       return s;
1065     }
1066
1067   s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
1068               trace_name, vec_len (tp->traces), tp->nitems,
1069               tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
1070   return s;
1071 }
1072
1073 static u8 post_mortem_dump_enabled;
1074
1075 static clib_error_t *
1076 api_trace_command_fn (vlib_main_t * vm,
1077                       unformat_input_t * input, vlib_cli_command_t * cmd)
1078 {
1079   u32 nitems = 256 << 10;
1080   api_main_t *am = &api_main;
1081   vl_api_trace_which_t which = VL_API_TRACE_RX;
1082   u8 *filename;
1083   u32 first = 0;
1084   u32 last = (u32) ~ 0;
1085   FILE *fp;
1086   int rv;
1087
1088   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1089     {
1090       if (unformat (input, "on") || unformat (input, "enable"))
1091         {
1092           if (unformat (input, "nitems %d", &nitems))
1093             ;
1094           vl_msg_api_trace_configure (am, which, nitems);
1095           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
1096         }
1097       else if (unformat (input, "off"))
1098         {
1099           vl_msg_api_trace_onoff (am, which, 0);
1100         }
1101       else if (unformat (input, "save %s", &filename))
1102         {
1103           u8 *chroot_filename;
1104           if (strstr ((char *) filename, "..")
1105               || index ((char *) filename, '/'))
1106             {
1107               vlib_cli_output (vm, "illegal characters in filename '%s'",
1108                                filename);
1109               return 0;
1110             }
1111
1112           chroot_filename = format (0, "/tmp/%s%c", filename, 0);
1113
1114           vec_free (filename);
1115
1116           fp = fopen ((char *) chroot_filename, "w");
1117           if (fp == NULL)
1118             {
1119               vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
1120               return 0;
1121             }
1122           rv = vl_msg_api_trace_save (am, which, fp);
1123           fclose (fp);
1124           if (rv == -1)
1125             vlib_cli_output (vm, "API Trace data not present\n");
1126           else if (rv == -2)
1127             vlib_cli_output (vm, "File for writing is closed\n");
1128           else if (rv == -10)
1129             vlib_cli_output (vm, "Error while writing header to file\n");
1130           else if (rv == -11)
1131             vlib_cli_output (vm, "Error while writing trace to file\n");
1132           else if (rv == -12)
1133             vlib_cli_output (vm,
1134                              "Error while writing end of buffer trace to file\n");
1135           else if (rv == -13)
1136             vlib_cli_output (vm,
1137                              "Error while writing start of buffer trace to file\n");
1138           else if (rv < 0)
1139             vlib_cli_output (vm, "Unkown error while saving: %d", rv);
1140           else
1141             vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
1142           vec_free (chroot_filename);
1143         }
1144       else if (unformat (input, "dump %s", &filename))
1145         {
1146           vl_msg_api_process_file (vm, filename, first, last, DUMP);
1147         }
1148       else if (unformat (input, "custom-dump %s", &filename))
1149         {
1150           vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
1151         }
1152       else if (unformat (input, "replay %s", &filename))
1153         {
1154           vl_msg_api_process_file (vm, filename, first, last, REPLAY);
1155         }
1156       else if (unformat (input, "initializers %s", &filename))
1157         {
1158           vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
1159         }
1160       else if (unformat (input, "tx"))
1161         {
1162           which = VL_API_TRACE_TX;
1163         }
1164       else if (unformat (input, "first %d", &first))
1165         {
1166           ;
1167         }
1168       else if (unformat (input, "last %d", &last))
1169         {
1170           ;
1171         }
1172       else if (unformat (input, "status"))
1173         {
1174           vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
1175                            am, which);
1176         }
1177       else if (unformat (input, "free"))
1178         {
1179           vl_msg_api_trace_onoff (am, which, 0);
1180           vl_msg_api_trace_free (am, which);
1181         }
1182       else if (unformat (input, "post-mortem-on"))
1183         post_mortem_dump_enabled = 1;
1184       else if (unformat (input, "post-mortem-off"))
1185         post_mortem_dump_enabled = 0;
1186       else
1187         return clib_error_return (0, "unknown input `%U'",
1188                                   format_unformat_error, input);
1189     }
1190   return 0;
1191 }
1192
1193 /* *INDENT-OFF* */
1194 VLIB_CLI_COMMAND (api_trace_command, static) = {
1195     .path = "api trace",
1196     .short_help =
1197     "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]",
1198     .function = api_trace_command_fn,
1199 };
1200 /* *INDENT-ON* */
1201
1202 static clib_error_t *
1203 api_config_fn (vlib_main_t * vm, unformat_input_t * input)
1204 {
1205   u32 nitems = 256 << 10;
1206   vl_api_trace_which_t which = VL_API_TRACE_RX;
1207   api_main_t *am = &api_main;
1208
1209   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1210     {
1211       if (unformat (input, "on") || unformat (input, "enable"))
1212         {
1213           if (unformat (input, "nitems %d", &nitems))
1214             ;
1215           vl_msg_api_trace_configure (am, which, nitems);
1216           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
1217           post_mortem_dump_enabled = 1;
1218         }
1219       else
1220         return clib_error_return (0, "unknown input `%U'",
1221                                   format_unformat_error, input);
1222     }
1223   return 0;
1224 }
1225
1226 VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
1227
1228 void
1229 vl_msg_api_post_mortem_dump (void)
1230 {
1231   api_main_t *am = &api_main;
1232   FILE *fp;
1233   char filename[64];
1234   int rv;
1235
1236   if (post_mortem_dump_enabled == 0)
1237     return;
1238
1239   snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
1240             getpid ());
1241
1242   fp = fopen (filename, "w");
1243   if (fp == NULL)
1244     {
1245       rv = write (2, "Couldn't create ", 16);
1246       rv = write (2, filename, strlen (filename));
1247       rv = write (2, "\n", 1);
1248       return;
1249     }
1250   rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
1251   fclose (fp);
1252   if (rv < 0)
1253     {
1254       rv = write (2, "Failed to save post-mortem API trace to ", 40);
1255       rv = write (2, filename, strlen (filename));
1256       rv = write (2, "\n", 1);
1257     }
1258
1259 }
1260
1261 /* Layered message handling support */
1262
1263 void
1264 vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
1265 {
1266   api_main_t *am = &api_main;
1267
1268   /* Mild idiot proofing */
1269   if (msg_id_host_byte_order > 10000)
1270     clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
1271                   msg_id_host_byte_order,
1272                   clib_net_to_host_u16 (msg_id_host_byte_order));
1273   vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
1274   am->pd_msg_handlers[msg_id_host_byte_order] = fp;
1275 }
1276
1277 int
1278 vl_msg_api_pd_handler (void *mp, int rv)
1279 {
1280   api_main_t *am = &api_main;
1281   int (*fp) (void *, int);
1282   u16 msg_id;
1283
1284   if (clib_arch_is_little_endian)
1285     msg_id = clib_net_to_host_u16 (*((u16 *) mp));
1286   else
1287     msg_id = *((u16 *) mp);
1288
1289   if (msg_id >= vec_len (am->pd_msg_handlers)
1290       || am->pd_msg_handlers[msg_id] == 0)
1291     return rv;
1292
1293   fp = am->pd_msg_handlers[msg_id];
1294   rv = (*fp) (mp, rv);
1295   return rv;
1296 }
1297
1298 void
1299 vl_msg_api_set_first_available_msg_id (u16 first_avail)
1300 {
1301   api_main_t *am = &api_main;
1302
1303   am->first_available_msg_id = first_avail;
1304 }
1305
1306 u16
1307 vl_msg_api_get_msg_ids (char *name, int n)
1308 {
1309   api_main_t *am = &api_main;
1310   u8 *name_copy;
1311   vl_api_msg_range_t *rp;
1312   uword *p;
1313   u16 rv;
1314
1315   if (am->msg_range_by_name == 0)
1316     am->msg_range_by_name = hash_create_string (0, sizeof (uword));
1317
1318   name_copy = format (0, "%s%c", name, 0);
1319
1320   p = hash_get_mem (am->msg_range_by_name, name_copy);
1321   if (p)
1322     {
1323       clib_warning ("WARNING: duplicate message range registration for '%s'",
1324                     name_copy);
1325       vec_free (name_copy);
1326       return ((u16) ~ 0);
1327     }
1328
1329   if (n < 0 || n > 1024)
1330     {
1331       clib_warning
1332         ("WARNING: bad number of message-IDs (%d) requested by '%s'",
1333          n, name_copy);
1334       vec_free (name_copy);
1335       return ((u16) ~ 0);
1336     }
1337
1338   vec_add2 (am->msg_ranges, rp, 1);
1339
1340   rv = rp->first_msg_id = am->first_available_msg_id;
1341   am->first_available_msg_id += n;
1342   rp->last_msg_id = am->first_available_msg_id - 1;
1343   rp->name = name_copy;
1344
1345   hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
1346
1347   return rv;
1348 }
1349
1350 void
1351 vl_msg_api_add_msg_name_crc (api_main_t * am, char *string, u32 id)
1352 {
1353   uword *p;
1354
1355   if (am->msg_index_by_name_and_crc == 0)
1356     am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword));
1357
1358   p = hash_get_mem (am->msg_index_by_name_and_crc, string);
1359   if (p)
1360     {
1361       clib_warning ("attempt to redefine '%s' ignored...", string);
1362       return;
1363     }
1364
1365   hash_set_mem (am->msg_index_by_name_and_crc, string, id);
1366 }
1367
1368
1369 /*
1370  * fd.io coding-style-patch-verification: ON
1371  *
1372  * Local Variables:
1373  * eval: (c-set-style "gnu")
1374  * End:
1375  */