21 #include <arpa/inet.h> 132 VAPI_DBG (
"stored@%d: context:%x (start is @%d)", requests_end, context,
139 struct to_be_freed_s;
143 struct to_be_freed_s *next;
146 static struct to_be_freed_s *to_be_freed =
NULL;
149 vapi_add_to_be_freed (
void *
v)
151 struct to_be_freed_s *prev =
NULL;
152 struct to_be_freed_s *tmp;
154 while (tmp && tmp->v)
163 tmp = to_be_freed = calloc (1,
sizeof (*to_be_freed));
167 tmp = prev->next = calloc (1,
sizeof (*to_be_freed));
175 vapi_trace_free (
void *v)
177 struct to_be_freed_s *tmp = to_be_freed;
178 while (tmp && tmp->v != v)
182 if (tmp && tmp->v == v)
189 VAPI_ERR (
"Trying to free untracked pointer %p", v);
195 vapi_to_be_freed_validate ()
197 struct to_be_freed_s *tmp = to_be_freed;
202 VAPI_ERR (
"Unfreed msg %p!", tmp->v);
229 vapi_trace_free (msg);
254 malloc (__vapi_metadata.count *
293 const char *chroot_prefix,
294 int max_outstanding_requests,
297 if (response_queue_size <= 0 || max_outstanding_requests <= 0)
303 void *tmp = realloc (ctx->
requests, size);
314 VAPI_DBG (
"set memory root path `%s'", chroot_prefix);
317 static char api_map[] =
"/vpe-api";
318 VAPI_DBG (
"client api map `%s'", api_map);
323 VAPI_DBG (
"connect client `%s'", name);
329 #if VAPI_DEBUG_CONNECT 330 VAPI_DBG (
"start probing messages");
334 for (i = 0; i < __vapi_metadata.count; ++
i)
344 VAPI_ERR (
"Returned vl_msg_id `%u' > UINT16MAX `%u'!",
id,
365 #if VAPI_DEBUG_CONNECT 376 #if VAPI_DEBUG_CONNECT 377 VAPI_DBG (
"finished probing messages");
383 (
"control ping or control ping reply not available, cannot connect");
406 vapi_to_be_freed_validate ();
430 unsigned msgid = be16toh (*(
u16 *) msg);
434 if (
id < __vapi_metadata.count)
436 VAPI_DBG (
"send msg@%p:%u[%s]", msg, msgid,
437 __vapi_metadata.msgs[
id]->name);
441 VAPI_DBG (
"send msg@%p:%u[UNKNOWN]", msg, msgid);
446 VAPI_DBG (
"send msg@%p:%u[UNKNOWN]", msg, msgid);
457 VAPI_DBG (
"vapi_send() rv = %d", rv);
465 if (!ctx || !msg1 || !msg2 || !ctx->
connected)
472 unsigned msgid1 = be16toh (*(
u16 *) msg1);
473 unsigned msgid2 = be16toh (*(
u16 *) msg2);
474 const char *name1 =
"UNKNOWN";
475 const char *name2 =
"UNKNOWN";
479 if (
id < __vapi_metadata.count)
481 name1 = __vapi_metadata.msgs[id]->name;
484 if (msgid2 <= ctx->vl_msg_id_max)
487 if (
id < __vapi_metadata.count)
489 name2 = __vapi_metadata.msgs[id]->name;
492 VAPI_DBG (
"send two: %u[%s], %u[%s]", msgid1, name1, msgid2, name2);
502 VAPI_DBG (
"vapi_send() rv = %d", rv);
509 if (!ctx || !ctx->
connected || !msg || !msg_size)
528 vapi_add_to_be_freed ((
void *) data);
538 *msg_size = ntohl (msgbuf->
data_len);
540 unsigned msgid = be16toh (*(
u16 *) * msg);
544 if (
id < __vapi_metadata.count)
546 VAPI_DBG (
"recv msg@%p:%u[%s]", *msg, msgid,
547 __vapi_metadata.msgs[
id]->name);
551 VAPI_DBG (
"recv msg@%p:%u[UNKNOWN]", *msg, msgid);
556 VAPI_DBG (
"recv msg@%p:%u[UNKNOWN]", *msg, msgid);
575 u32 context,
void *msg)
580 VAPI_DBG (
"pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
601 VAPI_ERR (
"No response to req with context=%u",
620 void *payload = ((
u8 *) msg) + payload_offset;
624 if (vapi_msg_id_control_ping_reply ==
id)
633 if (payload_offset != -1)
660 VAPI_DBG (
"after dispatch, req start = %d, end = %d, count = %d",
665 VAPI_DBG (
"pthread_mutex_unlock() failed, rv=%d:%s", mrv,
686 (
"No handler/generic handler for msg id %u[%s], message ignored",
687 (
unsigned)
id, __vapi_metadata.msgs[
id]->name);
695 assert (
id <= __vapi_metadata.count);
696 return __vapi_metadata.msgs[id]->has_context;
708 VAPI_DBG (
"vapi_recv failed with rv=%d", rv);
711 u16 vpp_id = be16toh (*(
u16 *) msg);
714 VAPI_ERR (
"Unknown msg ID received, id `%u', out of range <0,%u>",
721 VAPI_ERR (
"Unknown msg ID received, id `%u' marked as not supported",
728 if (size < expect_size)
731 (
"Invalid msg received, unexpected size `%zu' < expected min `%zu'",
742 VAPI_DBG (
"dispatch, context is %x", context);
743 if (context & context_counter_mask)
777 c->
ctx = callback_ctx;
804 assert (
id < __vapi_metadata.count);
829 assert (
id < __vapi_metadata.count);
830 return __vapi_metadata.msgs[id]->payload_offset;
835 assert (
id < __vapi_metadata.count);
836 return __vapi_metadata.msgs[id]->swap_to_host;
841 assert (
id < __vapi_metadata.count);
842 return __vapi_metadata.msgs[id]->swap_to_be;
848 assert (
id < __vapi_metadata.count);
849 return __vapi_metadata.msgs[id]->size;
855 assert (
id < __vapi_metadata.count);
856 return __vapi_metadata.msgs[id]->context_offset;
863 for (i = 0; i < __vapi_metadata.count; ++
i)
866 (msg->
name_with_crc, __vapi_metadata.msgs[i]->name_with_crc))
871 msg->
id = __vapi_metadata.msgs[
i]->id;
876 ++__vapi_metadata.count;
877 __vapi_metadata.msgs =
878 realloc (__vapi_metadata.msgs,
879 sizeof (*__vapi_metadata.msgs) * __vapi_metadata.count);
880 __vapi_metadata.msgs[id] = msg;
882 if (s > __vapi_metadata.max_len_name_with_crc)
884 __vapi_metadata.max_len_name_with_crc = s;
896 VAPI_DBG (
"pthread_mutex_lock() failed, rv=%d:%s", mrv, strerror (mrv));
909 VAPI_DBG (
"pthread_mutex_unlock() failed, rv=%d:%s", mrv,
920 return __vapi_metadata.count;
926 return __vapi_metadata.msgs[id]->name;
failure manipulating internal mutex(es)
sll srl srl sll sra u16x4 i
operations block until response received
void vl_client_disconnect(void)
size_t vapi_get_message_count()
Fixed length block allocator.
unix_shared_memory_queue_t * vl_input_queue
int my_client_index
All VLIB-side message handlers use my_client_index to identify the queue / client.
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, vapi_msg_id_t id, void *payload)
vapi_error_e vapi_send(vapi_ctx_t ctx, void *msg)
low-level api for sending messages to vpp
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
unix_shared_memory_queue_t * vl_input_queue
Peer input queue pointer.
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 vl_client_connect(const char *name, int ctx_quota, int input_queue_size)
fundamental incompatibility while connecting to vpp (control ping/control ping reply mismatch) ...
vapi_error_e vapi_recv(vapi_ctx_t ctx, void **msg, size_t *msg_size)
low-level api for reading messages from vpp
size_t vapi_get_request_count(vapi_ctx_t ctx)
void vl_client_api_unmap(void)
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)
int unix_shared_memory_queue_add2(unix_shared_memory_queue_t *q, u8 *elem, u8 *elem2, int nowait)
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
int vapi_get_payload_offset(vapi_msg_id_t id)
u32 vl_api_get_msg_index(u8 *name_and_crc)
size_t vapi_get_context_offset(vapi_msg_id_t id)
vapi_event_cb_with_ctx * event_cbs
size_t vapi_get_max_request_count(vapi_ctx_t ctx)
int unix_shared_memory_queue_add(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
vapi_msg_id_t vapi_msg_id_control_ping_reply
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)
void vl_msg_api_free(void *)
invalid value encountered
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.
bool vapi_msg_is_with_context(vapi_msg_id_t id)
int unix_shared_memory_queue_sub(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
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)
struct vapi_ctx_s * vapi_ctx_t
static const u32 context_counter_mask
pthread_mutex_t requests_mutex
internal vpp api C declarations
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.
int vapi_get_client_index(vapi_ctx_t ctx)
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)
bool vapi_requests_full(vapi_ctx_t ctx)
vapi_error_e vapi_get_fd(vapi_ctx_t ctx, int *fd)
get event file descriptor
vapi_error_e(* cb)(vapi_ctx_t ctx, void *callback_ctx, void *payload)
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
int vl_client_api_map(const char *region_name)
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)
connect to vpp
void vl_set_memory_root_path(const char *root_path)
vapi_error_e vapi_ctx_alloc(vapi_ctx_t *result)
allocate vapi context
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 * vl_msg_api_alloc_or_null(int nbytes)
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)
struct _unix_shared_memory_queue unix_shared_memory_queue_t
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