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