src/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 <vppinfra/format.h>
  27 #include <vppinfra/byte_order.h>
  28 #include <vppinfra/error.h>
  29 #include <vlib/vlib.h>
  30 #include <vlib/unix/unix.h>
  31 #include <vlibapi/api.h>
  32 #include <vppinfra/elog.h>
  33
  34 /* *INDENT-OFF* */
  35 api_main_t api_main =
  36   {
  37     .region_name = "/unset",
  38     .api_uid = -1,
  39     .api_gid = -1,
  40   };
  41 /* *INDENT-ON* */
  42
  43 void
  44 vl_msg_api_increment_missing_client_counter (void)
  45 {
  46   api_main_t *am = &api_main;
  47   am->missing_clients++;
  48 }
  49
  50 int
  51 vl_msg_api_rx_trace_enabled (api_main_t * am)
  52 {
  53   return (am->rx_trace && am->rx_trace->enabled);
  54 }
  55
  56 int
  57 vl_msg_api_tx_trace_enabled (api_main_t * am)
  58 {
  59   return (am->tx_trace && am->tx_trace->enabled);
  60 }
  61
  62 /*
  63  * vl_msg_api_trace
  64  */
  65 void
  66 vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
  67 {
  68   u8 **this_trace;
  69   u8 **old_trace;
  70   u8 *msg_copy;
  71   u32 length;
  72   trace_cfg_t *cfgp;
  73   u16 msg_id = ntohs (*((u16 *) msg));
  74   msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
  75
  76   cfgp = am->api_trace_cfg + msg_id;
  77
  78   if (!cfgp || !cfgp->trace_enable)
  79     return;
  80
  81   msg_copy = 0;
  82
  83   if (tp->nitems == 0)
  84     {
  85       clib_warning ("tp->nitems is 0");
  86       return;
  87     }
  88
  89   if (vec_len (tp->traces) < tp->nitems)
  90     {
  91       vec_add1 (tp->traces, 0);
  92       this_trace = tp->traces + vec_len (tp->traces) - 1;
  93     }
  94   else
  95     {
  96       tp->wrapped = 1;
  97       old_trace = tp->traces + tp->curindex++;
  98       if (tp->curindex == tp->nitems)
  99         tp->curindex = 0;
 100       vec_free (*old_trace);
 101       this_trace = old_trace;
 102     }
 103
 104   length = clib_net_to_host_u32 (header->data_len);
 105
 106   vec_validate (msg_copy, length - 1);
 107   clib_memcpy (msg_copy, msg, length);
 108   *this_trace = msg_copy;
 109 }
 110
 111 int
 112 vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
 113                         int onoff)
 114 {
 115   vl_api_trace_t *tp;
 116   int rv;
 117
 118   switch (which)
 119     {
 120     case VL_API_TRACE_TX:
 121       tp = am->tx_trace;
 122       if (tp == 0)
 123         {
 124           vl_msg_api_trace_configure (am, which, 1024);
 125           tp = am->tx_trace;
 126         }
 127       break;
 128
 129     case VL_API_TRACE_RX:
 130       tp = am->rx_trace;
 131       if (tp == 0)
 132         {
 133           vl_msg_api_trace_configure (am, which, 1024);
 134           tp = am->rx_trace;
 135         }
 136       break;
 137
 138     default:
 139       /* duh? */
 140       return -1;
 141     }
 142
 143   /* Configured? */
 144   if (tp == 0 || tp->nitems == 0)
 145     return -1;
 146
 147   rv = tp->enabled;
 148   tp->enabled = onoff;
 149
 150   return rv;
 151 }
 152
 153 int
 154 vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 155 {
 156   vl_api_trace_t *tp;
 157   int i;
 158
 159   switch (which)
 160     {
 161     case VL_API_TRACE_TX:
 162       tp = am->tx_trace;
 163       break;
 164
 165     case VL_API_TRACE_RX:
 166       tp = am->rx_trace;
 167       break;
 168
 169     default:
 170       /* duh? */
 171       return -1;
 172     }
 173
 174   /* Configured? */
 175   if (!tp || tp->nitems == 0)
 176     return -1;
 177
 178   tp->curindex = 0;
 179   tp->wrapped = 0;
 180
 181   for (i = 0; i < vec_len (tp->traces); i++)
 182     {
 183       vec_free (tp->traces[i]);
 184     }
 185   vec_free (tp->traces);
 186
 187   return 0;
 188 }
 189
 190 int
 191 vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
 192 {
 193   vl_api_trace_t *tp;
 194   vl_api_trace_file_header_t fh;
 195   int i;
 196   u8 *msg;
 197
 198   switch (which)
 199     {
 200     case VL_API_TRACE_TX:
 201       tp = am->tx_trace;
 202       break;
 203
 204     case VL_API_TRACE_RX:
 205       tp = am->rx_trace;
 206       break;
 207
 208     default:
 209       /* duh? */
 210       return -1;
 211     }
 212
 213   /* Configured, data present? */
 214   if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
 215     return -1;
 216
 217   /* "Dare to be stupid" check */
 218   if (fp == 0)
 219     {
 220       return -2;
 221     }
 222
 223   /* Write the file header */
 224   fh.nitems = vec_len (tp->traces);
 225   fh.endian = tp->endian;
 226   fh.wrapped = tp->wrapped;
 227
 228   if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
 229     {
 230       return (-10);
 231     }
 232
 233   /* No-wrap case */
 234   if (tp->wrapped == 0)
 235     {
 236       /*
 237        * Note: vec_len return 0 when fed a NULL pointer.
 238        * Unfortunately, the static analysis tool doesn't
 239        * figure it out, hence the suppressed warnings.
 240        * What a great use of my time.
 241        */
 242       for (i = 0; i < vec_len (tp->traces); i++)
 243         {
 244           u32 msg_length;
 245           /*sa_ignore NO_NULL_CHK */
 246           msg = tp->traces[i];
 247           /*
 248            * This retarded check required to pass
 249            * [sic] SA-checking.
 250            */
 251           if (!msg)
 252             continue;
 253
 254           msg_length = clib_host_to_net_u32 (vec_len (msg));
 255           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 256               != sizeof (msg_length))
 257             {
 258               return (-14);
 259             }
 260           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 261             {
 262               return (-11);
 263             }
 264         }
 265     }
 266   else
 267     {
 268       /* Wrap case: write oldest -> end of buffer */
 269       for (i = tp->curindex; i < vec_len (tp->traces); i++)
 270         {
 271           u32 msg_length;
 272           msg = tp->traces[i];
 273           /*
 274            * This retarded check required to pass
 275            * [sic] SA-checking
 276            */
 277           if (!msg)
 278             continue;
 279
 280           msg_length = clib_host_to_net_u32 (vec_len (msg));
 281           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 282               != sizeof (msg_length))
 283             {
 284               return (-14);
 285             }
 286
 287           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 288             {
 289               return (-12);
 290             }
 291         }
 292       /* write beginning of buffer -> oldest-1 */
 293       for (i = 0; i < tp->curindex; i++)
 294         {
 295           u32 msg_length;
 296           /*sa_ignore NO_NULL_CHK */
 297           msg = tp->traces[i];
 298           /*
 299            * This retarded check required to pass
 300            * [sic] SA-checking
 301            */
 302           if (!msg)
 303             continue;
 304
 305           msg_length = clib_host_to_net_u32 (vec_len (msg));
 306           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 307               != sizeof (msg_length))
 308             {
 309               return (-14);
 310             }
 311
 312           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 313             {
 314               return (-13);
 315             }
 316         }
 317     }
 318   return 0;
 319 }
 320
 321 int
 322 vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
 323                             u32 nitems)
 324 {
 325   vl_api_trace_t *tp;
 326   int was_on = 0;
 327
 328   switch (which)
 329     {
 330     case VL_API_TRACE_TX:
 331       tp = am->tx_trace;
 332       if (tp == 0)
 333         {
 334           vec_validate (am->tx_trace, 0);
 335           tp = am->tx_trace;
 336         }
 337       break;
 338
 339     case VL_API_TRACE_RX:
 340       tp = am->rx_trace;
 341       if (tp == 0)
 342         {
 343           vec_validate (am->rx_trace, 0);
 344           tp = am->rx_trace;
 345         }
 346
 347       break;
 348
 349     default:
 350       return -1;
 351
 352     }
 353
 354   if (tp->enabled)
 355     {
 356       was_on = vl_msg_api_trace_onoff (am, which, 0);
 357     }
 358   if (tp->traces)
 359     {
 360       vl_msg_api_trace_free (am, which);
 361     }
 362
 363   memset (tp, 0, sizeof (*tp));
 364
 365   if (clib_arch_is_big_endian)
 366     {
 367       tp->endian = VL_API_BIG_ENDIAN;
 368     }
 369   else
 370     {
 371       tp->endian = VL_API_LITTLE_ENDIAN;
 372     }
 373
 374   tp->nitems = nitems;
 375   if (was_on)
 376     {
 377       (void) vl_msg_api_trace_onoff (am, which, was_on);
 378     }
 379   return 0;
 380 }
 381
 382 void
 383 vl_msg_api_barrier_sync (void)
 384 {
 385 }
 386
 387 void
 388 vl_msg_api_barrier_release (void)
 389 {
 390 }
 391
 392 always_inline void
 393 msg_handler_internal (api_main_t * am,
 394                       void *the_msg, int trace_it, int do_it, int free_it)
 395 {
 396   u16 id = ntohs (*((u16 *) the_msg));
 397   u8 *(*print_fp) (void *, void *);
 398
 399   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 400     {
 401       if (trace_it)
 402         vl_msg_api_trace (am, am->rx_trace, the_msg);
 403
 404       if (am->msg_print_flag)
 405         {
 406           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 407           print_fp = (void *) am->msg_print_handlers[id];
 408           if (print_fp == 0)
 409             {
 410               fformat (stdout, "  [no registered print fn]\n");
 411             }
 412           else
 413             {
 414               (*print_fp) (the_msg, stdout);
 415             }
 416         }
 417
 418       if (do_it)
 419         {
 420           if (!am->is_mp_safe[id])
 421             {
 422               vl_msg_api_barrier_trace_context (am->msg_names[id]);
 423               vl_msg_api_barrier_sync ();
 424             }
 425           (*am->msg_handlers[id]) (the_msg);
 426           if (!am->is_mp_safe[id])
 427             vl_msg_api_barrier_release ();
 428         }
 429     }
 430   else
 431     {
 432       clib_warning ("no handler for msg id %d", id);
 433     }
 434
 435   if (free_it)
 436     vl_msg_api_free (the_msg);
 437 }
 438
 439 /* set to 1 if you want before/after message handler event logging */
 440 #define ELOG_API_MESSAGE_HANDLERS 0
 441
 442 #if ELOG_API_MESSAGE_HANDLERS > 0
 443 static u32
 444 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 445 {
 446   uword *p, r;
 447   static uword *h;
 448   u8 *name_copy;
 449
 450   if (!h)
 451     h = hash_create_string (0, sizeof (uword));
 452
 453   p = hash_get_mem (h, msg_name);
 454   if (p)
 455     return p[0];
 456   r = elog_string (&vm->elog_main, "%s", msg_name);
 457
 458   name_copy = format (0, "%s%c", msg_name, 0);
 459
 460   hash_set_mem (h, name_copy, r);
 461
 462   return r;
 463 }
 464 #endif
 465
 466 /* This is only to be called from a vlib/vnet app */
 467 void
 468 vl_msg_api_handler_with_vm_node (api_main_t * am,
 469                                  void *the_msg, vlib_main_t * vm,
 470                                  vlib_node_runtime_t * node)
 471 {
 472   u16 id = ntohs (*((u16 *) the_msg));
 473   u8 *(*handler) (void *, void *, void *);
 474
 475 #if ELOG_API_MESSAGE_HANDLERS > 0
 476   {
 477     /* *INDENT-OFF* */
 478     ELOG_TYPE_DECLARE (e) =
 479       {
 480         .format = "api-msg: %s",
 481         .format_args = "T4",
 482       };
 483     /* *INDENT-ON* */
 484     struct
 485     {
 486       u32 c;
 487     } *ed;
 488     ed = ELOG_DATA (&vm->elog_main, e);
 489     if (id < vec_len (am->msg_names))
 490       ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
 491     else
 492       ed->c = elog_id_for_msg_name (vm, "BOGUS");
 493   }
 494 #endif
 495
 496   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 497     {
 498       handler = (void *) am->msg_handlers[id];
 499
 500       if (am->rx_trace && am->rx_trace->enabled)
 501         vl_msg_api_trace (am, am->rx_trace, the_msg);
 502
 503       if (!am->is_mp_safe[id])
 504         {
 505           vl_msg_api_barrier_trace_context (am->msg_names[id]);
 506           vl_msg_api_barrier_sync ();
 507         }
 508       (*handler) (the_msg, vm, node);
 509       if (!am->is_mp_safe[id])
 510         vl_msg_api_barrier_release ();
 511     }
 512   else
 513     {
 514       clib_warning ("no handler for msg id %d", id);
 515     }
 516
 517   /*
 518    * Special-case, so we can e.g. bounce messages off the vnet
 519    * main thread without copying them...
 520    */
 521   if (!(am->message_bounce[id]))
 522     vl_msg_api_free (the_msg);
 523
 524 #if ELOG_API_MESSAGE_HANDLERS > 0
 525   {
 526   /* *INDENT-OFF* */
 527   ELOG_TYPE_DECLARE (e) = {
 528     .format = "api-msg-done: %s",
 529     .format_args = "T4",
 530   };
 531   /* *INDENT-ON* */
 532
 533     struct
 534     {
 535       u32 c;
 536     } *ed;
 537     ed = ELOG_DATA (&vm->elog_main, e);
 538     if (id < vec_len (am->msg_names))
 539       ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
 540     else
 541       ed->c = elog_id_for_msg_name (vm, "BOGUS");
 542   }
 543 #endif
 544 }
 545
 546 void
 547 vl_msg_api_handler (void *the_msg)
 548 {
 549   api_main_t *am = &api_main;
 550
 551   msg_handler_internal (am, the_msg,
 552                         (am->rx_trace
 553                          && am->rx_trace->enabled) /* trace_it */ ,
 554                         1 /* do_it */ , 1 /* free_it */ );
 555 }
 556
 557 void
 558 vl_msg_api_handler_no_free (void *the_msg)
 559 {
 560   api_main_t *am = &api_main;
 561   msg_handler_internal (am, the_msg,
 562                         (am->rx_trace
 563                          && am->rx_trace->enabled) /* trace_it */ ,
 564                         1 /* do_it */ , 0 /* free_it */ );
 565 }
 566
 567 void
 568 vl_msg_api_handler_no_trace_no_free (void *the_msg)
 569 {
 570   api_main_t *am = &api_main;
 571   msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
 572                         0 /* free_it */ );
 573 }
 574
 575 /*
 576  * Add a trace record to the API message trace buffer, if
 577  * API message tracing is enabled. Handy for adding sufficient
 578  * data to the trace to reproduce autonomous state, as opposed to
 579  * state downloaded via control-plane API messages. Example: the NAT
 580  * application creates database entries based on packet traffic, not
 581  * control-plane messages.
 582  *
 583  */
 584 void
 585 vl_msg_api_trace_only (void *the_msg)
 586 {
 587   api_main_t *am = &api_main;
 588
 589   msg_handler_internal (am, the_msg,
 590                         (am->rx_trace
 591                          && am->rx_trace->enabled) /* trace_it */ ,
 592                         0 /* do_it */ , 0 /* free_it */ );
 593 }
 594
 595 void
 596 vl_msg_api_cleanup_handler (void *the_msg)
 597 {
 598   api_main_t *am = &api_main;
 599   u16 id = ntohs (*((u16 *) the_msg));
 600
 601   if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
 602     {
 603       clib_warning ("_vl_msg_id too large: %d\n", id);
 604       return;
 605     }
 606   if (am->msg_cleanup_handlers[id])
 607     (*am->msg_cleanup_handlers[id]) (the_msg);
 608
 609   vl_msg_api_free (the_msg);
 610 }
 611
 612 /*
 613  * vl_msg_api_replay_handler
 614  */
 615 void
 616 vl_msg_api_replay_handler (void *the_msg)
 617 {
 618   api_main_t *am = &api_main;
 619
 620   u16 id = ntohs (*((u16 *) the_msg));
 621
 622   if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
 623     {
 624       clib_warning ("_vl_msg_id too large: %d\n", id);
 625       return;
 626     }
 627   /* do NOT trace the message... */
 628   if (am->msg_handlers[id])
 629     (*am->msg_handlers[id]) (the_msg);
 630   /* do NOT free the message buffer... */
 631 }
 632
 633 u32
 634 vl_msg_api_get_msg_length (void *msg_arg)
 635 {
 636   return vl_msg_api_get_msg_length_inline (msg_arg);
 637 }
 638
 639 /*
 640  * vl_msg_api_socket_handler
 641  */
 642 void
 643 vl_msg_api_socket_handler (void *the_msg)
 644 {
 645   api_main_t *am = &api_main;
 646
 647   msg_handler_internal (am, the_msg,
 648                         (am->rx_trace
 649                          && am->rx_trace->enabled) /* trace_it */ ,
 650                         1 /* do_it */ , 0 /* free_it */ );
 651 }
 652
 653 #define foreach_msg_api_vector                  \
 654 _(msg_names)                                    \
 655 _(msg_handlers)                                 \
 656 _(msg_cleanup_handlers)                         \
 657 _(msg_endian_handlers)                          \
 658 _(msg_print_handlers)                           \
 659 _(api_trace_cfg)                                \
 660 _(message_bounce)                               \
 661 _(is_mp_safe)
 662
 663 void
 664 vl_msg_api_config (vl_msg_api_msg_config_t * c)
 665 {
 666   api_main_t *am = &api_main;
 667
 668   /*
 669    * This happens during the java core tests if the message
 670    * dictionary is missing newly added xxx_reply_t messages.
 671    * Should never happen, but since I shot myself in the foot once
 672    * this way, I thought I'd make it easy to debug if I ever do
 673    * it again... (;-)...
 674    */
 675   if (c->id == 0)
 676     {
 677       if (c->name)
 678         clib_warning ("Trying to register %s with a NULL msg id!", c->name);
 679       else
 680         clib_warning ("Trying to register a NULL msg with a NULL msg id!");
 681       clib_warning ("Did you forget to call setup_message_id_table?");
 682       return;
 683     }
 684
 685 #define _(a) vec_validate (am->a, c->id);
 686   foreach_msg_api_vector;
 687 #undef _
 688
 689   if (am->msg_handlers[c->id] && am->msg_handlers[c->id] != c->handler)
 690     clib_warning
 691       ("BUG: re-registering 'vl_api_%s_t_handler'."
 692        "Handler was %llx, replaced by %llx",
 693        c->name, am->msg_handlers[c->id], c->handler);
 694
 695   am->msg_names[c->id] = c->name;
 696   am->msg_handlers[c->id] = c->handler;
 697   am->msg_cleanup_handlers[c->id] = c->cleanup;
 698   am->msg_endian_handlers[c->id] = c->endian;
 699   am->msg_print_handlers[c->id] = c->print;
 700   am->message_bounce[c->id] = c->message_bounce;
 701   am->is_mp_safe[c->id] = c->is_mp_safe;
 702
 703   am->api_trace_cfg[c->id].size = c->size;
 704   am->api_trace_cfg[c->id].trace_enable = c->traced;
 705   am->api_trace_cfg[c->id].replay_enable = c->replay;
 706 }
 707
 708 /*
 709  * vl_msg_api_set_handlers
 710  * preserve the old API for a while
 711  */
 712 void
 713 vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
 714                          void *endian, void *print, int size, int traced)
 715 {
 716   vl_msg_api_msg_config_t cfg;
 717   vl_msg_api_msg_config_t *c = &cfg;
 718
 719   memset (c, 0, sizeof (*c));
 720
 721   c->id = id;
 722   c->name = name;
 723   c->handler = handler;
 724   c->cleanup = cleanup;
 725   c->endian = endian;
 726   c->print = print;
 727   c->traced = traced;
 728   c->replay = 1;
 729   c->message_bounce = 0;
 730   c->is_mp_safe = 0;
 731   vl_msg_api_config (c);
 732 }
 733
 734 void
 735 vl_msg_api_clean_handlers (int msg_id)
 736 {
 737   vl_msg_api_msg_config_t cfg;
 738   vl_msg_api_msg_config_t *c = &cfg;
 739
 740   memset (c, 0, sizeof (*c));
 741
 742   c->id = msg_id;
 743   vl_msg_api_config (c);
 744 }
 745
 746 void
 747 vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
 748 {
 749   api_main_t *am = &api_main;
 750   ASSERT (msg_id > 0);
 751
 752   vec_validate (am->msg_cleanup_handlers, msg_id);
 753   am->msg_cleanup_handlers[msg_id] = fp;
 754 }
 755
 756 void
 757 vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
 758 {
 759   uword msg;
 760
 761   while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
 762     vl_msg_api_handler ((void *) msg);
 763 }
 764
 765 vl_api_trace_t *
 766 vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
 767 {
 768   switch (which)
 769     {
 770     case VL_API_TRACE_RX:
 771       return am->rx_trace;
 772     case VL_API_TRACE_TX:
 773       return am->tx_trace;
 774     default:
 775       return 0;
 776     }
 777 }
 778
 779 void
 780 vl_noop_handler (void *mp)
 781 {
 782 }
 783
 784
 785 static u8 post_mortem_dump_enabled;
 786
 787 void
 788 vl_msg_api_post_mortem_dump_enable_disable (int enable)
 789 {
 790   post_mortem_dump_enabled = enable;
 791 }
 792
 793 void
 794 vl_msg_api_post_mortem_dump (void)
 795 {
 796   api_main_t *am = &api_main;
 797   FILE *fp;
 798   char filename[64];
 799   int rv;
 800
 801   if (post_mortem_dump_enabled == 0)
 802     return;
 803
 804   snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
 805             getpid ());
 806
 807   fp = fopen (filename, "w");
 808   if (fp == NULL)
 809     {
 810       rv = write (2, "Couldn't create ", 16);
 811       rv = write (2, filename, strlen (filename));
 812       rv = write (2, "\n", 1);
 813       return;
 814     }
 815   rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
 816   fclose (fp);
 817   if (rv < 0)
 818     {
 819       rv = write (2, "Failed to save post-mortem API trace to ", 40);
 820       rv = write (2, filename, strlen (filename));
 821       rv = write (2, "\n", 1);
 822     }
 823
 824 }
 825
 826 /* Layered message handling support */
 827
 828 void
 829 vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
 830 {
 831   api_main_t *am = &api_main;
 832
 833   /* Mild idiot proofing */
 834   if (msg_id_host_byte_order > 10000)
 835     clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
 836                   msg_id_host_byte_order,
 837                   clib_net_to_host_u16 (msg_id_host_byte_order));
 838   vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
 839   am->pd_msg_handlers[msg_id_host_byte_order] = fp;
 840 }
 841
 842 int
 843 vl_msg_api_pd_handler (void *mp, int rv)
 844 {
 845   api_main_t *am = &api_main;
 846   int (*fp) (void *, int);
 847   u16 msg_id;
 848
 849   if (clib_arch_is_little_endian)
 850     msg_id = clib_net_to_host_u16 (*((u16 *) mp));
 851   else
 852     msg_id = *((u16 *) mp);
 853
 854   if (msg_id >= vec_len (am->pd_msg_handlers)
 855       || am->pd_msg_handlers[msg_id] == 0)
 856     return rv;
 857
 858   fp = am->pd_msg_handlers[msg_id];
 859   rv = (*fp) (mp, rv);
 860   return rv;
 861 }
 862
 863 void
 864 vl_msg_api_set_first_available_msg_id (u16 first_avail)
 865 {
 866   api_main_t *am = &api_main;
 867
 868   am->first_available_msg_id = first_avail;
 869 }
 870
 871 u16
 872 vl_msg_api_get_msg_ids (const char *name, int n)
 873 {
 874   api_main_t *am = &api_main;
 875   u8 *name_copy;
 876   vl_api_msg_range_t *rp;
 877   uword *p;
 878   u16 rv;
 879
 880   if (am->msg_range_by_name == 0)
 881     am->msg_range_by_name = hash_create_string (0, sizeof (uword));
 882
 883   name_copy = format (0, "%s%c", name, 0);
 884
 885   p = hash_get_mem (am->msg_range_by_name, name_copy);
 886   if (p)
 887     {
 888       clib_warning ("WARNING: duplicate message range registration for '%s'",
 889                     name_copy);
 890       vec_free (name_copy);
 891       return ((u16) ~ 0);
 892     }
 893
 894   if (n < 0 || n > 1024)
 895     {
 896       clib_warning
 897         ("WARNING: bad number of message-IDs (%d) requested by '%s'",
 898          n, name_copy);
 899       vec_free (name_copy);
 900       return ((u16) ~ 0);
 901     }
 902
 903   vec_add2 (am->msg_ranges, rp, 1);
 904
 905   rv = rp->first_msg_id = am->first_available_msg_id;
 906   am->first_available_msg_id += n;
 907   rp->last_msg_id = am->first_available_msg_id - 1;
 908   rp->name = name_copy;
 909
 910   hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
 911
 912   return rv;
 913 }
 914
 915 void
 916 vl_msg_api_add_msg_name_crc (api_main_t * am, const char *string, u32 id)
 917 {
 918   uword *p;
 919
 920   if (am->msg_index_by_name_and_crc == 0)
 921     am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword));
 922
 923   p = hash_get_mem (am->msg_index_by_name_and_crc, string);
 924   if (p)
 925     {
 926       clib_warning ("attempt to redefine '%s' ignored...", string);
 927       return;
 928     }
 929
 930   hash_set_mem (am->msg_index_by_name_and_crc, string, id);
 931 }
 932
 933 void
 934 vl_msg_api_add_version (api_main_t * am, const char *string,
 935                         u32 major, u32 minor, u32 patch)
 936 {
 937   api_version_t version = {.major = major,.minor = minor,.patch = patch };
 938   ASSERT (strlen (string) < 64);
 939   strncpy (version.name, string, 64 - 1);
 940   vec_add1 (am->api_version_list, version);
 941 }
 942
 943 /*
 944  * fd.io coding-style-patch-verification: ON
 945  *
 946  * Local Variables:
 947  * eval: (c-set-style "gnu")
 948  * End:
 949  */