blob: 8c6469080d7a612c0749a7cc2bd45a1b70048032 [file] [log] [blame]
Dave Barach371e4e12016-07-08 09:38:52 -04001/*
Ed Warnickecb9cada2015-12-08 15:45:58 -07002 *------------------------------------------------------------------
3 * memclnt_shared.c - API message handling, common code for both clients
4 * and the vlib process itself.
Dave Barach371e4e12016-07-08 09:38:52 -04005 *
Ed Warnickecb9cada2015-12-08 15:45:58 -07006 *
7 * Copyright (c) 2009 Cisco and/or its affiliates.
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at:
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *------------------------------------------------------------------
20 */
21
22#include <stdio.h>
23#include <stdlib.h>
Ole Troan6855f6c2016-04-09 03:16:30 +020024#include <stddef.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070025#include <string.h>
26#include <unistd.h>
27#include <signal.h>
28#include <vppinfra/format.h>
29#include <vppinfra/byte_order.h>
30#include <vppinfra/error.h>
31#include <vlib/vlib.h>
32#include <vlib/unix/unix.h>
33#include <vlibmemory/api.h>
34#include <vlibmemory/unix_shared_memory_queue.h>
35
Dave Barach371e4e12016-07-08 09:38:52 -040036#include <vlibmemory/vl_memory_msg_enum.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070037
Dave Barach371e4e12016-07-08 09:38:52 -040038#define vl_typedefs
Ed Warnickecb9cada2015-12-08 15:45:58 -070039#include <vlibmemory/vl_memory_api_h.h>
40#undef vl_typedefs
41
Dave Barach371e4e12016-07-08 09:38:52 -040042static inline void *
Dave Barach77378332016-10-13 17:35:09 -040043vl_msg_api_alloc_internal (int nbytes, int pool, int may_return_null)
Ed Warnickecb9cada2015-12-08 15:45:58 -070044{
Dave Barach371e4e12016-07-08 09:38:52 -040045 int i;
46 msgbuf_t *rv;
47 ring_alloc_t *ap;
48 unix_shared_memory_queue_t *q;
49 void *oldheap;
50 vl_shmem_hdr_t *shmem_hdr;
51 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -070052
Dave Barach371e4e12016-07-08 09:38:52 -040053 shmem_hdr = am->shmem_hdr;
Ed Warnickecb9cada2015-12-08 15:45:58 -070054
Dave Barach371e4e12016-07-08 09:38:52 -040055 if (shmem_hdr == 0)
56 {
57 clib_warning ("shared memory header NULL");
58 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -070059 }
60
Dave Barach371e4e12016-07-08 09:38:52 -040061 /* account for the msgbuf_t header */
62 nbytes += sizeof (msgbuf_t);
Ed Warnickecb9cada2015-12-08 15:45:58 -070063
Dave Barach371e4e12016-07-08 09:38:52 -040064 if (shmem_hdr->vl_rings == 0)
65 {
66 clib_warning ("vl_rings NULL");
Dave Barach77378332016-10-13 17:35:09 -040067 ASSERT (0);
68 abort ();
Ed Warnickecb9cada2015-12-08 15:45:58 -070069 }
70
Dave Barach371e4e12016-07-08 09:38:52 -040071 if (shmem_hdr->client_rings == 0)
72 {
73 clib_warning ("client_rings NULL");
Dave Barach77378332016-10-13 17:35:09 -040074 ASSERT (0);
75 abort ();
Ed Warnickecb9cada2015-12-08 15:45:58 -070076 }
77
Dave Barach371e4e12016-07-08 09:38:52 -040078 ap = pool ? shmem_hdr->vl_rings : shmem_hdr->client_rings;
79 for (i = 0; i < vec_len (ap); i++)
80 {
81 /* Too big? */
82 if (nbytes > ap[i].size)
83 {
84 continue;
85 }
Ed Warnickecb9cada2015-12-08 15:45:58 -070086
Dave Barach371e4e12016-07-08 09:38:52 -040087 q = ap[i].rp;
88 if (pool == 0)
89 {
90 pthread_mutex_lock (&q->mutex);
91 }
92 rv = (msgbuf_t *) (&q->data[0] + q->head * q->elsize);
93 /*
94 * Is this item still in use?
95 */
96 if (rv->q)
97 {
Dave Barach842b9c52017-01-09 15:54:00 -050098 u32 now = (u32) time (0);
99
100 if (PREDICT_TRUE (rv->gc_mark_timestamp == 0))
101 rv->gc_mark_timestamp = now;
102 else
103 {
104 if (now - rv->gc_mark_timestamp > 10)
105 {
106 if (CLIB_DEBUG > 0)
Dave Barach10d8cc62017-05-30 09:30:07 -0400107 {
108 u16 *msg_idp, msg_id;
109 clib_warning
110 ("garbage collect pool %d ring %d index %d", pool, i,
111 q->head);
112 msg_idp = (u16 *) (rv->data);
113 msg_id = clib_net_to_host_u16 (*msg_idp);
114 if (msg_id < vec_len (api_main.msg_names))
115 clib_warning ("msg id %d name %s", (u32) msg_id,
116 api_main.msg_names[msg_id]);
117 }
Dave Barach842b9c52017-01-09 15:54:00 -0500118 shmem_hdr->garbage_collects++;
119 goto collected;
120 }
121 }
122
123
Dave Barach371e4e12016-07-08 09:38:52 -0400124 /* yes, loser; try next larger pool */
125 ap[i].misses++;
126 if (pool == 0)
127 pthread_mutex_unlock (&q->mutex);
128 continue;
129 }
Dave Barach842b9c52017-01-09 15:54:00 -0500130 collected:
131
Dave Barach371e4e12016-07-08 09:38:52 -0400132 /* OK, we have a winner */
133 ap[i].hits++;
134 /*
135 * Remember the source queue, although we
136 * don't need to know the queue to free the item.
137 */
138 rv->q = q;
Dave Barach842b9c52017-01-09 15:54:00 -0500139 rv->gc_mark_timestamp = 0;
Dave Barach371e4e12016-07-08 09:38:52 -0400140 q->head++;
141 if (q->head == q->maxsize)
142 q->head = 0;
143
144 if (pool == 0)
145 pthread_mutex_unlock (&q->mutex);
146 goto out;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700147 }
148
Dave Barach371e4e12016-07-08 09:38:52 -0400149 /*
150 * Request too big, or head element of all size-compatible rings
151 * still in use. Fall back to shared-memory malloc.
152 */
153 am->ring_misses++;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700154
Dave Barach371e4e12016-07-08 09:38:52 -0400155 pthread_mutex_lock (&am->vlib_rp->mutex);
156 oldheap = svm_push_data_heap (am->vlib_rp);
Dave Barach77378332016-10-13 17:35:09 -0400157 if (may_return_null)
158 {
159 rv = clib_mem_alloc_or_null (nbytes);
160 if (PREDICT_FALSE (rv == 0))
161 {
162 svm_pop_heap (oldheap);
163 pthread_mutex_unlock (&am->vlib_rp->mutex);
164 return 0;
165 }
166 }
167 else
168 rv = clib_mem_alloc (nbytes);
169
Dave Barach371e4e12016-07-08 09:38:52 -0400170 rv->q = 0;
171 svm_pop_heap (oldheap);
172 pthread_mutex_unlock (&am->vlib_rp->mutex);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700173
Dave Barach371e4e12016-07-08 09:38:52 -0400174out:
175 rv->data_len = htonl (nbytes - sizeof (msgbuf_t));
176 return (rv->data);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700177}
178
Dave Barach371e4e12016-07-08 09:38:52 -0400179void *
180vl_msg_api_alloc (int nbytes)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700181{
Dave Barach371e4e12016-07-08 09:38:52 -0400182 int pool;
183 api_main_t *am = &api_main;
184 vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700185
Dave Barach371e4e12016-07-08 09:38:52 -0400186 /*
187 * Clients use pool-0, vlib proc uses pool 1
188 */
189 pool = (am->our_pid == shmem_hdr->vl_pid);
Dave Barach77378332016-10-13 17:35:09 -0400190 return vl_msg_api_alloc_internal (nbytes, pool, 0 /* may_return_null */ );
191}
192
193void *
194vl_msg_api_alloc_or_null (int nbytes)
195{
196 int pool;
197 api_main_t *am = &api_main;
198 vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
199
200 pool = (am->our_pid == shmem_hdr->vl_pid);
201 return vl_msg_api_alloc_internal (nbytes, pool, 1 /* may_return_null */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700202}
203
Dave Barach371e4e12016-07-08 09:38:52 -0400204void *
205vl_msg_api_alloc_as_if_client (int nbytes)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700206{
Dave Barach77378332016-10-13 17:35:09 -0400207 return vl_msg_api_alloc_internal (nbytes, 0, 0 /* may_return_null */ );
208}
209
210void *
211vl_msg_api_alloc_as_if_client_or_null (int nbytes)
212{
213 return vl_msg_api_alloc_internal (nbytes, 0, 1 /* may_return_null */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700214}
215
Dave Barach371e4e12016-07-08 09:38:52 -0400216void
217vl_msg_api_free (void *a)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700218{
Dave Barach371e4e12016-07-08 09:38:52 -0400219 msgbuf_t *rv;
220 void *oldheap;
221 api_main_t *am = &api_main;
Ole Troan6855f6c2016-04-09 03:16:30 +0200222
Dave Barach371e4e12016-07-08 09:38:52 -0400223 rv = (msgbuf_t *) (((u8 *) a) - offsetof (msgbuf_t, data));
224
225 /*
226 * Here's the beauty of the scheme. Only one proc/thread has
227 * control of a given message buffer. To free a buffer, we just clear the
228 * queue field, and leave. No locks, no hits, no errors...
229 */
230 if (rv->q)
231 {
232 rv->q = 0;
Dave Barach842b9c52017-01-09 15:54:00 -0500233 rv->gc_mark_timestamp = 0;
Dave Barach371e4e12016-07-08 09:38:52 -0400234 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700235 }
236
Dave Barach371e4e12016-07-08 09:38:52 -0400237 pthread_mutex_lock (&am->vlib_rp->mutex);
238 oldheap = svm_push_data_heap (am->vlib_rp);
239 clib_mem_free (rv);
240 svm_pop_heap (oldheap);
241 pthread_mutex_unlock (&am->vlib_rp->mutex);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700242}
243
Dave Barach371e4e12016-07-08 09:38:52 -0400244static void
245vl_msg_api_free_nolock (void *a)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700246{
Dave Barach371e4e12016-07-08 09:38:52 -0400247 msgbuf_t *rv;
248 void *oldheap;
249 api_main_t *am = &api_main;
250
251 rv = (msgbuf_t *) (((u8 *) a) - offsetof (msgbuf_t, data));
252 /*
253 * Here's the beauty of the scheme. Only one proc/thread has
254 * control of a given message buffer. To free a buffer, we just clear the
255 * queue field, and leave. No locks, no hits, no errors...
256 */
257 if (rv->q)
258 {
259 rv->q = 0;
260 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700261 }
262
Dave Barach371e4e12016-07-08 09:38:52 -0400263 oldheap = svm_push_data_heap (am->vlib_rp);
264 clib_mem_free (rv);
265 svm_pop_heap (oldheap);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700266}
267
Dave Barach371e4e12016-07-08 09:38:52 -0400268void
Neale Rannse72be392017-04-26 13:59:20 -0700269vl_set_memory_root_path (const char *name)
Dave Barach309bef22016-01-22 16:09:52 -0500270{
Dave Barach371e4e12016-07-08 09:38:52 -0400271 api_main_t *am = &api_main;
Dave Barach309bef22016-01-22 16:09:52 -0500272
Dave Barach371e4e12016-07-08 09:38:52 -0400273 am->root_path = name;
Dave Barach309bef22016-01-22 16:09:52 -0500274}
275
Dave Barach371e4e12016-07-08 09:38:52 -0400276void
277vl_set_memory_uid (int uid)
Dave Barach16c75df2016-05-31 14:05:46 -0400278{
Dave Barach371e4e12016-07-08 09:38:52 -0400279 api_main_t *am = &api_main;
Dave Barach16c75df2016-05-31 14:05:46 -0400280
Dave Barach371e4e12016-07-08 09:38:52 -0400281 am->api_uid = uid;
Dave Barach16c75df2016-05-31 14:05:46 -0400282}
283
Dave Barach371e4e12016-07-08 09:38:52 -0400284void
285vl_set_memory_gid (int gid)
Dave Barach16c75df2016-05-31 14:05:46 -0400286{
Dave Barach371e4e12016-07-08 09:38:52 -0400287 api_main_t *am = &api_main;
Dave Barach16c75df2016-05-31 14:05:46 -0400288
Dave Barach371e4e12016-07-08 09:38:52 -0400289 am->api_gid = gid;
Dave Barach16c75df2016-05-31 14:05:46 -0400290}
291
Dave Barachb3d93da2016-08-03 14:34:38 -0400292void
293vl_set_global_memory_baseva (u64 baseva)
294{
295 api_main_t *am = &api_main;
296
297 am->global_baseva = baseva;
298}
299
300void
301vl_set_global_memory_size (u64 size)
302{
303 api_main_t *am = &api_main;
304
305 am->global_size = size;
306}
307
308void
309vl_set_api_memory_size (u64 size)
310{
311 api_main_t *am = &api_main;
312
313 am->api_size = size;
314}
315
316void
317vl_set_global_pvt_heap_size (u64 size)
318{
319 api_main_t *am = &api_main;
320
321 am->global_pvt_heap_size = size;
322}
323
324void
325vl_set_api_pvt_heap_size (u64 size)
326{
327 api_main_t *am = &api_main;
328
329 am->api_pvt_heap_size = size;
330}
331
Dave Barach371e4e12016-07-08 09:38:52 -0400332int
Neale Rannse72be392017-04-26 13:59:20 -0700333vl_map_shmem (const char *region_name, int is_vlib)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700334{
Dave Barach371e4e12016-07-08 09:38:52 -0400335 svm_map_region_args_t _a, *a = &_a;
336 svm_region_t *vlib_rp, *root_rp;
337 void *oldheap;
338 vl_shmem_hdr_t *shmem_hdr = 0;
339 api_main_t *am = &api_main;
Ole Troan3cdc25f2017-08-17 11:07:33 +0200340 int i, rv;
Dave Barach371e4e12016-07-08 09:38:52 -0400341 struct timespec ts, tsrem;
Dave Barach10d8cc62017-05-30 09:30:07 -0400342 u32 vlib_input_queue_length;
Dave Wallacecfc997e2017-08-22 18:32:34 -0400343 char *vpe_api_region_suffix = "-vpe-api";
Ed Warnickecb9cada2015-12-08 15:45:58 -0700344
Jan Srnicek5beec812017-03-24 10:18:11 +0100345 memset (a, 0, sizeof (*a));
346
Dave Wallacecfc997e2017-08-22 18:32:34 -0400347 if (strstr (region_name, vpe_api_region_suffix))
Jan Srnicek5beec812017-03-24 10:18:11 +0100348 {
Dave Wallacecfc997e2017-08-22 18:32:34 -0400349 u8 *root_path = format (0, "%s", region_name);
350 _vec_len (root_path) = (vec_len (root_path) -
351 strlen (vpe_api_region_suffix));
352 vec_terminate_c_string (root_path);
353 a->root_path = (const char *) root_path;
354 am->root_path = (const char *) root_path;
Jan Srnicek5beec812017-03-24 10:18:11 +0100355 }
356
Dave Barach371e4e12016-07-08 09:38:52 -0400357 if (is_vlib == 0)
Ole Troan3cdc25f2017-08-17 11:07:33 +0200358 {
359 rv = svm_region_init_chroot (am->root_path);
360 if (rv)
361 return rv;
362 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700363
Jan Srnicek5beec812017-03-24 10:18:11 +0100364 if (a->root_path != NULL)
365 {
366 a->name = "/vpe-api";
367 }
368 else
369 a->name = region_name;
Dave Barachc3799992016-08-15 11:12:27 -0400370 a->size = am->api_size ? am->api_size : (16 << 20);
Dave Barach371e4e12016-07-08 09:38:52 -0400371 a->flags = SVM_FLAGS_MHEAP;
372 a->uid = am->api_uid;
373 a->gid = am->api_gid;
Dave Barachb3d93da2016-08-03 14:34:38 -0400374 a->pvt_heap_size = am->api_pvt_heap_size;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700375
Dave Barach371e4e12016-07-08 09:38:52 -0400376 vlib_rp = svm_region_find_or_create (a);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700377
Dave Barach371e4e12016-07-08 09:38:52 -0400378 if (vlib_rp == 0)
379 return (-2);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700380
Dave Barach371e4e12016-07-08 09:38:52 -0400381 pthread_mutex_lock (&vlib_rp->mutex);
382 /* Has someone else set up the shared-memory variable table? */
383 if (vlib_rp->user_ctx)
384 {
385 am->shmem_hdr = (void *) vlib_rp->user_ctx;
386 am->our_pid = getpid ();
387 if (is_vlib)
388 {
389 unix_shared_memory_queue_t *q;
390 uword old_msg;
391 /*
392 * application restart. Reset cached pids, API message
393 * rings, list of clients; otherwise, various things
394 * fail. (e.g. queue non-empty notification)
395 */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700396
Dave Barach371e4e12016-07-08 09:38:52 -0400397 /* ghosts keep the region from disappearing properly */
398 svm_client_scan_this_region_nolock (vlib_rp);
399 am->shmem_hdr->application_restarts++;
400 q = am->shmem_hdr->vl_input_queue;
401 am->shmem_hdr->vl_pid = getpid ();
402 q->consumer_pid = am->shmem_hdr->vl_pid;
403 /* Drain the input queue, freeing msgs */
404 for (i = 0; i < 10; i++)
405 {
406 if (pthread_mutex_trylock (&q->mutex) == 0)
407 {
408 pthread_mutex_unlock (&q->mutex);
409 goto mutex_ok;
410 }
411 ts.tv_sec = 0;
412 ts.tv_nsec = 10000 * 1000; /* 10 ms */
413 while (nanosleep (&ts, &tsrem) < 0)
414 ts = tsrem;
415 }
416 /* Mutex buggered, "fix" it */
417 memset (&q->mutex, 0, sizeof (q->mutex));
418 clib_warning ("forcibly release main input queue mutex");
419
420 mutex_ok:
421 am->vlib_rp = vlib_rp;
422 while (unix_shared_memory_queue_sub (q,
423 (u8 *) & old_msg,
424 1 /* nowait */ )
425 != -2 /* queue underflow */ )
426 {
427 vl_msg_api_free_nolock ((void *) old_msg);
428 am->shmem_hdr->restart_reclaims++;
429 }
430 pthread_mutex_unlock (&vlib_rp->mutex);
431 root_rp = svm_get_root_rp ();
432 ASSERT (root_rp);
433 /* Clean up the root region client list */
434 pthread_mutex_lock (&root_rp->mutex);
435 svm_client_scan_this_region_nolock (root_rp);
436 pthread_mutex_unlock (&root_rp->mutex);
437 }
438 else
439 {
440 pthread_mutex_unlock (&vlib_rp->mutex);
441 }
442 am->vlib_rp = vlib_rp;
443 vec_add1 (am->mapped_shmem_regions, vlib_rp);
444 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700445 }
Dave Barach371e4e12016-07-08 09:38:52 -0400446 /* Clients simply have to wait... */
447 if (!is_vlib)
448 {
449 pthread_mutex_unlock (&vlib_rp->mutex);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700450
Dave Barach371e4e12016-07-08 09:38:52 -0400451 /* Wait up to 100 seconds... */
452 for (i = 0; i < 10000; i++)
453 {
454 ts.tv_sec = 0;
455 ts.tv_nsec = 10000 * 1000; /* 10 ms */
456 while (nanosleep (&ts, &tsrem) < 0)
457 ts = tsrem;
458 if (vlib_rp->user_ctx)
459 goto ready;
460 }
461 /* Clean up and leave... */
462 svm_region_unmap (vlib_rp);
463 clib_warning ("region init fail");
464 return (-2);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700465
466 ready:
Dave Barach371e4e12016-07-08 09:38:52 -0400467 am->shmem_hdr = (void *) vlib_rp->user_ctx;
468 am->our_pid = getpid ();
469 am->vlib_rp = vlib_rp;
470 vec_add1 (am->mapped_shmem_regions, vlib_rp);
471 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700472 }
473
Dave Barach371e4e12016-07-08 09:38:52 -0400474 /* Nope, it's our problem... */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700475
Dave Barach371e4e12016-07-08 09:38:52 -0400476 oldheap = svm_push_data_heap (vlib_rp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700477
Dave Barach371e4e12016-07-08 09:38:52 -0400478 vec_validate (shmem_hdr, 0);
479 shmem_hdr->version = VL_SHM_VERSION;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700480
Dave Barach371e4e12016-07-08 09:38:52 -0400481 /* vlib main input queue */
Dave Barach10d8cc62017-05-30 09:30:07 -0400482 vlib_input_queue_length = 1024;
483 if (am->vlib_input_queue_length)
484 vlib_input_queue_length = am->vlib_input_queue_length;
485
Dave Barach371e4e12016-07-08 09:38:52 -0400486 shmem_hdr->vl_input_queue =
Dave Barach10d8cc62017-05-30 09:30:07 -0400487 unix_shared_memory_queue_init (vlib_input_queue_length, sizeof (uword),
488 getpid (), am->vlib_signal);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700489
Dave Barach371e4e12016-07-08 09:38:52 -0400490 /* Set up the msg ring allocator */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700491#define _(sz,n) \
492 do { \
493 ring_alloc_t _rp; \
494 _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \
495 _rp.size = (sz); \
496 _rp.nitems = n; \
497 _rp.hits = 0; \
498 _rp.misses = 0; \
499 vec_add1(shmem_hdr->vl_rings, _rp); \
500 } while (0);
501
Dave Barach371e4e12016-07-08 09:38:52 -0400502 foreach_vl_aring_size;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700503#undef _
504
505#define _(sz,n) \
506 do { \
507 ring_alloc_t _rp; \
508 _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \
509 _rp.size = (sz); \
510 _rp.nitems = n; \
511 _rp.hits = 0; \
512 _rp.misses = 0; \
513 vec_add1(shmem_hdr->client_rings, _rp); \
514 } while (0);
515
Dave Barach371e4e12016-07-08 09:38:52 -0400516 foreach_clnt_aring_size;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700517#undef _
518
Dave Barach371e4e12016-07-08 09:38:52 -0400519 am->shmem_hdr = shmem_hdr;
520 am->vlib_rp = vlib_rp;
521 am->our_pid = getpid ();
522 if (is_vlib)
523 am->shmem_hdr->vl_pid = am->our_pid;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700524
Dave Barach371e4e12016-07-08 09:38:52 -0400525 svm_pop_heap (oldheap);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700526
Dave Barach371e4e12016-07-08 09:38:52 -0400527 /*
528 * After absolutely everything that a client might see is set up,
529 * declare the shmem region valid
530 */
531 vlib_rp->user_ctx = shmem_hdr;
532
533 pthread_mutex_unlock (&vlib_rp->mutex);
534 vec_add1 (am->mapped_shmem_regions, vlib_rp);
535 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700536}
537
Dave Barach371e4e12016-07-08 09:38:52 -0400538void
539vl_register_mapped_shmem_region (svm_region_t * rp)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700540{
Dave Barach371e4e12016-07-08 09:38:52 -0400541 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700542
Dave Barach371e4e12016-07-08 09:38:52 -0400543 vec_add1 (am->mapped_shmem_regions, rp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700544}
545
Dave Barach371e4e12016-07-08 09:38:52 -0400546void
547vl_unmap_shmem (void)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700548{
Dave Barach371e4e12016-07-08 09:38:52 -0400549 svm_region_t *rp;
550 int i;
551 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700552
Dave Barach371e4e12016-07-08 09:38:52 -0400553 if (!svm_get_root_rp ())
554 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700555
Dave Barach371e4e12016-07-08 09:38:52 -0400556 for (i = 0; i < vec_len (am->mapped_shmem_regions); i++)
557 {
558 rp = am->mapped_shmem_regions[i];
559 svm_region_unmap (rp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700560 }
561
Dave Barach371e4e12016-07-08 09:38:52 -0400562 vec_free (am->mapped_shmem_regions);
563 am->shmem_hdr = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700564
Dave Barach371e4e12016-07-08 09:38:52 -0400565 svm_region_exit ();
566 /* $$$ more careful cleanup, valgrind run... */
567 vec_free (am->msg_handlers);
568 vec_free (am->msg_endian_handlers);
569 vec_free (am->msg_print_handlers);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700570}
571
Dave Barach371e4e12016-07-08 09:38:52 -0400572void
573vl_msg_api_send_shmem (unix_shared_memory_queue_t * q, u8 * elem)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700574{
Dave Barach371e4e12016-07-08 09:38:52 -0400575 api_main_t *am = &api_main;
576 uword *trace = (uword *) elem;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700577
Dave Barach371e4e12016-07-08 09:38:52 -0400578 if (am->tx_trace && am->tx_trace->enabled)
579 vl_msg_api_trace (am, am->tx_trace, (void *) trace[0]);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700580
Dave Barach371e4e12016-07-08 09:38:52 -0400581 (void) unix_shared_memory_queue_add (q, elem, 0 /* nowait */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700582}
583
Dave Barach371e4e12016-07-08 09:38:52 -0400584void
585vl_msg_api_send_shmem_nolock (unix_shared_memory_queue_t * q, u8 * elem)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700586{
Dave Barach371e4e12016-07-08 09:38:52 -0400587 api_main_t *am = &api_main;
588 uword *trace = (uword *) elem;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700589
Dave Barach371e4e12016-07-08 09:38:52 -0400590 if (am->tx_trace && am->tx_trace->enabled)
591 vl_msg_api_trace (am, am->tx_trace, (void *) trace[0]);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700592
Dave Barach371e4e12016-07-08 09:38:52 -0400593 (void) unix_shared_memory_queue_add_nolock (q, elem);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700594}
595
Dave Barach557d1282016-11-10 14:22:49 -0500596u32
597vl_api_get_msg_index (u8 * name_and_crc)
Dave Barach371e4e12016-07-08 09:38:52 -0400598{
Dave Barach557d1282016-11-10 14:22:49 -0500599 api_main_t *am = &api_main;
600 uword *p;
Dave Barach371e4e12016-07-08 09:38:52 -0400601
Dave Barach557d1282016-11-10 14:22:49 -0500602 if (am->msg_index_by_name_and_crc)
603 {
604 p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc);
605 if (p)
606 return p[0];
607 }
608 return ~0;
Dave Barach371e4e12016-07-08 09:38:52 -0400609}
610
Dave Barach371e4e12016-07-08 09:38:52 -0400611static inline vl_api_registration_t *
612vl_api_client_index_to_registration_internal (u32 handle)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700613{
Dave Barach371e4e12016-07-08 09:38:52 -0400614 vl_api_registration_t **regpp;
615 vl_api_registration_t *regp;
616 api_main_t *am = &api_main;
617 u32 index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700618
Dave Barach371e4e12016-07-08 09:38:52 -0400619 index = vl_msg_api_handle_get_index (handle);
620 if ((am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK)
621 != vl_msg_api_handle_get_epoch (handle))
622 {
623 vl_msg_api_increment_missing_client_counter ();
624 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700625 }
626
Dave Barach371e4e12016-07-08 09:38:52 -0400627 regpp = am->vl_clients + index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700628
Dave Barach371e4e12016-07-08 09:38:52 -0400629 if (pool_is_free (am->vl_clients, regpp))
630 {
631 vl_msg_api_increment_missing_client_counter ();
632 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700633 }
Dave Barach371e4e12016-07-08 09:38:52 -0400634 regp = *regpp;
635 return (regp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700636}
637
Dave Barach371e4e12016-07-08 09:38:52 -0400638vl_api_registration_t *
639vl_api_client_index_to_registration (u32 index)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700640{
Dave Barach371e4e12016-07-08 09:38:52 -0400641 return (vl_api_client_index_to_registration_internal (index));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700642}
643
Dave Barach371e4e12016-07-08 09:38:52 -0400644unix_shared_memory_queue_t *
645vl_api_client_index_to_input_queue (u32 index)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700646{
Dave Barach371e4e12016-07-08 09:38:52 -0400647 vl_api_registration_t *regp;
Dave Barachfc262a02016-12-14 14:49:55 -0500648 api_main_t *am = &api_main;
649
650 /* Special case: vlib trying to send itself a message */
651 if (index == (u32) ~ 0)
652 return (am->shmem_hdr->vl_input_queue);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700653
Dave Barach371e4e12016-07-08 09:38:52 -0400654 regp = vl_api_client_index_to_registration_internal (index);
655 if (!regp)
656 return 0;
657 return (regp->vl_input_queue);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700658}
659
Dave Barach371e4e12016-07-08 09:38:52 -0400660/*
661 * fd.io coding-style-patch-verification: ON
662 *
663 * Local Variables:
664 * eval: (c-set-style "gnu")
665 * End:
666 */