FD.io VPP  v18.07-34-g55fbdb9
Vector Packet Processing
vapi.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2017 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 
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <stdint.h>
21 #include <arpa/inet.h>
22 #include <stddef.h>
23 #include <assert.h>
24 
25 #include <vpp-api/vapi/vapi_dbg.h>
26 #include <vpp-api/vapi/vapi.h>
28 #include <vppinfra/types.h>
29 #include <vppinfra/pool.h>
30 #include <vlib/vlib.h>
31 #include <vlibapi/api_common.h>
33 
34 #include <vapi/memclnt.api.vapi.h>
35 
36 /* we need to use control pings for some stuff and because we're forced to put
37  * the code in headers, we need a way to be able to grab the ids of these
38  * messages - so declare them here as extern */
41 
43 
44 struct
45 {
46  size_t count;
49 } __vapi_metadata;
50 
51 typedef struct
52 {
55  void *callback_ctx;
56  bool is_dump;
57 } vapi_req_t;
58 
59 static const u32 context_counter_mask = (1 << 31);
60 
61 typedef struct
62 {
63  vapi_error_e (*cb) (vapi_ctx_t ctx, void *callback_ctx, vapi_msg_id_t id,
64  void *payload);
65  void *ctx;
67 
68 typedef struct
69 {
70  vapi_error_e (*cb) (vapi_ctx_t ctx, void *callback_ctx, void *payload);
71  void *ctx;
73 
74 struct vapi_ctx_s
75 {
77  int requests_size; /* size of the requests array (circular queue) */
78  int requests_start; /* index of first request */
79  int requests_count; /* number of used slots */
87  bool connected;
89  pthread_mutex_t requests_mutex;
90 };
91 
92 u32
94 {
95  ++ctx->context_counter;
98 }
99 
100 size_t
102 {
103  return ctx->requests_count;
104 }
105 
106 bool
108 {
109  return (ctx->requests_count == ctx->requests_size);
110 }
111 
112 bool
114 {
115  return (0 == ctx->requests_count);
116 }
117 
118 static int
120 {
121  return (ctx->requests_start + ctx->requests_count) % ctx->requests_size;
122 }
123 
124 void
125 vapi_store_request (vapi_ctx_t ctx, u32 context, bool is_dump,
126  vapi_cb_t callback, void *callback_ctx)
127 {
128  assert (!vapi_requests_full (ctx));
129  /* if the mutex is not held, bad things will happen */
130  assert (0 != pthread_mutex_trylock (&ctx->requests_mutex));
131  const int requests_end = vapi_requests_end (ctx);
132  vapi_req_t *slot = &ctx->requests[requests_end];
133  slot->is_dump = is_dump;
134  slot->context = context;
135  slot->callback = callback;
136  slot->callback_ctx = callback_ctx;
137  VAPI_DBG ("stored@%d: context:%x (start is @%d)", requests_end, context,
138  ctx->requests_start);
139  ++ctx->requests_count;
140  assert (!vapi_requests_empty (ctx));
141 }
142 
143 #if VAPI_DEBUG_ALLOC
144 struct to_be_freed_s;
145 struct to_be_freed_s
146 {
147  void *v;
148  struct to_be_freed_s *next;
149 };
150 
151 static struct to_be_freed_s *to_be_freed = NULL;
152 
153 void
154 vapi_add_to_be_freed (void *v)
155 {
156  struct to_be_freed_s *prev = NULL;
157  struct to_be_freed_s *tmp;
158  tmp = to_be_freed;
159  while (tmp && tmp->v)
160  {
161  prev = tmp;
162  tmp = tmp->next;
163  }
164  if (!tmp)
165  {
166  if (!prev)
167  {
168  tmp = to_be_freed = calloc (1, sizeof (*to_be_freed));
169  }
170  else
171  {
172  tmp = prev->next = calloc (1, sizeof (*to_be_freed));
173  }
174  }
175  VAPI_DBG ("To be freed %p", v);
176  tmp->v = v;
177 }
178 
179 void
180 vapi_trace_free (void *v)
181 {
182  struct to_be_freed_s *tmp = to_be_freed;
183  while (tmp && tmp->v != v)
184  {
185  tmp = tmp->next;
186  }
187  if (tmp && tmp->v == v)
188  {
189  VAPI_DBG ("Freed %p", v);
190  tmp->v = NULL;
191  }
192  else
193  {
194  VAPI_ERR ("Trying to free untracked pointer %p", v);
195  abort ();
196  }
197 }
198 
199 void
200 vapi_to_be_freed_validate ()
201 {
202  struct to_be_freed_s *tmp = to_be_freed;
203  while (tmp)
204  {
205  if (tmp->v)
206  {
207  VAPI_ERR ("Unfreed msg %p!", tmp->v);
208  }
209  tmp = tmp->next;
210  }
211 }
212 
213 #endif
214 
215 void *
217 {
218  if (!ctx->connected)
219  {
220  return NULL;
221  }
222  void *rv = vl_msg_api_alloc_or_null (size);
223  return rv;
224 }
225 
226 void
228 {
229  if (!ctx->connected)
230  {
231  return;
232  }
233 #if VAPI_DEBUG_ALLOC
234  vapi_trace_free (msg);
235 #endif
236  vl_msg_api_free (msg);
237 }
238 
241 {
242  if (vl_msg_id <= ctx->vl_msg_id_max)
243  {
244  return ctx->vl_msg_id_to_vapi_msg_t[vl_msg_id];
245  }
246  return VAPI_INVALID_MSG_ID;
247 }
248 
251 {
252  vapi_ctx_t ctx = calloc (1, sizeof (struct vapi_ctx_s));
253  if (!ctx)
254  {
255  return VAPI_ENOMEM;
256  }
257  ctx->context_counter = 0;
259  malloc (__vapi_metadata.count *
260  sizeof (*ctx->vapi_msg_id_t_to_vl_msg_id));
261  if (!ctx->vapi_msg_id_t_to_vl_msg_id)
262  {
263  goto fail;
264  }
265  memset (ctx->vapi_msg_id_t_to_vl_msg_id, ~0,
266  __vapi_metadata.count * sizeof (*ctx->vapi_msg_id_t_to_vl_msg_id));
267  ctx->event_cbs = calloc (__vapi_metadata.count, sizeof (*ctx->event_cbs));
268  if (!ctx->event_cbs)
269  {
270  goto fail;
271  }
272  pthread_mutex_init (&ctx->requests_mutex, NULL);
273  *result = ctx;
274  return VAPI_OK;
275 fail:
276  vapi_ctx_free (ctx);
277  return VAPI_ENOMEM;
278 }
279 
280 void
282 {
283  assert (!ctx->connected);
284  free (ctx->requests);
285  free (ctx->vapi_msg_id_t_to_vl_msg_id);
286  free (ctx->event_cbs);
287  free (ctx->vl_msg_id_to_vapi_msg_t);
288  pthread_mutex_destroy (&ctx->requests_mutex);
289  free (ctx);
290 }
291 
292 bool
294 {
295  return vapi_lookup_vl_msg_id (ctx, id) != UINT16_MAX;
296 }
297 
299 vapi_connect (vapi_ctx_t ctx, const char *name,
300  const char *chroot_prefix,
301  int max_outstanding_requests,
302  int response_queue_size, vapi_mode_e mode,
303  bool handle_keepalives)
304 {
305  if (response_queue_size <= 0 || max_outstanding_requests <= 0)
306  {
307  return VAPI_EINVAL;
308  }
309  ctx->requests_size = max_outstanding_requests;
310  const size_t size = ctx->requests_size * sizeof (*ctx->requests);
311  void *tmp = realloc (ctx->requests, size);
312  if (!tmp)
313  {
314  return VAPI_ENOMEM;
315  }
316  ctx->requests = tmp;
317  memset (ctx->requests, 0, size);
318  /* coverity[MISSING_LOCK] - 177211 requests_mutex is not needed here */
319  ctx->requests_start = ctx->requests_count = 0;
320  if (chroot_prefix)
321  {
322  VAPI_DBG ("set memory root path `%s'", chroot_prefix);
323  vl_set_memory_root_path ((char *) chroot_prefix);
324  }
325  static char api_map[] = "/vpe-api";
326  VAPI_DBG ("client api map `%s'", api_map);
327  if ((vl_client_api_map (api_map)) < 0)
328  {
329  return VAPI_EMAP_FAIL;
330  }
331  VAPI_DBG ("connect client `%s'", name);
332  if (vl_client_connect ((char *) name, 0, response_queue_size) < 0)
333  {
335  return VAPI_ECON_FAIL;
336  }
337 #if VAPI_DEBUG_CONNECT
338  VAPI_DBG ("start probing messages");
339 #endif
340  int rv;
341  int i;
342  for (i = 0; i < __vapi_metadata.count; ++i)
343  {
344  vapi_message_desc_t *m = __vapi_metadata.msgs[i];
345  u8 scratch[m->name_with_crc_len + 1];
346  memcpy (scratch, m->name_with_crc, m->name_with_crc_len + 1);
347  u32 id = vl_msg_api_get_msg_index (scratch);
348  if (VAPI_INVALID_MSG_ID != id)
349  {
350  if (id > UINT16_MAX)
351  {
352  VAPI_ERR ("Returned vl_msg_id `%u' > UINT16MAX `%u'!", id,
353  UINT16_MAX);
354  rv = VAPI_EINVAL;
355  goto fail;
356  }
357  if (id > ctx->vl_msg_id_max)
358  {
359  vapi_msg_id_t *tmp = realloc (ctx->vl_msg_id_to_vapi_msg_t,
360  sizeof
361  (*ctx->vl_msg_id_to_vapi_msg_t) *
362  (id + 1));
363  if (!tmp)
364  {
365  rv = VAPI_ENOMEM;
366  goto fail;
367  }
368  ctx->vl_msg_id_to_vapi_msg_t = tmp;
369  ctx->vl_msg_id_max = id;
370  }
371  ctx->vl_msg_id_to_vapi_msg_t[id] = m->id;
372  ctx->vapi_msg_id_t_to_vl_msg_id[m->id] = id;
373 #if VAPI_DEBUG_CONNECT
374  VAPI_DBG ("Message `%s' has vl_msg_id `%u'", m->name_with_crc,
375  (unsigned) id);
376 #endif
377  }
378  else
379  {
380  ctx->vapi_msg_id_t_to_vl_msg_id[m->id] = UINT16_MAX;
381  VAPI_DBG ("Message `%s' not available", m->name_with_crc);
382  }
383  }
384 #if VAPI_DEBUG_CONNECT
385  VAPI_DBG ("finished probing messages");
386 #endif
387  if (!vapi_is_msg_available (ctx, vapi_msg_id_control_ping) ||
388  !vapi_is_msg_available (ctx, vapi_msg_id_control_ping_reply))
389  {
390  VAPI_ERR
391  ("control ping or control ping reply not available, cannot connect");
392  rv = VAPI_EINCOMPATIBLE;
393  goto fail;
394  }
395  ctx->mode = mode;
396  ctx->connected = true;
397  if (vapi_is_msg_available (ctx, vapi_msg_id_memclnt_keepalive))
398  {
400  }
401  else
402  {
403  ctx->handle_keepalives = false;
404  }
405  return VAPI_OK;
406 fail:
409  return rv;
410 }
411 
414 {
415  if (!ctx->connected)
416  {
417  return VAPI_EINVAL;
418  }
421 #if VAPI_DEBUG_ALLOC
422  vapi_to_be_freed_validate ();
423 #endif
424  ctx->connected = false;
425  return VAPI_OK;
426 }
427 
430 {
431  return VAPI_ENOTSUP;
432 }
433 
436 {
437  vapi_error_e rv = VAPI_OK;
438  if (!ctx || !msg || !ctx->connected)
439  {
440  rv = VAPI_EINVAL;
441  goto out;
442  }
443  int tmp;
445 #if VAPI_DEBUG
446  unsigned msgid = be16toh (*(u16 *) msg);
447  if (msgid <= ctx->vl_msg_id_max)
448  {
449  vapi_msg_id_t id = ctx->vl_msg_id_to_vapi_msg_t[msgid];
450  if (id < __vapi_metadata.count)
451  {
452  VAPI_DBG ("send msg@%p:%u[%s]", msg, msgid,
453  __vapi_metadata.msgs[id]->name);
454  }
455  else
456  {
457  VAPI_DBG ("send msg@%p:%u[UNKNOWN]", msg, msgid);
458  }
459  }
460  else
461  {
462  VAPI_DBG ("send msg@%p:%u[UNKNOWN]", msg, msgid);
463  }
464 #endif
465  tmp = svm_queue_add (q, (u8 *) & msg,
466  VAPI_MODE_BLOCKING == ctx->mode ? 0 : 1);
467  if (tmp < 0)
468  {
469  rv = VAPI_EAGAIN;
470  }
471 out:
472  VAPI_DBG ("vapi_send() rv = %d", rv);
473  return rv;
474 }
475 
477 vapi_send2 (vapi_ctx_t ctx, void *msg1, void *msg2)
478 {
479  vapi_error_e rv = VAPI_OK;
480  if (!ctx || !msg1 || !msg2 || !ctx->connected)
481  {
482  rv = VAPI_EINVAL;
483  goto out;
484  }
486 #if VAPI_DEBUG
487  unsigned msgid1 = be16toh (*(u16 *) msg1);
488  unsigned msgid2 = be16toh (*(u16 *) msg2);
489  const char *name1 = "UNKNOWN";
490  const char *name2 = "UNKNOWN";
491  if (msgid1 <= ctx->vl_msg_id_max)
492  {
493  vapi_msg_id_t id = ctx->vl_msg_id_to_vapi_msg_t[msgid1];
494  if (id < __vapi_metadata.count)
495  {
496  name1 = __vapi_metadata.msgs[id]->name;
497  }
498  }
499  if (msgid2 <= ctx->vl_msg_id_max)
500  {
501  vapi_msg_id_t id = ctx->vl_msg_id_to_vapi_msg_t[msgid2];
502  if (id < __vapi_metadata.count)
503  {
504  name2 = __vapi_metadata.msgs[id]->name;
505  }
506  }
507  VAPI_DBG ("send two: %u[%s], %u[%s]", msgid1, name1, msgid2, name2);
508 #endif
509  int tmp = svm_queue_add2 (q, (u8 *) & msg1, (u8 *) & msg2,
510  VAPI_MODE_BLOCKING == ctx->mode ? 0 : 1);
511  if (tmp < 0)
512  {
513  rv = VAPI_EAGAIN;
514  }
515 out:
516  VAPI_DBG ("vapi_send() rv = %d", rv);
517  return rv;
518 }
519 
521 vapi_recv (vapi_ctx_t ctx, void **msg, size_t * msg_size,
522  svm_q_conditional_wait_t cond, u32 time)
523 {
524  if (!ctx || !ctx->connected || !msg || !msg_size)
525  {
526  return VAPI_EINVAL;
527  }
528  vapi_error_e rv = VAPI_OK;
529  api_main_t *am = &api_main;
530  uword data;
531 
532  if (am->our_pid == 0)
533  {
534  return VAPI_EINVAL;
535  }
536 
537  svm_queue_t *q = am->vl_input_queue;
538 again:
539  VAPI_DBG ("doing shm queue sub");
540 
541  int tmp = svm_queue_sub (q, (u8 *) & data, cond, time);
542 
543  if (tmp == 0)
544  {
545 #if VAPI_DEBUG_ALLOC
546  vapi_add_to_be_freed ((void *) data);
547 #endif
548  msgbuf_t *msgbuf =
549  (msgbuf_t *) ((u8 *) data - offsetof (msgbuf_t, data));
550  if (!msgbuf->data_len)
551  {
552  vapi_msg_free (ctx, (u8 *) data);
553  return VAPI_EAGAIN;
554  }
555  *msg = (u8 *) data;
556  *msg_size = ntohl (msgbuf->data_len);
557 #if VAPI_DEBUG
558  unsigned msgid = be16toh (*(u16 *) * msg);
559  if (msgid <= ctx->vl_msg_id_max)
560  {
561  vapi_msg_id_t id = ctx->vl_msg_id_to_vapi_msg_t[msgid];
562  if (id < __vapi_metadata.count)
563  {
564  VAPI_DBG ("recv msg@%p:%u[%s]", *msg, msgid,
565  __vapi_metadata.msgs[id]->name);
566  }
567  else
568  {
569  VAPI_DBG ("recv msg@%p:%u[UNKNOWN]", *msg, msgid);
570  }
571  }
572  else
573  {
574  VAPI_DBG ("recv msg@%p:%u[UNKNOWN]", *msg, msgid);
575  }
576 #endif
577  if (ctx->handle_keepalives)
578  {
579  unsigned msgid = be16toh (*(u16 *) * msg);
580  if (msgid ==
581  vapi_lookup_vl_msg_id (ctx, vapi_msg_id_memclnt_keepalive))
582  {
583  vapi_msg_memclnt_keepalive_reply *reply = NULL;
584  do
585  {
586  reply = vapi_msg_alloc (ctx, sizeof (*reply));
587  }
588  while (!reply);
589  reply->header.context = vapi_get_client_index (ctx);
590  reply->header._vl_msg_id =
592  vapi_msg_id_memclnt_keepalive_reply);
593  reply->payload.retval = 0;
594  vapi_msg_memclnt_keepalive_reply_hton (reply);
595  while (VAPI_EAGAIN == vapi_send (ctx, reply));
596  vapi_msg_free (ctx, *msg);
597  VAPI_DBG ("autohandled memclnt_keepalive");
598  goto again;
599  }
600  }
601  }
602  else
603  {
604  rv = VAPI_EAGAIN;
605  }
606  return rv;
607 }
608 
611 {
612  return VAPI_ENOTSUP;
613 }
614 
615 static vapi_error_e
617  u32 context, void *msg)
618 {
619  int mrv;
620  if (0 != (mrv = pthread_mutex_lock (&ctx->requests_mutex)))
621  {
622  VAPI_DBG ("pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
623  return VAPI_MUTEX_FAILURE;
624  }
625  int tmp = ctx->requests_start;
626  const int requests_end = vapi_requests_end (ctx);
627  while (ctx->requests[tmp].context != context && tmp != requests_end)
628  {
629  ++tmp;
630  if (tmp == ctx->requests_size)
631  {
632  tmp = 0;
633  }
634  }
635  VAPI_DBG ("dispatch, search from %d, %s at %d", ctx->requests_start,
636  ctx->requests[tmp].context == context ? "matched" : "stopped",
637  tmp);
638  vapi_error_e rv = VAPI_OK;
639  if (ctx->requests[tmp].context == context)
640  {
641  while (ctx->requests_start != tmp)
642  {
643  VAPI_ERR ("No response to req with context=%u",
644  (unsigned) ctx->requests[tmp].context);
645  ctx->requests[ctx->requests_start].callback (ctx, ctx->requests
646  [ctx->
648  VAPI_ENORESP, true,
649  NULL);
650  memset (&ctx->requests[ctx->requests_start], 0,
651  sizeof (ctx->requests[ctx->requests_start]));
652  ++ctx->requests_start;
653  --ctx->requests_count;
654  if (ctx->requests_start == ctx->requests_size)
655  {
656  ctx->requests_start = 0;
657  }
658  }
659  // now ctx->requests_start == tmp
660  int payload_offset = vapi_get_payload_offset (id);
661  void *payload = ((u8 *) msg) + payload_offset;
662  bool is_last = true;
663  if (ctx->requests[tmp].is_dump)
664  {
665  if (vapi_msg_id_control_ping_reply == id)
666  {
667  payload = NULL;
668  }
669  else
670  {
671  is_last = false;
672  }
673  }
674  if (payload_offset != -1)
675  {
676  rv =
677  ctx->requests[tmp].callback (ctx, ctx->requests[tmp].callback_ctx,
678  VAPI_OK, is_last, payload);
679  }
680  else
681  {
682  /* this is a message without payload, so bend the callback a little
683  */
684  rv =
685  ((vapi_error_e (*)(vapi_ctx_t, void *, vapi_error_e, bool))
686  ctx->requests[tmp].callback) (ctx,
687  ctx->requests[tmp].callback_ctx,
688  VAPI_OK, is_last);
689  }
690  if (is_last)
691  {
692  memset (&ctx->requests[ctx->requests_start], 0,
693  sizeof (ctx->requests[ctx->requests_start]));
694  ++ctx->requests_start;
695  --ctx->requests_count;
696  if (ctx->requests_start == ctx->requests_size)
697  {
698  ctx->requests_start = 0;
699  }
700  }
701  VAPI_DBG ("after dispatch, req start = %d, end = %d, count = %d",
702  ctx->requests_start, requests_end, ctx->requests_count);
703  }
704  if (0 != (mrv = pthread_mutex_unlock (&ctx->requests_mutex)))
705  {
706  VAPI_DBG ("pthread_mutex_unlock() failed, rv=%d:%s", mrv,
707  strerror (mrv));
708  abort (); /* this really shouldn't happen */
709  }
710  return rv;
711 }
712 
713 static vapi_error_e
715 {
716  if (ctx->event_cbs[id].cb)
717  {
718  return ctx->event_cbs[id].cb (ctx, ctx->event_cbs[id].ctx, msg);
719  }
720  else if (ctx->generic_cb.cb)
721  {
722  return ctx->generic_cb.cb (ctx, ctx->generic_cb.ctx, id, msg);
723  }
724  else
725  {
726  VAPI_DBG
727  ("No handler/generic handler for msg id %u[%s], message ignored",
728  (unsigned) id, __vapi_metadata.msgs[id]->name);
729  }
730  return VAPI_OK;
731 }
732 
733 bool
735 {
736  assert (id <= __vapi_metadata.count);
737  return __vapi_metadata.msgs[id]->has_context;
738 }
739 
742 {
743  VAPI_DBG ("vapi_dispatch_one()");
744  void *msg;
745  size_t size;
746  vapi_error_e rv = vapi_recv (ctx, &msg, &size, SVM_Q_WAIT, 0);
747  if (VAPI_OK != rv)
748  {
749  VAPI_DBG ("vapi_recv failed with rv=%d", rv);
750  return rv;
751  }
752  u16 vpp_id = be16toh (*(u16 *) msg);
753  if (vpp_id > ctx->vl_msg_id_max)
754  {
755  VAPI_ERR ("Unknown msg ID received, id `%u', out of range <0,%u>",
756  (unsigned) vpp_id, (unsigned) ctx->vl_msg_id_max);
757  vapi_msg_free (ctx, msg);
758  return VAPI_EINVAL;
759  }
760  if (VAPI_INVALID_MSG_ID == (unsigned) ctx->vl_msg_id_to_vapi_msg_t[vpp_id])
761  {
762  VAPI_ERR ("Unknown msg ID received, id `%u' marked as not supported",
763  (unsigned) vpp_id);
764  vapi_msg_free (ctx, msg);
765  return VAPI_EINVAL;
766  }
767  const vapi_msg_id_t id = ctx->vl_msg_id_to_vapi_msg_t[vpp_id];
768  const size_t expect_size = vapi_get_message_size (id);
769  if (size < expect_size)
770  {
771  VAPI_ERR
772  ("Invalid msg received, unexpected size `%zu' < expected min `%zu'",
773  size, expect_size);
774  vapi_msg_free (ctx, msg);
775  return VAPI_EINVAL;
776  }
777  u32 context;
778  vapi_get_swap_to_host_func (id) (msg);
779  if (vapi_msg_is_with_context (id))
780  {
781  context = *(u32 *) (((u8 *) msg) + vapi_get_context_offset (id));
782  /* is this a message originating from VAPI? */
783  VAPI_DBG ("dispatch, context is %x", context);
784  if (context & context_counter_mask)
785  {
786  rv = vapi_dispatch_response (ctx, id, context, msg);
787  goto done;
788  }
789  }
790  rv = vapi_dispatch_event (ctx, id, msg);
791 
792 done:
793  vapi_msg_free (ctx, msg);
794  return rv;
795 }
796 
799 {
800  vapi_error_e rv = VAPI_OK;
801  while (!vapi_requests_empty (ctx))
802  {
803  rv = vapi_dispatch_one (ctx);
804  if (VAPI_OK != rv)
805  {
806  return rv;
807  }
808  }
809  return rv;
810 }
811 
812 void
814  vapi_event_cb callback, void *callback_ctx)
815 {
816  vapi_event_cb_with_ctx *c = &ctx->event_cbs[id];
817  c->cb = callback;
818  c->ctx = callback_ctx;
819 }
820 
821 void
823 {
824  vapi_set_event_cb (ctx, id, NULL, NULL);
825 }
826 
827 void
829  void *callback_ctx)
830 {
831  ctx->generic_cb.cb = callback;
832  ctx->generic_cb.ctx = callback_ctx;
833 }
834 
835 void
837 {
838  ctx->generic_cb.cb = NULL;
839  ctx->generic_cb.ctx = NULL;
840 }
841 
842 u16
844 {
845  assert (id < __vapi_metadata.count);
846  return ctx->vapi_msg_id_t_to_vl_msg_id[id];
847 }
848 
849 int
851 {
852  return api_main.my_client_index;
853 }
854 
855 bool
857 {
858  return (VAPI_MODE_NONBLOCKING == ctx->mode);
859 }
860 
861 size_t
863 {
864  return ctx->requests_size - 1;
865 }
866 
867 int
869 {
870  assert (id < __vapi_metadata.count);
871  return __vapi_metadata.msgs[id]->payload_offset;
872 }
873 
875 {
876  assert (id < __vapi_metadata.count);
877  return __vapi_metadata.msgs[id]->swap_to_host;
878 }
879 
880 void (*vapi_get_swap_to_be_func (vapi_msg_id_t id)) (void *msg)
881 {
882  assert (id < __vapi_metadata.count);
883  return __vapi_metadata.msgs[id]->swap_to_be;
884 }
885 
886 size_t
888 {
889  assert (id < __vapi_metadata.count);
890  return __vapi_metadata.msgs[id]->size;
891 }
892 
893 size_t
895 {
896  assert (id < __vapi_metadata.count);
897  return __vapi_metadata.msgs[id]->context_offset;
898 }
899 
902 {
903  int i = 0;
904  for (i = 0; i < __vapi_metadata.count; ++i)
905  {
906  if (!strcmp
907  (msg->name_with_crc, __vapi_metadata.msgs[i]->name_with_crc))
908  {
909  /* this happens if somebody is linking together several objects while
910  * using the static inline headers, just fill in the already
911  * assigned id here so that all the objects are in sync */
912  msg->id = __vapi_metadata.msgs[i]->id;
913  return msg->id;
914  }
915  }
916  vapi_msg_id_t id = __vapi_metadata.count;
917  ++__vapi_metadata.count;
918  __vapi_metadata.msgs =
919  realloc (__vapi_metadata.msgs,
920  sizeof (*__vapi_metadata.msgs) * __vapi_metadata.count);
921  __vapi_metadata.msgs[id] = msg;
922  size_t s = strlen (msg->name_with_crc);
923  if (s > __vapi_metadata.max_len_name_with_crc)
924  {
925  __vapi_metadata.max_len_name_with_crc = s;
926  }
927  msg->id = id;
928  return id;
929 }
930 
933 {
934  int mrv;
935  if (0 != (mrv = pthread_mutex_lock (&ctx->requests_mutex)))
936  {
937  VAPI_DBG ("pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
938  (void) mrv; /* avoid warning if the above debug is not enabled */
939  return VAPI_MUTEX_FAILURE;
940  }
941  return VAPI_OK;
942 }
943 
946 {
947  int mrv;
948  if (0 != (mrv = pthread_mutex_unlock (&ctx->requests_mutex)))
949  {
950  VAPI_DBG ("pthread_mutex_unlock() failed, rv=%d:%s", mrv,
951  strerror (mrv));
952  (void) mrv; /* avoid warning if the above debug is not enabled */
953  return VAPI_MUTEX_FAILURE;
954  }
955  return VAPI_OK;
956 }
957 
958 size_t
960 {
961  return __vapi_metadata.count;
962 }
963 
964 const char *
966 {
967  return __vapi_metadata.msgs[id]->name;
968 }
969 
970 /*
971  * fd.io coding-style-patch-verification: ON
972  *
973  * Local Variables:
974  * eval: (c-set-style "gnu")
975  * End:
976  */
failure manipulating internal mutex(es)
Definition: vapi_common.h:37
vapi_msg_id_t id
Definition: vapi_internal.h:98
operations block until response received
Definition: vapi_common.h:44
int svm_queue_add(svm_queue_t *q, u8 *elem, int nowait)
Definition: queue.c:184
operations never block
Definition: vapi_common.h:45
size_t vapi_get_message_count()
Definition: vapi.c:959
void * callback_ctx
Definition: vapi.c:55
Fixed length block allocator.
bool handle_keepalives
Definition: vapi.c:88
int my_client_index
All VLIB-side message handlers use my_client_index to identify the queue / client.
Definition: api_common.h:309
u32 context
Definition: vapi.c:53
#define NULL
Definition: clib.h:55
u16 vl_msg_id_max
Definition: vapi.c:85
operation would block
Definition: vapi_common.h:29
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, vapi_msg_id_t id, void *payload)
Definition: vapi.c:63
vapi_error_e vapi_recv(vapi_ctx_t ctx, void **msg, size_t *msg_size, svm_q_conditional_wait_t cond, u32 time)
low-level api for reading messages from vpp
Definition: vapi.c:521
int i
vapi_error_e vapi_send(vapi_ctx_t ctx, void *msg)
low-level api for sending messages to vpp
Definition: vapi.c:435
vapi_mode_e
Definition: vapi_common.h:42
int requests_start
Definition: vapi.c:78
bool connected
Definition: vapi.c:87
int requests_size
Definition: vapi.c:77
vapi_error_e vapi_connect(vapi_ctx_t ctx, const char *name, const char *chroot_prefix, int max_outstanding_requests, int response_queue_size, vapi_mode_e mode, bool handle_keepalives)
connect to vpp
Definition: vapi.c:299
vapi_cb_t callback
Definition: vapi.c:54
svm_queue_t * vl_input_queue
Peer input queue pointer.
Definition: api_common.h:303
void * vapi_msg_alloc(vapi_ctx_t ctx, size_t size)
allocate vapi message of given size
Definition: vapi.c:216
void vapi_store_request(vapi_ctx_t ctx, u32 context, bool is_dump, vapi_cb_t callback, void *callback_ctx)
Definition: vapi.c:125
vapi_msg_id_t * vl_msg_id_to_vapi_msg_t
Definition: vapi.c:86
#define vl_msg_id(n, h)
unsigned char u8
Definition: types.h:56
out of memory
Definition: vapi_common.h:31
void vl_client_api_unmap(void)
int our_pid
Current process PID.
Definition: api_common.h:251
vapi_req_t * requests
Definition: vapi.c:80
vapi_msg_id_t vapi_register_msg(vapi_message_desc_t *msg)
Definition: vapi.c:901
vapi_error_e(* vapi_generic_event_cb)(vapi_ctx_t ctx, void *callback_ctx, vapi_msg_id_t id, void *msg)
generic vapi event callback
Definition: vapi.h:233
vapi_error_e vapi_send2(vapi_ctx_t ctx, void *msg1, void *msg2)
low-level api for atomically sending two messages to vpp - either both messages are sent or neither o...
Definition: vapi.c:477
size_t vapi_get_message_size(vapi_msg_id_t id)
Definition: vapi.c:887
int svm_queue_sub(svm_queue_t *q, u8 *elem, svm_q_conditional_wait_t cond, u32 time)
Definition: queue.c:303
fundamental incompatibility while connecting to vpp (control ping/control ping reply mismatch) ...
Definition: vapi_common.h:35
size_t vapi_get_request_count(vapi_ctx_t ctx)
Definition: vapi.c:101
operation not supported
Definition: vapi_common.h:30
vapi_error_e vapi_disconnect(vapi_ctx_t ctx)
disconnect from vpp
Definition: vapi.c:413
static vapi_error_e vapi_dispatch_event(vapi_ctx_t ctx, vapi_msg_id_t id, void *msg)
Definition: vapi.c:714
bool vapi_is_nonblocking(vapi_ctx_t ctx)
Definition: vapi.c:856
struct vl_shmem_hdr_ * shmem_hdr
Binary API shared-memory segment header pointer.
Definition: api_common.h:264
vapi_message_desc_t ** msgs
Definition: vapi.c:47
unsigned int u32
Definition: types.h:88
#define VAPI_INVALID_MSG_ID
Definition: vapi_common.h:57
int vapi_get_payload_offset(vapi_msg_id_t id)
Definition: vapi.c:868
size_t vapi_get_context_offset(vapi_msg_id_t id)
Definition: vapi.c:894
vapi_event_cb_with_ctx * event_cbs
Definition: vapi.c:83
int svm_queue_add2(svm_queue_t *q, u8 *elem, u8 *elem2, int nowait)
Definition: queue.c:239
size_t vapi_get_max_request_count(vapi_ctx_t ctx)
Definition: vapi.c:862
void vl_set_memory_root_path(const char *name)
vapi_msg_id_t vapi_msg_id_control_ping_reply
Definition: vapi.c:40
int vl_client_connect(const char *name, int ctx_quota, int input_queue_size)
const char * vapi_get_msg_name(vapi_msg_id_t id)
Definition: vapi.c:965
uword size
int requests_count
Definition: vapi.c:79
const char * name_with_crc
Definition: vapi_internal.h:90
u32 vapi_gen_req_context(vapi_ctx_t ctx)
Definition: vapi.c:93
void vapi_set_generic_event_cb(vapi_ctx_t ctx, vapi_generic_event_cb callback, void *callback_ctx)
set generic event callback
Definition: vapi.c:828
bool vapi_requests_empty(vapi_ctx_t ctx)
Definition: vapi.c:113
#define v
Definition: acl.c:491
unsigned short u16
Definition: types.h:57
void(*)(void *msg) vapi_get_swap_to_host_func(vapi_msg_id_t id)
Definition: vapi.c:874
void(*)(void *msg) vapi_get_swap_to_be_func(vapi_msg_id_t id)
Definition: vapi.c:880
invalid value encountered
Definition: vapi_common.h:28
common vpp api C declarations
size_t max_len_name_with_crc
Definition: vapi.c:48
#define VAPI_DBG(...)
Definition: vapi_dbg.h:65
vapi_error_e vapi_dispatch(vapi_ctx_t ctx)
loop vapi_dispatch_one until responses to all currently outstanding requests have been received and t...
Definition: vapi.c:798
no response to request
Definition: vapi_common.h:32
bool is_dump
Definition: vapi.c:56
failure while mapping api
Definition: vapi_common.h:33
vapi_error_e(* vapi_cb_t)(struct vapi_ctx_s *, void *, vapi_error_e, bool, void *)
Definition: vapi_internal.h:81
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:201
bool vapi_msg_is_with_context(vapi_msg_id_t id)
Definition: vapi.c:734
static vapi_error_e vapi_dispatch_response(vapi_ctx_t ctx, vapi_msg_id_t id, u32 context, void *msg)
Definition: vapi.c:616
vapi_msg_id_t vapi_lookup_vapi_msg_id_t(vapi_ctx_t ctx, u16 vl_msg_id)
Definition: vapi.c:240
svmdb_client_t * c
svm_q_conditional_wait_t
Definition: queue.h:39
u32 vl_msg_api_get_msg_index(u8 *name_and_crc)
Definition: api_shared.c:944
struct vapi_ctx_s * vapi_ctx_t
Definition: vapi.h:46
int vl_client_api_map(const char *region_name)
static const u32 context_counter_mask
Definition: vapi.c:59
blocking call
Definition: queue.h:44
vapi_wait_mode_e
Definition: vapi_common.h:48
pthread_mutex_t requests_mutex
Definition: vapi.c:89
internal vpp api C declarations
svm_queue_t * vl_input_queue
Definition: memory_shared.h:84
vapi_msg_id_t vapi_msg_id_control_ping
Definition: vapi.c:39
u16 vapi_lookup_vl_msg_id(vapi_ctx_t ctx, vapi_msg_id_t id)
Definition: vapi.c:843
bool vapi_is_msg_available(vapi_ctx_t ctx, vapi_msg_id_t id)
check if message identified by it&#39;s message id is known by the vpp to which the connection is open ...
Definition: vapi.c:293
success
Definition: vapi_common.h:27
long ctx[MAX_CONNS]
Definition: main.c:126
u32 data_len
message length not including header
Definition: api_common.h:138
Message header structure.
Definition: api_common.h:135
#define bool
Definition: radix.c:95
size_t count
Definition: vapi.c:46
DEFINE_VAPI_MSG_IDS_MEMCLNT_API_JSON
Definition: vapi.c:42
int vapi_get_client_index(vapi_ctx_t ctx)
Definition: vapi.c:850
void vl_msg_api_free(void *)
void vapi_ctx_free(vapi_ctx_t ctx)
free vapi context
Definition: vapi.c:281
u32 context_counter
Definition: vapi.c:81
void vapi_clear_generic_event_cb(vapi_ctx_t ctx)
clear generic event callback
Definition: vapi.c:836
vapi_error_e(* vapi_event_cb)(vapi_ctx_t ctx, void *callback_ctx, void *payload)
generic vapi event callback
Definition: vapi.h:210
vapi_error_e vapi_dispatch_one(vapi_ctx_t ctx)
pick next message sent by vpp and call the appropriate callback
Definition: vapi.c:741
vapi_error_e vapi_producer_unlock(vapi_ctx_t ctx)
Definition: vapi.c:945
int vl_client_disconnect(void)
u64 uword
Definition: types.h:112
bool vapi_requests_full(vapi_ctx_t ctx)
Definition: vapi.c:107
vapi_error_e vapi_get_fd(vapi_ctx_t ctx, int *fd)
get event file descriptor
Definition: vapi.c:429
struct _svm_queue svm_queue_t
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, void *payload)
Definition: vapi.c:70
void vapi_msg_free(vapi_ctx_t ctx, void *msg)
free a vapi message
Definition: vapi.c:227
vapi_error_e vapi_producer_lock(vapi_ctx_t ctx)
Definition: vapi.c:932
u16 * vapi_msg_id_t_to_vl_msg_id
Definition: vapi.c:84
vapi_mode_e mode
Definition: vapi.c:76
vapi_error_e vapi_ctx_alloc(vapi_ctx_t *result)
allocate vapi context
Definition: vapi.c:250
void * vl_msg_api_alloc_or_null(int nbytes)
unsigned int vapi_msg_id_t
Definition: vapi_common.h:55
void vapi_set_event_cb(vapi_ctx_t ctx, vapi_msg_id_t id, vapi_event_cb callback, void *callback_ctx)
set event callback to call when message with given id is dispatched
Definition: vapi.c:813
api_main_t api_main
Definition: api_shared.c:35
void vapi_clear_event_cb(vapi_ctx_t ctx, vapi_msg_id_t id)
clear event callback for given message id
Definition: vapi.c:822
vapi_generic_cb_with_ctx generic_cb
Definition: vapi.c:82
static int vapi_requests_end(vapi_ctx_t ctx)
Definition: vapi.c:119
vapi_error_e
Definition: vapi_common.h:25
#define VAPI_ERR(...)
Definition: vapi_dbg.h:66
vapi_error_e vapi_wait(vapi_ctx_t ctx, vapi_wait_mode_e mode)
wait for connection to become readable or writable
Definition: vapi.c:610
failure while connecting to vpp
Definition: vapi_common.h:34