X-Git-Url: https://gerrit.fd.io/r/gitweb?p=vpp.git;a=blobdiff_plain;f=src%2Fvlibmemory%2Fmemory_client.c;h=f0b05b70695745ac2e8a4234114d4d1ecb04b780;hp=c47f25e6e3d5c47794810f2d1de0d381e61257ec;hb=36217e3ca;hpb=6d1caf91147ee8676b57216ca891af0f44d7a074 diff --git a/src/vlibmemory/memory_client.c b/src/vlibmemory/memory_client.c index c47f25e6e3d..f0b05b70695 100644 --- a/src/vlibmemory/memory_client.c +++ b/src/vlibmemory/memory_client.c @@ -17,33 +17,17 @@ *------------------------------------------------------------------ */ -#include -#include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include + +#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include +#include +#include + +/* A hack. vl_client_get_first_plugin_msg_id depends on it */ +#include #include @@ -61,52 +45,34 @@ #include #undef vl_printfun -typedef struct -{ - u8 rx_thread_jmpbuf_valid; - u8 connected_to_vlib; - jmp_buf rx_thread_jmpbuf; - pthread_t rx_thread_handle; - /* Plugin message base lookup scheme */ - volatile u8 first_msg_id_reply_ready; - u16 first_msg_id_reply; -} memory_client_main_t; - 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) { - unix_shared_memory_queue_t *q; - memory_client_main_t *mm = &memory_client_main; - api_main_t *am = &api_main; - int i; + rx_thread_fn_arg_t *a = (rx_thread_fn_arg_t *) arg; + memory_client_main_t *mm; + svm_queue_t *q; + + vlibapi_set_main (a->am); + vlibapi_set_memory_client_main (a->mm); + free (a); - q = am->vl_input_queue; + 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) { mm->rx_thread_jmpbuf_valid = 1; - /* - * Find an unused slot in the per-cpu-mheaps array, - * and grab it for this thread. We need to be able to - * push/pop the thread heap without affecting other thread(s). - */ - if (__os_thread_index == 0) - { - for (i = 0; i < ARRAY_LEN (clib_per_cpu_mheaps); i++) - { - if (clib_per_cpu_mheaps[i] == 0) - { - /* Copy the main thread mheap pointer */ - clib_per_cpu_mheaps[i] = clib_per_cpu_mheaps[0]; - __os_thread_index = i; - break; - } - } - ASSERT (__os_thread_index > 0); - } + clib_mem_set_thread_index (); while (1) vl_msg_api_queue_handler (q); } @@ -116,16 +82,46 @@ rx_thread_fn (void *arg) static void vl_api_rx_thread_exit_t_handler (vl_api_rx_thread_exit_t * mp) { - memory_client_main_t *mm = &memory_client_main; - vl_msg_api_free (mp); - longjmp (mm->rx_thread_jmpbuf, 1); + 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 = vlibapi_get_main (); + int i; + u8 **keys = 0; + hash_pair_t *hp; + + if (!am->msg_index_by_name_and_crc) + return; + + /* *INDENT-OFF* */ + hash_foreach_pair (hp, am->msg_index_by_name_and_crc, + ({ + vec_add1 (keys, (u8 *) hp->key); + })); + /* *INDENT-ON* */ + for (i = 0; i < vec_len (keys); i++) + vec_free (keys[i]); + vec_free (keys); + 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; @@ -136,21 +132,7 @@ vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp) am->my_registration = (vl_api_registration_t *) (uword) mp->handle; /* Clean out any previous hash table (unlikely) */ - if (am->msg_index_by_name_and_crc) - { - int i; - u8 **keys = 0; - hash_pair_t *hp; - /* *INDENT-OFF* */ - hash_foreach_pair (hp, am->msg_index_by_name_and_crc, - ({ - vec_add1 (keys, (u8 *) hp->key); - })); - /* *INDENT-ON* */ - for (i = 0; i < vec_len (keys); i++) - vec_free (keys[i]); - vec_free (keys); - } + vl_api_name_and_crc_free (); am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword)); @@ -159,6 +141,8 @@ vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp) 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); @@ -172,17 +156,17 @@ noop_handler (void *notused) { } +void vl_msg_api_send_shmem (svm_queue_t * q, u8 * elem); 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; - unix_shared_memory_queue_t *vl_input_queue; + 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) { @@ -196,7 +180,6 @@ vl_client_connect (const char *name, int ctx_quota, int input_queue_size) return -1; } - svm = am->vlib_rp; shmem_hdr = am->shmem_hdr; if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0) @@ -205,20 +188,20 @@ vl_client_connect (const char *name, int ctx_quota, int input_queue_size) return -1; } - pthread_mutex_lock (&svm->mutex); - oldheap = svm_push_data_heap (svm); - vl_input_queue = - unix_shared_memory_queue_init (input_queue_size, sizeof (uword), - getpid (), 0); - pthread_mutex_unlock (&svm->mutex); - svm_pop_heap (oldheap); + 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 ()); + vl_msg_pop_heap (oldheap); am->my_client_index = ~0; am->my_registration = 0; am->vl_input_queue = vl_input_queue; mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_create_t)); - memset (mp, 0, sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE); mp->ctx_quota = ctx_quota; mp->input_queue = (uword) vl_input_queue; @@ -235,8 +218,8 @@ vl_client_connect (const char *name, int ctx_quota, int input_queue_size) /* Wait up to 10 seconds */ for (i = 0; i < 1000; i++) { - qstatus = unix_shared_memory_queue_sub (vl_input_queue, (u8 *) & rp, - 1 /* nowait */ ); + qstatus = svm_queue_sub (vl_input_queue, (u8 *) & rp, + SVM_Q_NOWAIT, 0); if (qstatus == 0) goto read_one_msg; ts.tv_sec = 0; @@ -249,6 +232,7 @@ vl_client_connect (const char *name, int ctx_quota, int input_queue_size) 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)); @@ -266,13 +250,11 @@ static void 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); - unix_shared_memory_queue_free (am->vl_input_queue); - pthread_mutex_unlock (&am->vlib_rp->mutex); - svm_pop_heap (oldheap); + oldheap = vl_msg_push_heap (); + svm_queue_free (am->vl_input_queue); + vl_msg_pop_heap (oldheap); am->my_client_index = ~0; am->my_registration = 0; @@ -280,34 +262,41 @@ vl_api_memclnt_delete_reply_t_handler (vl_api_memclnt_delete_reply_t * mp) } void -vl_client_disconnect (void) +vl_client_send_disconnect (u8 do_cleanup) { vl_api_memclnt_delete_t *mp; - vl_api_memclnt_delete_reply_t *rp; - unix_shared_memory_queue_t *vl_input_queue; vl_shmem_hdr_t *shmem_hdr; - time_t begin; - api_main_t *am = &api_main; + api_main_t *am = vlibapi_get_main (); ASSERT (am->vlib_rp); shmem_hdr = am->shmem_hdr; ASSERT (shmem_hdr && shmem_hdr->vl_input_queue); - vl_input_queue = am->vl_input_queue; - mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_delete_t)); - memset (mp, 0, sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE); mp->index = am->my_client_index; mp->handle = (uword) am->my_registration; + mp->do_cleanup = do_cleanup; vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & mp); +} + +int +vl_client_disconnect (void) +{ + vl_api_memclnt_delete_reply_t *rp; + svm_queue_t *vl_input_queue; + api_main_t *am = vlibapi_get_main (); + time_t begin; + + vl_input_queue = am->vl_input_queue; + vl_client_send_disconnect (0 /* wait for reply */ ); /* * Have to be careful here, in case the client is disconnecting * because e.g. the vlib process died, or is unresponsive. */ - begin = time (0); while (1) { @@ -321,11 +310,13 @@ vl_client_disconnect (void) am->my_client_index = ~0; am->my_registration = 0; am->shmem_hdr = 0; - break; + return -1; } - if (unix_shared_memory_queue_sub (vl_input_queue, (u8 *) & rp, 1) < 0) + 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) { @@ -336,6 +327,9 @@ vl_client_disconnect (void) vl_msg_api_handler ((void *) rp); break; } + + vl_api_name_and_crc_free (); + return 0; } /** @@ -349,11 +343,11 @@ vl_api_memclnt_keepalive_t_handler (vl_api_memclnt_keepalive_t * mp) 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)); - memset (rmp, 0, sizeof (*rmp)); + clib_memset (rmp, 0, sizeof (*rmp)); rmp->_vl_msg_id = ntohs (VL_API_MEMCLNT_KEEPALIVE_REPLY); rmp->context = mp->context; vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & rmp); @@ -365,23 +359,21 @@ _(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \ _(MEMCLNT_DELETE_REPLY, memclnt_delete_reply) \ _(MEMCLNT_KEEPALIVE, memclnt_keepalive) - 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 _ } - int vl_client_api_map (const char *region_name) { @@ -397,16 +389,24 @@ vl_client_api_map (const char *region_name) void vl_client_api_unmap (void) { - vl_unmap_shmem (); + vl_unmap_shmem_client (); +} + +u8 +vl_mem_client_is_connected (void) +{ + 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, int want_pthread, int do_map) + int rx_queue_size, void *(*thread_fn) (void *), + void *thread_fn_arg, int do_map) { int rv = 0; - memory_client_main_t *mm = &memory_client_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))) { @@ -423,12 +423,28 @@ connect_to_vlib_internal (const char *svm_name, /* Start the rx queue thread */ - if (want_pthread) + 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 */ , rx_thread_fn, 0); + NULL /*attr */ , thread_fn, thread_fn_arg); if (rv) - clib_warning ("pthread_create returned %d", rv); + { + clib_warning ("pthread_create returned %d", rv); + am->rx_thread_handle = 0; + } + else + { + am->rx_thread_handle = mm->rx_thread_handle; + } } mm->connected_to_vlib = 1; @@ -440,7 +456,7 @@ vl_client_connect_to_vlib (const char *svm_name, const char *client_name, int rx_queue_size) { return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, - 1 /* want pthread */ , + rx_thread_fn, 0 /* thread fn arg */ , 1 /* do map */ ); } @@ -450,7 +466,8 @@ vl_client_connect_to_vlib_no_rx_pthread (const char *svm_name, int rx_queue_size) { return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, - 0 /* want pthread */ , + 0 /* no rx_thread_fn */ , + 0 /* no thread fn arg */ , 1 /* do map */ ); } @@ -459,15 +476,37 @@ vl_client_connect_to_vlib_no_map (const char *svm_name, const char *client_name, int rx_queue_size) { return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, - 1 /* want pthread */ , + rx_thread_fn, 0 /* no thread fn arg */ , 0 /* dont map */ ); } -void -vl_client_disconnect_from_vlib (void) +int +vl_client_connect_to_vlib_no_rx_pthread_no_map (const char *svm_name, + const char *client_name, + int rx_queue_size) { - memory_client_main_t *mm = &memory_client_main; - api_main_t *am = &api_main; + return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, + 0 /* no thread_fn */ , + 0 /* no thread fn arg */ , + 0 /* dont map */ ); +} + +int +vl_client_connect_to_vlib_thread_fn (const char *svm_name, + const char *client_name, + int rx_queue_size, + void *(*thread_fn) (void *), void *arg) +{ + return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, + thread_fn, arg, 1 /* do map */ ); +} + + +static void +disconnect_from_vlib_internal (u8 do_unmap) +{ + 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) @@ -481,15 +520,28 @@ vl_client_disconnect_from_vlib (void) if (mm->connected_to_vlib) { vl_client_disconnect (); - vl_client_api_unmap (); + if (do_unmap) + vl_client_api_unmap (); } - memset (mm, 0, sizeof (*mm)); + clib_memset (mm, 0, sizeof (*mm)); +} + +void +vl_client_disconnect_from_vlib (void) +{ + disconnect_from_vlib_internal (1); +} + +void +vl_client_disconnect_from_vlib_no_unmap (void) +{ + disconnect_from_vlib_internal (0); } 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; @@ -500,8 +552,8 @@ u16 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; @@ -510,7 +562,7 @@ vl_client_get_first_plugin_msg_id (const char *plugin_name) if (strlen (plugin_name) + 1 > sizeof (mp->name)) return (rv); - memset (&clib_time, 0, sizeof (clib_time)); + clib_memset (&clib_time, 0, sizeof (clib_time)); clib_time_init (&clib_time); /* Push this plugin's first_msg_id_reply handler */ @@ -525,7 +577,7 @@ vl_client_get_first_plugin_msg_id (const char *plugin_name) if (!am->my_registration) { mp = vl_socket_client_msg_alloc (sizeof (*mp)); - memset (mp, 0, sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID); mp->client_index = am->my_client_index; strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1); @@ -550,7 +602,7 @@ vl_client_get_first_plugin_msg_id (const char *plugin_name) else { mp = vl_msg_api_alloc (sizeof (*mp)); - memset (mp, 0, sizeof (*mp)); + clib_memset (mp, 0, sizeof (*mp)); mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID); mp->client_index = am->my_client_index; strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);