#include <vppinfra/serialize.h>
#include <vppinfra/hash.h>
#include <vlibmemory/memory_client.h>
+#include <vlibapi/api_common.h>
/* A hack. vl_client_get_first_plugin_msg_id depends on it */
#include <vlibmemory/socket_client.h>
#undef vl_printfun
memory_client_main_t memory_client_main;
+__thread memory_client_main_t *my_memory_client_main = &memory_client_main;
+
+typedef struct rx_thread_fn_arg
+{
+ api_main_t *am;
+ memory_client_main_t *mm;
+} rx_thread_fn_arg_t;
static void *
rx_thread_fn (void *arg)
{
+ rx_thread_fn_arg_t *a = (rx_thread_fn_arg_t *) arg;
+ memory_client_main_t *mm;
svm_queue_t *q;
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
- q = am->vl_input_queue;
+ vlibapi_set_main (a->am);
+ vlibapi_set_memory_client_main (a->mm);
+ free (a);
+
+ mm = vlibapi_get_memory_client_main ();
+ q = vlibapi_get_main ()->vl_input_queue;
/* So we can make the rx thread terminate cleanly */
if (setjmp (mm->rx_thread_jmpbuf) == 0)
static void
vl_api_rx_thread_exit_t_handler (vl_api_rx_thread_exit_t * mp)
{
- memory_client_main_t *mm = &memory_client_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
if (mm->rx_thread_jmpbuf_valid)
longjmp (mm->rx_thread_jmpbuf, 1);
}
static void
vl_api_name_and_crc_free (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int i;
u8 **keys = 0;
hash_pair_t *hp;
hash_free (am->msg_index_by_name_and_crc);
}
+CLIB_NOSANITIZE_ADDR static void
+VL_API_VEC_UNPOISON (const void *v)
+{
+ const vec_header_t *vh = &((vec_header_t *) v)[-1];
+ CLIB_MEM_UNPOISON (vh, sizeof (*vh) + vec_len (v));
+}
+
static void
vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp)
{
serialize_main_t _sm, *sm = &_sm;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *tblv;
u32 nmsgs;
int i;
unserialize_open_data (sm, tblv, vec_len (tblv));
unserialize_integer (sm, &nmsgs, sizeof (u32));
+ VL_API_VEC_UNPOISON (tblv);
+
for (i = 0; i < nmsgs; i++)
{
msg_index = unserialize_likely_small_unsigned_integer (sm);
int
vl_client_connect (const char *name, int ctx_quota, int input_queue_size)
{
- svm_region_t *svm;
vl_api_memclnt_create_t *mp;
vl_api_memclnt_create_reply_t *rp;
svm_queue_t *vl_input_queue;
vl_shmem_hdr_t *shmem_hdr;
int rv = 0;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (am->my_registration)
{
return -1;
}
- svm = am->vlib_rp;
shmem_hdr = am->shmem_hdr;
if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0)
return -1;
}
- pthread_mutex_lock (&svm->mutex);
- oldheap = svm_push_data_heap (svm);
+ CLIB_MEM_UNPOISON (shmem_hdr, sizeof (*shmem_hdr));
+ VL_MSG_API_SVM_QUEUE_UNPOISON (shmem_hdr->vl_input_queue);
+
+ oldheap = vl_msg_push_heap ();
vl_input_queue = svm_queue_alloc_and_init (input_queue_size, sizeof (uword),
getpid ());
- svm_pop_heap (oldheap);
- pthread_mutex_unlock (&svm->mutex);
+ vl_msg_pop_heap (oldheap);
am->my_client_index = ~0;
am->my_registration = 0;
return -1;
read_one_msg:
+ VL_MSG_API_UNPOISON (rp);
if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY)
{
clib_warning ("unexpected reply: id %d", ntohs (rp->_vl_msg_id));
vl_api_memclnt_delete_reply_t_handler (vl_api_memclnt_delete_reply_t * mp)
{
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
- pthread_mutex_lock (&am->vlib_rp->mutex);
- oldheap = svm_push_data_heap (am->vlib_rp);
+ oldheap = vl_msg_push_heap ();
svm_queue_free (am->vl_input_queue);
- pthread_mutex_unlock (&am->vlib_rp->mutex);
- svm_pop_heap (oldheap);
+ vl_msg_pop_heap (oldheap);
am->my_client_index = ~0;
am->my_registration = 0;
{
vl_api_memclnt_delete_t *mp;
vl_shmem_hdr_t *shmem_hdr;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
ASSERT (am->vlib_rp);
shmem_hdr = am->shmem_hdr;
{
vl_api_memclnt_delete_reply_t *rp;
svm_queue_t *vl_input_queue;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
time_t begin;
vl_input_queue = am->vl_input_queue;
if (svm_queue_sub (vl_input_queue, (u8 *) & rp, SVM_Q_NOWAIT, 0) < 0)
continue;
+ VL_MSG_API_UNPOISON (rp);
+
/* drain the queue */
if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY)
{
api_main_t *am;
vl_shmem_hdr_t *shmem_hdr;
- am = &api_main;
+ am = vlibapi_get_main ();
shmem_hdr = am->shmem_hdr;
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
void
vl_client_install_client_message_handlers (void)
{
-
-#define _(N,n) \
- vl_msg_api_set_handlers(VL_API_##N, #n, \
- vl_api_##n##_t_handler, \
- noop_handler, \
- vl_api_##n##_t_endian, \
- vl_api_##n##_t_print, \
- sizeof(vl_api_##n##_t), 1);
+ api_main_t *am = vlibapi_get_main ();
+#define _(N, n) \
+ vl_msg_api_set_handlers (VL_API_##N, #n, vl_api_##n##_t_handler, \
+ noop_handler, vl_api_##n##_t_endian, \
+ vl_api_##n##_t_print, sizeof (vl_api_##n##_t), 0, \
+ vl_api_##n##_t_print_json, vl_api_##n##_t_tojson, \
+ vl_api_##n##_t_fromjson); \
+ am->api_trace_cfg[VL_API_##N].replay_enable = 0;
foreach_api_msg;
#undef _
}
u8
vl_mem_client_is_connected (void)
{
- return (memory_client_main.connected_to_vlib != 0);
+ return (my_memory_client_main->connected_to_vlib != 0);
}
static int
connect_to_vlib_internal (const char *svm_name,
const char *client_name,
int rx_queue_size, void *(*thread_fn) (void *),
- int do_map)
+ void *thread_fn_arg, int do_map)
{
int rv = 0;
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
+ api_main_t *am = vlibapi_get_main ();
if (do_map && (rv = vl_client_api_map (svm_name)))
{
if (thread_fn)
{
+ if (thread_fn == rx_thread_fn)
+ {
+ rx_thread_fn_arg_t *arg;
+ arg = malloc (sizeof (*arg));
+ arg->am = vlibapi_get_main ();
+ arg->mm = vlibapi_get_memory_client_main ();
+ thread_fn_arg = (void *) arg;
+ }
+
rv = pthread_create (&mm->rx_thread_handle,
- NULL /*attr */ , thread_fn, 0);
+ NULL /*attr */ , thread_fn, thread_fn_arg);
if (rv)
{
clib_warning ("pthread_create returned %d", rv);
const char *client_name, int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- rx_thread_fn, 1 /* do map */ );
+ rx_thread_fn, 0 /* thread fn arg */ ,
+ 1 /* do map */ );
}
int
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
0 /* no rx_thread_fn */ ,
+ 0 /* no thread fn arg */ ,
1 /* do map */ );
}
const char *client_name, int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- rx_thread_fn, 0 /* dont map */ );
+ rx_thread_fn, 0 /* no thread fn arg */ ,
+ 0 /* dont map */ );
}
int
int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- 0 /* want pthread */ ,
+ 0 /* no thread_fn */ ,
+ 0 /* no thread fn arg */ ,
0 /* dont map */ );
}
vl_client_connect_to_vlib_thread_fn (const char *svm_name,
const char *client_name,
int rx_queue_size,
- void *(*thread_fn) (void *))
+ void *(*thread_fn) (void *), void *arg)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- thread_fn, 1 /* do map */ );
+ thread_fn, arg, 1 /* do map */ );
}
static void
disconnect_from_vlib_internal (u8 do_unmap)
{
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
+ api_main_t *am = vlibapi_get_main ();
uword junk;
if (mm->rx_thread_jmpbuf_valid)
static void vl_api_get_first_msg_id_reply_t_handler
(vl_api_get_first_msg_id_reply_t * mp)
{
- memory_client_main_t *mm = &memory_client_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
i32 retval = ntohl (mp->retval);
mm->first_msg_id_reply = (retval >= 0) ? ntohs (mp->first_msg_id) : ~0;
vl_client_get_first_plugin_msg_id (const char *plugin_name)
{
vl_api_get_first_msg_id_t *mp;
- api_main_t *am = &api_main;
- memory_client_main_t *mm = &memory_client_main;
+ api_main_t *am = vlibapi_get_main ();
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
f64 timeout;
void *old_handler;
clib_time_t clib_time;
Code Review / vpp.git / blobdiff