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 #include <vppinfra/callback.h>
  34
  35 /* *INDENT-OFF* */
  36 api_main_t api_global_main =
  37   {
  38     .region_name = "/unset",
  39     .api_uid = -1,
  40     .api_gid = -1,
  41   };
  42 /* *INDENT-ON* */
  43
  44 /* Please use vlibapi_get_main() to access my_api_main */
  45 __thread api_main_t *my_api_main = &api_global_main;
  46
  47 void
  48 vl_msg_api_set_global_main (void *am_arg)
  49 {
  50   ASSERT (am_arg);
  51   my_api_main = (api_main_t *) am_arg;
  52 }
  53
  54 void
  55 vl_msg_api_increment_missing_client_counter (void)
  56 {
  57   api_main_t *am = vlibapi_get_main ();
  58   am->missing_clients++;
  59 }
  60
  61 int
  62 vl_msg_api_rx_trace_enabled (api_main_t * am)
  63 {
  64   return (am->rx_trace && am->rx_trace->enabled);
  65 }
  66
  67 int
  68 vl_msg_api_tx_trace_enabled (api_main_t * am)
  69 {
  70   return (am->tx_trace && am->tx_trace->enabled);
  71 }
  72
  73 /*
  74  * vl_msg_api_trace
  75  */
  76 void
  77 vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
  78 {
  79   u8 **this_trace;
  80   u8 **old_trace;
  81   u8 *msg_copy;
  82   u32 length;
  83   trace_cfg_t *cfgp;
  84   u16 msg_id = clib_net_to_host_u16 (*((u16 *) msg));
  85   msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data));
  86
  87   cfgp = am->api_trace_cfg + msg_id;
  88
  89   if (!cfgp || !cfgp->trace_enable)
  90     return;
  91
  92   msg_copy = 0;
  93
  94   if (tp->nitems == 0)
  95     {
  96       clib_warning ("tp->nitems is 0");
  97       return;
  98     }
  99
 100   if (vec_len (tp->traces) < tp->nitems)
 101     {
 102       vec_add1 (tp->traces, 0);
 103       this_trace = tp->traces + vec_len (tp->traces) - 1;
 104     }
 105   else
 106     {
 107       tp->wrapped = 1;
 108       old_trace = tp->traces + tp->curindex++;
 109       if (tp->curindex == tp->nitems)
 110         tp->curindex = 0;
 111       /* Reuse the trace record, may save some memory allocator traffic */
 112       msg_copy = *old_trace;
 113       vec_reset_length (msg_copy);
 114       this_trace = old_trace;
 115     }
 116
 117   length = clib_net_to_host_u32 (header->data_len);
 118
 119   vec_validate (msg_copy, length - 1);
 120   clib_memcpy_fast (msg_copy, msg, length);
 121   *this_trace = msg_copy;
 122 }
 123
 124 int
 125 vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
 126                         int onoff)
 127 {
 128   vl_api_trace_t *tp;
 129   int rv;
 130
 131   switch (which)
 132     {
 133     case VL_API_TRACE_TX:
 134       tp = am->tx_trace;
 135       if (tp == 0)
 136         {
 137           vl_msg_api_trace_configure (am, which, 1024);
 138           tp = am->tx_trace;
 139         }
 140       break;
 141
 142     case VL_API_TRACE_RX:
 143       tp = am->rx_trace;
 144       if (tp == 0)
 145         {
 146           vl_msg_api_trace_configure (am, which, 1024);
 147           tp = am->rx_trace;
 148         }
 149       break;
 150
 151     default:
 152       /* duh? */
 153       return -1;
 154     }
 155
 156   /* Configured? */
 157   if (tp == 0 || tp->nitems == 0)
 158     return -1;
 159
 160   rv = tp->enabled;
 161   tp->enabled = onoff;
 162
 163   return rv;
 164 }
 165
 166 int
 167 vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 168 {
 169   vl_api_trace_t *tp;
 170   int i;
 171
 172   switch (which)
 173     {
 174     case VL_API_TRACE_TX:
 175       tp = am->tx_trace;
 176       break;
 177
 178     case VL_API_TRACE_RX:
 179       tp = am->rx_trace;
 180       break;
 181
 182     default:
 183       /* duh? */
 184       return -1;
 185     }
 186
 187   /* Configured? */
 188   if (!tp || tp->nitems == 0)
 189     return -1;
 190
 191   tp->curindex = 0;
 192   tp->wrapped = 0;
 193
 194   for (i = 0; i < vec_len (tp->traces); i++)
 195     {
 196       vec_free (tp->traces[i]);
 197     }
 198   vec_free (tp->traces);
 199
 200   return 0;
 201 }
 202
 203 u8 *
 204 vl_api_serialize_message_table (api_main_t * am, u8 * vector)
 205 {
 206   serialize_main_t _sm, *sm = &_sm;
 207   hash_pair_t *hp;
 208   u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
 209
 210   serialize_open_vector (sm, vector);
 211
 212   /* serialize the count */
 213   serialize_integer (sm, nmsg, sizeof (u32));
 214
 215   /* *INDENT-OFF* */
 216   hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
 217   ({
 218     serialize_likely_small_unsigned_integer (sm, hp->value[0]);
 219     serialize_cstring (sm, (char *) hp->key);
 220   }));
 221   /* *INDENT-ON* */
 222
 223   return serialize_close_vector (sm);
 224 }
 225
 226 int
 227 vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
 228 {
 229   vl_api_trace_t *tp;
 230   vl_api_trace_file_header_t fh;
 231   int i;
 232   u8 *msg;
 233
 234   switch (which)
 235     {
 236     case VL_API_TRACE_TX:
 237       tp = am->tx_trace;
 238       break;
 239
 240     case VL_API_TRACE_RX:
 241       tp = am->rx_trace;
 242       break;
 243
 244     default:
 245       /* duh? */
 246       return -1;
 247     }
 248
 249   /* Configured, data present? */
 250   if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
 251     return -1;
 252
 253   /* "Dare to be stupid" check */
 254   if (fp == 0)
 255     {
 256       return -2;
 257     }
 258
 259   /* Write the file header */
 260   fh.wrapped = tp->wrapped;
 261   fh.nitems = clib_host_to_net_u32 (vec_len (tp->traces));
 262   u8 *m = vl_api_serialize_message_table (am, 0);
 263   fh.msgtbl_size = clib_host_to_net_u32 (vec_len (m));
 264
 265   if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
 266     {
 267       return (-10);
 268     }
 269
 270   /* Write the message table */
 271   if (fwrite (m, vec_len (m), 1, fp) != 1)
 272     {
 273       return (-14);
 274     }
 275   vec_free (m);
 276
 277   /* No-wrap case */
 278   if (tp->wrapped == 0)
 279     {
 280       /*
 281        * Note: vec_len return 0 when fed a NULL pointer.
 282        * Unfortunately, the static analysis tool doesn't
 283        * figure it out, hence the suppressed warnings.
 284        * What a great use of my time.
 285        */
 286       for (i = 0; i < vec_len (tp->traces); i++)
 287         {
 288           u32 msg_length;
 289           /*sa_ignore NO_NULL_CHK */
 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           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 305             {
 306               return (-11);
 307             }
 308         }
 309     }
 310   else
 311     {
 312       /* Wrap case: write oldest -> end of buffer */
 313       for (i = tp->curindex; i < vec_len (tp->traces); i++)
 314         {
 315           u32 msg_length;
 316           msg = tp->traces[i];
 317           /*
 318            * This retarded check required to pass
 319            * [sic] SA-checking
 320            */
 321           if (!msg)
 322             continue;
 323
 324           msg_length = clib_host_to_net_u32 (vec_len (msg));
 325           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 326               != sizeof (msg_length))
 327             {
 328               return (-14);
 329             }
 330
 331           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 332             {
 333               return (-12);
 334             }
 335         }
 336       /* write beginning of buffer -> oldest-1 */
 337       for (i = 0; i < tp->curindex; i++)
 338         {
 339           u32 msg_length;
 340           /*sa_ignore NO_NULL_CHK */
 341           msg = tp->traces[i];
 342           /*
 343            * This retarded check required to pass
 344            * [sic] SA-checking
 345            */
 346           if (!msg)
 347             continue;
 348
 349           msg_length = clib_host_to_net_u32 (vec_len (msg));
 350           if (fwrite (&msg_length, 1, sizeof (msg_length), fp)
 351               != sizeof (msg_length))
 352             {
 353               return (-14);
 354             }
 355
 356           if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
 357             {
 358               return (-13);
 359             }
 360         }
 361     }
 362   return 0;
 363 }
 364
 365 int
 366 vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
 367                             u32 nitems)
 368 {
 369   vl_api_trace_t *tp;
 370   int was_on = 0;
 371
 372   switch (which)
 373     {
 374     case VL_API_TRACE_TX:
 375       tp = am->tx_trace;
 376       if (tp == 0)
 377         {
 378           vec_validate (am->tx_trace, 0);
 379           tp = am->tx_trace;
 380         }
 381       break;
 382
 383     case VL_API_TRACE_RX:
 384       tp = am->rx_trace;
 385       if (tp == 0)
 386         {
 387           vec_validate (am->rx_trace, 0);
 388           tp = am->rx_trace;
 389         }
 390
 391       break;
 392
 393     default:
 394       return -1;
 395
 396     }
 397
 398   if (tp->enabled)
 399     {
 400       was_on = vl_msg_api_trace_onoff (am, which, 0);
 401     }
 402   if (tp->traces)
 403     {
 404       vl_msg_api_trace_free (am, which);
 405     }
 406
 407   clib_memset (tp, 0, sizeof (*tp));
 408
 409   if (clib_arch_is_big_endian)
 410     {
 411       tp->endian = VL_API_BIG_ENDIAN;
 412     }
 413   else
 414     {
 415       tp->endian = VL_API_LITTLE_ENDIAN;
 416     }
 417
 418   tp->nitems = nitems;
 419   if (was_on)
 420     {
 421       (void) vl_msg_api_trace_onoff (am, which, was_on);
 422     }
 423   return 0;
 424 }
 425
 426 void
 427 vl_msg_api_barrier_sync (void)
 428 {
 429 }
 430
 431 void
 432 vl_msg_api_barrier_release (void)
 433 {
 434 }
 435
 436 always_inline void
 437 msg_handler_internal (api_main_t * am,
 438                       void *the_msg, int trace_it, int do_it, int free_it)
 439 {
 440   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 441   u8 *(*print_fp) (void *, void *);
 442
 443   if (PREDICT_FALSE (am->elog_trace_api_messages))
 444     {
 445       /* *INDENT-OFF* */
 446       ELOG_TYPE_DECLARE (e) =
 447         {
 448           .format = "api-msg: %s",
 449           .format_args = "T4",
 450         };
 451       /* *INDENT-ON* */
 452       struct
 453       {
 454         u32 c;
 455       } *ed;
 456       ed = ELOG_DATA (am->elog_main, e);
 457       if (id < vec_len (am->msg_names) && am->msg_names[id])
 458         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 459       else
 460         ed->c = elog_string (am->elog_main, "BOGUS");
 461     }
 462
 463   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 464     {
 465       if (trace_it)
 466         vl_msg_api_trace (am, am->rx_trace, the_msg);
 467
 468       if (am->msg_print_flag)
 469         {
 470           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 471           print_fp = (void *) am->msg_print_handlers[id];
 472           if (print_fp == 0)
 473             {
 474               fformat (stdout, "  [no registered print fn]\n");
 475             }
 476           else
 477             {
 478               (*print_fp) (the_msg, stdout);
 479             }
 480         }
 481
 482       if (do_it)
 483         {
 484           if (!am->is_mp_safe[id])
 485             {
 486               vl_msg_api_barrier_trace_context (am->msg_names[id]);
 487               vl_msg_api_barrier_sync ();
 488             }
 489
 490           if (am->is_autoendian[id])
 491             {
 492               void (*endian_fp) (void *);
 493               endian_fp = am->msg_endian_handlers[id];
 494               (*endian_fp) (the_msg);
 495             }
 496
 497           if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 498             clib_call_callbacks (am->perf_counter_cbs, am, id,
 499                                  0 /* before */ );
 500
 501           (*am->msg_handlers[id]) (the_msg);
 502
 503           if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 504             clib_call_callbacks (am->perf_counter_cbs, am, id,
 505                                  1 /* after */ );
 506           if (!am->is_mp_safe[id])
 507             vl_msg_api_barrier_release ();
 508         }
 509     }
 510   else
 511     {
 512       clib_warning ("no handler for msg id %d", id);
 513     }
 514
 515   if (free_it)
 516     vl_msg_api_free (the_msg);
 517
 518   if (PREDICT_FALSE (am->elog_trace_api_messages))
 519     {
 520       /* *INDENT-OFF* */
 521       ELOG_TYPE_DECLARE (e) =
 522         {
 523           .format = "api-msg-done(%s): %s",
 524           .format_args = "t4T4",
 525           .n_enum_strings = 2,
 526           .enum_strings =
 527           {
 528             "barrier",
 529             "mp-safe",
 530           }
 531         };
 532       /* *INDENT-ON* */
 533
 534       struct
 535       {
 536         u32 barrier;
 537         u32 c;
 538       } *ed;
 539       ed = ELOG_DATA (am->elog_main, e);
 540       if (id < vec_len (am->msg_names) && am->msg_names[id])
 541         {
 542           ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 543           ed->barrier = !am->is_mp_safe[id];
 544         }
 545       else
 546         {
 547           ed->c = elog_string (am->elog_main, "BOGUS");
 548           ed->barrier = 0;
 549         }
 550     }
 551 }
 552
 553 void (*vl_msg_api_fuzz_hook) (u16, void *);
 554
 555 /* This is only to be called from a vlib/vnet app */
 556 void
 557 vl_msg_api_handler_with_vm_node (api_main_t * am, svm_region_t * vlib_rp,
 558                                  void *the_msg, vlib_main_t * vm,
 559                                  vlib_node_runtime_t * node, u8 is_private)
 560 {
 561   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 562   u8 *(*handler) (void *, void *, void *);
 563   u8 *(*print_fp) (void *, void *);
 564   svm_region_t *old_vlib_rp;
 565   void *save_shmem_hdr;
 566   int is_mp_safe = 1;
 567
 568   if (PREDICT_FALSE (am->elog_trace_api_messages))
 569     {
 570       /* *INDENT-OFF* */
 571       ELOG_TYPE_DECLARE (e) =
 572         {
 573           .format = "api-msg: %s",
 574           .format_args = "T4",
 575         };
 576       /* *INDENT-ON* */
 577       struct
 578       {
 579         u32 c;
 580       } *ed;
 581       ed = ELOG_DATA (am->elog_main, e);
 582       if (id < vec_len (am->msg_names) && am->msg_names[id])
 583         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 584       else
 585         ed->c = elog_string (am->elog_main, "BOGUS");
 586     }
 587
 588   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 589     {
 590       handler = (void *) am->msg_handlers[id];
 591
 592       if (PREDICT_FALSE (am->rx_trace && am->rx_trace->enabled))
 593         vl_msg_api_trace (am, am->rx_trace, the_msg);
 594
 595       if (PREDICT_FALSE (am->msg_print_flag))
 596         {
 597           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 598           print_fp = (void *) am->msg_print_handlers[id];
 599           if (print_fp == 0)
 600             {
 601               fformat (stdout, "  [no registered print fn for msg %d]\n", id);
 602             }
 603           else
 604             {
 605               (*print_fp) (the_msg, vm);
 606             }
 607         }
 608       is_mp_safe = am->is_mp_safe[id];
 609
 610       if (!is_mp_safe)
 611         {
 612           vl_msg_api_barrier_trace_context (am->msg_names[id]);
 613           vl_msg_api_barrier_sync ();
 614         }
 615       if (is_private)
 616         {
 617           old_vlib_rp = am->vlib_rp;
 618           save_shmem_hdr = am->shmem_hdr;
 619           am->vlib_rp = vlib_rp;
 620           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 621         }
 622
 623       if (PREDICT_FALSE (vl_msg_api_fuzz_hook != 0))
 624         (*vl_msg_api_fuzz_hook) (id, the_msg);
 625
 626       if (am->is_autoendian[id])
 627         {
 628           void (*endian_fp) (void *);
 629           endian_fp = am->msg_endian_handlers[id];
 630           (*endian_fp) (the_msg);
 631         }
 632       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 633         clib_call_callbacks (am->perf_counter_cbs, am, id, 0 /* before */ );
 634
 635       (*handler) (the_msg, vm, node);
 636
 637       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 638         clib_call_callbacks (am->perf_counter_cbs, am, id, 1 /* after */ );
 639       if (is_private)
 640         {
 641           am->vlib_rp = old_vlib_rp;
 642           am->shmem_hdr = save_shmem_hdr;
 643         }
 644       if (!is_mp_safe)
 645         vl_msg_api_barrier_release ();
 646     }
 647   else
 648     {
 649       clib_warning ("no handler for msg id %d", id);
 650     }
 651
 652   /*
 653    * Special-case, so we can e.g. bounce messages off the vnet
 654    * main thread without copying them...
 655    */
 656   if (id >= vec_len (am->message_bounce) || !(am->message_bounce[id]))
 657     {
 658       if (is_private)
 659         {
 660           old_vlib_rp = am->vlib_rp;
 661           save_shmem_hdr = am->shmem_hdr;
 662           am->vlib_rp = vlib_rp;
 663           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 664         }
 665       vl_msg_api_free (the_msg);
 666       if (is_private)
 667         {
 668           am->vlib_rp = old_vlib_rp;
 669           am->shmem_hdr = save_shmem_hdr;
 670         }
 671     }
 672
 673   if (PREDICT_FALSE (am->elog_trace_api_messages))
 674     {
 675       /* *INDENT-OFF* */
 676       ELOG_TYPE_DECLARE (e) =
 677         {
 678           .format = "api-msg-done(%s): %s",
 679           .format_args = "t4T4",
 680           .n_enum_strings = 2,
 681           .enum_strings =
 682           {
 683             "barrier",
 684             "mp-safe",
 685           }
 686         };
 687       /* *INDENT-ON* */
 688
 689       struct
 690       {
 691         u32 barrier;
 692         u32 c;
 693       } *ed;
 694       ed = ELOG_DATA (am->elog_main, e);
 695       if (id < vec_len (am->msg_names) && am->msg_names[id])
 696         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 697       else
 698         ed->c = elog_string (am->elog_main, "BOGUS");
 699       ed->barrier = is_mp_safe;
 700     }
 701 }
 702
 703 void
 704 vl_msg_api_handler (void *the_msg)
 705 {
 706   api_main_t *am = vlibapi_get_main ();
 707
 708   msg_handler_internal (am, the_msg,
 709                         (am->rx_trace
 710                          && am->rx_trace->enabled) /* trace_it */ ,
 711                         1 /* do_it */ , 1 /* free_it */ );
 712 }
 713
 714 void
 715 vl_msg_api_handler_no_free (void *the_msg)
 716 {
 717   api_main_t *am = vlibapi_get_main ();
 718   msg_handler_internal (am, the_msg,
 719                         (am->rx_trace
 720                          && am->rx_trace->enabled) /* trace_it */ ,
 721                         1 /* do_it */ , 0 /* free_it */ );
 722 }
 723
 724 void
 725 vl_msg_api_handler_no_trace_no_free (void *the_msg)
 726 {
 727   api_main_t *am = vlibapi_get_main ();
 728   msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
 729                         0 /* free_it */ );
 730 }
 731
 732 /*
 733  * Add a trace record to the API message trace buffer, if
 734  * API message tracing is enabled. Handy for adding sufficient
 735  * data to the trace to reproduce autonomous state, as opposed to
 736  * state downloaded via control-plane API messages. Example: the NAT
 737  * application creates database entries based on packet traffic, not
 738  * control-plane messages.
 739  *
 740  */
 741 void
 742 vl_msg_api_trace_only (void *the_msg)
 743 {
 744   api_main_t *am = vlibapi_get_main ();
 745
 746   msg_handler_internal (am, the_msg,
 747                         (am->rx_trace
 748                          && am->rx_trace->enabled) /* trace_it */ ,
 749                         0 /* do_it */ , 0 /* free_it */ );
 750 }
 751
 752 void
 753 vl_msg_api_cleanup_handler (void *the_msg)
 754 {
 755   api_main_t *am = vlibapi_get_main ();
 756   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 757
 758   if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
 759     {
 760       clib_warning ("_vl_msg_id too large: %d\n", id);
 761       return;
 762     }
 763   if (am->msg_cleanup_handlers[id])
 764     (*am->msg_cleanup_handlers[id]) (the_msg);
 765
 766   vl_msg_api_free (the_msg);
 767 }
 768
 769 /*
 770  * vl_msg_api_replay_handler
 771  */
 772 void
 773 vl_msg_api_replay_handler (void *the_msg)
 774 {
 775   api_main_t *am = vlibapi_get_main ();
 776
 777   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 778
 779   if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
 780     {
 781       clib_warning ("_vl_msg_id too large: %d\n", id);
 782       return;
 783     }
 784   /* do NOT trace the message... */
 785   if (am->msg_handlers[id])
 786     (*am->msg_handlers[id]) (the_msg);
 787   /* do NOT free the message buffer... */
 788 }
 789
 790 u32
 791 vl_msg_api_get_msg_length (void *msg_arg)
 792 {
 793   return vl_msg_api_get_msg_length_inline (msg_arg);
 794 }
 795
 796 /*
 797  * vl_msg_api_socket_handler
 798  */
 799 void
 800 vl_msg_api_socket_handler (void *the_msg)
 801 {
 802   api_main_t *am = vlibapi_get_main ();
 803
 804   msg_handler_internal (am, the_msg,
 805                         (am->rx_trace
 806                          && am->rx_trace->enabled) /* trace_it */ ,
 807                         1 /* do_it */ , 0 /* free_it */ );
 808 }
 809
 810 #define foreach_msg_api_vector                  \
 811 _(msg_names)                                    \
 812 _(msg_handlers)                                 \
 813 _(msg_cleanup_handlers)                         \
 814 _(msg_endian_handlers)                          \
 815 _(msg_print_handlers)                           \
 816 _(api_trace_cfg)                                \
 817 _(message_bounce)                               \
 818 _(is_mp_safe)                                   \
 819 _(is_autoendian)
 820
 821 void
 822 vl_msg_api_config (vl_msg_api_msg_config_t * c)
 823 {
 824   api_main_t *am = vlibapi_get_main ();
 825
 826   /*
 827    * This happens during the java core tests if the message
 828    * dictionary is missing newly added xxx_reply_t messages.
 829    * Should never happen, but since I shot myself in the foot once
 830    * this way, I thought I'd make it easy to debug if I ever do
 831    * it again... (;-)...
 832    */
 833   if (c->id == 0)
 834     {
 835       if (c->name)
 836         clib_warning ("Trying to register %s with a NULL msg id!", c->name);
 837       else
 838         clib_warning ("Trying to register a NULL msg with a NULL msg id!");
 839       clib_warning ("Did you forget to call setup_message_id_table?");
 840       return;
 841     }
 842
 843 #define _(a) vec_validate (am->a, c->id);
 844   foreach_msg_api_vector;
 845 #undef _
 846
 847   if (am->msg_handlers[c->id] && am->msg_handlers[c->id] != c->handler)
 848     clib_warning
 849       ("BUG: re-registering 'vl_api_%s_t_handler'."
 850        "Handler was %llx, replaced by %llx",
 851        c->name, am->msg_handlers[c->id], c->handler);
 852
 853   am->msg_names[c->id] = c->name;
 854   am->msg_handlers[c->id] = c->handler;
 855   am->msg_cleanup_handlers[c->id] = c->cleanup;
 856   am->msg_endian_handlers[c->id] = c->endian;
 857   am->msg_print_handlers[c->id] = c->print;
 858   am->message_bounce[c->id] = c->message_bounce;
 859   am->is_mp_safe[c->id] = c->is_mp_safe;
 860   am->is_autoendian[c->id] = c->is_autoendian;
 861
 862   am->api_trace_cfg[c->id].size = c->size;
 863   am->api_trace_cfg[c->id].trace_enable = c->traced;
 864   am->api_trace_cfg[c->id].replay_enable = c->replay;
 865 }
 866
 867 /*
 868  * vl_msg_api_set_handlers
 869  * preserve the old API for a while
 870  */
 871 void
 872 vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
 873                          void *endian, void *print, int size, int traced)
 874 {
 875   vl_msg_api_msg_config_t cfg;
 876   vl_msg_api_msg_config_t *c = &cfg;
 877
 878   clib_memset (c, 0, sizeof (*c));
 879
 880   c->id = id;
 881   c->name = name;
 882   c->handler = handler;
 883   c->cleanup = cleanup;
 884   c->endian = endian;
 885   c->print = print;
 886   c->traced = traced;
 887   c->replay = 1;
 888   c->message_bounce = 0;
 889   c->is_mp_safe = 0;
 890   c->is_autoendian = 0;
 891   vl_msg_api_config (c);
 892 }
 893
 894 void
 895 vl_msg_api_clean_handlers (int msg_id)
 896 {
 897   vl_msg_api_msg_config_t cfg;
 898   vl_msg_api_msg_config_t *c = &cfg;
 899
 900   clib_memset (c, 0, sizeof (*c));
 901
 902   c->id = msg_id;
 903   vl_msg_api_config (c);
 904 }
 905
 906 void
 907 vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
 908 {
 909   api_main_t *am = vlibapi_get_main ();
 910   ASSERT (msg_id > 0);
 911
 912   vec_validate (am->msg_cleanup_handlers, msg_id);
 913   am->msg_cleanup_handlers[msg_id] = fp;
 914 }
 915
 916 void
 917 vl_msg_api_queue_handler (svm_queue_t * q)
 918 {
 919   uword msg;
 920
 921   while (!svm_queue_sub (q, (u8 *) & msg, SVM_Q_WAIT, 0))
 922     vl_msg_api_handler ((void *) msg);
 923 }
 924
 925 u32
 926 vl_msg_api_max_length (void *mp)
 927 {
 928   msgbuf_t *mb;
 929   u32 data_len = ~0;
 930
 931   /* Work out the maximum sane message length, and return it */
 932   if (PREDICT_TRUE (mp != 0))
 933     {
 934       mb = (msgbuf_t *) (((u8 *) mp) - offsetof (msgbuf_t, data));
 935       data_len = clib_net_to_host_u32 (mb->data_len);
 936     }
 937   return data_len;
 938 }
 939
 940 vl_api_trace_t *
 941 vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
 942 {
 943   switch (which)
 944     {
 945     case VL_API_TRACE_RX:
 946       return am->rx_trace;
 947     case VL_API_TRACE_TX:
 948       return am->tx_trace;
 949     default:
 950       return 0;
 951     }
 952 }
 953
 954 void
 955 vl_noop_handler (void *mp)
 956 {
 957 }
 958
 959
 960 static u8 post_mortem_dump_enabled;
 961
 962 void
 963 vl_msg_api_post_mortem_dump_enable_disable (int enable)
 964 {
 965   post_mortem_dump_enabled = enable;
 966 }
 967
 968 void
 969 vl_msg_api_post_mortem_dump (void)
 970 {
 971   api_main_t *am = vlibapi_get_main ();
 972   FILE *fp;
 973   char filename[64];
 974   int rv;
 975
 976   if (post_mortem_dump_enabled == 0)
 977     return;
 978
 979   snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
 980             getpid ());
 981
 982   fp = fopen (filename, "w");
 983   if (fp == NULL)
 984     {
 985       rv = write (2, "Couldn't create ", 16);
 986       rv = write (2, filename, strlen (filename));
 987       rv = write (2, "\n", 1);
 988       return;
 989     }
 990   rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
 991   fclose (fp);
 992   if (rv < 0)
 993     {
 994       rv = write (2, "Failed to save post-mortem API trace to ", 40);
 995       rv = write (2, filename, strlen (filename));
 996       rv = write (2, "\n", 1);
 997     }
 998
 999 }
