42 #define vl_print(handle, ...) clib_warning (__VA_ARGS__) 79 if (__os_thread_index == 0)
87 __os_thread_index =
i;
91 ASSERT (__os_thread_index > 0);
121 vec_add1 (keys, (u8 *) hp->key);
124 for (i = 0; i <
vec_len (keys); i++)
154 for (i = 0; i < nmsgs; i++)
200 pthread_mutex_lock (&svm->
mutex);
205 pthread_mutex_unlock (&svm->
mutex);
213 mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE);
216 strncpy ((
char *) mp->
name, name, sizeof (mp->
name) - 1);
223 struct timespec ts, tsrem;
227 for (i = 0; i < 1000; i++)
234 ts.tv_nsec = 10000 * 1000;
235 while (nanosleep (&ts, &tsrem) < 0)
243 if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY)
245 clib_warning (
"unexpected reply: id %d", ntohs (rp->_vl_msg_id));
248 rv = clib_net_to_host_u32 (rp->
response);
286 mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE);
316 if (now >= (begin + 2))
328 if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY)
330 clib_warning (
"queue drain: %d", ntohs (rp->_vl_msg_id));
349 vl_api_memclnt_keepalive_reply_t *rmp;
358 rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
363 #define foreach_api_msg \ 364 _(RX_THREAD_EXIT, rx_thread_exit) \ 365 _(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \ 366 _(MEMCLNT_DELETE_REPLY, memclnt_delete_reply) \ 367 _(MEMCLNT_KEEPALIVE, memclnt_keepalive) 374 vl_msg_api_set_handlers(VL_API_##N, #n, \ 375 vl_api_##n##_t_handler, \ 377 vl_api_##n##_t_endian, \ 378 vl_api_##n##_t_print, \ 379 sizeof(vl_api_##n##_t), 1); 410 const char *client_name,
411 int rx_queue_size,
int want_pthread,
int do_map)
445 const char *client_name,
int rx_queue_size)
454 const char *client_name,
464 const char *client_name,
int rx_queue_size)
482 ep->_vl_msg_id = ntohs (VL_API_RX_THREAD_EXIT);
528 if (strlen (plugin_name) + 1 >
sizeof (mp->
name))
535 old_handler = am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY];
536 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = (
void *)
547 mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
549 strncpy ((
char *) mp->
name, plugin_name, sizeof (mp->
name) - 1);
564 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
572 mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
574 strncpy ((
char *) mp->
name, plugin_name, sizeof (mp->
name) - 1);
589 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
597 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
600 clib_warning (
"plugin '%s' not registered", plugin_name);
void * clib_per_cpu_mheaps[CLIB_MAX_MHEAPS]
static void svm_pop_heap(void *oldheap)
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)
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)
u8 rx_thread_jmpbuf_valid
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.
static f64 clib_time_now(clib_time_t *c)
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.
#define hash_set_mem(h, key, value)
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
svm_queue_t * vl_input_queue
Peer input queue pointer.
void * vl_msg_api_alloc(int nbytes)
static void noop_handler(void *notused)
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't use it to id the connection since it can't...
int svm_queue_sub(svm_queue_t *q, u8 *elem, svm_q_conditional_wait_t cond, u32 time)
pthread_t rx_thread_handle
void unserialize_open_data(serialize_main_t *m, u8 *data, uword n_data_bytes)
static void * svm_push_data_heap(svm_region_t *rp)
static void * rx_thread_fn(void *arg)
svm_region_t * vlib_rp
Current binary api segment descriptor.
struct vl_shmem_hdr_ * shmem_hdr
Binary API shared-memory segment header pointer.
#define hash_create_string(elts, value_bytes)
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)
void clib_time_init(clib_time_t *c)
void unserialize_cstring(serialize_main_t *m, char **s)
API main structure, used by both vpp and binary API clients.
static void vl_api_memclnt_delete_reply_t_handler(vl_api_memclnt_delete_reply_t *mp)
An API client registration, only in vpp/vlib.
void vl_msg_api_send_shmem(svm_queue_t *q, u8 *elem)
#define vec_free(V)
Free vector's memory (no header).
#define clib_warning(format, args...)
int vl_client_api_map(const char *region_name)
static void unserialize_integer(serialize_main_t *m, void *x, u32 n_bytes)
u16 vl_client_get_first_plugin_msg_id(const char *plugin_name)
svm_queue_t * vl_input_queue
void vl_unmap_shmem_client(void)
void svm_queue_free(svm_queue_t *q)
#define uword_to_pointer(u, type)
svm_queue_t * svm_queue_alloc_and_init(int nels, int elsize, int consumer_pid)
Allocate and initialize svm queue.
void vl_msg_api_queue_handler(svm_queue_t *q)
void vl_msg_api_free(void *)
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)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
int vl_client_disconnect(void)
static void vl_api_rx_thread_exit_t_handler(vl_api_rx_thread_exit_t *mp)
struct _svm_queue svm_queue_t
memory_client_main_t memory_client_main
void(** msg_handlers)(void *)
Message handler vector.
void vl_client_disconnect_from_vlib(void)
static int connect_to_vlib_internal(const char *svm_name, const char *client_name, int rx_queue_size, int want_pthread, int do_map)
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
volatile u8 first_msg_id_reply_ready
non-blocking call - works with both condvar and eventfd signaling
void vl_msg_api_handler(void *the_msg)