23 #include <sys/types.h> 26 #include <netinet/in.h> 59 #define vl_print(handle, ...) clib_warning (__VA_ARGS__) 96 if (__os_thread_index == 0)
104 __os_thread_index =
i;
108 ASSERT (__os_thread_index > 0);
147 vec_add1 (keys, (u8 *) hp->key);
150 for (i = 0; i <
vec_len (keys); i++)
162 for (i = 0; i < nmsgs; i++)
208 pthread_mutex_lock (&svm->
mutex);
213 pthread_mutex_unlock (&svm->
mutex);
221 memset (mp, 0,
sizeof (*mp));
222 mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE);
225 strncpy ((
char *) mp->
name, name, sizeof (mp->
name) - 1);
232 struct timespec ts, tsrem;
236 for (i = 0; i < 1000; i++)
243 ts.tv_nsec = 10000 * 1000;
244 while (nanosleep (&ts, &tsrem) < 0)
252 if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY)
254 clib_warning (
"unexpected reply: id %d", ntohs (rp->_vl_msg_id));
257 rv = clib_net_to_host_u32 (rp->
response);
299 memset (mp, 0,
sizeof (*mp));
300 mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE);
318 if (now >= (begin + 2))
330 if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY)
332 clib_warning (
"queue drain: %d", ntohs (rp->_vl_msg_id));
348 vl_api_memclnt_keepalive_reply_t *rmp;
356 memset (rmp, 0,
sizeof (*rmp));
357 rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY);
362 #define foreach_api_msg \ 363 _(RX_THREAD_EXIT, rx_thread_exit) \ 364 _(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \ 365 _(MEMCLNT_DELETE_REPLY, memclnt_delete_reply) \ 366 _(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); 405 const char *client_name,
406 int rx_queue_size,
int want_pthread,
int do_map)
440 const char *client_name,
int rx_queue_size)
449 const char *client_name,
459 const char *client_name,
int rx_queue_size)
477 ep->_vl_msg_id = ntohs (VL_API_RX_THREAD_EXIT);
486 memset (mm, 0,
sizeof (*mm));
510 if (strlen (plugin_name) + 1 >
sizeof (mp->
name))
513 memset (&clib_time, 0,
sizeof (clib_time));
517 old_handler = am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY];
518 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = (
void *)
525 memset (mp, 0,
sizeof (*mp));
526 mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID);
528 strncpy ((
char *) mp->
name, plugin_name, sizeof (mp->
name) - 1);
546 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
555 am->
msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
558 clib_warning (
"plugin '%s' not registered", plugin_name);
void * vl_msg_api_alloc_as_if_client(int nbytes)
sll srl srl sll sra u16x4 i
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)
int vl_client_connect_to_vlib_no_map(const char *svm_name, const char *client_name, int rx_queue_size)
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)
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.
void unix_shared_memory_queue_free(unix_shared_memory_queue_t *q)
static f64 clib_time_now(clib_time_t *c)
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)
static void noop_handler(void *notused)
unix_shared_memory_queue_t * vl_input_queue
Peer input queue pointer.
void vl_client_api_unmap(void)
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...
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.
void * vl_msg_api_alloc(int nbytes)
#define hash_create_string(elts, value_bytes)
vl_shmem_hdr_t * shmem_hdr
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_msg_api_free(void *)
void vl_msg_api_handler(void *the_msg)
void clib_time_init(clib_time_t *c)
void unserialize_cstring(serialize_main_t *m, char **s)
#define uword_to_pointer(u, type)
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.
int unix_shared_memory_queue_sub(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
void vl_unmap_shmem(void)
#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)
void vl_msg_api_send_shmem(unix_shared_memory_queue_t *q, u8 *elem)
unix_shared_memory_queue_t * unix_shared_memory_queue_init(int nels, int elsize, int consumer_pid, int signal_when_queue_non_empty)
Bitmaps built as vectors of machine words.
void vl_client_disconnect(void)
void vl_client_install_client_message_handlers(void)
static void vl_api_get_first_msg_id_reply_t_handler(vl_api_get_first_msg_id_reply_t *mp)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
static void vl_api_rx_thread_exit_t_handler(vl_api_rx_thread_exit_t *mp)
void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q)
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_map_shmem(const char *region_name, int is_vlib)
uword * msg_index_by_name_and_crc
client message index hash table
volatile u8 first_msg_id_reply_ready
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
struct _unix_shared_memory_queue unix_shared_memory_queue_t