1000
1001 /* Layered message handling support */
1002
1003 void
1004 vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
1005 {
1006   api_main_t *am = vlibapi_get_main ();
1007
1008   /* Mild idiot proofing */
1009   if (msg_id_host_byte_order > 10000)
1010     clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
1011                   msg_id_host_byte_order,
1012                   clib_net_to_host_u16 (msg_id_host_byte_order));
1013   vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
1014   am->pd_msg_handlers[msg_id_host_byte_order] = fp;
1015 }
1016
1017 int
1018 vl_msg_api_pd_handler (void *mp, int rv)
1019 {
1020   api_main_t *am = vlibapi_get_main ();
1021   int (*fp) (void *, int);
1022   u16 msg_id;
1023
1024   if (clib_arch_is_little_endian)
1025     msg_id = clib_net_to_host_u16 (*((u16 *) mp));
1026   else
1027     msg_id = *((u16 *) mp);
1028
1029   if (msg_id >= vec_len (am->pd_msg_handlers)
1030       || am->pd_msg_handlers[msg_id] == 0)
1031     return rv;
1032
1033   fp = am->pd_msg_handlers[msg_id];
1034   rv = (*fp) (mp, rv);
1035   return rv;
1036 }
1037
1038 void
1039 vl_msg_api_set_first_available_msg_id (u16 first_avail)
1040 {
1041   api_main_t *am = vlibapi_get_main ();
1042
1043   am->first_available_msg_id = first_avail;
1044 }
1045
1046 u16
1047 vl_msg_api_get_msg_ids (const char *name, int n)
1048 {
1049   api_main_t *am = vlibapi_get_main ();
1050   u8 *name_copy;
1051   vl_api_msg_range_t *rp;
1052   uword *p;
1053   u16 rv;
1054
1055   if (am->msg_range_by_name == 0)
1056     am->msg_range_by_name = hash_create_string (0, sizeof (uword));
1057
1058   name_copy = format (0, "%s%c", name, 0);
1059
1060   p = hash_get_mem (am->msg_range_by_name, name_copy);
1061   if (p)
1062     {
1063       clib_warning ("WARNING: duplicate message range registration for '%s'",
1064                     name_copy);
1065       vec_free (name_copy);
1066       return ((u16) ~ 0);
1067     }
1068
1069   if (n < 0 || n > 1024)
1070     {
1071       clib_warning
1072         ("WARNING: bad number of message-IDs (%d) requested by '%s'",
1073          n, name_copy);
1074       vec_free (name_copy);
1075       return ((u16) ~ 0);
1076     }
1077
1078   vec_add2 (am->msg_ranges, rp, 1);
1079
1080   rv = rp->first_msg_id = am->first_available_msg_id;
1081   am->first_available_msg_id += n;
1082   rp->last_msg_id = am->first_available_msg_id - 1;
1083   rp->name = name_copy;
1084
1085   hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
1086
1087   return rv;
1088 }
1089
1090 void
1091 vl_msg_api_add_msg_name_crc (api_main_t * am, const char *string, u32 id)
1092 {
1093   uword *p;
1094
1095   if (am->msg_index_by_name_and_crc == 0)
1096     am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword));
1097
1098   p = hash_get_mem (am->msg_index_by_name_and_crc, string);
1099   if (p)
1100     {
1101       clib_warning ("attempt to redefine '%s' ignored...", string);
1102       return;
1103     }
1104
1105   hash_set_mem (am->msg_index_by_name_and_crc, string, id);
1106 }
1107
1108 void
1109 vl_msg_api_add_version (api_main_t * am, const char *string,
1110                         u32 major, u32 minor, u32 patch)
1111 {
1112   api_version_t version = {.major = major,.minor = minor,.patch = patch };
1113   ASSERT (strlen (string) < 64);
1114   strncpy (version.name, string, 64 - 1);
1115   vec_add1 (am->api_version_list, version);
1116 }
1117
1118 u32
1119 vl_msg_api_get_msg_index (u8 * name_and_crc)
1120 {
1121   api_main_t *am = vlibapi_get_main ();
1122   uword *p;
1123
1124   if (am->msg_index_by_name_and_crc)
1125     {
1126       p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc);
1127       if (p)
1128         return p[0];
1129     }
1130   return ~0;
1131 }
1132
1133 void *
1134 vl_msg_push_heap_w_region (svm_region_t * vlib_rp)
1135 {
1136   pthread_mutex_lock (&vlib_rp->mutex);
1137   return svm_push_data_heap (vlib_rp);
1138 }
1139
1140 void *
1141 vl_msg_push_heap (void)
1142 {
1143   api_main_t *am = vlibapi_get_main ();
1144   return vl_msg_push_heap_w_region (am->vlib_rp);
1145 }
1146
1147 void
1148 vl_msg_pop_heap_w_region (svm_region_t * vlib_rp, void *oldheap)
1149 {
1150   svm_pop_heap (oldheap);
1151   pthread_mutex_unlock (&vlib_rp->mutex);
1152 }
1153
1154 void
1155 vl_msg_pop_heap (void *oldheap)
1156 {
1157   api_main_t *am = vlibapi_get_main ();
1158   vl_msg_pop_heap_w_region (am->vlib_rp, oldheap);
1159 }
1160
1161 /* Must be nul terminated */
1162 int
1163 vl_api_c_string_to_api_string (const char *buf, vl_api_string_t * str)
1164 {
1165   /* copy without nul terminator */
1166   u32 len = strlen (buf);
1167   if (len > 0)
1168     clib_memcpy_fast (str->buf, buf, len);
1169   str->length = htonl (len);
1170   return len + sizeof (u32);
1171 }
1172
1173 /* Must NOT be nul terminated */
1174 int
1175 vl_api_vec_to_api_string (const u8 * vec, vl_api_string_t * str)
1176 {
1177   u32 len = vec_len (vec);
1178   clib_memcpy (str->buf, vec, len);
1179   str->length = htonl (len);
1180   return len + sizeof (u32);
1181 }
1182
1183 u32
1184 vl_api_string_len (vl_api_string_t * astr)
1185 {
1186   return clib_net_to_host_u32 (astr->length);
1187 }
1188
1189 u8 *
1190 vl_api_format_string (u8 * s, va_list * args)
1191 {
1192   vl_api_string_t *a = va_arg (*args, vl_api_string_t *);
1193   vec_add (s, a->buf, clib_net_to_host_u32 (a->length));
1194   return s;
1195 }
1196
1197 /*
1198  * Returns a new vector. Remember to free it after use.
1199  * NOT nul terminated.
1200  */
1201 u8 *
1202 vl_api_from_api_to_new_vec (void *mp, vl_api_string_t * astr)
1203 {
1204   u8 *v = 0;
1205
1206   if (vl_msg_api_max_length (mp) < clib_net_to_host_u32 (astr->length))
1207     return format (0, "insane astr->length %u%c",
1208                    clib_net_to_host_u32 (astr->length), 0);
1209   vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
1210   return v;
1211 }
1212
1213 /*
1214  * Returns a new vector. Remember to free it after use.
1215  * Nul terminated.
1216  */
1217 char *
1218 vl_api_from_api_to_new_c_string (vl_api_string_t * astr)
1219 {
1220   char *v = 0;
1221   if (clib_net_to_host_u32 (astr->length) > 0)
1222     {
1223       vec_add (v, astr->buf, clib_net_to_host_u32 (astr->length));
1224       vec_add1 (v, 0);
1225     }
1226   return v;
1227 }
1228
1229 void
1230 vl_api_set_elog_main (elog_main_t * m)
1231 {
1232   api_main_t *am = vlibapi_get_main ();
1233   am->elog_main = m;
1234 }
1235
1236 int
1237 vl_api_set_elog_trace_api_messages (int enable)
1238 {
1239   int rv;
1240   api_main_t *am = vlibapi_get_main ();
1241
1242   rv = am->elog_trace_api_messages;
1243   am->elog_trace_api_messages = enable;
1244   return rv;
1245 }
1246
1247 int
1248 vl_api_get_elog_trace_api_messages (void)
1249 {
1250   api_main_t *am = vlibapi_get_main ();
1251
1252   return am->elog_trace_api_messages;
1253 }
1254
1255 /*
1256  * fd.io coding-style-patch-verification: ON
1257  *
1258  * Local Variables:
1259  * eval: (c-set-style "gnu")
1260  * End:
1261  */