diff options
Diffstat (limited to 'src/vcl')
| -rw-r--r-- | src/vcl/sock_test.h | 4 | ||||
| -rw-r--r-- | src/vcl/sock_test_client.c | 44 | ||||
| -rw-r--r-- | src/vcl/vcl_event.c | 91 | ||||
| -rw-r--r-- | src/vcl/vcl_event.h | 22 | ||||
| -rw-r--r-- | src/vcl/vppcom.c | 261 | ||||
| -rw-r--r-- | src/vcl/vppcom.h | 35 |
6 files changed, 367 insertions, 90 deletions
diff --git a/src/vcl/sock_test.h b/src/vcl/sock_test.h index f9f5c7070b2..26dc3f1e653 100644 --- a/src/vcl/sock_test.h +++ b/src/vcl/sock_test.h @@ -65,6 +65,7 @@ typedef enum typedef struct __attribute__ ((packed)) { uint32_t magic; + uint32_t seq_num; uint32_t test; uint32_t ctrl_handle; uint32_t num_test_sockets; @@ -215,6 +216,7 @@ sock_test_cfg_dump (sock_test_cfg_t * cfg, uint8_t is_client) printf (" test config (%p):\n" SOCK_TEST_SEPARATOR_STRING " magic: 0x%08x\n" + " seq_num: 0x%08x\n" "%-5s test: %s (%d)\n" " ctrl handle: %d (0x%x)\n" "%-5s num test sockets: %u (0x%08x)\n" @@ -224,7 +226,7 @@ sock_test_cfg_dump (sock_test_cfg_t * cfg, uint8_t is_client) "%-5s num writes: %lu (0x%08lx)\n" " client tx bytes: %lu (0x%08lx)\n" SOCK_TEST_SEPARATOR_STRING, - (void *) cfg, cfg->magic, + (void *) cfg, cfg->magic, cfg->seq_num, is_client && (cfg->test == SOCK_TEST_TYPE_UNI) ? "'"SOCK_TEST_TOKEN_RUN_UNI"'" : is_client && (cfg->test == SOCK_TEST_TYPE_BI) ? diff --git a/src/vcl/sock_test_client.c b/src/vcl/sock_test_client.c index 1ed4b89a3b1..e88b2b91b9d 100644 --- a/src/vcl/sock_test_client.c +++ b/src/vcl/sock_test_client.c @@ -37,6 +37,7 @@ typedef struct #endif struct sockaddr_storage server_addr; uint32_t server_addr_size; + uint32_t cfg_seq_num; sock_test_socket_t ctrl_socket; sock_test_socket_t *test_socket; uint32_t num_test_sockets; @@ -57,12 +58,18 @@ sock_test_cfg_sync (sock_test_socket_t * socket) if (socket->cfg.verbose) sock_test_cfg_dump (&socket->cfg, 1 /* is_client */ ); + ctrl->cfg.seq_num = ++scm->cfg_seq_num; + if (socket->cfg.verbose) + { + printf ("CLIENT (fd %d): Sending config sent to server.\n", socket->fd); + sock_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + } tx_bytes = sock_test_write (socket->fd, (uint8_t *) & ctrl->cfg, sizeof (ctrl->cfg), NULL, ctrl->cfg.verbose); if (tx_bytes < 0) { - fprintf (stderr, "CLIENT: ERROR: write test cfg failed (%d)!\n", - tx_bytes); + fprintf (stderr, "CLIENT (fd %d): ERROR: write test cfg failed (%d)!\n", + socket->fd, tx_bytes); return tx_bytes; } @@ -73,22 +80,34 @@ sock_test_cfg_sync (sock_test_socket_t * socket) if (rl_cfg->magic != SOCK_TEST_CFG_CTRL_MAGIC) { - fprintf (stderr, "CLIENT: ERROR: Bad server reply cfg -- aborting!\n"); + fprintf (stderr, "CLIENT (fd %d): ERROR: Bad server reply cfg " + "-- aborting!\n", socket->fd); return -1; } - if (socket->cfg.verbose) - { - printf ("CLIENT (fd %d): Got config back from server.\n", socket->fd); - sock_test_cfg_dump (rl_cfg, 1 /* is_client */ ); - } if ((rx_bytes != sizeof (sock_test_cfg_t)) || !sock_test_cfg_verify (rl_cfg, &ctrl->cfg)) { - fprintf (stderr, "CLIENT: ERROR: Invalid config received " - "from server -- aborting!\n"); - sock_test_cfg_dump (rl_cfg, 1 /* is_client */ ); + fprintf (stderr, "CLIENT (fd %d): ERROR: Invalid config received " + "from server!\n", socket->fd); + if (rx_bytes != sizeof (sock_test_cfg_t)) + { + fprintf (stderr, "\tRx bytes %d != cfg size %lu\n", + rx_bytes, sizeof (sock_test_cfg_t)); + } + else + { + sock_test_cfg_dump (rl_cfg, 1 /* is_client */ ); + fprintf (stderr, "CLIENT (fd %d): Valid config sent to server.\n", + socket->fd); + sock_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + } return -1; } + else if (socket->cfg.verbose) + { + printf ("CLIENT (fd %d): Got config back from server.\n", socket->fd); + sock_test_cfg_dump (rl_cfg, 1 /* is_client */ ); + } ctrl->cfg.ctrl_handle = ((ctrl->cfg.ctrl_handle == ~0) ? rl_cfg->ctrl_handle : ctrl->cfg.ctrl_handle); @@ -118,7 +137,8 @@ echo_test_client () tsock = &scm->test_socket[n]; tsock->cfg = ctrl->cfg; sock_test_socket_buf_alloc (tsock); - sock_test_cfg_sync (tsock); + if (sock_test_cfg_sync (tsock)) + return; memcpy (tsock->txbuf, ctrl->txbuf, nbytes); memset (&tsock->stats, 0, sizeof (tsock->stats)); diff --git a/src/vcl/vcl_event.c b/src/vcl/vcl_event.c index d8bd8c74e36..dafa2500d1d 100644 --- a/src/vcl/vcl_event.c +++ b/src/vcl/vcl_event.c @@ -59,10 +59,10 @@ vce_generate_event (vce_event_thread_t *evt, u32 ev_idx) } void -vce_clear_event (vce_event_thread_t *evt, vce_event_t *ev) +vce_clear_event (vce_event_thread_t *evt, u32 ev_idx) { clib_spinlock_lock (&(evt->events_lockp)); - pool_put (evt->vce_events, ev); + pool_put_index (evt->vce_events, ev_idx); clib_spinlock_unlock (&(evt->events_lockp)); } @@ -70,11 +70,10 @@ vce_event_t * vce_get_event_from_index(vce_event_thread_t *evt, u32 ev_idx) { vce_event_t *ev = 0; + /* Assumes caller has obtained the spinlock (evt->events_lockp) */ - clib_spinlock_lock (&(evt->events_lockp)); if ( ! pool_is_free_index (evt->vce_events, ev_idx)) ev = pool_elt_at_index (evt->vce_events, ev_idx); - clib_spinlock_unlock (&(evt->events_lockp)); return ev; } @@ -96,7 +95,7 @@ vce_get_event_handler (vce_event_thread_t *evt, vce_event_key_t *evk) vce_event_handler_reg_t * vce_register_handler (vce_event_thread_t *evt, vce_event_key_t *evk, - vce_event_callback_t cb, void *cb_args) + vce_event_callback_t cb, void *cb_args) { vce_event_handler_reg_t *handler; vce_event_handler_reg_t *old_handler = 0; @@ -115,25 +114,25 @@ vce_register_handler (vce_event_thread_t *evt, vce_event_key_t *evk, /* If we are just re-registering, ignore and move on * else store the old handler_fn for unregister to re-instate */ if (old_handler->handler_fn == cb) - { + { - clib_spinlock_unlock (&evt->handlers_lockp); + clib_spinlock_unlock (&evt->handlers_lockp); - /* Signal event thread that a handler exists in case any - * recycled events requiring this handler are pending */ - pthread_mutex_lock (&(evt->generator_lock)); - pthread_cond_signal (&(evt->generator_cond)); - pthread_mutex_unlock (&(evt->generator_lock)); - return old_handler; - } + /* Signal event thread that a handler exists in case any + * recycled events requiring this handler are pending */ + pthread_mutex_lock (&(evt->generator_lock)); + pthread_cond_signal (&(evt->generator_cond)); + pthread_mutex_unlock (&(evt->generator_lock)); + return old_handler; + } } pool_get (evt->vce_event_handlers, handler); handler_index = (u32) (handler - evt->vce_event_handlers); handler->handler_fn = cb; - handler->replaced_handler_idx = (p) ? p[0] : ~0; - handler->ev_idx = ~0; //This will be set by the event thread if event happens + handler->replaced_handler_idx = (u32) ((p) ? p[0] : ~0); + handler->ev_idx = (u32) ~0; //This will be set by the event thread if event happens handler->evk = evk->as_u64; handler->handler_fn_args = cb_args; @@ -210,61 +209,64 @@ vce_event_thread_fn (void *arg) u32 ev_idx; vce_event_handler_reg_t *handler; uword *p; + u32 recycle_count = 0; pthread_mutex_lock (&(evt->generator_lock)); - clib_spinlock_lock (&(evt->events_lockp)); - evt->recycle_event = 1; // Used for recycling events with no handlers - clib_spinlock_unlock (&(evt->events_lockp)); - - do + while (1) { - while ( (clib_fifo_elts (evt->event_index_fifo) == 0) || - evt->recycle_event) - { - clib_spinlock_lock (&(evt->events_lockp)); - evt->recycle_event = 0; - clib_spinlock_unlock (&(evt->events_lockp)); - pthread_cond_wait (&(evt->generator_cond), - &(evt->generator_lock)); - } + uword fifo_depth = clib_fifo_elts (evt->event_index_fifo); + while ((fifo_depth == 0) || (recycle_count == fifo_depth)) + { + recycle_count = 0; + pthread_cond_wait (&(evt->generator_cond), &(evt->generator_lock)); + fifo_depth = clib_fifo_elts (evt->event_index_fifo); + } /* Remove event */ clib_spinlock_lock (&(evt->events_lockp)); - clib_fifo_sub1 (evt->event_index_fifo, ev_idx); - ev = pool_elt_at_index (evt->vce_events, ev_idx); - + ev = vce_get_event_from_index (evt, ev_idx); ASSERT(ev); - + if (recycle_count && ev->recycle) + { + clib_fifo_add1 (evt->event_index_fifo, ev_idx); + clib_spinlock_unlock (&(evt->events_lockp)); + continue; + } clib_spinlock_lock (&evt->handlers_lockp); p = hash_get (evt->handlers_index_by_event_key, ev->evk.as_u64); if (!p) - { - /* If an event falls in the woods, and there is no handler to hear it, - * does it make any sound? - * I don't know either, so lets try recycling the event */ - clib_fifo_add1 (evt->event_index_fifo, ev_idx); - evt->recycle_event = 1; + { + /* If an event falls in the woods, and there is no handler to hear it, + * does it make any sound? + * I don't know either, so lets biff the event */ + pool_put(evt->vce_events, ev); clib_spinlock_unlock (&(evt->events_lockp)); - clib_spinlock_unlock (&evt->handlers_lockp); + clib_spinlock_unlock (&evt->handlers_lockp); pthread_mutex_unlock (&(evt->generator_lock)); - } + } else { + u32 evt_recycle = ev->recycle; handler = pool_elt_at_index (evt->vce_event_handlers, p[0]); handler->ev_idx = ev_idx; + ev->recycle = 0; clib_spinlock_unlock (&(evt->events_lockp)); clib_spinlock_unlock (&evt->handlers_lockp); pthread_mutex_unlock (&(evt->generator_lock)); (handler->handler_fn)(handler); + + clib_spinlock_lock (&(evt->events_lockp)); + ev = vce_get_event_from_index (evt, ev_idx); + recycle_count += (!evt_recycle && ev && ev->recycle) ? 1 : 0; + clib_spinlock_unlock(&(evt->events_lockp)); } pthread_mutex_lock (&(evt->generator_lock)); } - while (1); return NULL; } @@ -281,5 +283,6 @@ vce_start_event_thread (vce_event_thread_t *evt, u8 max_events) clib_spinlock_init (&(evt->handlers_lockp)); return pthread_create (&(evt->thread), NULL /* attr */ , - vce_event_thread_fn, evt); + vce_event_thread_fn, evt); } + diff --git a/src/vcl/vcl_event.h b/src/vcl/vcl_event.h index f2a85a0f1d2..21884665075 100644 --- a/src/vcl/vcl_event.h +++ b/src/vcl/vcl_event.h @@ -39,8 +39,8 @@ typedef union vce_event_key_ typedef struct vce_event_ { vce_event_key_t evk; - u32 refcnt; - void *data; + u32 recycle; + u64 data[2]; // Hard code size to avoid allocator thrashing. } vce_event_t; typedef void (*vce_event_callback_t) (void *reg /*vce_event_handler_reg_t* */); @@ -87,9 +87,9 @@ int vce_generate_event (vce_event_thread_t *evt, u32 ev_idx); * - removes event from event_pool * * @param evt - vce_event_thread_t - event system state - * @param ev - vce_event_t - event to remove + * @param ev_idx - u32 - index of event to remove */ -void vce_clear_event (vce_event_thread_t *evt, vce_event_t *ev); +void vce_clear_event (vce_event_thread_t *evt, u32 ev_idx); /** * @brief vce_get_event_from_index() @@ -102,6 +102,20 @@ void vce_clear_event (vce_event_thread_t *evt, vce_event_t *ev); vce_event_t * vce_get_event_from_index(vce_event_thread_t *evt, u32 ev_idx); /** + * @brief vce_get_event_data() + * + * @param ev - vce_event_t * - event + * @param data_size - u32 - required size of data + * + * @return vce_event_t * + */ +always_inline void * vce_get_event_data(vce_event_t *ev, u32 data_size) +{ + ASSERT(sizeof(ev->data) >= data_size); + return (&ev->data); +} + +/** * @brief vce_get_event_handler() * - returns handler if exists or 0 * @param evt - vce_event_thread_t - event system state diff --git a/src/vcl/vppcom.c b/src/vcl/vppcom.c index cab2f6039e9..a66926d8731 100644 --- a/src/vcl/vppcom.c +++ b/src/vcl/vppcom.c @@ -195,9 +195,12 @@ typedef enum vcl_event_id_ { VCL_EVENT_INVALID_EVENT, VCL_EVENT_CONNECT_REQ_ACCEPTED, + VCL_EVENT_IOEVENT_RX_FIFO, + VCL_EVENT_IOEVENT_TX_FIFO, VCL_EVENT_N_EVENTS } vcl_event_id_t; + typedef struct vce_event_connect_request_ { u32 accepted_session_index; @@ -210,6 +213,22 @@ typedef struct vppcom_session_listener void *user_cb_data; } vppcom_session_listener_t; +typedef struct vppcom_session_ioevent_ +{ + vppcom_session_ioevent_cb user_cb; + void *user_cb_data; +} vppcom_session_ioevent_t; + +typedef struct vppcom_session_io_thread_ +{ + pthread_t thread; + pthread_mutex_t vce_io_lock; + pthread_cond_t vce_io_cond; + u32 *active_session_indexes; //pool + vppcom_session_ioevent_t *ioevents; //pool + clib_spinlock_t io_sessions_lockp; +} vppcom_session_io_thread_t; + typedef struct vppcom_main_t_ { u8 init; @@ -254,6 +273,9 @@ typedef struct vppcom_main_t_ /* Event thread */ vce_event_thread_t event_thread; + /* IO thread */ + vppcom_session_io_thread_t session_io_thread; + /* VPP Event-logger */ elog_main_t elog_main; elog_track_t elog_track; @@ -364,6 +386,9 @@ vppcom_session_state_str (session_state_t state) /* * VPPCOM Utility Functions */ + + + static inline int vppcom_session_at_index (u32 session_index, session_t * volatile *sess) { @@ -379,6 +404,81 @@ vppcom_session_at_index (u32 session_index, session_t * volatile *sess) return VPPCOM_OK; } +void * +vppcom_session_io_thread_fn (void *arg) +{ + vppcom_session_io_thread_t *evt = (vppcom_session_io_thread_t *) arg; + u32 *session_indexes = 0, *session_index; + int i, rv; + u32 bytes = 0; + session_t *session; + + while (1) + { + vec_reset_length (session_indexes); + clib_spinlock_lock (&evt->io_sessions_lockp); + pool_foreach (session_index, evt->active_session_indexes, ( + { + vec_add1 + (session_indexes, + *session_index); + } + )); + clib_spinlock_unlock (&evt->io_sessions_lockp); + if (session_indexes) + { + for (i = 0; i < vec_len (session_indexes); ++i) + { + VCL_LOCK_AND_GET_SESSION (session_indexes[i], &session); + bytes = svm_fifo_max_dequeue (session->rx_fifo); + clib_spinlock_unlock (&vcm->sessions_lockp); + + if (bytes) + { + vppcom_ioevent_t *eio; + vce_event_t *ev; + u32 ev_idx; + + clib_spinlock_lock (&vcm->event_thread.events_lockp); + + pool_get (vcm->event_thread.vce_events, ev); + ev_idx = (u32) (ev - vcm->event_thread.vce_events); + eio = vce_get_event_data (ev, sizeof (*eio)); + ev->evk.eid = VCL_EVENT_IOEVENT_RX_FIFO; + ev->evk.session_index = session_indexes[i]; + eio->bytes = bytes; + eio->session_index = session_indexes[i]; + + clib_spinlock_unlock (&vcm->event_thread.events_lockp); + + rv = vce_generate_event (&vcm->event_thread, ev_idx); + } + } + } + struct timespec ts; + ts.tv_sec = 0; + ts.tv_nsec = 1000000; /* 1 millisecond */ + nanosleep (&ts, NULL); + } +done: + clib_spinlock_unlock (&vcm->sessions_lockp); + return NULL; +} + +int +vppcom_start_io_event_thread (vppcom_session_io_thread_t * evt, + u8 max_sessions) +{ + pthread_cond_init (&(evt->vce_io_cond), NULL); + pthread_mutex_init (&(evt->vce_io_lock), NULL); + + clib_spinlock_init (&(evt->io_sessions_lockp)); + + return pthread_create (&(evt->thread), NULL /* attr */ , + vppcom_session_io_thread_fn, evt); +} + + static inline void vppcom_session_table_add_listener (u64 listener_handle, u32 value) { @@ -462,6 +562,32 @@ vppcom_send_accept_session_reply (u64 handle, u32 context, int retval) */ void +vce_registered_ioevent_handler_fn (void *arg) +{ + vce_event_handler_reg_t *reg = (vce_event_handler_reg_t *) arg; + vppcom_ioevent_t *eio; + vce_event_t *ev; + u32 ioevt_ndx = (u64) (reg->handler_fn_args); + vppcom_session_ioevent_t *ioevent, ioevent_; + + clib_spinlock_lock (&(vcm->event_thread.events_lockp)); + ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx); + eio = vce_get_event_data (ev, sizeof (*eio)); + clib_spinlock_unlock (&(vcm->event_thread.events_lockp)); + + clib_spinlock_lock (&vcm->session_io_thread.io_sessions_lockp); + ioevent = pool_elt_at_index (vcm->session_io_thread.ioevents, ioevt_ndx); + ioevent_ = *ioevent; + clib_spinlock_unlock (&vcm->session_io_thread.io_sessions_lockp); + (ioevent_.user_cb) (eio, ioevent_.user_cb_data); + vce_clear_event (&vcm->event_thread, reg->ev_idx); + return; + + /*TODO - Unregister check in close for this listener */ + +} + +void vce_registered_listener_connect_handler_fn (void *arg) { vce_event_handler_reg_t *reg = (vce_event_handler_reg_t *) arg; @@ -475,12 +601,12 @@ vce_registered_listener_connect_handler_fn (void *arg) vppcom_session_listener_t *session_listener = (vppcom_session_listener_t *) reg->handler_fn_args; + clib_spinlock_lock (&(vcm->event_thread.events_lockp)); ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx); - - ecr = (vce_event_connect_request_t *) ev->data; + ecr = vce_get_event_data (ev, sizeof (*ecr)); + clib_spinlock_unlock (&(vcm->event_thread.events_lockp)); VCL_LOCK_AND_GET_SESSION (ecr->accepted_session_index, &new_session); - ep.is_ip4 = new_session->peer_addr.is_ip4; ep.port = new_session->peer_port; if (new_session->peer_addr.is_ip4) @@ -498,8 +624,18 @@ vce_registered_listener_connect_handler_fn (void *arg) (session_listener->user_cb) (ecr->accepted_session_index, &ep, session_listener->user_cb_data); - /*TODO - Unregister check in close for this listener */ + if (vcm->session_io_thread.io_sessions_lockp) + { + /* Throw this new accepted session index into the rx poll thread pool */ + clib_spinlock_lock (&vcm->session_io_thread.io_sessions_lockp); + u32 *active_session_index; + pool_get (vcm->session_io_thread.active_session_indexes, + active_session_index); + *active_session_index = ecr->accepted_session_index; + clib_spinlock_unlock (&vcm->session_io_thread.io_sessions_lockp); + } + /*TODO - Unregister check in close for this listener */ return; done: @@ -541,7 +677,7 @@ vce_poll_wait_connect_request_handler_fn (void *arg) vce_event_t *ev; /* Retrieve the VCL_EVENT_CONNECT_REQ_ACCEPTED event */ ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx); - vce_event_connect_request_t *ecr = (vce_event_connect_request_t *) ev->data; + vce_event_connect_request_t *ecr = vce_get_event_data (ev, sizeof (*ecr)); /* Add the accepted_session_index to the FIFO */ clib_spinlock_lock (&vcm->session_fifo_lockp); @@ -551,7 +687,7 @@ vce_poll_wait_connect_request_handler_fn (void *arg) /* Recycling the event. */ clib_spinlock_lock (&(vcm->event_thread.events_lockp)); - vcm->event_thread.recycle_event = 1; + ev->recycle = 1; clib_fifo_add1 (vcm->event_thread.event_index_fifo, reg->ev_idx); clib_spinlock_unlock (&(vcm->event_thread.events_lockp)); } @@ -811,8 +947,8 @@ vppcom_app_send_attach (void) (vcm->cfg.app_scope_global ? APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE : 0) | (app_is_proxy ? APP_OPTIONS_FLAGS_IS_PROXY : 0); bmp->options[APP_OPTIONS_PROXY_TRANSPORT] = - (vcm->cfg.app_proxy_transport_tcp ? 1 << TRANSPORT_PROTO_TCP : 0) | - (vcm->cfg.app_proxy_transport_udp ? 1 << TRANSPORT_PROTO_UDP : 0); + (u64) ((vcm->cfg.app_proxy_transport_tcp ? 1 << TRANSPORT_PROTO_TCP : 0) | + (vcm->cfg.app_proxy_transport_udp ? 1 << TRANSPORT_PROTO_UDP : 0)); bmp->options[APP_OPTIONS_SEGMENT_SIZE] = vcm->cfg.segment_size; bmp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = vcm->cfg.add_segment_size; bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = vcm->cfg.rx_fifo_size; @@ -1085,6 +1221,16 @@ done: /* * Setup session */ + if (vcm->session_io_thread.io_sessions_lockp) + { + // Add this connection to the active io sessions list + clib_spinlock_lock (&vcm->session_io_thread.io_sessions_lockp); + u32 *active_session_index; + pool_get (vcm->session_io_thread.active_session_indexes, + active_session_index); + *active_session_index = session_index; + clib_spinlock_unlock (&vcm->session_io_thread.io_sessions_lockp); + } session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address, svm_queue_t *); @@ -1360,7 +1506,7 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp) /* Allocate local session and set it up */ pool_get (vcm->sessions, session); memset (session, 0, sizeof (*session)); - session_index = session - vcm->sessions; + session_index = (u32) (session - vcm->sessions); rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *); rx_fifo->client_session_index = session_index; @@ -1388,10 +1534,8 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp) clib_spinlock_lock (&vcm->event_thread.events_lockp); pool_get (vcm->event_thread.vce_events, ev); - ev->data = clib_mem_alloc (sizeof (vce_event_connect_request_t)); - ev->refcnt = 0; ev_idx = (u32) (ev - vcm->event_thread.vce_events); - ecr = ev->data; + ecr = vce_get_event_data (ev, sizeof (*ecr)); ev->evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED; listen_session = vppcom_session_table_lookup_listener (mp->listener_handle); ev->evk.session_index = (u32) (listen_session - vcm->sessions); @@ -1400,7 +1544,6 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp) clib_spinlock_unlock (&vcm->event_thread.events_lockp); rv = vce_generate_event (&vcm->event_thread, ev_idx); - ASSERT (rv == 0); if (VPPCOM_DEBUG > 1) @@ -1454,6 +1597,9 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp) } +/* VPP combines bind and listen as one operation. VCL manages the separation + * of bind and listen locally via vppcom_session_bind() and + * vppcom_session_listen() */ static void vppcom_send_bind_sock (session_t * session, u32 session_index) { @@ -2194,6 +2340,7 @@ vppcom_app_create (char *app_name) vcm->cfg.listen_queue_size); vppcom_cfg_read (conf_fname); + env_var_str = getenv (VPPCOM_ENV_API_PREFIX); if (env_var_str) { @@ -2310,7 +2457,6 @@ vppcom_app_create (char *app_name) rv = vce_start_event_thread (&(vcm->event_thread), 20); - if (VPPCOM_DEBUG > 0) clib_warning ("VCL<%d>: sending session enable", getpid ()); @@ -2704,7 +2850,7 @@ vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len) if (VPPCOM_DEBUG > 0) clib_warning ("VCL<%d>: vpp handle 0x%llx, " - "sid %u: sending bind request...", + "sid %u: sending VPP bind+listen request...", getpid (), listen_vpp_handle, listen_session_index); vppcom_send_bind_sock (listen_session, listen_session_index); @@ -2717,10 +2863,10 @@ vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len) if (PREDICT_FALSE (retval)) { if (VPPCOM_DEBUG > 0) - clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: bind failed! " - "returning %d (%s)", getpid (), - listen_session->vpp_handle, listen_session_index, - retval, vppcom_retval_str (retval)); + clib_warning + ("VCL<%d>: vpp handle 0x%llx, sid %u: bind+listen failed! " + "returning %d (%s)", getpid (), listen_session->vpp_handle, + listen_session_index, retval, vppcom_retval_str (retval)); clib_spinlock_unlock (&vcm->sessions_lockp); rv = retval; goto done; @@ -2746,15 +2892,21 @@ vppcom_session_register_listener (uint32_t session_index, vce_event_key_t evk; vppcom_session_listener_t *listener_args; + if (!vcm->session_io_thread.io_sessions_lockp) + rv = vppcom_start_io_event_thread (&vcm->session_io_thread, 100 /* DAW_TODO: ??? hard-coded value */ + ); + if (rv) + { + goto done; + } rv = vppcom_session_listen (session_index, q_len); if (rv) { goto done; } - /* Register handler for connect_request event on listen_session_index */ - listener_args = clib_mem_alloc (sizeof (vppcom_session_listener_t)); + listener_args = clib_mem_alloc (sizeof (vppcom_session_listener_t)); // DAW_TODO: Use a pool instead of thrashing the memory allocator! listener_args->user_cb = cb; listener_args->user_cb_data = ptr; listener_args->user_errcb = errcb; @@ -2841,23 +2993,25 @@ vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep, evk.eid = VCL_EVENT_CONNECT_REQ_ACCEPTED; reg = vce_register_handler (&vcm->event_thread, &evk, vce_connect_request_handler_fn, 0); + clib_spinlock_lock (&(vcm->event_thread.events_lockp)); ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx); pthread_mutex_lock (®->handler_lock); while (!ev) { - rv = - pthread_cond_timedwait (®->handler_cond, ®->handler_lock, &ts); + clib_spinlock_unlock (&(vcm->event_thread.events_lockp)); + rv = pthread_cond_timedwait (®->handler_cond, + ®->handler_lock, &ts); if (rv == ETIMEDOUT) { rv = VPPCOM_EAGAIN; goto cleanup; } + clib_spinlock_lock (&(vcm->event_thread.events_lockp)); ev = vce_get_event_from_index (&vcm->event_thread, reg->ev_idx); } - result = (vce_event_connect_request_t *) ev->data; + result = vce_get_event_data (ev, sizeof (*result)); client_session_index = result->accepted_session_index; - - + clib_spinlock_unlock (&(vcm->event_thread.events_lockp)); /* Remove from the FIFO used to service epoll */ clib_spinlock_lock (&vcm->session_fifo_lockp); @@ -2982,8 +3136,17 @@ vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep, clib_spinlock_unlock (&vcm->sessions_lockp); rv = (int) client_session_index; - vce_clear_event (&vcm->event_thread, ev); - + vce_clear_event (&vcm->event_thread, reg->ev_idx); + if (vcm->session_io_thread.io_sessions_lockp) + { + /* Throw this new accepted session index into the rx poll thread pool */ + clib_spinlock_lock (&vcm->session_io_thread.io_sessions_lockp); + u32 *active_session_index; + pool_get (vcm->session_io_thread.active_session_indexes, + active_session_index); + *active_session_index = client_session_index; + clib_spinlock_unlock (&vcm->session_io_thread.io_sessions_lockp); + } cleanup: vce_unregister_handler (&vcm->event_thread, reg); pthread_mutex_unlock (®->handler_lock); @@ -3285,6 +3448,41 @@ done: } int +vppcom_session_register_ioevent_cb (uint32_t session_index, + vppcom_session_ioevent_cb cb, + uint8_t rx, void *ptr) +{ + int rv = VPPCOM_OK; + vce_event_key_t evk; + vppcom_session_ioevent_t *ioevent; + + if (!vcm->session_io_thread.io_sessions_lockp) + rv = vppcom_start_io_event_thread (&vcm->session_io_thread, 100 /* DAW_TODO: ??? hard-coded value */ + ); + + if (rv == VPPCOM_OK) + { + void *io_evt_ndx; + + /* Register handler for ioevent on session_index */ + clib_spinlock_lock (&vcm->session_io_thread.io_sessions_lockp); + pool_get (vcm->session_io_thread.ioevents, ioevent); + io_evt_ndx = (void *) (ioevent - vcm->session_io_thread.ioevents); + ioevent->user_cb = cb; + ioevent->user_cb_data = ptr; + clib_spinlock_unlock (&vcm->session_io_thread.io_sessions_lockp); + + evk.session_index = session_index; + evk.eid = rx ? VCL_EVENT_IOEVENT_RX_FIFO : VCL_EVENT_IOEVENT_TX_FIFO; + + (void) vce_register_handler (&vcm->event_thread, &evk, + vce_registered_ioevent_handler_fn, + io_evt_ndx); + } + return rv; +} + +int vppcom_session_write (uint32_t session_index, void *buf, size_t n) { session_t *session = 0; @@ -3339,7 +3537,12 @@ vppcom_session_write (uint32_t session_index, void *buf, size_t n) } while (!is_nonblocking && (n_write <= 0)); - /* If event wasn't set, add one */ + /* If event wasn't set, add one + * + * To reduce context switching, can check if an + * event is already there for this event_key, but for now + * this will suffice. */ + if ((n_write > 0) && svm_fifo_set_event (tx_fifo)) { /* Fabricate TX event, send to vpp */ diff --git a/src/vcl/vppcom.h b/src/vcl/vppcom.h index 34a69b2c2ec..c752e50413b 100644 --- a/src/vcl/vppcom.h +++ b/src/vcl/vppcom.h @@ -144,6 +144,13 @@ typedef struct _vcl_poll short *revents; } vcl_poll_t; +typedef struct vppcom_ioevent_ +{ + uint32_t session_index; + size_t bytes; +} vppcom_ioevent_t; + + /* * VPPCOM Public API Functions */ @@ -221,6 +228,34 @@ typedef void (*vppcom_session_listener_cb) (uint32_t, vppcom_endpt_t *, void *); /** + * User registered callback for IO events (rx/tx) + * @param vppcom_ioevent_t* - + * @param void* - user passed arg to pass back + */ +typedef void (*vppcom_session_ioevent_cb) (vppcom_ioevent_t *, void *); + +/** + * @brief vppcom_session_register_listener accepts a bound session_index, and + * listens for connections. + * + * On successful connection, calls registered callback (cb) with new + * session_index. + * + * On error, calls registered error callback (errcb). + * + * @param session_index - bound session_index to create listener on + * @param cb - on new accepted session callback + * @param errcb - on failure callback + * @param flags - placeholder for future use. Must be ZERO + * @param q_len - max listener connection backlog + * @param ptr - user data + * @return + */ +extern int vppcom_session_register_ioevent_cb (uint32_t session_index, + vppcom_session_ioevent_cb cb, + uint8_t rx, void *ptr); + +/** * User registered ERROR callback for any errors associated with * handling vppcom_session_register_listener() and connections * @param void* - user passed arg to pass back |