src/vlibmemory/memory_vlib.c

   1 /*
   2  *------------------------------------------------------------------
   3  * memory_vlib.c
   4  *
   5  * Copyright (c) 2009 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <signal.h>
  28 #include <pthread.h>
  29 #include <vppinfra/vec.h>
  30 #include <vppinfra/hash.h>
  31 #include <vppinfra/pool.h>
  32 #include <vppinfra/format.h>
  33 #include <vppinfra/byte_order.h>
  34 #include <vppinfra/elog.h>
  35 #include <stdarg.h>
  36 #include <vlib/vlib.h>
  37 #include <vlib/unix/unix.h>
  38 #include <vlibapi/api.h>
  39 #include <vlibmemory/api.h>
  40
  41 /**
  42  * @file
  43  * @brief Binary API messaging via shared memory
  44  * Low-level, primary provisioning interface
  45  */
  46 /*? %%clicmd:group_label Binary API CLI %% ?*/
  47 /*? %%syscfg:group_label Binary API configuration %% ?*/
  48
  49 #define TRACE_VLIB_MEMORY_QUEUE 0
  50
  51 #include <vlibmemory/vl_memory_msg_enum.h>      /* enumerate all vlib messages */
  52
  53 #define vl_typedefs             /* define message structures */
  54 #include <vlibmemory/vl_memory_api_h.h>
  55 #undef vl_typedefs
  56
  57 /* instantiate all the print functions we know about */
  58 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  59 #define vl_printfun
  60 #include <vlibmemory/vl_memory_api_h.h>
  61 #undef vl_printfun
  62
  63 static inline void *
  64 vl_api_memclnt_create_t_print (vl_api_memclnt_create_t * a, void *handle)
  65 {
  66   vl_print (handle, "vl_api_memclnt_create_t:\n");
  67   vl_print (handle, "name: %s\n", a->name);
  68   vl_print (handle, "input_queue: 0x%wx\n", a->input_queue);
  69   vl_print (handle, "context: %u\n", (unsigned) a->context);
  70   vl_print (handle, "ctx_quota: %ld\n", (long) a->ctx_quota);
  71   return handle;
  72 }
  73
  74 static inline void *
  75 vl_api_memclnt_delete_t_print (vl_api_memclnt_delete_t * a, void *handle)
  76 {
  77   vl_print (handle, "vl_api_memclnt_delete_t:\n");
  78   vl_print (handle, "index: %u\n", (unsigned) a->index);
  79   vl_print (handle, "handle: 0x%wx\n", a->handle);
  80   return handle;
  81 }
  82
  83 static inline void *
  84 vl_api_trace_plugin_msg_ids_t_print (vl_api_trace_plugin_msg_ids_t * a,
  85                                      void *handle)
  86 {
  87   vl_print (handle, "vl_api_trace_plugin_msg_ids: %s first %u last %u\n",
  88             a->plugin_name,
  89             clib_host_to_net_u16 (a->first_msg_id),
  90             clib_host_to_net_u16 (a->last_msg_id));
  91   return handle;
  92 }
  93
  94 /* instantiate all the endian swap functions we know about */
  95 #define vl_endianfun
  96 #include <vlibmemory/vl_memory_api_h.h>
  97 #undef vl_endianfun
  98
  99 void vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
 100   __attribute__ ((weak));
 101
 102 void
 103 vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
 104 {
 105   static int count;
 106
 107   if (count++ < 5)
 108     clib_warning ("need to link against -lvlibsocket, msg not sent!");
 109 }
 110
 111 void
 112 vl_msg_api_send (vl_api_registration_t * rp, u8 * elem)
 113 {
 114   if (PREDICT_FALSE (rp->registration_type > REGISTRATION_TYPE_SHMEM))
 115     {
 116       vl_socket_api_send (rp, elem);
 117     }
 118   else
 119     {
 120       vl_msg_api_send_shmem (rp->vl_input_queue, elem);
 121     }
 122 }
 123
 124 u8 *
 125 vl_api_serialize_message_table (api_main_t * am, u8 * vector)
 126 {
 127   serialize_main_t _sm, *sm = &_sm;
 128   hash_pair_t *hp;
 129   u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
 130
 131   serialize_open_vector (sm, vector);
 132
 133   /* serialize the count */
 134   serialize_integer (sm, nmsg, sizeof (u32));
 135
 136   /* *INDENT-OFF* */
 137   hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
 138   ({
 139     serialize_likely_small_unsigned_integer (sm, hp->value[0]);
 140     serialize_cstring (sm, (char *) hp->key);
 141   }));
 142   /* *INDENT-ON* */
 143
 144   return serialize_close_vector (sm);
 145 }
 146
 147 /*
 148  * vl_api_memclnt_create_internal
 149  */
 150
 151 u32
 152 vl_api_memclnt_create_internal (char *name, unix_shared_memory_queue_t * q)
 153 {
 154   vl_api_registration_t **regpp;
 155   vl_api_registration_t *regp;
 156   svm_region_t *svm;
 157   void *oldheap;
 158   api_main_t *am = &api_main;
 159
 160   ASSERT (vlib_get_thread_index () == 0);
 161   pool_get (am->vl_clients, regpp);
 162
 163   svm = am->vlib_rp;
 164
 165   pthread_mutex_lock (&svm->mutex);
 166   oldheap = svm_push_data_heap (svm);
 167   *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
 168
 169   regp = *regpp;
 170   memset (regp, 0, sizeof (*regp));
 171   regp->registration_type = REGISTRATION_TYPE_SHMEM;
 172   regp->vl_api_registration_pool_index = regpp - am->vl_clients;
 173
 174   regp->vl_input_queue = q;
 175   regp->name = format (0, "%s%c", name, 0);
 176
 177   pthread_mutex_unlock (&svm->mutex);
 178   svm_pop_heap (oldheap);
 179   return vl_msg_api_handle_from_index_and_epoch
 180     (regp->vl_api_registration_pool_index,
 181      am->shmem_hdr->application_restarts);
 182 }
 183
 184
 185 /*
 186  * vl_api_memclnt_create_t_handler
 187  */
 188 void
 189 vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp)
 190 {
 191   vl_api_registration_t **regpp;
 192   vl_api_registration_t *regp;
 193   vl_api_memclnt_create_reply_t *rp;
 194   svm_region_t *svm;
 195   unix_shared_memory_queue_t *q;
 196   int rv = 0;
 197   void *oldheap;
 198   api_main_t *am = &api_main;
 199
 200   /*
 201    * This is tortured. Maintain a vlib-address-space private
 202    * pool of client registrations. We use the shared-memory virtual
 203    * address of client structure as a handle, to allow direct
 204    * manipulation of context quota vbls from the client library.
 205    *
 206    * This scheme causes trouble w/ API message trace replay, since
 207    * some random VA from clib_mem_alloc() certainly won't
 208    * occur in the Linux sim. The (very) few places
 209    * that care need to use the pool index.
 210    *
 211    * Putting the registration object(s) into a pool in shared memory and
 212    * using the pool index as a handle seems like a great idea.
 213    * Unfortunately, each and every reference to that pool would need
 214    * to be protected by a mutex:
 215    *
 216    *     Client                      VLIB
 217    *     ------                      ----
 218    *     convert pool index to
 219    *     pointer.
 220    *     <deschedule>
 221    *                                 expand pool
 222    *                                 <deschedule>
 223    *     kaboom!
 224    */
 225
 226   pool_get (am->vl_clients, regpp);
 227
 228   svm = am->vlib_rp;
 229
 230   pthread_mutex_lock (&svm->mutex);
 231   oldheap = svm_push_data_heap (svm);
 232   *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
 233
 234   regp = *regpp;
 235   memset (regp, 0, sizeof (*regp));
 236   regp->registration_type = REGISTRATION_TYPE_SHMEM;
 237   regp->vl_api_registration_pool_index = regpp - am->vl_clients;
 238
 239   q = regp->vl_input_queue = (unix_shared_memory_queue_t *) (uword)
 240     mp->input_queue;
 241
 242   regp->name = format (0, "%s", mp->name);
 243   vec_add1 (regp->name, 0);
 244
 245   pthread_mutex_unlock (&svm->mutex);
 246   svm_pop_heap (oldheap);
 247
 248   ASSERT (am->serialized_message_table_in_shmem);
 249
 250   rp = vl_msg_api_alloc (sizeof (*rp));
 251   rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_REPLY);
 252   rp->handle = (uword) regp;
 253   rp->index = vl_msg_api_handle_from_index_and_epoch
 254     (regp->vl_api_registration_pool_index,
 255      am->shmem_hdr->application_restarts);
 256   rp->context = mp->context;
 257   rp->response = ntohl (rv);
 258   rp->message_table =
 259     pointer_to_uword (am->serialized_message_table_in_shmem);
 260
 261   vl_msg_api_send_shmem (q, (u8 *) & rp);
 262 }
 263
 264 static int
 265 call_reaper_functions (u32 client_index)
 266 {
 267   clib_error_t *error = 0;
 268   _vl_msg_api_function_list_elt_t *i;
 269
 270   i = api_main.reaper_function_registrations;
 271   while (i)
 272     {
 273       error = i->f (client_index);
 274       if (error)
 275         clib_error_report (error);
 276       i = i->next_init_function;
 277     }
 278   return 0;
 279 }
 280
 281 /*
 282  * vl_api_memclnt_delete_t_handler
 283  */
 284 void
 285 vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
 286 {
 287   vl_api_registration_t **regpp;
 288   vl_api_registration_t *regp;
 289   vl_api_memclnt_delete_reply_t *rp;
 290   svm_region_t *svm;
 291   void *oldheap;
 292   api_main_t *am = &api_main;
 293   u32 handle, client_index, epoch;
 294
 295   handle = mp->index;
 296
 297   if (call_reaper_functions (handle))
 298     return;
 299
 300   epoch = vl_msg_api_handle_get_epoch (handle);
 301   client_index = vl_msg_api_handle_get_index (handle);
 302
 303   if (epoch != (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK))
 304     {
 305       clib_warning
 306         ("Stale clnt delete index %d old epoch %d cur epoch %d",
 307          client_index, epoch,
 308          (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK));
 309       return;
 310     }
 311
 312   regpp = am->vl_clients + client_index;
 313
 314   if (!pool_is_free (am->vl_clients, regpp))
 315     {
 316       regp = *regpp;
 317       svm = am->vlib_rp;
 318
 319       /* $$$ check the input queue for e.g. punted sf's */
 320
 321       rp = vl_msg_api_alloc (sizeof (*rp));
 322       rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE_REPLY);
 323       rp->handle = mp->handle;
 324       rp->response = 1;
 325
 326       vl_msg_api_send_shmem (regp->vl_input_queue, (u8 *) & rp);
 327
 328       if (client_index != regp->vl_api_registration_pool_index)
 329         {
 330           clib_warning ("mismatch client_index %d pool_index %d",
 331                         client_index, regp->vl_api_registration_pool_index);
 332           vl_msg_api_free (rp);
 333           return;
 334         }
 335
 336       /* No dangling references, please */
 337       *regpp = 0;
 338
 339       pool_put_index (am->vl_clients, regp->vl_api_registration_pool_index);
 340
 341       pthread_mutex_lock (&svm->mutex);
 342       oldheap = svm_push_data_heap (svm);
 343       /* Poison the old registration */
 344       memset (regp, 0xF1, sizeof (*regp));
 345       clib_mem_free (regp);
 346       pthread_mutex_unlock (&svm->mutex);
 347       svm_pop_heap (oldheap);
 348     }
 349   else
 350     {
 351       clib_warning ("unknown client ID %d", mp->index);
 352     }
 353 }
 354
 355 void
 356 vl_api_get_first_msg_id_t_handler (vl_api_get_first_msg_id_t * mp)
 357 {
 358   vl_api_get_first_msg_id_reply_t *rmp;
 359   unix_shared_memory_queue_t *q;
 360   uword *p;
 361   api_main_t *am = &api_main;
 362   vl_api_msg_range_t *rp;
 363   u8 name[64];
 364   u16 first_msg_id = ~0;
 365   int rv = -7;                  /* VNET_API_ERROR_INVALID_VALUE */
 366
 367   q = vl_api_client_index_to_input_queue (mp->client_index);
 368   if (!q)
 369     return;
 370
 371   if (am->msg_range_by_name == 0)
 372     goto out;
 373
 374   strncpy ((char *) name, (char *) mp->name, ARRAY_LEN (name) - 1);
 375
 376   p = hash_get_mem (am->msg_range_by_name, name);
 377   if (p == 0)
 378     goto out;
 379
 380   rp = vec_elt_at_index (am->msg_ranges, p[0]);
 381
 382   first_msg_id = rp->first_msg_id;
 383   rv = 0;
 384
 385 out:
 386
 387   rmp = vl_msg_api_alloc (sizeof (*rmp));
 388   rmp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID_REPLY);
 389   rmp->context = mp->context;
 390   rmp->retval = ntohl (rv);
 391   rmp->first_msg_id = ntohs (first_msg_id);
 392   vl_msg_api_send_shmem (q, (u8 *) & rmp);
 393 }
 394
 395 #define foreach_vlib_api_msg                    \
 396 _(MEMCLNT_CREATE, memclnt_create)               \
 397 _(MEMCLNT_DELETE, memclnt_delete)               \
 398 _(GET_FIRST_MSG_ID, get_first_msg_id)
 399
 400 /*
 401  * vl_api_init
 402  */
 403 static int
 404 memory_api_init (const char *region_name)
 405 {
 406   int rv;
 407   vl_msg_api_msg_config_t cfg;
 408   vl_msg_api_msg_config_t *c = &cfg;
 409
 410   memset (c, 0, sizeof (*c));
 411
 412   if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
 413     return rv;
 414
 415 #define _(N,n) do {                                             \
 416     c->id = VL_API_##N;                                         \
 417     c->name = #n;                                               \
 418     c->handler = vl_api_##n##_t_handler;                        \
 419     c->cleanup = vl_noop_handler;                               \
 420     c->endian = vl_api_##n##_t_endian;                          \
 421     c->print = vl_api_##n##_t_print;                            \
 422     c->size = sizeof(vl_api_##n##_t);                           \
 423     c->traced = 1; /* trace, so these msgs print */             \
 424     c->replay = 0; /* don't replay client create/delete msgs */ \
 425     c->message_bounce = 0; /* don't bounce this message */      \
 426     vl_msg_api_config(c);} while (0);
 427
 428   foreach_vlib_api_msg;
 429 #undef _
 430
 431   return 0;
 432 }
 433
 434 #define foreach_histogram_bucket                \
 435 _(400)                                          \
 436 _(200)                                          \
 437 _(100)                                          \
 438 _(10)
 439
 440 typedef enum
 441 {
 442 #define _(n) SLEEP_##n##_US,
 443   foreach_histogram_bucket
 444 #undef _
 445     SLEEP_N_BUCKETS,
 446 } histogram_index_t;
 447
 448 static u64 vector_rate_histogram[SLEEP_N_BUCKETS];
 449
 450 static void memclnt_queue_callback (vlib_main_t * vm);
 451
 452 /*
 453  * Callback to send ourselves a plugin numbering-space trace msg
 454  */
 455 static void
 456 send_one_plugin_msg_ids_msg (u8 * name, u16 first_msg_id, u16 last_msg_id)
 457 {
 458   vl_api_trace_plugin_msg_ids_t *mp;
 459   api_main_t *am = &api_main;
 460   vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
 461   unix_shared_memory_queue_t *q;
 462
 463   mp = vl_msg_api_alloc_as_if_client (sizeof (*mp));
 464   memset (mp, 0, sizeof (*mp));
 465
 466   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_TRACE_PLUGIN_MSG_IDS);
 467   strncpy ((char *) mp->plugin_name, (char *) name,
 468            sizeof (mp->plugin_name) - 1);
 469   mp->first_msg_id = clib_host_to_net_u16 (first_msg_id);
 470   mp->last_msg_id = clib_host_to_net_u16 (last_msg_id);
 471
 472   q = shmem_hdr->vl_input_queue;
 473
 474   vl_msg_api_send_shmem (q, (u8 *) & mp);
 475 }
 476
 477 static uword
 478 memclnt_process (vlib_main_t * vm,
 479                  vlib_node_runtime_t * node, vlib_frame_t * f)
 480 {
 481   uword mp;
 482   vl_shmem_hdr_t *shm;
 483   unix_shared_memory_queue_t *q;
 484   clib_error_t *e;
 485   int rv;
 486   api_main_t *am = &api_main;
 487   f64 dead_client_scan_time;
 488   f64 sleep_time, start_time;
 489   f64 vector_rate;
 490   int i;
 491   u8 *serialized_message_table = 0;
 492   svm_region_t *svm;
 493   void *oldheap;
 494
 495   vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
 496
 497   if ((rv = memory_api_init (am->region_name)) < 0)
 498     {
 499       clib_warning ("memory_api_init returned %d, wait for godot...", rv);
 500       vlib_process_suspend (vm, 1e70);
 501     }
 502
 503   shm = am->shmem_hdr;
 504   ASSERT (shm);
 505   q = shm->vl_input_queue;
 506   ASSERT (q);
 507
 508   e = vlib_call_init_exit_functions
 509     (vm, vm->api_init_function_registrations, 1 /* call_once */ );
 510   if (e)
 511     clib_error_report (e);
 512
 513   sleep_time = 20.0;
 514   dead_client_scan_time = vlib_time_now (vm) + 20.0;
 515
 516   /*
 517    * Send plugin message range messages for each plugin we loaded
 518    */
 519   for (i = 0; i < vec_len (am->msg_ranges); i++)
 520     {
 521       vl_api_msg_range_t *rp = am->msg_ranges + i;
 522       send_one_plugin_msg_ids_msg (rp->name, rp->first_msg_id,
 523                                    rp->last_msg_id);
 524     }
 525
 526   /*
 527    * Snapshoot the api message table.
 528    */
 529   serialized_message_table = vl_api_serialize_message_table (am, 0);
 530
 531   svm = am->vlib_rp;
 532   pthread_mutex_lock (&svm->mutex);
 533   oldheap = svm_push_data_heap (svm);
 534
 535   am->serialized_message_table_in_shmem = vec_dup (serialized_message_table);
 536
 537   pthread_mutex_unlock (&svm->mutex);
 538   svm_pop_heap (oldheap);
 539
 540   /*
 541    * Save the api message table snapshot, if configured
 542    */
 543   if (am->save_msg_table_filename)
 544     {
 545       int fd, rv;
 546       u8 *chroot_file;
 547       if (strstr ((char *) am->save_msg_table_filename, "..")
 548           || index ((char *) am->save_msg_table_filename, '/'))
 549         {
 550           clib_warning ("illegal save-message-table filename '%s'",
 551                         am->save_msg_table_filename);
 552           goto skip_save;
 553         }
 554
 555       chroot_file = format (0, "/tmp/%s%c", am->save_msg_table_filename, 0);
 556
 557       fd = creat ((char *) chroot_file, 0644);
 558
 559       if (fd < 0)
 560         {
 561           clib_unix_warning ("creat");
 562           goto skip_save;
 563         }
 564       rv = write (fd, serialized_message_table,
 565                   vec_len (serialized_message_table));
 566
 567       if (rv != vec_len (serialized_message_table))
 568         clib_unix_warning ("write");
 569
 570       rv = close (fd);
 571       if (rv < 0)
 572         clib_unix_warning ("close");
 573
 574       vec_free (chroot_file);
 575     }
 576
 577 skip_save:
 578   vec_free (serialized_message_table);
 579
 580   /* $$$ pay attention to frame size, control CPU usage */
 581   while (1)
 582     {
 583       uword event_type __attribute__ ((unused));
 584       i8 *headp;
 585       int need_broadcast;
 586
 587       /*
 588        * There's a reason for checking the queue before
 589        * sleeping. If the vlib application crashes, it's entirely
 590        * possible for a client to enqueue a connect request
 591        * during the process restart interval.
 592        *
 593        * Unless some force of physics causes the new incarnation
 594        * of the application to process the request, the client will
 595        * sit and wait for Godot...
 596        */
 597       vector_rate = vlib_last_vector_length_per_node (vm);
 598       start_time = vlib_time_now (vm);
 599       while (1)
 600         {
 601           pthread_mutex_lock (&q->mutex);
 602           if (q->cursize == 0)
 603             {
 604               vm->api_queue_nonempty = 0;
 605               pthread_mutex_unlock (&q->mutex);
 606
 607               if (TRACE_VLIB_MEMORY_QUEUE)
 608                 {
 609                   /* *INDENT-OFF* */
 610                   ELOG_TYPE_DECLARE (e) =
 611                     {
 612                       .format = "q-underflow: len %d",
 613                       .format_args = "i4",
 614                     };
 615                   /* *INDENT-ON* */
 616                   struct
 617                   {
 618                     u32 len;
 619                   } *ed;
 620                   ed = ELOG_DATA (&vm->elog_main, e);
 621                   ed->len = 0;
 622                 }
 623               sleep_time = 20.0;
 624               break;
 625             }
 626
 627           headp = (i8 *) (q->data + sizeof (uword) * q->head);
 628           clib_memcpy (&mp, headp, sizeof (uword));
 629
 630           q->head++;
 631           need_broadcast = (q->cursize == q->maxsize / 2);
 632           q->cursize--;
 633
 634           if (PREDICT_FALSE (q->head == q->maxsize))
 635             q->head = 0;
 636           pthread_mutex_unlock (&q->mutex);
 637           if (need_broadcast)
 638             (void) pthread_cond_broadcast (&q->condvar);
 639
 640           vl_msg_api_handler_with_vm_node (am, (void *) mp, vm, node);
 641
 642           /* Allow no more than 10us without a pause */
 643           if (vlib_time_now (vm) > start_time + 10e-6)
 644             {
 645               int index = SLEEP_400_US;
 646               if (vector_rate > 40.0)
 647                 sleep_time = 400e-6;
 648               else if (vector_rate > 20.0)
 649                 {
 650                   index = SLEEP_200_US;
 651                   sleep_time = 200e-6;
 652                 }
 653               else if (vector_rate >= 1.0)
 654                 {
 655                   index = SLEEP_100_US;
 656                   sleep_time = 100e-6;
 657                 }
 658               else
 659                 {
 660                   index = SLEEP_10_US;
 661                   sleep_time = 10e-6;
 662                 }
 663               vector_rate_histogram[index] += 1;
 664               break;
 665             }
 666         }
 667
 668       event_type = vlib_process_wait_for_event_or_clock (vm, sleep_time);
 669       vm->queue_signal_pending = 0;
 670       vlib_process_get_events (vm, 0 /* event_data */ );
 671
 672       if (vlib_time_now (vm) > dead_client_scan_time)
 673         {
 674           vl_api_registration_t **regpp;
 675           vl_api_registration_t *regp;
 676           unix_shared_memory_queue_t *q;
 677           static u32 *dead_indices;
 678           static u32 *confused_indices;
 679
 680           vec_reset_length (dead_indices);
 681           vec_reset_length (confused_indices);
 682
 683           /* *INDENT-OFF* */
 684           pool_foreach (regpp, am->vl_clients,
 685           ({
 686             regp = *regpp;
 687             if (regp)
 688               {
 689                 q = regp->vl_input_queue;
 690                 if (kill (q->consumer_pid, 0) < 0)
 691                   {
 692                     vec_add1(dead_indices, regpp - am->vl_clients);
 693                   }
 694               }
 695             else
 696               {
 697                 clib_warning ("NULL client registration index %d",
 698                               regpp - am->vl_clients);
 699                 vec_add1 (confused_indices, regpp - am->vl_clients);
 700               }
 701           }));
 702           /* *INDENT-ON* */
 703           /* This should "never happen," but if it does, fix it... */
 704           if (PREDICT_FALSE (vec_len (confused_indices) > 0))
 705             {
 706               int i;
 707               for (i = 0; i < vec_len (confused_indices); i++)
 708                 {
 709                   pool_put_index (am->vl_clients, confused_indices[i]);
 710                 }
 711             }
 712
 713           if (PREDICT_FALSE (vec_len (dead_indices) > 0))
 714             {
 715               int i;
 716               svm_region_t *svm;
 717               void *oldheap;
 718
 719               /* Allow the application to clean up its registrations */
 720               for (i = 0; i < vec_len (dead_indices); i++)
 721                 {
 722                   regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
 723                   if (regpp)
 724                     {
 725                       u32 handle;
 726
 727                       handle = vl_msg_api_handle_from_index_and_epoch
 728                         (dead_indices[i], shm->application_restarts);
 729                       (void) call_reaper_functions (handle);
 730                     }
 731                 }
 732
 733               svm = am->vlib_rp;
 734               pthread_mutex_lock (&svm->mutex);
 735               oldheap = svm_push_data_heap (svm);
 736
 737               for (i = 0; i < vec_len (dead_indices); i++)
 738                 {
 739                   regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
 740                   if (regpp)
 741                     {
 742                       /* Poison the old registration */
 743                       memset (*regpp, 0xF3, sizeof (**regpp));
 744                       clib_mem_free (*regpp);
 745                       /* no dangling references, please */
 746                       *regpp = 0;
 747                     }
 748                   else
 749                     {
 750                       svm_pop_heap (oldheap);
 751                       clib_warning ("Duplicate free, client index %d",
 752                                     regpp - am->vl_clients);
 753                       oldheap = svm_push_data_heap (svm);
 754                     }
 755                 }
 756
 757               svm_client_scan_this_region_nolock (am->vlib_rp);
 758
 759               pthread_mutex_unlock (&svm->mutex);
 760               svm_pop_heap (oldheap);
 761               for (i = 0; i < vec_len (dead_indices); i++)
 762                 pool_put_index (am->vl_clients, dead_indices[i]);
 763             }
 764
 765           dead_client_scan_time = vlib_time_now (vm) + 20.0;
 766         }
 767
 768       if (TRACE_VLIB_MEMORY_QUEUE)
 769         {
 770           /* *INDENT-OFF* */
 771           ELOG_TYPE_DECLARE (e) = {
 772             .format = "q-awake: len %d",
 773             .format_args = "i4",
 774           };
 775           /* *INDENT-ON* */
 776           struct
 777           {
 778             u32 len;
 779           } *ed;
 780           ed = ELOG_DATA (&vm->elog_main, e);
 781           ed->len = q->cursize;
 782         }
 783     }
 784
 785   return 0;
 786 }
 787 /* *INDENT-OFF* */
 788 VLIB_REGISTER_NODE (memclnt_node,static) = {
 789     .function = memclnt_process,
 790     .type = VLIB_NODE_TYPE_PROCESS,
 791     .name = "api-rx-from-ring",
 792     .state = VLIB_NODE_STATE_DISABLED,
 793 };
 794 /* *INDENT-ON* */
 795
 796
 797 static clib_error_t *
 798 vl_api_show_histogram_command (vlib_main_t * vm,
 799                                unformat_input_t * input,
 800                                vlib_cli_command_t * cli_cmd)
 801 {
 802   u64 total_counts = 0;
 803   int i;
 804
 805   for (i = 0; i < SLEEP_N_BUCKETS; i++)
 806     {
 807       total_counts += vector_rate_histogram[i];
 808     }
 809
 810   if (total_counts == 0)
 811     {
 812       vlib_cli_output (vm, "No control-plane activity.");
 813       return 0;
 814     }
 815
 816 #define _(n)                                                    \
 817     do {                                                        \
 818         f64 percent;                                            \
 819         percent = ((f64) vector_rate_histogram[SLEEP_##n##_US]) \
 820             / (f64) total_counts;                               \
 821         percent *= 100.0;                                       \
 822         vlib_cli_output (vm, "Sleep %3d us: %llu, %.2f%%",n,    \
 823                          vector_rate_histogram[SLEEP_##n##_US], \
 824                          percent);                              \
 825     } while (0);
 826   foreach_histogram_bucket;
 827 #undef _
 828
 829   return 0;
 830 }
 831
 832 /*?
 833  * Display the binary api sleep-time histogram
 834 ?*/
 835 /* *INDENT-OFF* */
 836 VLIB_CLI_COMMAND (cli_show_api_histogram_command, static) =
 837 {
 838   .path = "show api histogram",
 839   .short_help = "show api histogram",
 840   .function = vl_api_show_histogram_command,
 841 };
 842 /* *INDENT-ON* */
 843
 844 static clib_error_t *
 845 vl_api_clear_histogram_command (vlib_main_t * vm,
 846                                 unformat_input_t * input,
 847                                 vlib_cli_command_t * cli_cmd)
 848 {
 849   int i;
 850
 851   for (i = 0; i < SLEEP_N_BUCKETS; i++)
 852     vector_rate_histogram[i] = 0;
 853   return 0;
 854 }
 855
 856 /*?
 857  * Clear the binary api sleep-time histogram
 858 ?*/
 859 /* *INDENT-OFF* */
 860 VLIB_CLI_COMMAND (cli_clear_api_histogram_command, static) =
 861 {
 862   .path = "clear api histogram",
 863   .short_help = "clear api histogram",
 864   .function = vl_api_clear_histogram_command,
 865 };
 866 /* *INDENT-ON* */
 867
 868 static void
 869 memclnt_queue_callback (vlib_main_t * vm)
 870 {
 871   static volatile int *cursizep;
 872
 873   if (PREDICT_FALSE (cursizep == 0))
 874     {
 875       api_main_t *am = &api_main;
 876       vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
 877       unix_shared_memory_queue_t *q;
 878
 879       if (shmem_hdr == 0)
 880         return;
 881
 882       q = shmem_hdr->vl_input_queue;
 883       if (q == 0)
 884         return;
 885       cursizep = &q->cursize;
 886     }
 887
 888   if (*cursizep >= 1)
 889     {
 890       vm->queue_signal_pending = 1;
 891       vm->api_queue_nonempty = 1;
 892       vlib_process_signal_event (vm, memclnt_node.index,
 893                                  /* event_type */ 0, /* event_data */ 0);
 894     }
 895 }
 896
 897 void
 898 vl_enable_disable_memory_api (vlib_main_t * vm, int enable)
 899 {
 900   vlib_node_set_state (vm, memclnt_node.index,
 901                        (enable
 902                         ? VLIB_NODE_STATE_POLLING
 903                         : VLIB_NODE_STATE_DISABLED));
 904 }
 905
 906 static uword
 907 api_rx_from_node (vlib_main_t * vm,
 908                   vlib_node_runtime_t * node, vlib_frame_t * frame)
 909 {
 910   uword n_packets = frame->n_vectors;
 911   uword n_left_from;
 912   u32 *from;
 913   static u8 *long_msg;
 914
 915   vec_validate (long_msg, 4095);
 916   n_left_from = frame->n_vectors;
 917   from = vlib_frame_args (frame);
 918
 919   while (n_left_from > 0)
 920     {
 921       u32 bi0;
 922       vlib_buffer_t *b0;
 923       void *msg;
 924       uword msg_len;
 925
 926       bi0 = from[0];
 927       b0 = vlib_get_buffer (vm, bi0);
 928       from += 1;
 929       n_left_from -= 1;
 930
 931       msg = b0->data + b0->current_data;
 932       msg_len = b0->current_length;
 933       if (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
 934         {
 935           ASSERT (long_msg != 0);
 936           _vec_len (long_msg) = 0;
 937           vec_add (long_msg, msg, msg_len);
 938           while (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
 939             {
 940               b0 = vlib_get_buffer (vm, b0->next_buffer);
 941               msg = b0->data + b0->current_data;
 942               msg_len = b0->current_length;
 943               vec_add (long_msg, msg, msg_len);
 944             }
 945           msg = long_msg;
 946         }
 947       vl_msg_api_handler_no_trace_no_free (msg);
 948     }
 949
 950   /* Free what we've been given. */
 951   vlib_buffer_free (vm, vlib_frame_args (frame), n_packets);
 952
 953   return n_packets;
 954 }
 955
 956 /* *INDENT-OFF* */
 957 VLIB_REGISTER_NODE (api_rx_from_node_node,static) = {
 958     .function = api_rx_from_node,
 959     .type = VLIB_NODE_TYPE_INTERNAL,
 960     .vector_size = 4,
 961     .name = "api-rx-from-node",
 962 };
 963 /* *INDENT-ON* */
 964
 965 static clib_error_t *
 966 setup_memclnt_exit (vlib_main_t * vm)
 967 {
 968   atexit (vl_unmap_shmem);
 969   return 0;
 970 }
 971
 972 VLIB_INIT_FUNCTION (setup_memclnt_exit);
 973
 974
 975 static clib_error_t *
 976 vl_api_ring_command (vlib_main_t * vm,
 977                      unformat_input_t * input, vlib_cli_command_t * cli_cmd)
 978 {
 979   int i;
 980   ring_alloc_t *ap;
 981   vl_shmem_hdr_t *shmem_hdr;
 982   api_main_t *am = &api_main;
 983
 984   shmem_hdr = am->shmem_hdr;
 985
 986   if (shmem_hdr == 0)
 987     {
 988       vlib_cli_output (vm, "Shared memory segment not initialized...\n");
 989       return 0;
 990     }
 991
 992   vlib_cli_output (vm, "%8s %8s %8s %8s %8s\n",
 993                    "Owner", "Size", "Nitems", "Hits", "Misses");
 994
 995   ap = shmem_hdr->vl_rings;
 996
 997   for (i = 0; i < vec_len (shmem_hdr->vl_rings); i++)
 998     {
 999       vlib_cli_output (vm, "%8s %8d %8d %8d %8d\n",
1000                        "vlib", ap->size, ap->nitems, ap->hits, ap->misses);
1001       ap++;
1002     }
1003
1004   ap = shmem_hdr->client_rings;
1005
1006   for (i = 0; i < vec_len (shmem_hdr->client_rings); i++)
1007     {
1008       vlib_cli_output (vm, "%8s %8d %8d %8d %8d\n",
1009                        "clnt", ap->size, ap->nitems, ap->hits, ap->misses);
1010       ap++;
1011     }
1012
1013   vlib_cli_output (vm, "%d ring miss fallback allocations\n",
1014                    am->ring_misses);
1015
1016   vlib_cli_output
1017     (vm, "%d application restarts, %d reclaimed msgs, %d garbage collects\n",
1018      shmem_hdr->application_restarts,
1019      shmem_hdr->restart_reclaims, shmem_hdr->garbage_collects);
1020   return 0;
1021 }
1022
1023 void dump_socket_clients (vlib_main_t * vm, api_main_t * am)
1024   __attribute__ ((weak));
1025
1026 void
1027 dump_socket_clients (vlib_main_t * vm, api_main_t * am)
1028 {
1029 }
1030
1031 static clib_error_t *
1032 vl_api_client_command (vlib_main_t * vm,
1033                        unformat_input_t * input, vlib_cli_command_t * cli_cmd)
1034 {
1035   vl_api_registration_t **regpp, *regp;
1036   unix_shared_memory_queue_t *q;
1037   char *health;
1038   api_main_t *am = &api_main;
1039   u32 *confused_indices = 0;
1040
1041   if (!pool_elts (am->vl_clients))
1042     goto socket_clients;
1043   vlib_cli_output (vm, "Shared memory clients");
1044   vlib_cli_output (vm, "%16s %8s %14s %18s %s",
1045                    "Name", "PID", "Queue Length", "Queue VA", "Health");
1046
1047   /* *INDENT-OFF* */
1048   pool_foreach (regpp, am->vl_clients,
1049   ({
1050     regp = *regpp;
1051
1052     if (regp)
1053       {
1054         q = regp->vl_input_queue;
1055         if (kill (q->consumer_pid, 0) < 0)
1056           {
1057             health = "DEAD";
1058           }
1059         else
1060           {
1061             health = "alive";
1062           }
1063         vlib_cli_output (vm, "%16s %8d %14d 0x%016llx %s\n",
1064                          regp->name, q->consumer_pid, q->cursize,
1065                          q, health);
1066       }
1067     else
1068       {
1069         clib_warning ("NULL client registration index %d",
1070                       regpp - am->vl_clients);
1071         vec_add1 (confused_indices, regpp - am->vl_clients);
1072       }
1073   }));
1074   /* *INDENT-ON* */
1075
1076   /* This should "never happen," but if it does, fix it... */
1077   if (PREDICT_FALSE (vec_len (confused_indices) > 0))
1078     {
1079       int i;
1080       for (i = 0; i < vec_len (confused_indices); i++)
1081         {
1082           pool_put_index (am->vl_clients, confused_indices[i]);
1083         }
1084     }
1085   vec_free (confused_indices);
1086
1087   if (am->missing_clients)
1088     vlib_cli_output (vm, "%u messages with missing clients",
1089                      am->missing_clients);
1090 socket_clients:
1091   dump_socket_clients (vm, am);
1092
1093   return 0;
1094 }
1095
1096 static clib_error_t *
1097 vl_api_status_command (vlib_main_t * vm,
1098                        unformat_input_t * input, vlib_cli_command_t * cli_cmd)
1099 {
1100   api_main_t *am = &api_main;
1101
1102   // check if rx_trace and tx_trace are not null pointers
1103
1104   if (am->rx_trace == 0)
1105     {
1106       vlib_cli_output (vm, "RX Trace disabled\n");
1107     }
1108   else
1109     {
1110       if (am->rx_trace->enabled == 0)
1111         vlib_cli_output (vm, "RX Trace disabled\n");
1112       else
1113         vlib_cli_output (vm, "RX Trace enabled\n");
1114     }
1115
1116   if (am->tx_trace == 0)
1117     {
1118       vlib_cli_output (vm, "TX Trace disabled\n");
1119     }
1120   else
1121     {
1122       if (am->tx_trace->enabled == 0)
1123         vlib_cli_output (vm, "TX Trace disabled\n");
1124       else
1125         vlib_cli_output (vm, "TX Trace enabled\n");
1126     }
1127
1128   return 0;
1129 }
1130
1131 /* *INDENT-OFF* */
1132 VLIB_CLI_COMMAND (cli_show_api_command, static) =
1133 {
1134   .path = "show api",
1135   .short_help = "Show API information",
1136 };
1137 /* *INDENT-ON* */
1138
1139 /*?
1140  * Display binary api message allocation ring statistics
1141 ?*/
1142 /* *INDENT-OFF* */
1143 VLIB_CLI_COMMAND (cli_show_api_ring_command, static) =
1144 {
1145   .path = "show api ring-stats",
1146   .short_help = "Message ring statistics",
1147   .function = vl_api_ring_command,
1148 };
1149 /* *INDENT-ON* */
1150
1151 /*?
1152  * Display current api client connections
1153 ?*/
1154 /* *INDENT-OFF* */
1155 VLIB_CLI_COMMAND (cli_show_api_clients_command, static) =
1156 {
1157   .path = "show api clients",
1158   .short_help = "Client information",
1159   .function = vl_api_client_command,
1160 };
1161 /* *INDENT-ON* */
1162
1163 /*?
1164  * Display the current api message tracing status
1165 ?*/
1166 /* *INDENT-OFF* */
1167 VLIB_CLI_COMMAND (cli_show_api_status_command, static) =
1168 {
1169   .path = "show api trace-status",
1170   .short_help = "Display API trace status",
1171   .function = vl_api_status_command,
1172 };
1173 /* *INDENT-ON* */
1174
1175 static clib_error_t *
1176 vl_api_message_table_command (vlib_main_t * vm,
1177                               unformat_input_t * input,
1178                               vlib_cli_command_t * cli_cmd)
1179 {
1180   api_main_t *am = &api_main;
1181   int i;
1182   int verbose = 0;
1183
1184   if (unformat (input, "verbose"))
1185     verbose = 1;
1186
1187
1188   if (verbose == 0)
1189     vlib_cli_output (vm, "%-4s %s", "ID", "Name");
1190   else
1191     vlib_cli_output (vm, "%-4s %-40s %6s %7s", "ID", "Name", "Bounce",
1192                      "MP-safe");
1193
1194   for (i = 1; i < vec_len (am->msg_names); i++)
1195     {
1196       if (verbose == 0)
1197         {
1198           vlib_cli_output (vm, "%-4d %s", i,
1199                            am->msg_names[i] ? am->msg_names[i] :
1200                            "  [no handler]");
1201         }
1202       else
1203         {
1204           vlib_cli_output (vm, "%-4d %-40s %6d %7d", i,
1205                            am->msg_names[i] ? am->msg_names[i] :
1206                            "  [no handler]", am->message_bounce[i],
1207                            am->is_mp_safe[i]);
1208         }
1209     }
1210
1211   return 0;
1212 }
1213
1214 /*?
1215  * Display the current api message decode tables
1216 ?*/
1217 /* *INDENT-OFF* */
1218 VLIB_CLI_COMMAND (cli_show_api_message_table_command, static) =
1219 {
1220   .path = "show api message-table",
1221   .short_help = "Message Table",
1222   .function = vl_api_message_table_command,
1223 };
1224 /* *INDENT-ON* */
1225
1226 static clib_error_t *
1227 vl_api_trace_command (vlib_main_t * vm,
1228                       unformat_input_t * input, vlib_cli_command_t * cli_cmd)
1229 {
1230   u32 nitems = 1024;
1231   vl_api_trace_which_t which = VL_API_TRACE_RX;
1232   api_main_t *am = &api_main;
1233
1234   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1235     {
1236       if (unformat (input, "rx nitems %u", &nitems) || unformat (input, "rx"))
1237         goto configure;
1238       else if (unformat (input, "tx nitems %u", &nitems)
1239                || unformat (input, "tx"))
1240         {
1241           which = VL_API_TRACE_RX;
1242           goto configure;
1243         }
1244       else if (unformat (input, "on rx"))
1245         {
1246           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
1247         }
1248       else if (unformat (input, "on tx"))
1249         {
1250           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 1);
1251         }
1252       else if (unformat (input, "on"))
1253         {
1254           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
1255         }
1256       else if (unformat (input, "off"))
1257         {
1258           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
1259           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
1260         }
1261       else if (unformat (input, "free"))
1262         {
1263           vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
1264           vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
1265           vl_msg_api_trace_free (am, VL_API_TRACE_RX);
1266           vl_msg_api_trace_free (am, VL_API_TRACE_TX);
1267         }
1268       else if (unformat (input, "debug on"))
1269         {
1270           am->msg_print_flag = 1;
1271         }
1272       else if (unformat (input, "debug off"))
1273         {
1274           am->msg_print_flag = 0;
1275         }
1276       else
1277         return clib_error_return (0, "unknown input `%U'",
1278                                   format_unformat_error, input);
1279     }
1280   return 0;
1281
1282 configure:
1283   if (vl_msg_api_trace_configure (am, which, nitems))
1284     {
1285       vlib_cli_output (vm, "warning: trace configure error (%d, %d)",
1286                        which, nitems);
1287     }
1288
1289   return 0;
1290 }
1291
1292 /*?
1293  * Control the binary API trace mechanism
1294 ?*/
1295 /* *INDENT-OFF* */
1296 VLIB_CLI_COMMAND (trace, static) =
1297 {
1298   .path = "set api-trace [on][on tx][on rx][off][free][debug on][debug off]",
1299   .short_help = "API trace",
1300   .function = vl_api_trace_command,
1301 };
1302 /* *INDENT-ON* */
1303
1304 clib_error_t *
1305 vlibmemory_init (vlib_main_t * vm)
1306 {
1307   api_main_t *am = &api_main;
1308   svm_map_region_args_t _a, *a = &_a;
1309
1310   memset (a, 0, sizeof (*a));
1311   a->root_path = am->root_path;
1312   a->name = SVM_GLOBAL_REGION_NAME;
1313   a->baseva = (am->global_baseva != 0) ?
1314     am->global_baseva : SVM_GLOBAL_REGION_BASEVA;
1315   a->size = (am->global_size != 0) ? am->global_size : SVM_GLOBAL_REGION_SIZE;
1316   a->flags = SVM_FLAGS_NODATA;
1317   a->uid = am->api_uid;
1318   a->gid = am->api_gid;
1319   a->pvt_heap_size =
1320     (am->global_pvt_heap_size !=
1321      0) ? am->global_pvt_heap_size : SVM_PVT_MHEAP_SIZE;
1322
1323   svm_region_init_args (a);
1324   return 0;
1325 }
1326
1327 VLIB_INIT_FUNCTION (vlibmemory_init);
1328
1329 void
1330 vl_set_memory_region_name (const char *name)
1331 {
1332   api_main_t *am = &api_main;
1333
1334   am->region_name = name;
1335 }
1336
1337 static int
1338 range_compare (vl_api_msg_range_t * a0, vl_api_msg_range_t * a1)
1339 {
1340   int len0, len1, clen;
1341
1342   len0 = vec_len (a0->name);
1343   len1 = vec_len (a1->name);
1344   clen = len0 < len1 ? len0 : len1;
1345   return (strncmp ((char *) a0->name, (char *) a1->name, clen));
1346 }
1347
1348 static u8 *
1349 format_api_msg_range (u8 * s, va_list * args)
1350 {
1351   vl_api_msg_range_t *rp = va_arg (*args, vl_api_msg_range_t *);
1352
1353   if (rp == 0)
1354     s = format (s, "%-50s%9s%9s", "Name", "First-ID", "Last-ID");
1355   else
1356     s = format (s, "%-50s%9d%9d", rp->name, rp->first_msg_id,
1357                 rp->last_msg_id);
1358
1359   return s;
1360 }
1361
1362 static clib_error_t *
1363 vl_api_show_plugin_command (vlib_main_t * vm,
1364                             unformat_input_t * input,
1365                             vlib_cli_command_t * cli_cmd)
1366 {
1367   api_main_t *am = &api_main;
1368   vl_api_msg_range_t *rp = 0;
1369   int i;
1370
1371   if (vec_len (am->msg_ranges) == 0)
1372     {
1373       vlib_cli_output (vm, "No plugin API message ranges configured...");
1374       return 0;
1375     }
1376
1377   rp = vec_dup (am->msg_ranges);
1378
1379   vec_sort_with_function (rp, range_compare);
1380
1381   vlib_cli_output (vm, "Plugin API message ID ranges...\n");
1382   vlib_cli_output (vm, "%U", format_api_msg_range, 0 /* header */ );
1383
1384   for (i = 0; i < vec_len (rp); i++)
1385     vlib_cli_output (vm, "%U", format_api_msg_range, rp + i);
1386
1387   vec_free (rp);
1388
1389   return 0;
1390 }
1391
1392 /*?
1393  * Display the plugin binary API message range table
1394 ?*/
1395 /* *INDENT-OFF* */
1396 VLIB_CLI_COMMAND (cli_show_api_plugin_command, static) =
1397 {
1398   .path = "show api plugin",
1399   .short_help = "show api plugin",
1400   .function = vl_api_show_plugin_command,
1401 };
1402 /* *INDENT-ON* */
1403
1404 static void
1405 vl_api_rpc_call_t_handler (vl_api_rpc_call_t * mp)
1406 {
1407   vl_api_rpc_call_reply_t *rmp;
1408   int (*fp) (void *);
1409   i32 rv = 0;
1410   vlib_main_t *vm = vlib_get_main ();
1411
1412   if (mp->function == 0)
1413     {
1414       rv = -1;
1415       clib_warning ("rpc NULL function pointer");
1416     }
1417
1418   else
1419     {
1420       if (mp->need_barrier_sync)
1421         vlib_worker_thread_barrier_sync (vm);
1422
1423       fp = uword_to_pointer (mp->function, int (*)(void *));
1424       rv = fp (mp->data);
1425
1426       if (mp->need_barrier_sync)
1427         vlib_worker_thread_barrier_release (vm);
1428     }
1429
1430   if (mp->send_reply)
1431     {
1432       unix_shared_memory_queue_t *q =
1433         vl_api_client_index_to_input_queue (mp->client_index);
1434       if (q)
1435         {
1436           rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
1437           rmp->_vl_msg_id = ntohs (VL_API_RPC_CALL_REPLY);
1438           rmp->context = mp->context;
1439           rmp->retval = rv;
1440           vl_msg_api_send_shmem (q, (u8 *) & rmp);
1441         }
1442     }
1443   if (mp->multicast)
1444     {
1445       clib_warning ("multicast not yet implemented...");
1446     }
1447 }
1448
1449 static void
1450 vl_api_rpc_call_reply_t_handler (vl_api_rpc_call_reply_t * mp)
1451 {
1452   clib_warning ("unimplemented");
1453 }
1454
1455 void
1456 vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length)
1457 {
1458   vl_api_rpc_call_t *mp;
1459   api_main_t *am = &api_main;
1460   vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
1461   unix_shared_memory_queue_t *q;
1462
1463   /* Main thread: call the function directly */
1464   if (vlib_get_thread_index () == 0)
1465     {
1466       vlib_main_t *vm = vlib_get_main ();
1467       void (*call_fp) (void *);
1468
1469       vlib_worker_thread_barrier_sync (vm);
1470
1471       call_fp = fp;
1472       call_fp (data);
1473
1474       vlib_worker_thread_barrier_release (vm);
1475       return;
1476     }
1477
1478   /* Any other thread, actually do an RPC call... */
1479   mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + data_length);
1480
1481   memset (mp, 0, sizeof (*mp));
1482   clib_memcpy (mp->data, data, data_length);
1483   mp->_vl_msg_id = ntohs (VL_API_RPC_CALL);
1484   mp->function = pointer_to_uword (fp);
1485   mp->need_barrier_sync = 1;
1486
1487   /*
1488    * Use the "normal" control-plane mechanism for the main thread.
1489    * Well, almost. if the main input queue is full, we cannot
1490    * block. Otherwise, we can expect a barrier sync timeout.
1491    */
1492   q = shmem_hdr->vl_input_queue;
1493
1494   while (pthread_mutex_trylock (&q->mutex))
1495     vlib_worker_thread_barrier_check ();
1496
1497   while (PREDICT_FALSE (unix_shared_memory_queue_is_full (q)))
1498     {
1499       pthread_mutex_unlock (&q->mutex);
1500       vlib_worker_thread_barrier_check ();
1501       while (pthread_mutex_trylock (&q->mutex))
1502         vlib_worker_thread_barrier_check ();
1503     }
1504
1505   vl_msg_api_send_shmem_nolock (q, (u8 *) & mp);
1506
1507   pthread_mutex_unlock (&q->mutex);
1508 }
1509
1510 static void
1511 vl_api_trace_plugin_msg_ids_t_handler (vl_api_trace_plugin_msg_ids_t * mp)
1512 {
1513   api_main_t *am = &api_main;
1514   vl_api_msg_range_t *rp;
1515   uword *p;
1516
1517   /* Noop (except for tracing) during normal operation */
1518   if (am->replay_in_progress == 0)
1519     return;
1520
1521   p = hash_get_mem (am->msg_range_by_name, mp->plugin_name);
1522   if (p == 0)
1523     {
1524       clib_warning ("WARNING: traced plugin '%s' not in current image",
1525                     mp->plugin_name);
1526       return;
1527     }
1528
1529   rp = vec_elt_at_index (am->msg_ranges, p[0]);
1530   if (rp->first_msg_id != clib_net_to_host_u16 (mp->first_msg_id))
1531     {
1532       clib_warning ("WARNING: traced plugin '%s' first message id %d not %d",
1533                     mp->plugin_name, clib_net_to_host_u16 (mp->first_msg_id),
1534                     rp->first_msg_id);
1535     }
1536
1537   if (rp->last_msg_id != clib_net_to_host_u16 (mp->last_msg_id))
1538     {
1539       clib_warning ("WARNING: traced plugin '%s' last message id %d not %d",
1540                     mp->plugin_name, clib_net_to_host_u16 (mp->last_msg_id),
1541                     rp->last_msg_id);
1542     }
1543 }
1544
1545 #define foreach_rpc_api_msg                     \
1546 _(RPC_CALL,rpc_call)                            \
1547 _(RPC_CALL_REPLY,rpc_call_reply)
1548
1549 #define foreach_plugin_trace_msg                \
1550 _(TRACE_PLUGIN_MSG_IDS,trace_plugin_msg_ids)
1551
1552 static clib_error_t *
1553 rpc_api_hookup (vlib_main_t * vm)
1554 {
1555   api_main_t *am = &api_main;
1556 #define _(N,n)                                                  \
1557     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1558                            vl_api_##n##_t_handler,              \
1559                            vl_noop_handler,                     \
1560                            vl_noop_handler,                     \
1561                            vl_api_##n##_t_print,                \
1562                            sizeof(vl_api_##n##_t), 0 /* do not trace */);
1563   foreach_rpc_api_msg;
1564 #undef _
1565
1566 #define _(N,n)                                                  \
1567     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1568                            vl_api_##n##_t_handler,              \
1569                            vl_noop_handler,                     \
1570                            vl_noop_handler,                     \
1571                            vl_api_##n##_t_print,                \
1572                            sizeof(vl_api_##n##_t), 1 /* do trace */);
1573   foreach_plugin_trace_msg;
1574 #undef _
1575
1576   /* No reason to halt the parade to create a trace record... */
1577   am->is_mp_safe[VL_API_TRACE_PLUGIN_MSG_IDS] = 1;
1578
1579   return 0;
1580 }
1581
1582 VLIB_API_INIT_FUNCTION (rpc_api_hookup);
1583
1584 typedef enum
1585 {
1586   DUMP,
1587   CUSTOM_DUMP,
1588   REPLAY,
1589   INITIALIZERS,
1590 } vl_api_replay_t;
1591
1592 u8 *
1593 format_vl_msg_api_trace_status (u8 * s, va_list * args)
1594 {
1595   api_main_t *am = va_arg (*args, api_main_t *);
1596   vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
1597   vl_api_trace_t *tp;
1598   char *trace_name;
1599
1600   switch (which)
1601     {
1602     case VL_API_TRACE_TX:
1603       tp = am->tx_trace;
1604       trace_name = "TX trace";
1605       break;
1606
1607     case VL_API_TRACE_RX:
1608       tp = am->rx_trace;
1609       trace_name = "RX trace";
1610       break;
1611
1612     default:
1613       abort ();
1614     }
1615
1616   if (tp == 0)
1617     {
1618       s = format (s, "%s: not yet configured.\n", trace_name);
1619       return s;
1620     }
1621
1622   s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
1623               trace_name, vec_len (tp->traces), tp->nitems,
1624               tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
1625   return s;
1626 }
1627
1628 void vl_msg_api_custom_dump_configure (api_main_t * am)
1629   __attribute__ ((weak));
1630 void
1631 vl_msg_api_custom_dump_configure (api_main_t * am)
1632 {
1633 }
1634
1635 static void
1636 vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
1637                          u32 first_index, u32 last_index,
1638                          vl_api_replay_t which)
1639 {
1640   vl_api_trace_file_header_t *hp;
1641   int i, fd;
1642   struct stat statb;
1643   size_t file_size;
1644   u8 *msg;
1645   u8 endian_swap_needed = 0;
1646   api_main_t *am = &api_main;
1647   u8 *tmpbuf = 0;
1648   u32 nitems;
1649   void **saved_print_handlers = 0;
1650
1651   fd = open ((char *) filename, O_RDONLY);
1652
1653   if (fd < 0)
1654     {
1655       vlib_cli_output (vm, "Couldn't open %s\n", filename);
1656       return;
1657     }
1658
1659   if (fstat (fd, &statb) < 0)
1660     {
1661       vlib_cli_output (vm, "Couldn't stat %s\n", filename);
1662       close (fd);
1663       return;
1664     }
1665
1666   if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
1667     {
1668       vlib_cli_output (vm, "File not plausible: %s\n", filename);
1669       close (fd);
1670       return;
1671     }
1672
1673   file_size = statb.st_size;
1674   file_size = (file_size + 4095) & ~(4096);
1675
1676   hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
1677
1678   if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
1679     {
1680       vlib_cli_output (vm, "mmap failed: %s\n", filename);
1681       close (fd);
1682       return;
1683     }
1684   close (fd);
1685
1686   if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
1687       || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
1688     endian_swap_needed = 1;
1689
1690   if (endian_swap_needed)
1691     nitems = ntohl (hp->nitems);
1692   else
1693     nitems = hp->nitems;
1694
1695   if (last_index == (u32) ~ 0)
1696     {
1697       last_index = nitems - 1;
1698     }
1699
1700   if (first_index >= nitems || last_index >= nitems)
1701     {
1702       vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
1703                        first_index, last_index, nitems - 1);
1704       munmap (hp, file_size);
1705       return;
1706     }
1707   if (hp->wrapped)
1708     vlib_cli_output (vm,
1709                      "Note: wrapped/incomplete trace, results may vary\n");
1710
1711   if (which == CUSTOM_DUMP)
1712     {
1713       saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
1714       vl_msg_api_custom_dump_configure (am);
1715     }
1716
1717
1718   msg = (u8 *) (hp + 1);
1719
1720   for (i = 0; i < first_index; i++)
1721     {
1722       trace_cfg_t *cfgp;
1723       int size;
1724       u16 msg_id;
1725
1726       size = clib_host_to_net_u32 (*(u32 *) msg);
1727       msg += sizeof (u32);
1728
1729       if (clib_arch_is_little_endian)
1730         msg_id = ntohs (*((u16 *) msg));
1731       else
1732         msg_id = *((u16 *) msg);
1733
1734       cfgp = am->api_trace_cfg + msg_id;
1735       if (!cfgp)
1736         {
1737           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
1738           munmap (hp, file_size);
1739           return;
1740         }
1741       msg += size;
1742     }
1743
1744   if (which == REPLAY)
1745     am->replay_in_progress = 1;
1746
1747   for (; i <= last_index; i++)
1748     {
1749       trace_cfg_t *cfgp;
1750       u16 *msg_idp;
1751       u16 msg_id;
1752       int size;
1753
1754       if (which == DUMP)
1755         vlib_cli_output (vm, "---------- trace %d -----------\n", i);
1756
1757       size = clib_host_to_net_u32 (*(u32 *) msg);
1758       msg += sizeof (u32);
1759
1760       if (clib_arch_is_little_endian)
1761         msg_id = ntohs (*((u16 *) msg));
1762       else
1763         msg_id = *((u16 *) msg);
1764
1765       cfgp = am->api_trace_cfg + msg_id;
1766       if (!cfgp)
1767         {
1768           vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
1769           munmap (hp, file_size);
1770           vec_free (tmpbuf);
1771           am->replay_in_progress = 0;
1772           return;
1773         }
1774
1775       /* Copy the buffer (from the read-only mmap'ed file) */
1776       vec_validate (tmpbuf, size - 1 + sizeof (uword));
1777       clib_memcpy (tmpbuf + sizeof (uword), msg, size);
1778       memset (tmpbuf, 0xf, sizeof (uword));
1779
1780       /*
1781        * Endian swap if needed. All msg data is supposed to be
1782        * in network byte order. All msg handlers are supposed to
1783        * know that. The generic message dumpers don't know that.
1784        * One could fix apigen, I suppose.
1785        */
1786       if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
1787         {
1788           void (*endian_fp) (void *);
1789           if (msg_id >= vec_len (am->msg_endian_handlers)
1790               || (am->msg_endian_handlers[msg_id] == 0))
1791             {
1792               vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
1793               munmap (hp, file_size);
1794               vec_free (tmpbuf);
1795               am->replay_in_progress = 0;
1796               return;
1797             }
1798           endian_fp = am->msg_endian_handlers[msg_id];
1799           (*endian_fp) (tmpbuf + sizeof (uword));
1800         }
1801
1802       /* msg_id always in network byte order */
1803       if (clib_arch_is_little_endian)
1804         {
1805           msg_idp = (u16 *) (tmpbuf + sizeof (uword));
1806           *msg_idp = msg_id;
1807         }
1808
1809       switch (which)
1810         {
1811         case CUSTOM_DUMP:
1812         case DUMP:
1813           if (msg_id < vec_len (am->msg_print_handlers) &&
1814               am->msg_print_handlers[msg_id])
1815             {
1816               u8 *(*print_fp) (void *, void *);
1817
1818               print_fp = (void *) am->msg_print_handlers[msg_id];
1819               (*print_fp) (tmpbuf + sizeof (uword), vm);
1820             }
1821           else
1822             {
1823               vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
1824                                msg_id);
1825               break;
1826             }
1827           break;
1828
1829         case INITIALIZERS:
1830           if (msg_id < vec_len (am->msg_print_handlers) &&
1831               am->msg_print_handlers[msg_id])
1832             {
1833               u8 *s;
1834               int j;
1835               u8 *(*print_fp) (void *, void *);
1836
1837               print_fp = (void *) am->msg_print_handlers[msg_id];
1838
1839               vlib_cli_output (vm, "/*");
1840
1841               (*print_fp) (tmpbuf + sizeof (uword), vm);
1842               vlib_cli_output (vm, "*/\n");
1843
1844               s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
1845                           am->msg_names[msg_id], i,
1846                           am->api_trace_cfg[msg_id].size);
1847
1848               for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
1849                 {
1850                   if ((j & 7) == 0)
1851                     s = format (s, "\n    ");
1852                   s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
1853                 }
1854               s = format (s, "\n};\n%c", 0);
1855               vlib_cli_output (vm, (char *) s);
1856               vec_free (s);
1857             }
1858           break;
1859
1860         case REPLAY:
1861           if (msg_id < vec_len (am->msg_print_handlers) &&
1862               am->msg_print_handlers[msg_id] && cfgp->replay_enable)
1863             {
1864               void (*handler) (void *);
1865
1866               handler = (void *) am->msg_handlers[msg_id];
1867
1868               if (!am->is_mp_safe[msg_id])
1869                 vl_msg_api_barrier_sync ();
1870               (*handler) (tmpbuf + sizeof (uword));
1871               if (!am->is_mp_safe[msg_id])
1872                 vl_msg_api_barrier_release ();
1873             }
1874           else
1875             {
1876               if (cfgp->replay_enable)
1877                 vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
1878                                  msg_id);
1879               break;
1880             }
1881           break;
1882         }
1883
1884       _vec_len (tmpbuf) = 0;
1885       msg += size;
1886     }
1887
1888   if (saved_print_handlers)
1889     {
1890       clib_memcpy (am->msg_print_handlers, saved_print_handlers,
1891                    vec_len (am->msg_print_handlers) * sizeof (void *));
1892       vec_free (saved_print_handlers);
1893     }
1894
1895   munmap (hp, file_size);
1896   vec_free (tmpbuf);
1897   am->replay_in_progress = 0;
1898 }
1899
1900 static clib_error_t *
1901 api_trace_command_fn (vlib_main_t * vm,
1902                       unformat_input_t * input, vlib_cli_command_t * cmd)
1903 {
1904   u32 nitems = 256 << 10;
1905   api_main_t *am = &api_main;
1906   vl_api_trace_which_t which = VL_API_TRACE_RX;
1907   u8 *filename;
1908   u32 first = 0;
1909   u32 last = (u32) ~ 0;
1910   FILE *fp;
1911   int rv;
1912
1913   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1914     {
1915       if (unformat (input, "on") || unformat (input, "enable"))
1916         {
1917           if (unformat (input, "nitems %d", &nitems))
1918             ;
1919           vl_msg_api_trace_configure (am, which, nitems);
1920           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
1921         }
1922       else if (unformat (input, "off"))
1923         {
1924           vl_msg_api_trace_onoff (am, which, 0);
1925         }
1926       else if (unformat (input, "save %s", &filename))
1927         {
1928           u8 *chroot_filename;
1929           if (strstr ((char *) filename, "..")
1930               || index ((char *) filename, '/'))
1931             {
1932               vlib_cli_output (vm, "illegal characters in filename '%s'",
1933                                filename);
1934               return 0;
1935             }
1936
1937           chroot_filename = format (0, "/tmp/%s%c", filename, 0);
1938
1939           vec_free (filename);
1940
1941           fp = fopen ((char *) chroot_filename, "w");
1942           if (fp == NULL)
1943             {
1944               vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
1945               return 0;
1946             }
1947           rv = vl_msg_api_trace_save (am, which, fp);
1948           fclose (fp);
1949           if (rv == -1)
1950             vlib_cli_output (vm, "API Trace data not present\n");
1951           else if (rv == -2)
1952             vlib_cli_output (vm, "File for writing is closed\n");
1953           else if (rv == -10)
1954             vlib_cli_output (vm, "Error while writing header to file\n");
1955           else if (rv == -11)
1956             vlib_cli_output (vm, "Error while writing trace to file\n");
1957           else if (rv == -12)
1958             vlib_cli_output (vm,
1959                              "Error while writing end of buffer trace to file\n");
1960           else if (rv == -13)
1961             vlib_cli_output (vm,
1962                              "Error while writing start of buffer trace to file\n");
1963           else if (rv < 0)
1964             vlib_cli_output (vm, "Unkown error while saving: %d", rv);
1965           else
1966             vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
1967           vec_free (chroot_filename);
1968         }
1969       else if (unformat (input, "dump %s", &filename))
1970         {
1971           vl_msg_api_process_file (vm, filename, first, last, DUMP);
1972         }
1973       else if (unformat (input, "custom-dump %s", &filename))
1974         {
1975           vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
1976         }
1977       else if (unformat (input, "replay %s", &filename))
1978         {
1979           vl_msg_api_process_file (vm, filename, first, last, REPLAY);
1980         }
1981       else if (unformat (input, "initializers %s", &filename))
1982         {
1983           vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
1984         }
1985       else if (unformat (input, "tx"))
1986         {
1987           which = VL_API_TRACE_TX;
1988         }
1989       else if (unformat (input, "first %d", &first))
1990         {
1991           ;
1992         }
1993       else if (unformat (input, "last %d", &last))
1994         {
1995           ;
1996         }
1997       else if (unformat (input, "status"))
1998         {
1999           vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
2000                            am, which);
2001         }
2002       else if (unformat (input, "free"))
2003         {
2004           vl_msg_api_trace_onoff (am, which, 0);
2005           vl_msg_api_trace_free (am, which);
2006         }
2007       else if (unformat (input, "post-mortem-on"))
2008         vl_msg_api_post_mortem_dump_enable_disable (1 /* enable */ );
2009       else if (unformat (input, "post-mortem-off"))
2010         vl_msg_api_post_mortem_dump_enable_disable (0 /* enable */ );
2011       else
2012         return clib_error_return (0, "unknown input `%U'",
2013                                   format_unformat_error, input);
2014     }
2015   return 0;
2016 }
2017
2018 /*?
2019  * Display, replay, or save a binary API trace
2020 ?*/
2021
2022 /* *INDENT-OFF* */
2023 VLIB_CLI_COMMAND (api_trace_command, static) =
2024 {
2025   .path = "api trace",
2026   .short_help =
2027   "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]",
2028   .function = api_trace_command_fn,
2029 };
2030 /* *INDENT-ON* */
2031
2032 static clib_error_t *
2033 api_config_fn (vlib_main_t * vm, unformat_input_t * input)
2034 {
2035   u32 nitems = 256 << 10;
2036   vl_api_trace_which_t which = VL_API_TRACE_RX;
2037   api_main_t *am = &api_main;
2038
2039   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2040     {
2041       if (unformat (input, "on") || unformat (input, "enable"))
2042         {
2043           if (unformat (input, "nitems %d", &nitems))
2044             ;
2045           vl_msg_api_trace_configure (am, which, nitems);
2046           vl_msg_api_trace_onoff (am, which, 1 /* on */ );
2047           vl_msg_api_post_mortem_dump_enable_disable (1 /* enable */ );
2048         }
2049       else if (unformat (input, "save-api-table %s",
2050                          &am->save_msg_table_filename))
2051         ;
2052       else
2053         return clib_error_return (0, "unknown input `%U'",
2054                                   format_unformat_error, input);
2055     }
2056   return 0;
2057 }
2058
2059 /*?
2060  * This module has three configuration parameters:
2061  * "on" or "enable" - enables binary api tracing
2062  * "nitems <nnn>" - sets the size of the circular buffer to <nnn>
2063  * "save-api-table <filename>" - dumps the API message table to /tmp/<filename>
2064 ?*/
2065 VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
2066
2067 static clib_error_t *
2068 api_queue_config_fn (vlib_main_t * vm, unformat_input_t * input)
2069 {
2070   api_main_t *am = &api_main;
2071   u32 nitems;
2072
2073   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2074     {
2075       if (unformat (input, "length %d", &nitems) ||
2076           (unformat (input, "len %d", &nitems)))
2077         {
2078           if (nitems >= 1024)
2079             am->vlib_input_queue_length = nitems;
2080           else
2081             clib_warning ("vlib input queue length %d too small, ignored",
2082                           nitems);
2083         }
2084       else
2085         return clib_error_return (0, "unknown input `%U'",
2086                                   format_unformat_error, input);
2087     }
2088   return 0;
2089 }
2090
2091 VLIB_CONFIG_FUNCTION (api_queue_config_fn, "api-queue");
2092
2093 static u8 *
2094 extract_name (u8 * s)
2095 {
2096   u8 *rv;
2097
2098   rv = vec_dup (s);
2099
2100   while (vec_len (rv) && rv[vec_len (rv)] != '_')
2101     _vec_len (rv)--;
2102
2103   rv[vec_len (rv)] = 0;
2104
2105   return rv;
2106 }
2107
2108 static u8 *
2109 extract_crc (u8 * s)
2110 {
2111   int i;
2112   u8 *rv;
2113
2114   rv = vec_dup (s);
2115
2116   for (i = vec_len (rv) - 1; i >= 0; i--)
2117     {
2118       if (rv[i] == '_')
2119         {
2120           vec_delete (rv, i + 1, 0);
2121           break;
2122         }
2123     }
2124   return rv;
2125 }
2126
2127 typedef struct
2128 {
2129   u8 *name_and_crc;
2130   u8 *name;
2131   u8 *crc;
2132   u32 msg_index;
2133   int which;
2134 } msg_table_unserialize_t;
2135
2136 static int
2137 table_id_cmp (void *a1, void *a2)
2138 {
2139   msg_table_unserialize_t *n1 = a1;
2140   msg_table_unserialize_t *n2 = a2;
2141
2142   return (n1->msg_index - n2->msg_index);
2143 }
2144
2145 static int
2146 table_name_and_crc_cmp (void *a1, void *a2)
2147 {
2148   msg_table_unserialize_t *n1 = a1;
2149   msg_table_unserialize_t *n2 = a2;
2150
2151   return strcmp ((char *) n1->name_and_crc, (char *) n2->name_and_crc);
2152 }
2153
2154 static clib_error_t *
2155 dump_api_table_file_command_fn (vlib_main_t * vm,
2156                                 unformat_input_t * input,
2157                                 vlib_cli_command_t * cmd)
2158 {
2159   u8 *filename = 0;
2160   api_main_t *am = &api_main;
2161   serialize_main_t _sm, *sm = &_sm;
2162   clib_error_t *error;
2163   u32 nmsgs;
2164   u32 msg_index;
2165   u8 *name_and_crc;
2166   int compare_current = 0;
2167   int numeric_sort = 0;
2168   msg_table_unserialize_t *table = 0, *item;
2169   u32 i;
2170   u32 ndifferences = 0;
2171
2172   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2173     {
2174       if (unformat (input, "file %s", &filename))
2175         ;
2176       else if (unformat (input, "compare-current")
2177                || unformat (input, "compare"))
2178         compare_current = 1;
2179       else if (unformat (input, "numeric"))
2180         numeric_sort = 1;
2181       else
2182         return clib_error_return (0, "unknown input `%U'",
2183                                   format_unformat_error, input);
2184     }
2185
2186   if (numeric_sort && compare_current)
2187     return clib_error_return
2188       (0, "Comparison and numeric sorting are incompatible");
2189
2190   if (filename == 0)
2191     return clib_error_return (0, "File not specified");
2192
2193   /* Load the serialized message table from the table dump */
2194
2195   error = unserialize_open_unix_file (sm, (char *) filename);
2196
2197   if (error)
2198     return error;
2199
2200   unserialize_integer (sm, &nmsgs, sizeof (u32));
2201
2202   for (i = 0; i < nmsgs; i++)
2203     {
2204       msg_index = unserialize_likely_small_unsigned_integer (sm);
2205       unserialize_cstring (sm, (char **) &name_and_crc);
2206       vec_add2 (table, item, 1);
2207       item->msg_index = msg_index;
2208       item->name_and_crc = name_and_crc;
2209       item->name = extract_name (name_and_crc);
2210       item->crc = extract_crc (name_and_crc);
2211       item->which = 0;          /* file */
2212     }
2213   serialize_close (sm);
2214
2215   /* Compare with the current image? */
2216   if (compare_current)
2217     {
2218       /* Append the current message table */
2219       u8 *tblv = vec_dup (am->serialized_message_table_in_shmem);
2220
2221       serialize_open_vector (sm, tblv);
2222       unserialize_integer (sm, &nmsgs, sizeof (u32));
2223
2224       for (i = 0; i < nmsgs; i++)
2225         {
2226           msg_index = unserialize_likely_small_unsigned_integer (sm);
2227           unserialize_cstring (sm, (char **) &name_and_crc);
2228
2229           vec_add2 (table, item, 1);
2230           item->msg_index = msg_index;
2231           item->name_and_crc = name_and_crc;
2232           item->name = extract_name (name_and_crc);
2233           item->crc = extract_crc (name_and_crc);
2234           item->which = 1;      /* current_image */
2235         }
2236     }
2237
2238   /* Sort the table. */
2239   if (numeric_sort)
2240     vec_sort_with_function (table, table_id_cmp);
2241   else
2242     vec_sort_with_function (table, table_name_and_crc_cmp);
2243
2244   if (compare_current)
2245     {
2246       ndifferences = 0;
2247
2248       /*
2249        * In this case, the recovered table will have two entries per
2250        * API message. So, if entries i and i+1 match, the message definitions
2251        * are identical. Otherwise, the crc is different, or a message is
2252        * present in only one of the tables.
2253        */
2254       vlib_cli_output (vm, "%=60s %s", "Message Name", "Result");
2255
2256       for (i = 0; i < vec_len (table);)
2257         {
2258           /* Last message lonely? */
2259           if (i == vec_len (table) - 1)
2260             {
2261               ndifferences++;
2262               goto last_unique;
2263             }
2264
2265           /* Identical pair? */
2266           if (!strncmp
2267               ((char *) table[i].name_and_crc,
2268                (char *) table[i + 1].name_and_crc,
2269                vec_len (table[i].name_and_crc)))
2270             {
2271               i += 2;
2272               continue;
2273             }
2274
2275           ndifferences++;
2276
2277           /* Only in one of two tables? */
2278           if (strncmp ((char *) table[i].name, (char *) table[i + 1].name,
2279                        vec_len (table[i].name)))
2280             {
2281             last_unique:
2282               vlib_cli_output (vm, "%-60s only in %s",
2283                                table[i].name, table[i].which ?
2284                                "image" : "file");
2285               i++;
2286               continue;
2287             }
2288           /* In both tables, but with different signatures */
2289           vlib_cli_output (vm, "%-60s definition changed", table[i].name);
2290           i += 2;
2291         }
2292       if (ndifferences == 0)
2293         vlib_cli_output (vm, "No api message signature differences found.");
2294       else
2295         vlib_cli_output (vm, "Found %u api message signature differences",
2296                          ndifferences);
2297       goto cleanup;
2298     }
2299
2300   /* Dump the table, sorted as shown above */
2301   vlib_cli_output (vm, "%=60s %=8s %=10s", "Message name", "MsgID", "CRC");
2302
2303   for (i = 0; i < vec_len (table); i++)
2304     {
2305       item = table + i;
2306       vlib_cli_output (vm, "%-60s %8u %10s", item->name,
2307                        item->msg_index, item->crc);
2308     }
2309
2310 cleanup:
2311   for (i = 0; i < vec_len (table); i++)
2312     {
2313       vec_free (table[i].name_and_crc);
2314       vec_free (table[i].name);
2315       vec_free (table[i].crc);
2316     }
2317
2318   vec_free (table);
2319
2320   return 0;
2321 }
2322
2323 /*?
2324  * Displays a serialized API message decode table, sorted by message name
2325  *
2326  * @cliexpar
2327  * @cliexstart{show api dump file <filename>}
2328  *                                                Message name    MsgID        CRC
2329  * accept_session                                                    407   8e2a127e
2330  * accept_session_reply                                              408   67d8c22a
2331  * add_node_next                                                     549   e4202993
2332  * add_node_next_reply                                               550   e89d6eed
2333  * etc.
2334  * @cliexend
2335 ?*/
2336
2337 /*?
2338  * Compares a serialized API message decode table with the current image
2339  *
2340  * @cliexpar
2341  * @cliexstart{show api dump file <filename> compare}
2342  * ip_add_del_route                                             definition changed
2343  * ip_table_add_del                                             definition changed
2344  * l2_macs_event                                                only in image
2345  * vnet_ip4_fib_counters                                        only in file
2346  * vnet_ip4_nbr_counters                                        only in file
2347  * @cliexend
2348 ?*/
2349
2350 /*?
2351  * Display a serialized API message decode table
2352 ?*/
2353 /* *INDENT-OFF* */
2354 VLIB_CLI_COMMAND (dump_api_table_file, static) =
2355 {
2356   .path = "show api dump",
2357   .short_help = "show api dump file <filename> [numeric | compare-current]",
2358   .function = dump_api_table_file_command_fn,
2359 };
2360 /* *INDENT-ON* */
2361
2362 /*
2363  * fd.io coding-style-patch-verification: ON
2364  *
2365  * Local Variables:
2366  * eval: (c-set-style "gnu")
2367  * End:
2368  */