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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
19 #include <vlib/vlib.h>
20 #include <vlibapi/api.h>
21 #include <vlibmemory/api.h>
22 #include <vlibmemory/memory_api.h>
24 #include <vlibmemory/vl_memory_msg_enum.h> /* enumerate all vlib messages */
26 #define vl_typedefs /* define message structures */
27 #include <vlibmemory/vl_memory_api_h.h>
30 /* instantiate all the print functions we know about */
31 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
33 #include <vlibmemory/vl_memory_api_h.h>
36 /* instantiate all the endian swap functions we know about */
38 #include <vlibmemory/vl_memory_api_h.h>
42 vl_api_memclnt_create_t_print (vl_api_memclnt_create_t * a, void *handle)
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);
53 vl_api_memclnt_delete_t_print (vl_api_memclnt_delete_t * a, void *handle)
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);
61 volatile int **vl_api_queue_cursizes;
64 memclnt_queue_callback (vlib_main_t * vm)
67 api_main_t *am = &api_main;
69 if (PREDICT_FALSE (vec_len (vl_api_queue_cursizes) !=
70 1 + vec_len (am->vlib_private_rps)))
72 vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
78 q = shmem_hdr->vl_input_queue;
82 vec_add1 (vl_api_queue_cursizes, &q->cursize);
84 for (i = 0; i < vec_len (am->vlib_private_rps); i++)
86 svm_region_t *vlib_rp = am->vlib_private_rps[i];
88 shmem_hdr = (void *) vlib_rp->user_ctx;
89 q = shmem_hdr->vl_input_queue;
90 vec_add1 (vl_api_queue_cursizes, &q->cursize);
94 for (i = 0; i < vec_len (vl_api_queue_cursizes); i++)
96 if (*vl_api_queue_cursizes[i])
98 vm->queue_signal_pending = 1;
99 vm->api_queue_nonempty = 1;
100 vlib_process_signal_event (vm, vl_api_clnt_node.index,
101 /* event_type */ QUEUE_SIGNAL_EVENT,
109 * vl_api_memclnt_create_internal
112 vl_api_memclnt_create_internal (char *name, svm_queue_t * q)
114 vl_api_registration_t **regpp;
115 vl_api_registration_t *regp;
118 api_main_t *am = &api_main;
120 ASSERT (vlib_get_thread_index () == 0);
121 pool_get (am->vl_clients, regpp);
125 pthread_mutex_lock (&svm->mutex);
126 oldheap = svm_push_data_heap (svm);
127 *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
130 memset (regp, 0, sizeof (*regp));
131 regp->registration_type = REGISTRATION_TYPE_SHMEM;
132 regp->vl_api_registration_pool_index = regpp - am->vl_clients;
134 regp->shmem_hdr = am->shmem_hdr;
136 regp->vl_input_queue = q;
137 regp->name = format (0, "%s%c", name, 0);
139 pthread_mutex_unlock (&svm->mutex);
140 svm_pop_heap (oldheap);
141 return vl_msg_api_handle_from_index_and_epoch
142 (regp->vl_api_registration_pool_index,
143 am->shmem_hdr->application_restarts);
147 * vl_api_memclnt_create_t_handler
150 vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp)
152 vl_api_registration_t **regpp;
153 vl_api_registration_t *regp;
154 vl_api_memclnt_create_reply_t *rp;
159 api_main_t *am = &api_main;
162 * This is tortured. Maintain a vlib-address-space private
163 * pool of client registrations. We use the shared-memory virtual
164 * address of client structure as a handle, to allow direct
165 * manipulation of context quota vbls from the client library.
167 * This scheme causes trouble w/ API message trace replay, since
168 * some random VA from clib_mem_alloc() certainly won't
169 * occur in the Linux sim. The (very) few places
170 * that care need to use the pool index.
172 * Putting the registration object(s) into a pool in shared memory and
173 * using the pool index as a handle seems like a great idea.
174 * Unfortunately, each and every reference to that pool would need
175 * to be protected by a mutex:
179 * convert pool index to
187 pool_get (am->vl_clients, regpp);
191 pthread_mutex_lock (&svm->mutex);
192 oldheap = svm_push_data_heap (svm);
193 *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
196 memset (regp, 0, sizeof (*regp));
197 regp->registration_type = REGISTRATION_TYPE_SHMEM;
198 regp->vl_api_registration_pool_index = regpp - am->vl_clients;
200 regp->shmem_hdr = am->shmem_hdr;
202 q = regp->vl_input_queue = (svm_queue_t *) (uword) mp->input_queue;
204 regp->name = format (0, "%s", mp->name);
205 vec_add1 (regp->name, 0);
207 if (am->serialized_message_table_in_shmem == 0)
208 am->serialized_message_table_in_shmem =
209 vl_api_serialize_message_table (am, 0);
211 pthread_mutex_unlock (&svm->mutex);
212 svm_pop_heap (oldheap);
214 rp = vl_msg_api_alloc (sizeof (*rp));
215 rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_REPLY);
216 rp->handle = (uword) regp;
217 rp->index = vl_msg_api_handle_from_index_and_epoch
218 (regp->vl_api_registration_pool_index,
219 am->shmem_hdr->application_restarts);
220 rp->context = mp->context;
221 rp->response = ntohl (rv);
223 pointer_to_uword (am->serialized_message_table_in_shmem);
225 vl_msg_api_send_shmem (q, (u8 *) & rp);
229 vl_api_call_reaper_functions (u32 client_index)
231 clib_error_t *error = 0;
232 _vl_msg_api_function_list_elt_t *i;
234 i = api_main.reaper_function_registrations;
237 error = i->f (client_index);
239 clib_error_report (error);
240 i = i->next_init_function;
246 * vl_api_memclnt_delete_t_handler
249 vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
251 vl_api_registration_t **regpp;
252 vl_api_registration_t *regp;
253 vl_api_memclnt_delete_reply_t *rp;
256 api_main_t *am = &api_main;
257 u32 handle, client_index, epoch;
261 if (vl_api_call_reaper_functions (handle))
264 epoch = vl_msg_api_handle_get_epoch (handle);
265 client_index = vl_msg_api_handle_get_index (handle);
267 if (epoch != (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK))
270 ("Stale clnt delete index %d old epoch %d cur epoch %d",
272 (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK));
276 regpp = am->vl_clients + client_index;
278 if (!pool_is_free (am->vl_clients, regpp))
283 int private_registration = 0;
286 * Note: the API message handling path will set am->vlib_rp
287 * as appropriate for pairwise / private memory segments
289 rp = vl_msg_api_alloc (sizeof (*rp));
290 rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE_REPLY);
291 rp->handle = mp->handle;
294 vl_msg_api_send_shmem (regp->vl_input_queue, (u8 *) & rp);
296 if (client_index != regp->vl_api_registration_pool_index)
298 clib_warning ("mismatch client_index %d pool_index %d",
299 client_index, regp->vl_api_registration_pool_index);
300 vl_msg_api_free (rp);
304 /* For horizontal scaling, add a hash table... */
305 for (i = 0; i < vec_len (am->vlib_private_rps); i++)
307 /* Is this a pairwise / private API segment? */
308 if (am->vlib_private_rps[i] == svm)
310 /* Note: account for the memfd header page */
311 u64 virtual_base = svm->virtual_base - MMAP_PAGESIZE;
312 u64 virtual_size = svm->virtual_size + MMAP_PAGESIZE;
315 * Kill the registration pool element before we make
316 * the index vanish forever
318 pool_put_index (am->vl_clients,
319 regp->vl_api_registration_pool_index);
321 vec_delete (am->vlib_private_rps, 1, i);
322 /* Kill it, accounting for the memfd header page */
323 if (munmap ((void *) virtual_base, virtual_size) < 0)
324 clib_unix_warning ("munmap");
325 /* Reset the queue-length-address cache */
326 vec_reset_length (vl_api_queue_cursizes);
327 private_registration = 1;
332 /* No dangling references, please */
335 if (private_registration == 0)
337 pool_put_index (am->vl_clients,
338 regp->vl_api_registration_pool_index);
339 pthread_mutex_lock (&svm->mutex);
340 oldheap = svm_push_data_heap (svm);
341 /* Poison the old registration */
342 memset (regp, 0xF1, sizeof (*regp));
343 clib_mem_free (regp);
344 pthread_mutex_unlock (&svm->mutex);
345 svm_pop_heap (oldheap);
347 * These messages must be freed manually, since they're set up
348 * as "bounce" messages. In the private_registration == 1 case,
349 * we kill the shared-memory segment which contains the message
352 vl_msg_api_free (mp);
357 clib_warning ("unknown client ID %d", mp->index);
362 * client answered a ping, stave off the grim reaper...
365 vl_api_memclnt_keepalive_reply_t_handler
366 (vl_api_memclnt_keepalive_reply_t * mp)
368 vl_api_registration_t *regp;
369 vlib_main_t *vm = vlib_get_main ();
371 regp = vl_api_client_index_to_registration (mp->context);
374 regp->last_heard = vlib_time_now (vm);
375 regp->unanswered_pings = 0;
378 clib_warning ("BUG: anonymous memclnt_keepalive_reply");
382 * We can send ourselves these messages if someone uses the
383 * builtin binary api test tool...
386 vl_api_memclnt_keepalive_t_handler (vl_api_memclnt_keepalive_t * mp)
388 vl_api_memclnt_keepalive_reply_t *rmp;
390 vl_shmem_hdr_t *shmem_hdr;
393 shmem_hdr = am->shmem_hdr;
395 rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
396 memset (rmp, 0, sizeof (*rmp));
397 rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
398 rmp->context = mp->context;
399 vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
402 #define foreach_vlib_api_msg \
403 _(MEMCLNT_CREATE, memclnt_create) \
404 _(MEMCLNT_DELETE, memclnt_delete) \
405 _(MEMCLNT_KEEPALIVE, memclnt_keepalive) \
406 _(MEMCLNT_KEEPALIVE_REPLY, memclnt_keepalive_reply) \
412 vl_mem_api_init (const char *region_name)
415 api_main_t *am = &api_main;
416 vl_msg_api_msg_config_t cfg;
417 vl_msg_api_msg_config_t *c = &cfg;
419 vlib_main_t *vm = vlib_get_main ();
421 memset (c, 0, sizeof (*c));
423 if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
426 #define _(N,n) do { \
427 c->id = VL_API_##N; \
429 c->handler = vl_api_##n##_t_handler; \
430 c->cleanup = vl_noop_handler; \
431 c->endian = vl_api_##n##_t_endian; \
432 c->print = vl_api_##n##_t_print; \
433 c->size = sizeof(vl_api_##n##_t); \
434 c->traced = 1; /* trace, so these msgs print */ \
435 c->replay = 0; /* don't replay client create/delete msgs */ \
436 c->message_bounce = 0; /* don't bounce this message */ \
437 vl_msg_api_config(c);} while (0);
439 foreach_vlib_api_msg;
443 * special-case freeing of memclnt_delete messages, so we can
444 * simply munmap pairwise / private API segments...
446 am->message_bounce[VL_API_MEMCLNT_DELETE] = 1;
447 am->is_mp_safe[VL_API_MEMCLNT_KEEPALIVE_REPLY] = 1;
449 vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
452 ASSERT (shm && shm->vl_input_queue);
454 /* Make a note so we can always find the primary region easily */
455 am->vlib_primary_rp = am->vlib_rp;
461 send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
463 vl_api_memclnt_keepalive_t *mp;
465 api_main_t *am = &api_main;
466 svm_region_t *save_vlib_rp = am->vlib_rp;
467 vl_shmem_hdr_t *save_shmem_hdr = am->shmem_hdr;
469 q = regp->vl_input_queue;
472 * If the queue head is moving, assume that the client is processing
473 * messages and skip the ping. This heuristic may fail if the queue
474 * is in the same position as last time, net of wrapping; in which
475 * case, the client will receive a keepalive.
477 if (regp->last_queue_head != q->head)
479 regp->last_heard = now;
480 regp->unanswered_pings = 0;
481 regp->last_queue_head = q->head;
486 * push/pop shared memory segment, so this routine
487 * will work with "normal" as well as "private segment"
491 am->vlib_rp = regp->vlib_rp;
492 am->shmem_hdr = regp->shmem_hdr;
494 mp = vl_msg_api_alloc (sizeof (*mp));
495 memset (mp, 0, sizeof (*mp));
496 mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MEMCLNT_KEEPALIVE);
497 mp->context = mp->client_index =
498 vl_msg_api_handle_from_index_and_epoch
499 (regp->vl_api_registration_pool_index,
500 am->shmem_hdr->application_restarts);
502 regp->unanswered_pings++;
504 /* Failure-to-send due to a stuffed queue is absolutely expected */
505 if (svm_queue_add (q, (u8 *) & mp, 1 /* nowait */ ))
506 vl_msg_api_free (mp);
508 am->vlib_rp = save_vlib_rp;
509 am->shmem_hdr = save_shmem_hdr;
513 vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm, f64 now)
515 vl_api_registration_t **regpp;
516 vl_api_registration_t *regp;
517 static u32 *dead_indices;
518 static u32 *confused_indices;
520 vec_reset_length (dead_indices);
521 vec_reset_length (confused_indices);
524 pool_foreach (regpp, am->vl_clients,
529 /* If we haven't heard from this client recently... */
530 if (regp->last_heard < (now - 10.0))
532 if (regp->unanswered_pings == 2)
535 q = regp->vl_input_queue;
536 if (kill (q->consumer_pid, 0) >=0)
538 clib_warning ("REAPER: lazy binary API client '%s'",
540 regp->unanswered_pings = 0;
541 regp->last_heard = now;
545 clib_warning ("REAPER: binary API client '%s' died",
547 vec_add1(dead_indices, regpp - am->vl_clients);
551 send_memclnt_keepalive (regp, now);
554 regp->unanswered_pings = 0;
558 clib_warning ("NULL client registration index %d",
559 regpp - am->vl_clients);
560 vec_add1 (confused_indices, regpp - am->vl_clients);
564 /* This should "never happen," but if it does, fix it... */
565 if (PREDICT_FALSE (vec_len (confused_indices) > 0))
568 for (i = 0; i < vec_len (confused_indices); i++)
570 pool_put_index (am->vl_clients, confused_indices[i]);
574 if (PREDICT_FALSE (vec_len (dead_indices) > 0))
580 /* Allow the application to clean up its registrations */
581 for (i = 0; i < vec_len (dead_indices); i++)
583 regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
588 handle = vl_msg_api_handle_from_index_and_epoch
589 (dead_indices[i], shm->application_restarts);
590 (void) vl_api_call_reaper_functions (handle);
595 pthread_mutex_lock (&svm->mutex);
596 oldheap = svm_push_data_heap (svm);
598 for (i = 0; i < vec_len (dead_indices); i++)
600 regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
603 /* Is this a pairwise SVM segment? */
604 if ((*regpp)->vlib_rp != svm)
607 svm_region_t *dead_rp = (*regpp)->vlib_rp;
608 /* Note: account for the memfd header page */
609 u64 virtual_base = dead_rp->virtual_base - MMAP_PAGESIZE;
610 u64 virtual_size = dead_rp->virtual_size + MMAP_PAGESIZE;
612 /* For horizontal scaling, add a hash table... */
613 for (i = 0; i < vec_len (am->vlib_private_rps); i++)
614 if (am->vlib_private_rps[i] == dead_rp)
616 vec_delete (am->vlib_private_rps, 1, i);
619 clib_warning ("private rp %llx AWOL", dead_rp);
622 /* Kill it, accounting for the memfd header page */
623 if (munmap ((void *) virtual_base, virtual_size) < 0)
624 clib_unix_warning ("munmap");
625 /* Reset the queue-length-address cache */
626 vec_reset_length (vl_api_queue_cursizes);
630 /* Poison the old registration */
631 memset (*regpp, 0xF3, sizeof (**regpp));
632 clib_mem_free (*regpp);
634 /* no dangling references, please */
639 svm_pop_heap (oldheap);
640 clib_warning ("Duplicate free, client index %d",
641 regpp - am->vl_clients);
642 oldheap = svm_push_data_heap (svm);
646 svm_client_scan_this_region_nolock (am->vlib_rp);
648 pthread_mutex_unlock (&svm->mutex);
649 svm_pop_heap (oldheap);
650 for (i = 0; i < vec_len (dead_indices); i++)
651 pool_put_index (am->vl_clients, dead_indices[i]);
656 void_mem_api_handle_msg_i (api_main_t * am, vlib_main_t * vm,
657 vlib_node_runtime_t * node, svm_queue_t * q)
660 if (!svm_queue_sub2 (q, (u8 *) & mp))
662 vl_msg_api_handler_with_vm_node (am, (void *) mp, vm, node);
669 vl_mem_api_handle_msg_main (vlib_main_t * vm, vlib_node_runtime_t * node)
671 api_main_t *am = &api_main;
672 return void_mem_api_handle_msg_i (am, vm, node,
673 am->shmem_hdr->vl_input_queue);
677 vl_mem_api_handle_msg_private (vlib_main_t * vm, vlib_node_runtime_t * node,
680 api_main_t *am = &api_main;
681 vl_shmem_hdr_t *save_shmem_hdr = am->shmem_hdr;
682 svm_region_t *vlib_rp, *save_vlib_rp = am->vlib_rp;
686 vlib_rp = am->vlib_rp = am->vlib_private_rps[reg_index];
688 am->shmem_hdr = (void *) vlib_rp->user_ctx;
689 q = am->shmem_hdr->vl_input_queue;
691 rv = void_mem_api_handle_msg_i (am, vm, node, q);
693 am->shmem_hdr = save_shmem_hdr;
694 am->vlib_rp = save_vlib_rp;
699 vl_api_registration_t *
700 vl_mem_api_client_index_to_registration (u32 handle)
702 vl_api_registration_t **regpp;
703 vl_api_registration_t *regp;
704 api_main_t *am = &api_main;
707 index = vl_msg_api_handle_get_index (handle);
708 if ((am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK)
709 != vl_msg_api_handle_get_epoch (handle))
711 vl_msg_api_increment_missing_client_counter ();
715 regpp = am->vl_clients + index;
717 if (pool_is_free (am->vl_clients, regpp))
719 vl_msg_api_increment_missing_client_counter ();
727 vl_api_client_index_to_input_queue (u32 index)
729 vl_api_registration_t *regp;
730 api_main_t *am = &api_main;
732 /* Special case: vlib trying to send itself a message */
733 if (index == (u32) ~ 0)
734 return (am->shmem_hdr->vl_input_queue);
736 regp = vl_mem_api_client_index_to_registration (index);
739 return (regp->vl_input_queue);
742 static clib_error_t *
743 setup_memclnt_exit (vlib_main_t * vm)
745 atexit (vl_unmap_shmem);
749 VLIB_INIT_FUNCTION (setup_memclnt_exit);
752 format_api_message_rings (u8 * s, va_list * args)
754 api_main_t *am = va_arg (*args, api_main_t *);
755 vl_shmem_hdr_t *shmem_hdr = va_arg (*args, vl_shmem_hdr_t *);
756 int main_segment = va_arg (*args, int);
761 return format (s, "%8s %8s %8s %8s %8s\n",
762 "Owner", "Size", "Nitems", "Hits", "Misses");
764 ap = shmem_hdr->vl_rings;
766 for (i = 0; i < vec_len (shmem_hdr->vl_rings); i++)
768 s = format (s, "%8s %8d %8d %8d %8d\n",
769 "vlib", ap->size, ap->nitems, ap->hits, ap->misses);
773 ap = shmem_hdr->client_rings;
775 for (i = 0; i < vec_len (shmem_hdr->client_rings); i++)
777 s = format (s, "%8s %8d %8d %8d %8d\n",
778 "clnt", ap->size, ap->nitems, ap->hits, ap->misses);
784 s = format (s, "%d ring miss fallback allocations\n", am->ring_misses);
787 "%d application restarts, %d reclaimed msgs, %d garbage collects\n",
788 shmem_hdr->application_restarts, shmem_hdr->restart_reclaims,
789 shmem_hdr->garbage_collects);
794 static clib_error_t *
795 vl_api_ring_command (vlib_main_t * vm,
796 unformat_input_t * input, vlib_cli_command_t * cli_cmd)
799 vl_shmem_hdr_t *shmem_hdr;
800 api_main_t *am = &api_main;
802 /* First, dump the primary region rings.. */
804 if (am->vlib_primary_rp == 0 || am->vlib_primary_rp->user_ctx == 0)
806 vlib_cli_output (vm, "Shared memory segment not initialized...\n");
810 shmem_hdr = (void *) am->vlib_primary_rp->user_ctx;
812 vlib_cli_output (vm, "Main API segment rings:");
814 vlib_cli_output (vm, "%U", format_api_message_rings, am,
815 0 /* print header */ , 0 /* notused */ );
817 vlib_cli_output (vm, "%U", format_api_message_rings, am,
818 shmem_hdr, 1 /* main segment */ );
820 for (i = 0; i < vec_len (am->vlib_private_rps); i++)
822 svm_region_t *vlib_rp = am->vlib_private_rps[i];
823 shmem_hdr = (void *) vlib_rp->user_ctx;
824 vl_api_registration_t **regpp;
825 vl_api_registration_t *regp = 0;
827 /* For horizontal scaling, add a hash table... */
829 pool_foreach (regpp, am->vl_clients,
832 if (regp && regp->vlib_rp == vlib_rp)
834 vlib_cli_output (vm, "%s segment rings:", regp->name);
838 vlib_cli_output (vm, "regp %llx not found?", regp);
842 vlib_cli_output (vm, "%U", format_api_message_rings, am,
843 0 /* print header */ , 0 /* notused */ );
844 vlib_cli_output (vm, "%U", format_api_message_rings, am,
845 shmem_hdr, 0 /* main segment */ );
852 * Display binary api message allocation ring statistics
855 VLIB_CLI_COMMAND (cli_show_api_ring_command, static) =
857 .path = "show api ring-stats",
858 .short_help = "Message ring statistics",
859 .function = vl_api_ring_command,
864 vlibmemory_init (vlib_main_t * vm)
866 api_main_t *am = &api_main;
867 svm_map_region_args_t _a, *a = &_a;
870 memset (a, 0, sizeof (*a));
871 a->root_path = am->root_path;
872 a->name = SVM_GLOBAL_REGION_NAME;
873 a->baseva = (am->global_baseva != 0) ?
874 am->global_baseva : +svm_get_global_region_base_va ();
875 a->size = (am->global_size != 0) ? am->global_size : SVM_GLOBAL_REGION_SIZE;
876 a->flags = SVM_FLAGS_NODATA;
877 a->uid = am->api_uid;
878 a->gid = am->api_gid;
880 (am->global_pvt_heap_size !=
881 0) ? am->global_pvt_heap_size : SVM_PVT_MHEAP_SIZE;
883 svm_region_init_args (a);
885 error = vlib_call_init_function (vm, vlibsocket_init);
890 VLIB_INIT_FUNCTION (vlibmemory_init);
893 vl_set_memory_region_name (const char *name)
895 api_main_t *am = &api_main;
896 am->region_name = name;
900 * fd.io coding-style-patch-verification: ON
903 * eval: (c-set-style "gnu")