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