21 #include <arpa/inet.h> 34 #include <vapi/memclnt.api.vapi.h> 138 VAPI_DBG (
"stored@%d: context:%x (start is @%d)", requests_end, context,
145 struct to_be_freed_s;
149 struct to_be_freed_s *next;
152 static struct to_be_freed_s *to_be_freed = NULL;
155 vapi_add_to_be_freed (
void *v)
157 struct to_be_freed_s *prev = NULL;
158 struct to_be_freed_s *tmp;
160 while (tmp && tmp->v)
169 tmp = to_be_freed = calloc (1,
sizeof (*to_be_freed));
173 tmp = prev->next = calloc (1,
sizeof (*to_be_freed));
181 vapi_trace_free (
void *v)
183 struct to_be_freed_s *tmp = to_be_freed;
184 while (tmp && tmp->v != v)
188 if (tmp && tmp->v == v)
195 VAPI_ERR (
"Trying to free untracked pointer %p", v);
201 vapi_to_be_freed_validate ()
203 struct to_be_freed_s *tmp = to_be_freed;
208 VAPI_ERR (
"Unfreed msg %p!", tmp->v);
239 vapi_trace_free (msg);
264 malloc (__vapi_metadata.count *
271 __vapi_metadata.count *
306 const char *chroot_prefix,
307 int max_outstanding_requests,
311 if (response_queue_size <= 0 || max_outstanding_requests <= 0)
321 void *tmp = realloc (ctx->
requests, size);
332 VAPI_DBG (
"set memory root path `%s'", chroot_prefix);
335 static char api_map[] =
"/vpe-api";
336 VAPI_DBG (
"client api map `%s'", api_map);
341 VAPI_DBG (
"connect client `%s'", name);
347 #if VAPI_DEBUG_CONNECT 348 VAPI_DBG (
"start probing messages");
352 for (i = 0; i < __vapi_metadata.count; ++
i)
362 VAPI_ERR (
"Returned vl_msg_id `%u' > UINT16MAX `%u'!",
id,
383 #if VAPI_DEBUG_CONNECT 394 #if VAPI_DEBUG_CONNECT 395 VAPI_DBG (
"finished probing messages");
401 (
"control ping or control ping reply not available, cannot connect");
432 vapi_to_be_freed_validate ();
456 unsigned msgid = be16toh (*(
u16 *) msg);
460 if (
id < __vapi_metadata.count)
462 VAPI_DBG (
"send msg@%p:%u[%s]", msg, msgid,
463 __vapi_metadata.msgs[
id]->name);
467 VAPI_DBG (
"send msg@%p:%u[UNKNOWN]", msg, msgid);
472 VAPI_DBG (
"send msg@%p:%u[UNKNOWN]", msg, msgid);
484 VAPI_DBG (
"vapi_send() rv = %d", rv);
492 if (!ctx || !msg1 || !msg2 || !ctx->
connected)
499 unsigned msgid1 = be16toh (*(
u16 *) msg1);
500 unsigned msgid2 = be16toh (*(
u16 *) msg2);
501 const char *name1 =
"UNKNOWN";
502 const char *name2 =
"UNKNOWN";
506 if (
id < __vapi_metadata.count)
508 name1 = __vapi_metadata.msgs[
id]->name;
511 if (msgid2 <= ctx->vl_msg_id_max)
514 if (
id < __vapi_metadata.count)
516 name2 = __vapi_metadata.msgs[
id]->name;
519 VAPI_DBG (
"send two: %u[%s], %u[%s]", msgid1, name1, msgid2, name2);
530 VAPI_DBG (
"vapi_send() rv = %d", rv);
538 if (!ctx || !ctx->
connected || !msg || !msg_size)
561 vapi_add_to_be_freed ((
void *) data);
571 *msg_size = ntohl (msgbuf->
data_len);
573 unsigned msgid = be16toh (*(
u16 *) * msg);
577 if (
id < __vapi_metadata.count)
579 VAPI_DBG (
"recv msg@%p:%u[%s]", *msg, msgid,
580 __vapi_metadata.msgs[
id]->name);
584 VAPI_DBG (
"recv msg@%p:%u[UNKNOWN]", *msg, msgid);
589 VAPI_DBG (
"recv msg@%p:%u[UNKNOWN]", *msg, msgid);
594 unsigned msgid = be16toh (*(
u16 *) * msg);
598 vapi_msg_memclnt_keepalive_reply *reply = NULL;
605 reply->header._vl_msg_id =
607 vapi_msg_id_memclnt_keepalive_reply);
608 reply->payload.retval = 0;
609 vapi_msg_memclnt_keepalive_reply_hton (reply);
612 VAPI_DBG (
"autohandled memclnt_keepalive");
632 u32 context,
void *msg)
637 VAPI_DBG (
"pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
658 VAPI_ERR (
"No response to req with context=%u",
676 void *payload = ((
u8 *) msg) + payload_offset;
680 if (vapi_msg_id_control_ping_reply ==
id)
689 if (payload_offset != -1)
716 VAPI_DBG (
"after dispatch, req start = %d, end = %d, count = %d",
721 VAPI_DBG (
"pthread_mutex_unlock() failed, rv=%d:%s", mrv,
742 (
"No handler/generic handler for msg id %u[%s], message ignored",
743 (
unsigned)
id, __vapi_metadata.msgs[
id]->name);
751 assert (
id <= __vapi_metadata.count);
752 return __vapi_metadata.msgs[
id]->has_context;
764 VAPI_DBG (
"vapi_recv failed with rv=%d", rv);
767 u16 vpp_id = be16toh (*(
u16 *) msg);
770 VAPI_ERR (
"Unknown msg ID received, id `%u', out of range <0,%u>",
777 VAPI_ERR (
"Unknown msg ID received, id `%u' marked as not supported",
784 if (size < expect_size)
787 (
"Invalid msg received, unexpected size `%zu' < expected min `%zu'",
798 VAPI_DBG (
"dispatch, context is %x", context);
799 if (context & context_counter_mask)
833 c->
ctx = callback_ctx;
860 assert (
id < __vapi_metadata.count);
885 assert (
id < __vapi_metadata.count);
886 return __vapi_metadata.msgs[
id]->payload_offset;
891 assert (
id < __vapi_metadata.count);
892 return __vapi_metadata.msgs[
id]->swap_to_host;
897 assert (
id < __vapi_metadata.count);
898 return __vapi_metadata.msgs[
id]->swap_to_be;
904 assert (
id < __vapi_metadata.count);
905 return __vapi_metadata.msgs[
id]->size;
911 assert (
id < __vapi_metadata.count);
912 return __vapi_metadata.msgs[
id]->context_offset;
919 for (i = 0; i < __vapi_metadata.count; ++
i)
922 (msg->
name_with_crc, __vapi_metadata.msgs[i]->name_with_crc))
927 msg->
id = __vapi_metadata.msgs[
i]->id;
932 ++__vapi_metadata.count;
933 __vapi_metadata.msgs =
934 realloc (__vapi_metadata.msgs,
935 sizeof (*__vapi_metadata.msgs) * __vapi_metadata.count);
936 __vapi_metadata.msgs[
id] = msg;
938 if (s > __vapi_metadata.max_len_name_with_crc)
940 __vapi_metadata.max_len_name_with_crc = s;
952 VAPI_DBG (
"pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
965 VAPI_DBG (
"pthread_mutex_unlock() failed, rv=%d:%s", mrv,
976 return __vapi_metadata.count;
982 return __vapi_metadata.msgs[
id]->name;
failure manipulating internal mutex(es)
operations block until response received
int svm_queue_add(svm_queue_t *q, u8 *elem, int nowait)
size_t vapi_get_message_count()
Fixed length block allocator.
int my_client_index
All VLIB-side message handlers use my_client_index to identify the queue / client.
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static void VL_MSG_API_POISON(const void *a)
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, vapi_msg_id_t id, void *payload)
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
vapi_error_e vapi_send(vapi_ctx_t ctx, void *msg)
low-level api for sending messages to vpp
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
svm_queue_t * vl_input_queue
Peer input queue pointer.
void * vapi_msg_alloc(vapi_ctx_t ctx, size_t size)
allocate vapi message of given size
void vapi_store_request(vapi_ctx_t ctx, u32 context, bool is_dump, vapi_cb_t callback, void *callback_ctx)
vapi_msg_id_t * vl_msg_id_to_vapi_msg_t
void vl_client_api_unmap(void)
int our_pid
Current process PID.
vapi_msg_id_t vapi_register_msg(vapi_message_desc_t *msg)
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
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...
size_t vapi_get_message_size(vapi_msg_id_t id)
int svm_queue_sub(svm_queue_t *q, u8 *elem, svm_q_conditional_wait_t cond, u32 time)
fundamental incompatibility while connecting to vpp (control ping/control ping reply mismatch) ...
size_t vapi_get_request_count(vapi_ctx_t ctx)
vapi_error_e vapi_disconnect(vapi_ctx_t ctx)
disconnect from vpp
static vapi_error_e vapi_dispatch_event(vapi_ctx_t ctx, vapi_msg_id_t id, void *msg)
bool vapi_is_nonblocking(vapi_ctx_t ctx)
struct vl_shmem_hdr_ * shmem_hdr
Binary API shared-memory segment header pointer.
vapi_message_desc_t ** msgs
#define VAPI_INVALID_MSG_ID
int vapi_get_payload_offset(vapi_msg_id_t id)
size_t vapi_get_context_offset(vapi_msg_id_t id)
vapi_event_cb_with_ctx * event_cbs
int svm_queue_add2(svm_queue_t *q, u8 *elem, u8 *elem2, int nowait)
size_t vapi_get_max_request_count(vapi_ctx_t ctx)
void vl_set_memory_root_path(const char *name)
vapi_msg_id_t vapi_msg_id_control_ping_reply
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)
const char * name_with_crc
u32 vapi_gen_req_context(vapi_ctx_t ctx)
void vapi_set_generic_event_cb(vapi_ctx_t ctx, vapi_generic_event_cb callback, void *callback_ctx)
set generic event callback
bool vapi_requests_empty(vapi_ctx_t ctx)
void(*)(void *msg) vapi_get_swap_to_host_func(vapi_msg_id_t id)
void(*)(void *msg) vapi_get_swap_to_be_func(vapi_msg_id_t id)
invalid value encountered
static void * clib_mem_get_per_cpu_heap(void)
common vpp api C declarations
size_t max_len_name_with_crc
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...
failure while mapping api
vapi_error_e(* vapi_cb_t)(struct vapi_ctx_s *, void *, vapi_error_e, bool, void *)
API main structure, used by both vpp and binary API clients.
void * clib_mem_init(void *heap, uword size)
bool vapi_msg_is_with_context(vapi_msg_id_t id)
static vapi_error_e vapi_dispatch_response(vapi_ctx_t ctx, vapi_msg_id_t id, u32 context, void *msg)
vapi_msg_id_t vapi_lookup_vapi_msg_id_t(vapi_ctx_t ctx, u16 vl_msg_id)
sll srl srl sll sra u16x4 i
u32 vl_msg_api_get_msg_index(u8 *name_and_crc)
struct vapi_ctx_s * vapi_ctx_t
int vl_client_api_map(const char *region_name)
static const u32 context_counter_mask
blocking call - best used in combination with condvars, for eventfds we don't yield the cpu ...
pthread_mutex_t requests_mutex
internal vpp api C declarations
svm_queue_t * vl_input_queue
vapi_msg_id_t vapi_msg_id_control_ping
u16 vapi_lookup_vl_msg_id(vapi_ctx_t ctx, vapi_msg_id_t id)
bool vapi_is_msg_available(vapi_ctx_t ctx, vapi_msg_id_t id)
check if message identified by it's message id is known by the vpp to which the connection is open ...
u32 data_len
message length not including header
Message header structure.
DEFINE_VAPI_MSG_IDS_MEMCLNT_API_JSON
int vapi_get_client_index(vapi_ctx_t ctx)
void vl_msg_api_free(void *)
void vapi_ctx_free(vapi_ctx_t ctx)
free vapi context
void vapi_clear_generic_event_cb(vapi_ctx_t ctx)
clear generic event callback
vapi_error_e(* vapi_event_cb)(vapi_ctx_t ctx, void *callback_ctx, void *payload)
generic vapi event callback
vapi_error_e vapi_dispatch_one(vapi_ctx_t ctx)
pick next message sent by vpp and call the appropriate callback
vapi_error_e vapi_producer_unlock(vapi_ctx_t ctx)
int vl_client_disconnect(void)
bool vapi_requests_full(vapi_ctx_t ctx)
vapi_error_e vapi_get_fd(vapi_ctx_t ctx, int *fd)
get event file descriptor
struct _svm_queue svm_queue_t
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, void *payload)
static api_main_t * vlibapi_get_main(void)
API common definitions See api_doc.md for more info.
void vapi_msg_free(vapi_ctx_t ctx, void *msg)
free a vapi message
vapi_error_e vapi_producer_lock(vapi_ctx_t ctx)
u16 * vapi_msg_id_t_to_vl_msg_id
vapi_error_e vapi_ctx_alloc(vapi_ctx_t *result)
allocate vapi context
void * vl_msg_api_alloc_or_null(int nbytes)
DEFINE_VAPI_MSG_IDS_VPE_API_JSON
unsigned int vapi_msg_id_t
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
void vapi_clear_event_cb(vapi_ctx_t ctx, vapi_msg_id_t id)
clear event callback for given message id
vapi_generic_cb_with_ctx generic_cb
static int vapi_requests_end(vapi_ctx_t ctx)
static CLIB_NOSANITIZE_ADDR void VL_MSG_API_UNPOISON(const void *a)
vapi_error_e vapi_wait(vapi_ctx_t ctx, vapi_wait_mode_e mode)
wait for connection to become readable or writable
failure while connecting to vpp