FD.io VPP  v20.01-rc0-785-g1063f2ae8
Vector Packet Processing
memory_client.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * memory_client.c - API message handling, client code.
4  *
5  * Copyright (c) 2010 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <setjmp.h>
21 
22 #include <svm/svm.h>
23 #include <svm/ssvm.h>
24 #include <vppinfra/serialize.h>
25 #include <vppinfra/hash.h>
27 
28 /* A hack. vl_client_get_first_plugin_msg_id depends on it */
30 
32 
33 #define vl_typedefs /* define message structures */
35 #undef vl_typedefs
36 
37 #define vl_endianfun /* define message structures */
39 #undef vl_endianfun
40 
41 /* instantiate all the print functions we know about */
42 #define vl_print(handle, ...) clib_warning (__VA_ARGS__)
43 #define vl_printfun
45 #undef vl_printfun
46 
48 
49 static void *
50 rx_thread_fn (void *arg)
51 {
52  svm_queue_t *q;
54  api_main_t *am = &api_main;
55 
56  q = am->vl_input_queue;
57 
58  /* So we can make the rx thread terminate cleanly */
59  if (setjmp (mm->rx_thread_jmpbuf) == 0)
60  {
61  mm->rx_thread_jmpbuf_valid = 1;
63  while (1)
65  }
66  pthread_exit (0);
67 }
68 
69 static void
71 {
73  if (mm->rx_thread_jmpbuf_valid)
74  longjmp (mm->rx_thread_jmpbuf, 1);
75 }
76 
77 static void
79 {
80  api_main_t *am = &api_main;
81  int i;
82  u8 **keys = 0;
83  hash_pair_t *hp;
84 
86  return;
87 
88  /* *INDENT-OFF* */
90  ({
91  vec_add1 (keys, (u8 *) hp->key);
92  }));
93  /* *INDENT-ON* */
94  for (i = 0; i < vec_len (keys); i++)
95  vec_free (keys[i]);
96  vec_free (keys);
98 }
99 
100 CLIB_NOSANITIZE_ADDR static void
101 VL_API_VEC_UNPOISON (const void *v)
102 {
103  const vec_header_t *vh = &((vec_header_t *) v)[-1];
104  CLIB_MEM_UNPOISON (vh, sizeof (*vh) + vec_len (v));
105 }
106 
107 static void
109 {
110  serialize_main_t _sm, *sm = &_sm;
111  api_main_t *am = &api_main;
112  u8 *tblv;
113  u32 nmsgs;
114  int i;
115  u8 *name_and_crc;
116  u32 msg_index;
117 
118  am->my_client_index = mp->index;
120 
121  /* Clean out any previous hash table (unlikely) */
123 
125 
126  /* Recreate the vnet-side API message handler table */
127  tblv = uword_to_pointer (mp->message_table, u8 *);
128  unserialize_open_data (sm, tblv, vec_len (tblv));
129  unserialize_integer (sm, &nmsgs, sizeof (u32));
130 
131  VL_API_VEC_UNPOISON (tblv);
132 
133  for (i = 0; i < nmsgs; i++)
134  {
136  unserialize_cstring (sm, (char **) &name_and_crc);
137  hash_set_mem (am->msg_index_by_name_and_crc, name_and_crc, msg_index);
138  }
139 }
140 
141 static void
142 noop_handler (void *notused)
143 {
144 }
145 
146 void vl_msg_api_send_shmem (svm_queue_t * q, u8 * elem);
147 int
148 vl_client_connect (const char *name, int ctx_quota, int input_queue_size)
149 {
150  svm_region_t *svm;
153  svm_queue_t *vl_input_queue;
154  vl_shmem_hdr_t *shmem_hdr;
155  int rv = 0;
156  void *oldheap;
157  api_main_t *am = &api_main;
158 
159  if (am->my_registration)
160  {
161  clib_warning ("client %s already connected...", name);
162  return -1;
163  }
164 
165  if (am->vlib_rp == 0)
166  {
167  clib_warning ("am->vlib_rp NULL");
168  return -1;
169  }
170 
171  svm = am->vlib_rp;
172  shmem_hdr = am->shmem_hdr;
173 
174  if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0)
175  {
176  clib_warning ("shmem_hdr / input queue NULL");
177  return -1;
178  }
179 
180  CLIB_MEM_UNPOISON (shmem_hdr, sizeof (*shmem_hdr));
182 
183  pthread_mutex_lock (&svm->mutex);
184  oldheap = svm_push_data_heap (svm);
185  vl_input_queue = svm_queue_alloc_and_init (input_queue_size, sizeof (uword),
186  getpid ());
187  svm_pop_heap (oldheap);
188  pthread_mutex_unlock (&svm->mutex);
189 
190  am->my_client_index = ~0;
191  am->my_registration = 0;
192  am->vl_input_queue = vl_input_queue;
193 
195  clib_memset (mp, 0, sizeof (*mp));
196  mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE);
197  mp->ctx_quota = ctx_quota;
198  mp->input_queue = (uword) vl_input_queue;
199  strncpy ((char *) mp->name, name, sizeof (mp->name) - 1);
200 
201  vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & mp);
202 
203  while (1)
204  {
205  int qstatus;
206  struct timespec ts, tsrem;
207  int i;
208 
209  /* Wait up to 10 seconds */
210  for (i = 0; i < 1000; i++)
211  {
212  qstatus = svm_queue_sub (vl_input_queue, (u8 *) & rp,
213  SVM_Q_NOWAIT, 0);
214  if (qstatus == 0)
215  goto read_one_msg;
216  ts.tv_sec = 0;
217  ts.tv_nsec = 10000 * 1000; /* 10 ms */
218  while (nanosleep (&ts, &tsrem) < 0)
219  ts = tsrem;
220  }
221  /* Timeout... */
222  clib_warning ("memclnt_create_reply timeout");
223  return -1;
224 
225  read_one_msg:
226  VL_MSG_API_UNPOISON (rp);
227  if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY)
228  {
229  clib_warning ("unexpected reply: id %d", ntohs (rp->_vl_msg_id));
230  continue;
231  }
232  rv = clib_net_to_host_u32 (rp->response);
233 
234  vl_msg_api_handler ((void *) rp);
235  break;
236  }
237  return (rv);
238 }
239 
240 static void
242 {
243  void *oldheap;
244  api_main_t *am = &api_main;
245 
246  pthread_mutex_lock (&am->vlib_rp->mutex);
247  oldheap = svm_push_data_heap (am->vlib_rp);
249  pthread_mutex_unlock (&am->vlib_rp->mutex);
250  svm_pop_heap (oldheap);
251 
252  am->my_client_index = ~0;
253  am->my_registration = 0;
254  am->vl_input_queue = 0;
255 }
256 
257 void
259 {
261  vl_shmem_hdr_t *shmem_hdr;
262  api_main_t *am = &api_main;
263 
264  ASSERT (am->vlib_rp);
265  shmem_hdr = am->shmem_hdr;
266  ASSERT (shmem_hdr && shmem_hdr->vl_input_queue);
267 
269  clib_memset (mp, 0, sizeof (*mp));
270  mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE);
271  mp->index = am->my_client_index;
272  mp->handle = (uword) am->my_registration;
273  mp->do_cleanup = do_cleanup;
274 
275  vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & mp);
276 }
277 
278 int
280 {
282  svm_queue_t *vl_input_queue;
283  api_main_t *am = &api_main;
284  time_t begin;
285 
286  vl_input_queue = am->vl_input_queue;
287  vl_client_send_disconnect (0 /* wait for reply */ );
288 
289  /*
290  * Have to be careful here, in case the client is disconnecting
291  * because e.g. the vlib process died, or is unresponsive.
292  */
293  begin = time (0);
294  while (1)
295  {
296  time_t now;
297 
298  now = time (0);
299 
300  if (now >= (begin + 2))
301  {
302  clib_warning ("peer unresponsive, give up");
303  am->my_client_index = ~0;
304  am->my_registration = 0;
305  am->shmem_hdr = 0;
306  return -1;
307  }
308  if (svm_queue_sub (vl_input_queue, (u8 *) & rp, SVM_Q_NOWAIT, 0) < 0)
309  continue;
310 
311  VL_MSG_API_UNPOISON (rp);
312 
313  /* drain the queue */
314  if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY)
315  {
316  clib_warning ("queue drain: %d", ntohs (rp->_vl_msg_id));
317  vl_msg_api_handler ((void *) rp);
318  continue;
319  }
320  vl_msg_api_handler ((void *) rp);
321  break;
322  }
323 
325  return 0;
326 }
327 
328 /**
329  * Stave off the binary API dead client reaper
330  * Only sent to inactive clients
331  */
332 static void
334 {
335  vl_api_memclnt_keepalive_reply_t *rmp;
336  api_main_t *am;
337  vl_shmem_hdr_t *shmem_hdr;
338 
339  am = &api_main;
340  shmem_hdr = am->shmem_hdr;
341 
342  rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
343  clib_memset (rmp, 0, sizeof (*rmp));
344  rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
345  rmp->context = mp->context;
346  vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp);
347 }
348 
349 #define foreach_api_msg \
350 _(RX_THREAD_EXIT, rx_thread_exit) \
351 _(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \
352 _(MEMCLNT_DELETE_REPLY, memclnt_delete_reply) \
353 _(MEMCLNT_KEEPALIVE, memclnt_keepalive)
354 
355 void
357 {
358 
359 #define _(N,n) \
360  vl_msg_api_set_handlers(VL_API_##N, #n, \
361  vl_api_##n##_t_handler, \
362  noop_handler, \
363  vl_api_##n##_t_endian, \
364  vl_api_##n##_t_print, \
365  sizeof(vl_api_##n##_t), 1);
367 #undef _
368 }
369 
370 int
371 vl_client_api_map (const char *region_name)
372 {
373  int rv;
374 
375  if ((rv = vl_map_shmem (region_name, 0 /* is_vlib */ )) < 0)
376  return rv;
377 
379  return 0;
380 }
381 
382 void
384 {
386 }
387 
388 u8
390 {
391  return (memory_client_main.connected_to_vlib != 0);
392 }
393 
394 static int
395 connect_to_vlib_internal (const char *svm_name,
396  const char *client_name,
397  int rx_queue_size, void *(*thread_fn) (void *),
398  int do_map)
399 {
400  int rv = 0;
402  api_main_t *am = &api_main;
403 
404  if (do_map && (rv = vl_client_api_map (svm_name)))
405  {
406  clib_warning ("vl_client_api map rv %d", rv);
407  return rv;
408  }
409 
410  if (vl_client_connect (client_name, 0 /* punt quota */ ,
411  rx_queue_size /* input queue */ ) < 0)
412  {
414  return -1;
415  }
416 
417  /* Start the rx queue thread */
418 
419  if (thread_fn)
420  {
421  rv = pthread_create (&mm->rx_thread_handle,
422  NULL /*attr */ , thread_fn, 0);
423  if (rv)
424  {
425  clib_warning ("pthread_create returned %d", rv);
426  am->rx_thread_handle = 0;
427  }
428  else
429  {
431  }
432  }
433 
434  mm->connected_to_vlib = 1;
435  return 0;
436 }
437 
438 int
439 vl_client_connect_to_vlib (const char *svm_name,
440  const char *client_name, int rx_queue_size)
441 {
442  return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
443  rx_thread_fn, 1 /* do map */ );
444 }
445 
446 int
448  const char *client_name,
449  int rx_queue_size)
450 {
451  return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
452  0 /* no rx_thread_fn */ ,
453  1 /* do map */ );
454 }
455 
456 int
457 vl_client_connect_to_vlib_no_map (const char *svm_name,
458  const char *client_name, int rx_queue_size)
459 {
460  return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
461  rx_thread_fn, 0 /* dont map */ );
462 }
463 
464 int
466  const char *client_name,
467  int rx_queue_size)
468 {
469  return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
470  0 /* want pthread */ ,
471  0 /* dont map */ );
472 }
473 
474 int
476  const char *client_name,
477  int rx_queue_size,
478  void *(*thread_fn) (void *))
479 {
480  return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
481  thread_fn, 1 /* do map */ );
482 }
483 
484 
485 static void
487 {
489  api_main_t *am = &api_main;
490  uword junk;
491 
492  if (mm->rx_thread_jmpbuf_valid)
493  {
495  ep = vl_msg_api_alloc (sizeof (*ep));
496  ep->_vl_msg_id = ntohs (VL_API_RX_THREAD_EXIT);
497  vl_msg_api_send_shmem (am->vl_input_queue, (u8 *) & ep);
498  pthread_join (mm->rx_thread_handle, (void **) &junk);
499  }
500  if (mm->connected_to_vlib)
501  {
503  if (do_unmap)
505  }
506  clib_memset (mm, 0, sizeof (*mm));
507 }
508 
509 void
511 {
513 }
514 
515 void
517 {
519 }
520 
523 {
525  i32 retval = ntohl (mp->retval);
526 
527  mm->first_msg_id_reply = (retval >= 0) ? ntohs (mp->first_msg_id) : ~0;
528  mm->first_msg_id_reply_ready = 1;
529 }
530 
531 u16
532 vl_client_get_first_plugin_msg_id (const char *plugin_name)
533 {
535  api_main_t *am = &api_main;
537  f64 timeout;
538  void *old_handler;
539  clib_time_t clib_time;
540  u16 rv = ~0;
541 
542  if (strlen (plugin_name) + 1 > sizeof (mp->name))
543  return (rv);
544 
545  clib_memset (&clib_time, 0, sizeof (clib_time));
546  clib_time_init (&clib_time);
547 
548  /* Push this plugin's first_msg_id_reply handler */
549  old_handler = am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY];
550  am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = (void *)
552 
553  /* Ask the data-plane for the message-ID base of the indicated plugin */
554  mm->first_msg_id_reply_ready = 0;
555 
556  /* Not using shm client */
557  if (!am->my_registration)
558  {
559  mp = vl_socket_client_msg_alloc (sizeof (*mp));
560  clib_memset (mp, 0, sizeof (*mp));
561  mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
562  mp->client_index = am->my_client_index;
563  strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);
564 
565  if (vl_socket_client_write () <= 0)
566  goto sock_err;
567  if (vl_socket_client_read (1))
568  goto sock_err;
569 
570  if (mm->first_msg_id_reply_ready == 1)
571  {
572  rv = mm->first_msg_id_reply;
573  goto result;
574  }
575 
576  sock_err:
577  /* Restore old handler */
578  am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
579 
580  return -1;
581  }
582  else
583  {
584  mp = vl_msg_api_alloc (sizeof (*mp));
585  clib_memset (mp, 0, sizeof (*mp));
586  mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
587  mp->client_index = am->my_client_index;
588  strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);
589 
591 
592  /* Synchronously wait for the answer */
593  timeout = clib_time_now (&clib_time) + 1.0;
594  while (clib_time_now (&clib_time) < timeout)
595  {
596  if (mm->first_msg_id_reply_ready == 1)
597  {
598  rv = mm->first_msg_id_reply;
599  goto result;
600  }
601  }
602  /* Restore old handler */
603  am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
604 
605  return rv;
606  }
607 
608 result:
609 
610  /* Restore the old handler */
611  am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
612 
613  if (rv == (u16) ~ 0)
614  clib_warning ("plugin '%s' not registered", plugin_name);
615 
616  return rv;
617 }
618 
619 /*
620  * fd.io coding-style-patch-verification: ON
621  *
622  * Local Variables:
623  * eval: (c-set-style "gnu")
624  * End:
625  */
#define CLIB_MEM_UNPOISON(a, s)
Definition: sanitizer.h:47
static void svm_pop_heap(void *oldheap)
Definition: svm.h:94
int vl_client_connect_to_vlib(const char *svm_name, const char *client_name, int rx_queue_size)
static u64 unserialize_likely_small_unsigned_integer(serialize_main_t *m)
Definition: serialize.h:254
u8 vl_mem_client_is_connected(void)
int vl_map_shmem(const char *region_name, int is_vlib)
int vl_client_connect_to_vlib_no_map(const char *svm_name, const char *client_name, int rx_queue_size)
int vl_socket_client_read(int wait)
Definition: socket_client.c:56
int vl_client_connect_to_vlib_no_rx_pthread(const char *svm_name, const char *client_name, int rx_queue_size)
int my_client_index
All VLIB-side message handlers use my_client_index to identify the queue / client.
Definition: api_common.h:331
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 clib_time_now(clib_time_t *c)
Definition: time.h:224
static void disconnect_from_vlib_internal(u8 do_unmap)
static void vl_api_memclnt_keepalive_t_handler(vl_api_memclnt_keepalive_t *mp)
Stave off the binary API dead client reaper Only sent to inactive clients.
int i
#define hash_set_mem(h, key, value)
Definition: hash.h:275
svm_queue_t * vl_input_queue
Peer input queue pointer.
Definition: api_common.h:325
void * vl_msg_api_alloc(int nbytes)
static void noop_handler(void *notused)
int vl_client_connect_to_vlib_thread_fn(const char *svm_name, const char *client_name, int rx_queue_size, void *(*thread_fn)(void *))
unsigned char u8
Definition: types.h:56
double f64
Definition: types.h:142
void vl_client_api_unmap(void)
void * vl_socket_client_msg_alloc(int nbytes)
vl_api_registration_t * my_registration
This is the (shared VM) address of the registration, don&#39;t use it to id the connection since it can&#39;t...
Definition: api_common.h:337
int svm_queue_sub(svm_queue_t *q, u8 *elem, svm_q_conditional_wait_t cond, u32 time)
Definition: queue.c:348
static void clib_mem_set_thread_index(void)
Definition: mem.h:64
pthread_t rx_thread_handle
Definition: memory_client.h:32
void unserialize_open_data(serialize_main_t *m, u8 *data, uword n_data_bytes)
Definition: serialize.c:891
static void * svm_push_data_heap(svm_region_t *rp)
Definition: svm.h:86
static void * rx_thread_fn(void *arg)
Definition: memory_client.c:50
svm_region_t * vlib_rp
Current binary api segment descriptor.
Definition: api_common.h:276
struct vl_shmem_hdr_ * shmem_hdr
Binary API shared-memory segment header pointer.
Definition: api_common.h:286
unsigned int u32
Definition: types.h:88
void vl_msg_api_send_shmem(svm_queue_t *q, u8 *elem)
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
static void vl_api_memclnt_create_reply_t_handler(vl_api_memclnt_create_reply_t *mp)
int vl_client_connect(const char *name, int ctx_quota, int input_queue_size)
void vl_client_send_disconnect(u8 do_cleanup)
unsigned short u16
Definition: types.h:57
#define hash_free(h)
Definition: hash.h:310
int vl_client_connect_to_vlib_no_rx_pthread_no_map(const char *svm_name, const char *client_name, int rx_queue_size)
void clib_time_init(clib_time_t *c)
Definition: time.c:178
void unserialize_cstring(serialize_main_t *m, char **s)
Definition: serialize.c:178
#define CLIB_NOSANITIZE_ADDR
Definition: sanitizer.h:45
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:223
static void vl_api_memclnt_delete_reply_t_handler(vl_api_memclnt_delete_reply_t *mp)
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:342
static int connect_to_vlib_internal(const char *svm_name, const char *client_name, int rx_queue_size, void *(*thread_fn)(void *), int do_map)
#define clib_warning(format, args...)
Definition: error.h:59
int vl_client_api_map(const char *region_name)
static void unserialize_integer(serialize_main_t *m, void *x, u32 n_bytes)
Definition: serialize.h:201
u16 vl_client_get_first_plugin_msg_id(const char *plugin_name)
#define foreach_api_msg
svm_queue_t * vl_input_queue
Definition: memory_shared.h:84
u8 name[64]
Definition: ip.api:42
void vl_unmap_shmem_client(void)
static CLIB_NOSANITIZE_ADDR void VL_MSG_API_SVM_QUEUE_UNPOISON(const svm_queue_t *q)
Definition: api_common.h:153
void svm_queue_free(svm_queue_t *q)
Definition: queue.c:89
signed int i32
Definition: types.h:77
#define uword_to_pointer(u, type)
Definition: types.h:136
#define ASSERT(truth)
static CLIB_NOSANITIZE_ADDR void VL_API_VEC_UNPOISON(const void *v)
svm_queue_t * svm_queue_alloc_and_init(int nels, int elsize, int consumer_pid)
Allocate and initialize svm queue.
Definition: queue.c:72
vector header structure
Definition: vec_bootstrap.h:55
void vl_msg_api_queue_handler(svm_queue_t *q)
Definition: api_shared.c:841
pthread_t rx_thread_handle
Bin API thread handle.
Definition: api_common.h:364
void vl_client_install_client_message_handlers(void)
void vl_client_disconnect_from_vlib_no_unmap(void)
static void vl_api_get_first_msg_id_reply_t_handler(vl_api_get_first_msg_id_reply_t *mp)
static void vl_api_name_and_crc_free(void)
Definition: memory_client.c:78
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
int vl_client_disconnect(void)
u64 uword
Definition: types.h:112
static void vl_api_rx_thread_exit_t_handler(vl_api_rx_thread_exit_t *mp)
Definition: memory_client.c:70
struct _svm_queue svm_queue_t
memory_client_main_t memory_client_main
Definition: memory_client.c:47
void(** msg_handlers)(void *)
Message handler vector.
Definition: api_common.h:226
void vl_client_disconnect_from_vlib(void)
int vl_socket_client_write(void)
void * vl_msg_api_alloc_as_if_client(int nbytes)
uword * msg_index_by_name_and_crc
client message index hash table
Definition: api_common.h:343
api_main_t api_main
Definition: api_shared.c:35
volatile u8 first_msg_id_reply_ready
Definition: memory_client.h:34
pthread_mutex_t mutex
Definition: svm_common.h:37
static CLIB_NOSANITIZE_ADDR void VL_MSG_API_UNPOISON(const void *a)
Definition: api_common.h:146
non-blocking call - works with both condvar and eventfd signaling
Definition: queue.h:44
void vl_msg_api_handler(void *the_msg)
Definition: api_shared.c:631