src/vlibmemory/memory_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2018 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17 #include <signal.h>
  18
  19 #include <vlib/vlib.h>
  20 #include <vlibapi/api.h>
  21 #include <vlibmemory/api.h>
  22 #include <vlibmemory/memory_api.h>
  23
  24 #include <vlibmemory/vl_memory_msg_enum.h>      /* enumerate all vlib messages */
  25
  26 #define vl_typedefs             /* define message structures */
  27 #include <vlibmemory/vl_memory_api_h.h>
  28 #undef vl_typedefs
  29
  30 /* instantiate all the print functions we know about */
  31 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  32 #define vl_printfun
  33 #include <vlibmemory/vl_memory_api_h.h>
  34 #undef vl_printfun
  35
  36 /* instantiate all the endian swap functions we know about */
  37 #define vl_endianfun
  38 #include <vlibmemory/vl_memory_api_h.h>
  39 #undef vl_endianfun
  40
  41 volatile int **vl_api_queue_cursizes;
  42
  43 static void
  44 memclnt_queue_callback (vlib_main_t * vm)
  45 {
  46   int i;
  47   api_main_t *am = vlibapi_get_main ();
  48   int have_pending_rpcs;
  49
  50   if (PREDICT_FALSE (vec_len (vl_api_queue_cursizes) !=
  51                      1 + vec_len (am->vlib_private_rps)))
  52     {
  53       vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
  54       svm_queue_t *q;
  55
  56       if (shmem_hdr == 0)
  57         return;
  58
  59       q = shmem_hdr->vl_input_queue;
  60       if (q == 0)
  61         return;
  62
  63       vec_add1 (vl_api_queue_cursizes, &q->cursize);
  64
  65       for (i = 0; i < vec_len (am->vlib_private_rps); i++)
  66         {
  67           svm_region_t *vlib_rp = am->vlib_private_rps[i];
  68
  69           shmem_hdr = (void *) vlib_rp->user_ctx;
  70           q = shmem_hdr->vl_input_queue;
  71           vec_add1 (vl_api_queue_cursizes, &q->cursize);
  72         }
  73     }
  74
  75   for (i = 0; i < vec_len (vl_api_queue_cursizes); i++)
  76     {
  77       if (*vl_api_queue_cursizes[i])
  78         {
  79           vm->queue_signal_pending = 1;
  80           vm->api_queue_nonempty = 1;
  81           vlib_process_signal_event (vm, vl_api_clnt_node.index,
  82                                      /* event_type */ QUEUE_SIGNAL_EVENT,
  83                                      /* event_data */ 0);
  84           break;
  85         }
  86     }
  87
  88   clib_spinlock_lock_if_init (&vm->pending_rpc_lock);
  89   have_pending_rpcs = vec_len (vm->pending_rpc_requests) > 0;
  90   clib_spinlock_unlock_if_init (&vm->pending_rpc_lock);
  91
  92   if (have_pending_rpcs)
  93     {
  94       vm->queue_signal_pending = 1;
  95       vm->api_queue_nonempty = 1;
  96       vlib_process_signal_event (vm, vl_api_clnt_node.index,
  97                                  /* event_type */ QUEUE_SIGNAL_EVENT,
  98                                  /* event_data */ 0);
  99     }
 100 }
 101
 102 /*
 103  * vl_api_memclnt_create_internal
 104  */
 105 u32
 106 vl_api_memclnt_create_internal (char *name, svm_queue_t * q)
 107 {
 108   vl_api_registration_t **regpp;
 109   vl_api_registration_t *regp;
 110   void *oldheap;
 111   api_main_t *am = vlibapi_get_main ();
 112
 113   ASSERT (vlib_get_thread_index () == 0);
 114   pool_get (am->vl_clients, regpp);
 115
 116
 117   oldheap = vl_msg_push_heap ();
 118   *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
 119
 120   regp = *regpp;
 121   clib_memset (regp, 0, sizeof (*regp));
 122   regp->registration_type = REGISTRATION_TYPE_SHMEM;
 123   regp->vl_api_registration_pool_index = regpp - am->vl_clients;
 124   regp->vlib_rp = am->vlib_rp;
 125   regp->shmem_hdr = am->shmem_hdr;
 126
 127   regp->vl_input_queue = q;
 128   regp->name = format (0, "%s%c", name, 0);
 129
 130   vl_msg_pop_heap (oldheap);
 131   return vl_msg_api_handle_from_index_and_epoch
 132     (regp->vl_api_registration_pool_index,
 133      am->shmem_hdr->application_restarts);
 134 }
 135
 136 /*
 137  * vl_api_memclnt_create_t_handler
 138  */
 139 void
 140 vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp)
 141 {
 142   vl_api_registration_t **regpp;
 143   vl_api_registration_t *regp;
 144   vl_api_memclnt_create_reply_t *rp;
 145   svm_queue_t *q;
 146   int rv = 0;
 147   void *oldheap;
 148   api_main_t *am = vlibapi_get_main ();
 149   u8 *msg_table;
 150
 151   /*
 152    * This is tortured. Maintain a vlib-address-space private
 153    * pool of client registrations. We use the shared-memory virtual
 154    * address of client structure as a handle, to allow direct
 155    * manipulation of context quota vbls from the client library.
 156    *
 157    * This scheme causes trouble w/ API message trace replay, since
 158    * some random VA from clib_mem_alloc() certainly won't
 159    * occur in the Linux sim. The (very) few places
 160    * that care need to use the pool index.
 161    *
 162    * Putting the registration object(s) into a pool in shared memory and
 163    * using the pool index as a handle seems like a great idea.
 164    * Unfortunately, each and every reference to that pool would need
 165    * to be protected by a mutex:
 166    *
 167    *     Client                      VLIB
 168    *     ------                      ----
 169    *     convert pool index to
 170    *     pointer.
 171    *     <deschedule>
 172    *                                 expand pool
 173    *                                 <deschedule>
 174    *     kaboom!
 175    */
 176
 177   pool_get (am->vl_clients, regpp);
 178
 179   oldheap = vl_msg_push_heap ();
 180   *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
 181
 182   regp = *regpp;
 183   clib_memset (regp, 0, sizeof (*regp));
 184   regp->registration_type = REGISTRATION_TYPE_SHMEM;
 185   regp->vl_api_registration_pool_index = regpp - am->vl_clients;
 186   regp->vlib_rp = am->vlib_rp;
 187   regp->shmem_hdr = am->shmem_hdr;
 188   regp->clib_file_index = am->shmem_hdr->clib_file_index;
 189
 190   q = regp->vl_input_queue = (svm_queue_t *) (uword) mp->input_queue;
 191   VL_MSG_API_SVM_QUEUE_UNPOISON (q);
 192
 193   regp->name = format (0, "%s", mp->name);
 194   vec_add1 (regp->name, 0);
 195   regp->keepalive = true;
 196
 197   if (am->serialized_message_table_in_shmem == 0)
 198     am->serialized_message_table_in_shmem =
 199       vl_api_serialize_message_table (am, 0);
 200
 201   if (am->vlib_rp != am->vlib_primary_rp)
 202     msg_table = vl_api_serialize_message_table (am, 0);
 203   else
 204     msg_table = am->serialized_message_table_in_shmem;
 205
 206   vl_msg_pop_heap (oldheap);
 207
 208   rp = vl_msg_api_alloc (sizeof (*rp));
 209   rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_REPLY);
 210   rp->handle = (uword) regp;
 211   rp->index = vl_msg_api_handle_from_index_and_epoch
 212     (regp->vl_api_registration_pool_index,
 213      am->shmem_hdr->application_restarts);
 214   rp->context = mp->context;
 215   rp->response = ntohl (rv);
 216   rp->message_table = pointer_to_uword (msg_table);
 217
 218   vl_msg_api_send_shmem (q, (u8 *) & rp);
 219 }
 220
 221 void
 222 vl_api_memclnt_create_v2_t_handler (vl_api_memclnt_create_v2_t *mp)
 223 {
 224   vl_api_registration_t **regpp;
 225   vl_api_registration_t *regp;
 226   vl_api_memclnt_create_v2_reply_t *rp;
 227   svm_queue_t *q;
 228   int rv = 0;
 229   void *oldheap;
 230   api_main_t *am = vlibapi_get_main ();
 231   u8 *msg_table;
 232
 233   /*
 234    * This is tortured. Maintain a vlib-address-space private
 235    * pool of client registrations. We use the shared-memory virtual
 236    * address of client structure as a handle, to allow direct
 237    * manipulation of context quota vbls from the client library.
 238    *
 239    * This scheme causes trouble w/ API message trace replay, since
 240    * some random VA from clib_mem_alloc() certainly won't
 241    * occur in the Linux sim. The (very) few places
 242    * that care need to use the pool index.
 243    *
 244    * Putting the registration object(s) into a pool in shared memory and
 245    * using the pool index as a handle seems like a great idea.
 246    * Unfortunately, each and every reference to that pool would need
 247    * to be protected by a mutex:
 248    *
 249    *     Client                      VLIB
 250    *     ------                      ----
 251    *     convert pool index to
 252    *     pointer.
 253    *     <deschedule>
 254    *                                 expand pool
 255    *                                 <deschedule>
 256    *     kaboom!
 257    */
 258
 259   pool_get (am->vl_clients, regpp);
 260
 261   oldheap = vl_msg_push_heap ();
 262   *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
 263
 264   regp = *regpp;
 265   clib_memset (regp, 0, sizeof (*regp));
 266   regp->registration_type = REGISTRATION_TYPE_SHMEM;
 267   regp->vl_api_registration_pool_index = regpp - am->vl_clients;
 268   regp->vlib_rp = am->vlib_rp;
 269   regp->shmem_hdr = am->shmem_hdr;
 270   regp->clib_file_index = am->shmem_hdr->clib_file_index;
 271
 272   q = regp->vl_input_queue = (svm_queue_t *) (uword) mp->input_queue;
 273   VL_MSG_API_SVM_QUEUE_UNPOISON (q);
 274
 275   regp->name = format (0, "%s", mp->name);
 276   vec_add1 (regp->name, 0);
 277   regp->keepalive = mp->keepalive;
 278
 279   if (am->serialized_message_table_in_shmem == 0)
 280     am->serialized_message_table_in_shmem =
 281       vl_api_serialize_message_table (am, 0);
 282
 283   if (am->vlib_rp != am->vlib_primary_rp)
 284     msg_table = vl_api_serialize_message_table (am, 0);
 285   else
 286     msg_table = am->serialized_message_table_in_shmem;
 287
 288   vl_msg_pop_heap (oldheap);
 289
 290   rp = vl_msg_api_alloc (sizeof (*rp));
 291   rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_V2_REPLY);
 292   rp->handle = (uword) regp;
 293   rp->index = vl_msg_api_handle_from_index_and_epoch (
 294     regp->vl_api_registration_pool_index, am->shmem_hdr->application_restarts);
 295   rp->context = mp->context;
 296   rp->response = ntohl (rv);
 297   rp->message_table = pointer_to_uword (msg_table);
 298
 299   vl_msg_api_send_shmem (q, (u8 *) &rp);
 300 }
 301
 302 void
 303 vl_api_call_reaper_functions (u32 client_index)
 304 {
 305   clib_error_t *error = 0;
 306   _vl_msg_api_function_list_elt_t *i;
 307
 308   i = vlibapi_get_main ()->reaper_function_registrations;
 309   while (i)
 310     {
 311       error = i->f (client_index);
 312       if (error)
 313         clib_error_report (error);
 314       i = i->next_init_function;
 315     }
 316 }
 317
 318 /*
 319  * vl_api_memclnt_delete_t_handler
 320  */
 321 void
 322 vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
 323 {
 324   vl_api_registration_t **regpp;
 325   vl_api_registration_t *regp;
 326   vl_api_memclnt_delete_reply_t *rp;
 327   void *oldheap;
 328   api_main_t *am = vlibapi_get_main ();
 329   u32 handle, client_index, epoch;
 330
 331   handle = mp->index;
 332
 333   vl_api_call_reaper_functions (handle);
 334
 335   epoch = vl_msg_api_handle_get_epoch (handle);
 336   client_index = vl_msg_api_handle_get_index (handle);
 337
 338   if (epoch != (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK))
 339     {
 340       clib_warning
 341         ("Stale clnt delete index %d old epoch %d cur epoch %d",
 342          client_index, epoch,
 343          (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK));
 344       return;
 345     }
 346
 347   regpp = pool_elt_at_index (am->vl_clients, client_index);
 348
 349   if (!pool_is_free (am->vl_clients, regpp))
 350     {
 351       int i;
 352       regp = *regpp;
 353       int private_registration = 0;
 354
 355       /* Send reply unless client asked us to do the cleanup */
 356       if (!mp->do_cleanup)
 357         {
 358           /*
 359            * Note: the API message handling path will set am->vlib_rp
 360            * as appropriate for pairwise / private memory segments
 361            */
 362           rp = vl_msg_api_alloc (sizeof (*rp));
 363           rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE_REPLY);
 364           rp->handle = mp->handle;
 365           rp->response = 1;
 366
 367           vl_msg_api_send_shmem (regp->vl_input_queue, (u8 *) & rp);
 368           if (client_index != regp->vl_api_registration_pool_index)
 369             {
 370               clib_warning ("mismatch client_index %d pool_index %d",
 371                             client_index,
 372                             regp->vl_api_registration_pool_index);
 373               vl_msg_api_free (rp);
 374               return;
 375             }
 376         }
 377
 378       /* No dangling references, please */
 379       *regpp = 0;
 380
 381       /* For horizontal scaling, add a hash table... */
 382       for (i = 0; i < vec_len (am->vlib_private_rps); i++)
 383         {
 384           /* Is this a pairwise / private API segment? */
 385           if (am->vlib_private_rps[i] == am->vlib_rp)
 386             {
 387               /* Note: account for the memfd header page */
 388               uword virtual_base = am->vlib_rp->virtual_base - MMAP_PAGESIZE;
 389               uword virtual_size = am->vlib_rp->virtual_size + MMAP_PAGESIZE;
 390
 391               /*
 392                * Kill the registration pool element before we make
 393                * the index vanish forever
 394                */
 395               pool_put_index (am->vl_clients,
 396                               regp->vl_api_registration_pool_index);
 397
 398               vec_delete (am->vlib_private_rps, 1, i);
 399               /* Kill it, accounting for the memfd header page */
 400               if (munmap ((void *) virtual_base, virtual_size) < 0)
 401                 clib_unix_warning ("munmap");
 402               /* Reset the queue-length-address cache */
 403               vec_reset_length (vl_api_queue_cursizes);
 404               private_registration = 1;
 405               break;
 406             }
 407         }
 408
 409       if (private_registration == 0)
 410         {
 411           pool_put_index (am->vl_clients,
 412                           regp->vl_api_registration_pool_index);
 413           oldheap = vl_msg_push_heap ();
 414           if (mp->do_cleanup)
 415             svm_queue_free (regp->vl_input_queue);
 416           vec_free (regp->name);
 417           /* Poison the old registration */
 418           clib_memset (regp, 0xF1, sizeof (*regp));
 419           clib_mem_free (regp);
 420           vl_msg_pop_heap (oldheap);
 421           /*
 422            * These messages must be freed manually, since they're set up
 423            * as "bounce" messages. In the private_registration == 1 case,
 424            * we kill the shared-memory segment which contains the message
 425            * with munmap.
 426            */
 427           vl_msg_api_free (mp);
 428         }
 429     }
 430   else
 431     {
 432       clib_warning ("unknown client ID %d", mp->index);
 433     }
 434 }
 435
 436 /**
 437  * client answered a ping, stave off the grim reaper...
 438  */
 439 void
 440   vl_api_memclnt_keepalive_reply_t_handler
 441   (vl_api_memclnt_keepalive_reply_t * mp)
 442 {
 443   vl_api_registration_t *regp;
 444   vlib_main_t *vm = vlib_get_main ();
 445
 446   regp = vl_api_client_index_to_registration (mp->context);
 447   if (regp)
 448     {
 449       regp->last_heard = vlib_time_now (vm);
 450       regp->unanswered_pings = 0;
 451     }
 452   else
 453     clib_warning ("BUG: anonymous memclnt_keepalive_reply");
 454 }
 455
 456 /**
 457  * We can send ourselves these messages if someone uses the
 458  * builtin binary api test tool...
 459  */
 460 static void
 461 vl_api_memclnt_keepalive_t_handler (vl_api_memclnt_keepalive_t * mp)
 462 {
 463   vl_api_memclnt_keepalive_reply_t *rmp;
 464   api_main_t *am;
 465   vl_shmem_hdr_t *shmem_hdr;
 466
 467   am = vlibapi_get_main ();
 468   shmem_hdr = am->shmem_hdr;
 469
 470   rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
 471   clib_memset (rmp, 0, sizeof (*rmp));
 472   rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
 473   rmp->context = mp->context;
 474   vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
 475 }
 476
 477 /*
 478  * To avoid filling the API trace buffer with boring messages,
 479  * don't trace memclnt_keepalive[_reply] msgs
 480  */
 481
 482 #define foreach_vlib_api_msg                                                  \
 483   _ (MEMCLNT_CREATE, memclnt_create, 0)                                       \
 484   _ (MEMCLNT_CREATE_V2, memclnt_create_v2, 0)                                 \
 485   _ (MEMCLNT_DELETE, memclnt_delete, 0)                                       \
 486   _ (MEMCLNT_KEEPALIVE, memclnt_keepalive, 0)                                 \
 487   _ (MEMCLNT_KEEPALIVE_REPLY, memclnt_keepalive_reply, 0)
 488
 489 /*
 490  * memory_api_init
 491  */
 492 int
 493 vl_mem_api_init (const char *region_name)
 494 {
 495   int rv;
 496   api_main_t *am = vlibapi_get_main ();
 497   vl_msg_api_msg_config_t cfg;
 498   vl_msg_api_msg_config_t *c = &cfg;
 499   vl_shmem_hdr_t *shm;
 500   vlib_main_t *vm = vlib_get_main ();
 501
 502   clib_memset (c, 0, sizeof (*c));
 503
 504   if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
 505     return rv;
 506
 507 #define _(N,n,t) do {                                            \
 508     c->id = VL_API_##N;                                         \
 509     c->name = #n;                                               \
 510     c->handler = vl_api_##n##_t_handler;                        \
 511     c->cleanup = vl_noop_handler;                               \
 512     c->endian = vl_api_##n##_t_endian;                          \
 513     c->print = vl_api_##n##_t_print;                            \
 514     c->size = sizeof(vl_api_##n##_t);                           \
 515     c->traced = t; /* trace, so these msgs print */             \
 516     c->replay = 0; /* don't replay client create/delete msgs */ \
 517     c->message_bounce = 0; /* don't bounce this message */      \
 518     vl_msg_api_config(c);} while (0);
 519
 520   foreach_vlib_api_msg;
 521 #undef _
 522
 523 #define vl_msg_name_crc_list
 524 #include <vlibmemory/memclnt.api.h>
 525 #undef vl_msg_name_crc_list
 526
 527 #define _(id, n, crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
 528   foreach_vl_msg_name_crc_memclnt;
 529 #undef _
 530
 531   /*
 532    * special-case freeing of memclnt_delete messages, so we can
 533    * simply munmap pairwise / private API segments...
 534    */
 535   am->message_bounce[VL_API_MEMCLNT_DELETE] = 1;
 536   am->is_mp_safe[VL_API_MEMCLNT_KEEPALIVE_REPLY] = 1;
 537   am->is_mp_safe[VL_API_MEMCLNT_KEEPALIVE] = 1;
 538
 539   vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
 540
 541   shm = am->shmem_hdr;
 542   ASSERT (shm && shm->vl_input_queue);
 543
 544   /* Make a note so we can always find the primary region easily */
 545   am->vlib_primary_rp = am->vlib_rp;
 546
 547   return 0;
 548 }
 549
 550 clib_error_t *
 551 map_api_segment_init (vlib_main_t * vm)
 552 {
 553   api_main_t *am = vlibapi_get_main ();
 554   int rv;
 555
 556   if ((rv = vl_mem_api_init (am->region_name)) < 0)
 557     {
 558       return clib_error_return (0, "vl_mem_api_init (%s) failed",
 559                                 am->region_name);
 560     }
 561   return 0;
 562 }
 563
 564 static void
 565 send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
 566 {
 567   vl_api_memclnt_keepalive_t *mp;
 568   svm_queue_t *q;
 569   api_main_t *am = vlibapi_get_main ();
 570
 571   q = regp->vl_input_queue;
 572
 573   /*
 574    * If the queue head is moving, assume that the client is processing
 575    * messages and skip the ping. This heuristic may fail if the queue
 576    * is in the same position as last time, net of wrapping; in which
 577    * case, the client will receive a keepalive.
 578    */
 579   if (regp->last_queue_head != q->head)
 580     {
 581       regp->last_heard = now;
 582       regp->unanswered_pings = 0;
 583       regp->last_queue_head = q->head;
 584       return;
 585     }
 586
 587   /*
 588    * push/pop shared memory segment, so this routine
 589    * will work with "normal" as well as "private segment"
 590    * memory clients..
 591    */
 592
 593   mp = vl_mem_api_alloc_as_if_client_w_reg (regp, sizeof (*mp));
 594   clib_memset (mp, 0, sizeof (*mp));
 595   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MEMCLNT_KEEPALIVE);
 596   mp->context = mp->client_index =
 597     vl_msg_api_handle_from_index_and_epoch
 598     (regp->vl_api_registration_pool_index,
 599      am->shmem_hdr->application_restarts);
 600
 601   regp->unanswered_pings++;
 602
 603   /* Failure-to-send due to a stuffed queue is absolutely expected */
 604   if (svm_queue_add (q, (u8 *) & mp, 1 /* nowait */ ))
 605     vl_msg_api_free_w_region (regp->vlib_rp, mp);
 606 }
 607
 608 static void
 609 vl_mem_send_client_keepalive_w_reg (api_main_t * am, f64 now,
 610                                     vl_api_registration_t ** regpp,
 611                                     u32 ** dead_indices,
 612                                     u32 ** confused_indices)
 613 {
 614   vl_api_registration_t *regp = *regpp;
 615   if (regp)
 616     {
 617       /* If we haven't heard from this client recently... */
 618       if (regp->last_heard < (now - 10.0))
 619         {
 620           if (regp->unanswered_pings == 2)
 621             {
 622               svm_queue_t *q;
 623               q = regp->vl_input_queue;
 624               if (kill (q->consumer_pid, 0) >= 0)
 625                 {
 626                   clib_warning ("REAPER: lazy binary API client '%s'",
 627                                 regp->name);
 628                   regp->unanswered_pings = 0;
 629                   regp->last_heard = now;
 630                 }
 631               else
 632                 {
 633                   clib_warning ("REAPER: binary API client '%s' died",
 634                                 regp->name);
 635                   vec_add1 (*dead_indices, regpp - am->vl_clients);
 636                 }
 637             }
 638           else
 639             send_memclnt_keepalive (regp, now);
 640         }
 641       else
 642         regp->unanswered_pings = 0;
 643     }
 644   else
 645     {
 646       clib_warning ("NULL client registration index %d",
 647                     regpp - am->vl_clients);
 648       vec_add1 (*confused_indices, regpp - am->vl_clients);
 649     }
 650 }
 651
 652 void
 653 vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm, f64 now)
 654 {
 655   vl_api_registration_t **regpp;
 656   static u32 *dead_indices;
 657   static u32 *confused_indices;
 658
 659   vec_reset_length (dead_indices);
 660   vec_reset_length (confused_indices);
 661
 662   /* *INDENT-OFF* */
 663   pool_foreach (regpp, am->vl_clients)  {
 664       if (!(*regpp)->keepalive)
 665         continue;
 666       vl_mem_send_client_keepalive_w_reg (am, now, regpp, &dead_indices,
 667                                           &confused_indices);
 668   }
 669   /* *INDENT-ON* */
 670
 671   /* This should "never happen," but if it does, fix it... */
 672   if (PREDICT_FALSE (vec_len (confused_indices) > 0))
 673     {
 674       int i;
 675       for (i = 0; i < vec_len (confused_indices); i++)
 676         {
 677           pool_put_index (am->vl_clients, confused_indices[i]);
 678         }
 679     }
 680
 681   if (PREDICT_FALSE (vec_len (dead_indices) > 0))
 682     {
 683       int i;
 684       void *oldheap;
 685
 686       /* Allow the application to clean up its registrations */
 687       for (i = 0; i < vec_len (dead_indices); i++)
 688         {
 689           regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
 690           if (regpp)
 691             {
 692               u32 handle;
 693
 694               handle = vl_msg_api_handle_from_index_and_epoch
 695                 (dead_indices[i], shm->application_restarts);
 696               vl_api_call_reaper_functions (handle);
 697             }
 698         }
 699
 700       oldheap = vl_msg_push_heap ();
 701
 702       for (i = 0; i < vec_len (dead_indices); i++)
 703         {
 704           regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
 705           if (regpp)
 706             {
 707               /* Is this a pairwise SVM segment? */
 708               if ((*regpp)->vlib_rp != am->vlib_rp)
 709                 {
 710                   int i;
 711                   svm_region_t *dead_rp = (*regpp)->vlib_rp;
 712                   /* Note: account for the memfd header page */
 713                   uword virtual_base = dead_rp->virtual_base - MMAP_PAGESIZE;
 714                   uword virtual_size = dead_rp->virtual_size + MMAP_PAGESIZE;
 715
 716                   /* For horizontal scaling, add a hash table... */
 717                   for (i = 0; i < vec_len (am->vlib_private_rps); i++)
 718                     if (am->vlib_private_rps[i] == dead_rp)
 719                       {
 720                         vec_delete (am->vlib_private_rps, 1, i);
 721                         goto found;
 722                       }
 723                   svm_pop_heap (oldheap);
 724                   clib_warning ("private rp %llx AWOL", dead_rp);
 725                   oldheap = svm_push_data_heap (am->vlib_rp);
 726
 727                 found:
 728                   /* Kill it, accounting for the memfd header page */
 729                   svm_pop_heap (oldheap);
 730                   if (munmap ((void *) virtual_base, virtual_size) < 0)
 731                     clib_unix_warning ("munmap");
 732                   /* Reset the queue-length-address cache */
 733                   vec_reset_length (vl_api_queue_cursizes);
 734                   oldheap = svm_push_data_heap (am->vlib_rp);
 735                 }
 736               else
 737                 {
 738                   /* Poison the old registration */
 739                   clib_memset (*regpp, 0xF3, sizeof (**regpp));
 740                   clib_mem_free (*regpp);
 741                 }
 742               /* no dangling references, please */
 743               *regpp = 0;
 744             }
 745           else
 746             {
 747               svm_pop_heap (oldheap);
 748               clib_warning ("Duplicate free, client index %d",
 749                             regpp - am->vl_clients);
 750               oldheap = svm_push_data_heap (am->vlib_rp);
 751             }
 752         }
 753
 754       svm_client_scan_this_region_nolock (am->vlib_rp);
 755
 756       vl_msg_pop_heap (oldheap);
 757       for (i = 0; i < vec_len (dead_indices); i++)
 758         pool_put_index (am->vl_clients, dead_indices[i]);
 759     }
 760 }
 761
 762 void (*vl_mem_api_fuzz_hook) (u16, void *);
 763
 764 /* This is only to be called from a vlib/vnet app */
 765 static void
 766 vl_mem_api_handler_with_vm_node (api_main_t *am, svm_region_t *vlib_rp,
 767                                  void *the_msg, vlib_main_t *vm,
 768                                  vlib_node_runtime_t *node, u8 is_private)
 769 {
 770   u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
 771   u8 *(*handler) (void *, void *, void *);
 772   u8 *(*print_fp) (void *, void *);
 773   svm_region_t *old_vlib_rp;
 774   void *save_shmem_hdr;
 775   int is_mp_safe = 1;
 776
 777   if (PREDICT_FALSE (am->elog_trace_api_messages))
 778     {
 779       ELOG_TYPE_DECLARE (e) = {
 780         .format = "api-msg: %s",
 781         .format_args = "T4",
 782       };
 783       struct
 784       {
 785         u32 c;
 786       } * ed;
 787       ed = ELOG_DATA (am->elog_main, e);
 788       if (id < vec_len (am->msg_names) && am->msg_names[id])
 789         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 790       else
 791         ed->c = elog_string (am->elog_main, "BOGUS");
 792     }
 793
 794   if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
 795     {
 796       handler = (void *) am->msg_handlers[id];
 797
 798       if (PREDICT_FALSE (am->rx_trace && am->rx_trace->enabled))
 799         vl_msg_api_trace (am, am->rx_trace, the_msg);
 800
 801       if (PREDICT_FALSE (am->msg_print_flag))
 802         {
 803           fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
 804           print_fp = (void *) am->msg_print_handlers[id];
 805           if (print_fp == 0)
 806             {
 807               fformat (stdout, "  [no registered print fn for msg %d]\n", id);
 808             }
 809           else
 810             {
 811               (*print_fp) (the_msg, vm);
 812             }
 813         }
 814       is_mp_safe = am->is_mp_safe[id];
 815
 816       if (!is_mp_safe)
 817         {
 818           vl_msg_api_barrier_trace_context (am->msg_names[id]);
 819           vl_msg_api_barrier_sync ();
 820         }
 821       if (is_private)
 822         {
 823           old_vlib_rp = am->vlib_rp;
 824           save_shmem_hdr = am->shmem_hdr;
 825           am->vlib_rp = vlib_rp;
 826           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 827         }
 828
 829       if (PREDICT_FALSE (vl_mem_api_fuzz_hook != 0))
 830         (*vl_mem_api_fuzz_hook) (id, the_msg);
 831
 832       if (am->is_autoendian[id])
 833         {
 834           void (*endian_fp) (void *);
 835           endian_fp = am->msg_endian_handlers[id];
 836           (*endian_fp) (the_msg);
 837         }
 838       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 839         clib_call_callbacks (am->perf_counter_cbs, am, id, 0 /* before */);
 840
 841       (*handler) (the_msg, vm, node);
 842
 843       if (PREDICT_FALSE (vec_len (am->perf_counter_cbs) != 0))
 844         clib_call_callbacks (am->perf_counter_cbs, am, id, 1 /* after */);
 845       if (is_private)
 846         {
 847           am->vlib_rp = old_vlib_rp;
 848           am->shmem_hdr = save_shmem_hdr;
 849         }
 850       if (!is_mp_safe)
 851         vl_msg_api_barrier_release ();
 852     }
 853   else
 854     {
 855       clib_warning ("no handler for msg id %d", id);
 856     }
 857
 858   /*
 859    * Special-case, so we can e.g. bounce messages off the vnet
 860    * main thread without copying them...
 861    */
 862   if (id >= vec_len (am->message_bounce) || !(am->message_bounce[id]))
 863     {
 864       if (is_private)
 865         {
 866           old_vlib_rp = am->vlib_rp;
 867           save_shmem_hdr = am->shmem_hdr;
 868           am->vlib_rp = vlib_rp;
 869           am->shmem_hdr = (void *) vlib_rp->user_ctx;
 870         }
 871       vl_msg_api_free (the_msg);
 872       if (is_private)
 873         {
 874           am->vlib_rp = old_vlib_rp;
 875           am->shmem_hdr = save_shmem_hdr;
 876         }
 877     }
 878
 879   if (PREDICT_FALSE (am->elog_trace_api_messages))
 880     {
 881       ELOG_TYPE_DECLARE (e) = { .format = "api-msg-done(%s): %s",
 882                                 .format_args = "t4T4",
 883                                 .n_enum_strings = 2,
 884                                 .enum_strings = {
 885                                   "barrier",
 886                                   "mp-safe",
 887                                 } };
 888
 889       struct
 890       {
 891         u32 barrier;
 892         u32 c;
 893       } * ed;
 894       ed = ELOG_DATA (am->elog_main, e);
 895       if (id < vec_len (am->msg_names) && am->msg_names[id])
 896         ed->c = elog_string (am->elog_main, (char *) am->msg_names[id]);
 897       else
 898         ed->c = elog_string (am->elog_main, "BOGUS");
 899       ed->barrier = is_mp_safe;
 900     }
 901 }
 902
 903 static inline int
 904 void_mem_api_handle_msg_i (api_main_t * am, svm_region_t * vlib_rp,
 905                            vlib_main_t * vm, vlib_node_runtime_t * node,
 906                            u8 is_private)
 907 {
 908   svm_queue_t *q;
 909   uword mp;
 910
 911   q = ((vl_shmem_hdr_t *) (void *) vlib_rp->user_ctx)->vl_input_queue;
 912
 913   if (!svm_queue_sub2 (q, (u8 *) & mp))
 914     {
 915       VL_MSG_API_UNPOISON ((void *) mp);
 916       vl_mem_api_handler_with_vm_node (am, vlib_rp, (void *) mp, vm, node,
 917                                        is_private);
 918       return 0;
 919     }
 920   return -1;
 921 }
 922
 923 int
 924 vl_mem_api_handle_msg_main (vlib_main_t * vm, vlib_node_runtime_t * node)
 925 {
 926   api_main_t *am = vlibapi_get_main ();
 927   return void_mem_api_handle_msg_i (am, am->vlib_rp, vm, node,
 928                                     0 /* is_private */ );
 929 }
 930
 931 int
 932 vl_mem_api_handle_rpc (vlib_main_t * vm, vlib_node_runtime_t * node)
 933 {
 934   api_main_t *am = vlibapi_get_main ();
 935   int i;
 936   uword *tmp, mp;
 937
 938   /*
 939    * Swap pending and processing vectors, then process the RPCs
 940    * Avoid deadlock conditions by construction.
 941    */
 942   clib_spinlock_lock_if_init (&vm->pending_rpc_lock);
 943   tmp = vm->processing_rpc_requests;
 944   vec_reset_length (tmp);
 945   vm->processing_rpc_requests = vm->pending_rpc_requests;
 946   vm->pending_rpc_requests = tmp;
 947   clib_spinlock_unlock_if_init (&vm->pending_rpc_lock);
 948
 949   /*
 950    * RPCs are used to reflect function calls to thread 0
 951    * when the underlying code is not thread-safe.
 952    *
 953    * Grabbing the thread barrier across a set of RPCs
 954    * greatly increases efficiency, and avoids
 955    * running afoul of the barrier sync holddown timer.
 956    * The barrier sync code supports recursive locking.
 957    *
 958    * We really need to rewrite RPC-based code...
 959    */
 960   if (PREDICT_TRUE (vec_len (vm->processing_rpc_requests)))
 961     {
 962       vl_msg_api_barrier_sync ();
 963       for (i = 0; i < vec_len (vm->processing_rpc_requests); i++)
 964         {
 965           mp = vm->processing_rpc_requests[i];
 966           vl_mem_api_handler_with_vm_node (am, am->vlib_rp, (void *) mp, vm,
 967                                            node, 0 /* is_private */);
 968         }
 969       vl_msg_api_barrier_release ();
 970     }
 971
 972   return 0;
 973 }
 974
 975 int
 976 vl_mem_api_handle_msg_private (vlib_main_t * vm, vlib_node_runtime_t * node,
 977                                u32 reg_index)
 978 {
 979   api_main_t *am = vlibapi_get_main ();
 980   return void_mem_api_handle_msg_i (am, am->vlib_private_rps[reg_index], vm,
 981                                     node, 1 /* is_private */ );
 982 }
 983
 984 vl_api_registration_t *
 985 vl_mem_api_client_index_to_registration (u32 handle)
 986 {
 987   vl_api_registration_t **regpp;
 988   vl_api_registration_t *regp;
 989   api_main_t *am = vlibapi_get_main ();
 990   vl_shmem_hdr_t *shmem_hdr;
 991   u32 index;
 992
 993   index = vl_msg_api_handle_get_index (handle);
 994   regpp = am->vl_clients + index;
 995
 996   if (pool_is_free (am->vl_clients, regpp))
 997     {
 998       vl_msg_api_increment_missing_client_counter ();
 999       return 0;
1000     }
1001   regp = *regpp;
1002
1003   shmem_hdr = (vl_shmem_hdr_t *) regp->shmem_hdr;
1004   if (!vl_msg_api_handle_is_valid (handle, shmem_hdr->application_restarts))
1005     {
1006       vl_msg_api_increment_missing_client_counter ();
1007       return 0;
1008     }
1009
1010   return (regp);
1011 }
1012
1013 svm_queue_t *
1014 vl_api_client_index_to_input_queue (u32 index)
1015 {
1016   vl_api_registration_t *regp;
1017   api_main_t *am = vlibapi_get_main ();
1018
1019   /* Special case: vlib trying to send itself a message */
1020   if (index == (u32) ~ 0)
1021     return (am->shmem_hdr->vl_input_queue);
1022
1023   regp = vl_mem_api_client_index_to_registration (index);
1024   if (!regp)
1025     return 0;
1026   return (regp->vl_input_queue);
1027 }
1028
1029 static clib_error_t *
1030 setup_memclnt_exit (vlib_main_t * vm)
1031 {
1032   atexit (vl_unmap_shmem_client);
1033   return 0;
1034 }
1035
1036 VLIB_INIT_FUNCTION (setup_memclnt_exit);
1037
1038 u8 *
1039 format_api_message_rings (u8 * s, va_list * args)
1040 {
1041   api_main_t *am = va_arg (*args, api_main_t *);
1042   vl_shmem_hdr_t *shmem_hdr = va_arg (*args, vl_shmem_hdr_t *);
1043   int main_segment = va_arg (*args, int);
1044   ring_alloc_t *ap;
1045   int i;
1046
1047   if (shmem_hdr == 0)
1048     return format (s, "%8s %8s %8s %8s %8s\n",
1049                    "Owner", "Size", "Nitems", "Hits", "Misses");
1050
1051   ap = shmem_hdr->vl_rings;
1052
1053   for (i = 0; i < vec_len (shmem_hdr->vl_rings); i++)
1054     {
1055       s = format (s, "%8s %8d %8d %8d %8d\n",
1056                   "vlib", ap->size, ap->nitems, ap->hits, ap->misses);
1057       ap++;
1058     }
1059
1060   ap = shmem_hdr->client_rings;
1061
1062   for (i = 0; i < vec_len (shmem_hdr->client_rings); i++)
1063     {
1064       s = format (s, "%8s %8d %8d %8d %8d\n",
1065                   "clnt", ap->size, ap->nitems, ap->hits, ap->misses);
1066       ap++;
1067     }
1068
1069   if (main_segment)
1070     {
1071       s = format (s, "%d ring miss fallback allocations\n", am->ring_misses);
1072       s = format
1073         (s,
1074          "%d application restarts, %d reclaimed msgs, %d garbage collects\n",
1075          shmem_hdr->application_restarts, shmem_hdr->restart_reclaims,
1076          shmem_hdr->garbage_collects);
1077     }
1078   return s;
1079 }
1080
1081 static clib_error_t *
1082 vl_api_ring_command (vlib_main_t * vm,
1083                      unformat_input_t * input, vlib_cli_command_t * cli_cmd)
1084 {
1085   int i;
1086   vl_shmem_hdr_t *shmem_hdr;
1087   api_main_t *am = vlibapi_get_main ();
1088
1089   /* First, dump the primary region rings.. */
1090
1091   if (am->vlib_primary_rp == 0 || am->vlib_primary_rp->user_ctx == 0)
1092     {
1093       vlib_cli_output (vm, "Shared memory segment not initialized...\n");
1094       return 0;
1095     }
1096
1097   shmem_hdr = (void *) am->vlib_primary_rp->user_ctx;
1098
1099   vlib_cli_output (vm, "Main API segment rings:");
1100
1101   vlib_cli_output (vm, "%U", format_api_message_rings, am,
1102                    0 /* print header */ , 0 /* notused */ );
1103
1104   vlib_cli_output (vm, "%U", format_api_message_rings, am,
1105                    shmem_hdr, 1 /* main segment */ );
1106
1107   for (i = 0; i < vec_len (am->vlib_private_rps); i++)
1108     {
1109       svm_region_t *vlib_rp = am->vlib_private_rps[i];
1110       shmem_hdr = (void *) vlib_rp->user_ctx;
1111       vl_api_registration_t **regpp;
1112       vl_api_registration_t *regp = 0;
1113
1114       /* For horizontal scaling, add a hash table... */
1115       /* *INDENT-OFF* */
1116       pool_foreach (regpp, am->vl_clients)
1117        {
1118         regp = *regpp;
1119         if (regp && regp->vlib_rp == vlib_rp)
1120           {
1121             vlib_cli_output (vm, "%s segment rings:", regp->name);
1122             goto found;
1123           }
1124       }
1125       vlib_cli_output (vm, "regp %llx not found?", regp);
1126       continue;
1127       /* *INDENT-ON* */
1128     found:
1129       vlib_cli_output (vm, "%U", format_api_message_rings, am,
1130                        0 /* print header */ , 0 /* notused */ );
1131       vlib_cli_output (vm, "%U", format_api_message_rings, am,
1132                        shmem_hdr, 0 /* main segment */ );
1133     }
1134
1135   return 0;
1136 }
1137
1138 /*?
1139  * Display binary api message allocation ring statistics
1140 ?*/
1141 /* *INDENT-OFF* */
1142 VLIB_CLI_COMMAND (cli_show_api_ring_command, static) =
1143 {
1144   .path = "show api ring-stats",
1145   .short_help = "Message ring statistics",
1146   .function = vl_api_ring_command,
1147 };
1148 /* *INDENT-ON* */
1149
1150 clib_error_t *
1151 vlibmemory_init (vlib_main_t * vm)
1152 {
1153   api_main_t *am = vlibapi_get_main ();
1154   svm_map_region_args_t _a, *a = &_a;
1155   u8 *remove_path1, *remove_path2;
1156   void vlibsocket_reference (void);
1157
1158   vlibsocket_reference ();
1159
1160   /*
1161    * By popular request / to avoid support fires, remove any old api segment
1162    * files Right Here.
1163    */
1164   if (am->root_path == 0)
1165     {
1166       remove_path1 = format (0, "/dev/shm/global_vm%c", 0);
1167       remove_path2 = format (0, "/dev/shm/vpe-api%c", 0);
1168     }
1169   else
1170     {
1171       remove_path1 = format (0, "/dev/shm/%s-global_vm%c", am->root_path, 0);
1172       remove_path2 = format (0, "/dev/shm/%s-vpe-api%c", am->root_path, 0);
1173     }
1174
1175   (void) unlink ((char *) remove_path1);
1176   (void) unlink ((char *) remove_path2);
1177
1178   vec_free (remove_path1);
1179   vec_free (remove_path2);
1180
1181   clib_memset (a, 0, sizeof (*a));
1182   a->root_path = am->root_path;
1183   a->name = SVM_GLOBAL_REGION_NAME;
1184   a->baseva = (am->global_baseva != 0) ?
1185     am->global_baseva : +svm_get_global_region_base_va ();
1186   a->size = (am->global_size != 0) ? am->global_size : SVM_GLOBAL_REGION_SIZE;
1187   a->flags = SVM_FLAGS_NODATA;
1188   a->uid = am->api_uid;
1189   a->gid = am->api_gid;
1190   a->pvt_heap_size =
1191     (am->global_pvt_heap_size !=
1192      0) ? am->global_pvt_heap_size : SVM_PVT_MHEAP_SIZE;
1193
1194   svm_region_init_args (a);
1195
1196   return 0;
1197 }
1198
1199 void
1200 vl_set_memory_region_name (const char *name)
1201 {
1202   api_main_t *am = vlibapi_get_main ();
1203   am->region_name = name;
1204 }
1205
1206 /*
1207  * fd.io coding-style-patch-verification: ON
1208  *
1209  * Local Variables:
1210  * eval: (c-set-style "gnu")
1211  * End:
1212  */