X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsession_node.c;h=1656e2eed0e3d8c9a0bb84492e325b45fa7d8d77;hb=1553197f;hp=1902adc29d56343d5dceddbb39de253438765f95;hpb=8b20bf5ef72a85ed70d7457f33c096f1eef51d0a;p=vpp.git diff --git a/src/vnet/session/session_node.c b/src/vnet/session/session_node.c index 1902adc29d5..1656e2eed0e 100644 --- a/src/vnet/session/session_node.c +++ b/src/vnet/session/session_node.c @@ -20,9 +20,172 @@ #include #include #include +#include #include #include +static void +session_mq_accepted_reply_handler (void *data) +{ + session_accepted_reply_msg_t *mp = (session_accepted_reply_msg_t *) data; + vnet_disconnect_args_t _a = { 0 }, *a = &_a; + local_session_t *ls; + stream_session_t *s; + + /* Server isn't interested, kill the session */ + if (mp->retval) + { + a->app_index = mp->context; + a->handle = mp->handle; + vnet_disconnect_session (a); + return; + } + + if (session_handle_is_local (mp->handle)) + { + ls = application_get_local_session_from_handle (mp->handle); + if (!ls || ls->app_wrk_index != mp->context) + { + clib_warning ("server %u doesn't own local handle %llu", + mp->context, mp->handle); + return; + } + if (application_local_session_connect_notify (ls)) + return; + ls->session_state = SESSION_STATE_READY; + } + else + { + s = session_get_from_handle_if_valid (mp->handle); + if (!s) + { + clib_warning ("session doesn't exist"); + return; + } + if (s->app_wrk_index != mp->context) + { + clib_warning ("app doesn't own session"); + return; + } + s->session_state = SESSION_STATE_READY; + if (!svm_fifo_is_empty (s->server_rx_fifo)) + { + app_worker_t *app; + app = app_worker_get (s->app_wrk_index); + application_send_event (app, s, FIFO_EVENT_APP_RX); + } + } +} + +static void +session_mq_reset_reply_handler (void *data) +{ + session_reset_reply_msg_t *mp; + app_worker_t *app_wrk; + stream_session_t *s; + application_t *app; + u32 index, thread_index; + + mp = (session_reset_reply_msg_t *) data; + app = application_lookup (mp->client_index); + if (!app) + return; + + session_parse_handle (mp->handle, &index, &thread_index); + s = session_get_if_valid (index, thread_index); + if (!s) + { + clib_warning ("Invalid session!"); + return; + } + app_wrk = app_worker_get (s->app_wrk_index); + if (!app_wrk || app_wrk->app_index != app->app_index) + { + clib_warning ("App % does not own handle 0x%lx!", app->app_index, + mp->handle); + return; + } + + /* Client objected to resetting the session, log and continue */ + if (mp->retval) + { + clib_warning ("client retval %d", mp->retval); + return; + } + + /* This comes as a response to a reset, transport only waiting for + * confirmation to remove connection state, no need to disconnect */ + stream_session_cleanup (s); +} + +static void +session_mq_disconnected_handler (void *data) +{ + session_disconnected_reply_msg_t *rmp; + vnet_disconnect_args_t _a, *a = &_a; + svm_msg_q_msg_t _msg, *msg = &_msg; + session_disconnected_msg_t *mp; + app_worker_t *app_wrk; + session_event_t *evt; + stream_session_t *s; + application_t *app; + int rv = 0; + + mp = (session_disconnected_msg_t *) data; + s = session_get_from_handle_if_valid (mp->handle); + app_wrk = app_worker_get (s->app_wrk_index); + app = application_lookup (mp->client_index); + if (!(app_wrk && s && app->app_index == app_wrk->app_index)) + { + clib_warning ("could not disconnect session: %llu app_wrk: %u", + mp->handle, mp->client_index); + return; + } + + a->handle = mp->handle; + a->app_index = app_wrk->wrk_index; + rv = vnet_disconnect_session (a); + + svm_msg_q_lock_and_alloc_msg_w_ring (app_wrk->event_queue, + SESSION_MQ_CTRL_EVT_RING, + SVM_Q_WAIT, msg); + svm_msg_q_unlock (app_wrk->event_queue); + evt = svm_msg_q_msg_data (app_wrk->event_queue, msg); + memset (evt, 0, sizeof (*evt)); + evt->event_type = SESSION_CTRL_EVT_DISCONNECTED; + rmp = (session_disconnected_reply_msg_t *) evt->data; + rmp->handle = mp->handle; + rmp->context = mp->context; + rmp->retval = rv; + svm_msg_q_add (app_wrk->event_queue, msg, SVM_Q_WAIT); +} + +static void +session_mq_disconnected_reply_handler (void *data) +{ + session_disconnected_reply_msg_t *mp; + vnet_disconnect_args_t _a, *a = &_a; + application_t *app; + + mp = (session_disconnected_reply_msg_t *) data; + + /* Client objected to disconnecting the session, log and continue */ + if (mp->retval) + { + clib_warning ("client retval %d", mp->retval); + return; + } + + /* Disconnect has been confirmed. Confirm close to transport */ + app = application_lookup (mp->context); + if (app) + { + a->handle = mp->handle; + a->app_index = app->app_index; + vnet_disconnect_session (a); + } +} + vlib_node_registration_t session_queue_node; typedef struct @@ -44,8 +207,6 @@ format_session_queue_trace (u8 * s, va_list * args) return s; } -vlib_node_registration_t session_queue_node; - #define foreach_session_queue_error \ _(TX, "Packets transmitted") \ _(TIMER, "Timer events") \ @@ -65,6 +226,13 @@ static char *session_queue_error_strings[] = { #undef _ }; +enum +{ + SESSION_TX_NO_BUFFERS = -2, + SESSION_TX_NO_DATA, + SESSION_TX_OK +}; + static void session_tx_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node, u32 next_index, u32 * to_next, u16 n_segs, @@ -78,11 +246,11 @@ session_tx_trace_frame (vlib_main_t * vm, vlib_node_runtime_t * node, { b = vlib_get_buffer (vm, to_next[i - n_segs]); vlib_trace_buffer (vm, node, next_index, b, 1 /* follow_chain */ ); - vlib_set_trace_count (vm, node, --n_trace); t = vlib_add_trace (vm, node, b, sizeof (*t)); t->session_index = s->session_index; t->server_thread_index = s->thread_index; } + vlib_set_trace_count (vm, node, n_trace - i); } always_inline void @@ -190,7 +358,6 @@ session_tx_fill_buffer (vlib_main_t * vm, session_tx_context_t * ctx, b->error = 0; b->flags = VNET_BUFFER_F_LOCALLY_ORIGINATED; b->current_data = 0; - b->total_length_not_including_first_buffer = 0; data0 = vlib_buffer_make_headroom (b, MAX_HDRS_LEN); len_to_deq = clib_min (ctx->left_to_snd, ctx->deq_per_first_buf); @@ -362,7 +529,7 @@ session_tx_set_dequeue_params (vlib_main_t * vm, session_tx_context_t * ctx, always_inline int session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, - session_fifo_event_t * e, + session_event_t * e, stream_session_t * s, int *n_tx_packets, u8 peek_data) { @@ -379,7 +546,7 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, { if (rv < 2) vec_add1 (smm->pending_event_vector[thread_index], *e); - return 0; + return SESSION_TX_NO_DATA; } next_index = smm->session_type_to_next[s->session_type]; @@ -394,7 +561,7 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, if (ctx->snd_space == 0 || ctx->snd_mss == 0) { vec_add1 (smm->pending_event_vector[thread_index], *e); - return 0; + return SESSION_TX_NO_DATA; } /* Allow enqueuing of a new event */ @@ -405,7 +572,7 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, peek_data); if (PREDICT_FALSE (!ctx->max_len_to_snd)) - return 0; + return SESSION_TX_NO_DATA; n_bufs = vec_len (smm->tx_buffers[thread_index]); n_bufs_needed = ctx->n_segs_per_evt * ctx->n_bufs_per_seg; @@ -420,7 +587,7 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, if (PREDICT_FALSE (n_bufs < n_bufs_needed)) { vec_add1 (smm->pending_event_vector[thread_index], *e); - return -1; + return SESSION_TX_NO_BUFFERS; } } @@ -476,7 +643,13 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_buffer_t *b0; u32 bi0; - ASSERT (n_bufs >= 1); + if (n_left > 1) + { + pbi = smm->tx_buffers[thread_index][n_bufs - 2]; + pb = vlib_get_buffer (vm, pbi); + vlib_prefetch_buffer_header (pb, STORE); + } + to_next[0] = bi0 = smm->tx_buffers[thread_index][--n_bufs]; b0 = vlib_get_buffer (vm, bi0); session_tx_fill_buffer (vm, ctx, b0, &n_bufs, peek_data); @@ -520,187 +693,57 @@ session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node, if (svm_fifo_set_event (s->server_tx_fifo)) vec_add1 (smm->pending_event_vector[thread_index], *e); } - return 0; + return SESSION_TX_OK; } int session_tx_fifo_peek_and_snd (vlib_main_t * vm, vlib_node_runtime_t * node, - session_fifo_event_t * e0, - stream_session_t * s0, int *n_tx_pkts) + session_event_t * e, + stream_session_t * s, int *n_tx_pkts) { - return session_tx_fifo_read_and_snd_i (vm, node, e0, s0, n_tx_pkts, 1); + return session_tx_fifo_read_and_snd_i (vm, node, e, s, n_tx_pkts, 1); } int session_tx_fifo_dequeue_and_snd (vlib_main_t * vm, vlib_node_runtime_t * node, - session_fifo_event_t * e0, - stream_session_t * s0, int *n_tx_pkts) + session_event_t * e, + stream_session_t * s, int *n_tx_pkts) { - return session_tx_fifo_read_and_snd_i (vm, node, e0, s0, n_tx_pkts, 0); + return session_tx_fifo_read_and_snd_i (vm, node, e, s, n_tx_pkts, 0); } int session_tx_fifo_dequeue_internal (vlib_main_t * vm, vlib_node_runtime_t * node, - session_fifo_event_t * e0, - stream_session_t * s0, int *n_tx_pkts) + session_event_t * e, + stream_session_t * s, int *n_tx_pkts) { application_t *app; - app = application_get (s0->opaque); - svm_fifo_unset_event (s0->server_tx_fifo); - return app->cb_fns.builtin_app_tx_callback (s0); + app = application_get (s->opaque); + svm_fifo_unset_event (s->server_tx_fifo); + return app->cb_fns.builtin_app_tx_callback (s); } always_inline stream_session_t * -session_event_get_session (session_fifo_event_t * e, u8 thread_index) +session_event_get_session (session_event_t * e, u8 thread_index) { return session_get_if_valid (e->fifo->master_session_index, thread_index); } -void -dump_thread_0_event_queue (void) -{ - session_manager_main_t *smm = vnet_get_session_manager_main (); - vlib_main_t *vm = &vlib_global_main; - u32 my_thread_index = vm->thread_index; - session_fifo_event_t _e, *e = &_e; - stream_session_t *s0; - int i, index; - i8 *headp; - - svm_queue_t *q; - q = smm->vpp_event_queues[my_thread_index]; - - index = q->head; - - for (i = 0; i < q->cursize; i++) - { - headp = (i8 *) (&q->data[0] + q->elsize * index); - clib_memcpy (e, headp, q->elsize); - - switch (e->event_type) - { - case FIFO_EVENT_APP_TX: - s0 = session_event_get_session (e, my_thread_index); - fformat (stdout, "[%04d] TX session %d\n", i, s0->session_index); - break; - - case FIFO_EVENT_DISCONNECT: - s0 = session_get_from_handle (e->session_handle); - fformat (stdout, "[%04d] disconnect session %d\n", i, - s0->session_index); - break; - - case FIFO_EVENT_BUILTIN_RX: - s0 = session_event_get_session (e, my_thread_index); - fformat (stdout, "[%04d] builtin_rx %d\n", i, s0->session_index); - break; - - case FIFO_EVENT_RPC: - fformat (stdout, "[%04d] RPC call %llx with %llx\n", - i, (u64) (e->rpc_args.fp), (u64) (e->rpc_args.arg)); - break; - - default: - fformat (stdout, "[%04d] unhandled event type %d\n", - i, e->event_type); - break; - } - - index++; - - if (index == q->maxsize) - index = 0; - } -} - -static u8 -session_node_cmp_event (session_fifo_event_t * e, svm_fifo_t * f) -{ - stream_session_t *s; - switch (e->event_type) - { - case FIFO_EVENT_APP_RX: - case FIFO_EVENT_APP_TX: - case FIFO_EVENT_BUILTIN_RX: - if (e->fifo == f) - return 1; - break; - case FIFO_EVENT_DISCONNECT: - break; - case FIFO_EVENT_RPC: - s = session_get_from_handle (e->session_handle); - if (!s) - { - clib_warning ("session has event but doesn't exist!"); - break; - } - if (s->server_rx_fifo == f || s->server_tx_fifo == f) - return 1; - break; - default: - break; - } - return 0; -} - -u8 -session_node_lookup_fifo_event (svm_fifo_t * f, session_fifo_event_t * e) -{ - session_manager_main_t *smm = vnet_get_session_manager_main (); - svm_queue_t *q; - session_fifo_event_t *pending_event_vector, *evt; - int i, index, found = 0; - i8 *headp; - u8 thread_index; - - ASSERT (e); - thread_index = f->master_thread_index; - /* - * Search evt queue - */ - q = smm->vpp_event_queues[thread_index]; - index = q->head; - for (i = 0; i < q->cursize; i++) - { - headp = (i8 *) (&q->data[0] + q->elsize * index); - clib_memcpy (e, headp, q->elsize); - found = session_node_cmp_event (e, f); - if (found) - return 1; - if (++index == q->maxsize) - index = 0; - } - /* - * Search pending events vector - */ - pending_event_vector = smm->pending_event_vector[thread_index]; - vec_foreach (evt, pending_event_vector) - { - found = session_node_cmp_event (evt, f); - if (found) - { - clib_memcpy (e, evt, sizeof (*evt)); - break; - } - } - return found; -} - static uword session_queue_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame) { session_manager_main_t *smm = vnet_get_session_manager_main (); - session_fifo_event_t *my_pending_event_vector, *e; - session_fifo_event_t *my_fifo_events; - u32 n_to_dequeue, n_events; - svm_queue_t *q; - application_t *app; - int n_tx_packets = 0; - u32 thread_index = vm->thread_index; - int i, rv; + u32 thread_index = vm->thread_index, n_to_dequeue, n_events; + session_event_t *pending_events, *e; + session_event_t *fifo_events; + svm_msg_q_msg_t _msg, *msg = &_msg; f64 now = vlib_time_now (vm); + int n_tx_packets = 0, i, rv; + app_worker_t *app_wrk; + application_t *app; + svm_msg_q_t *mq; void (*fp) (void *); SESSION_EVT_DBG (SESSION_EVT_POLL_GAP_TRACK, smm, thread_index); @@ -711,19 +754,14 @@ session_queue_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node, transport_update_time (now, thread_index); /* - * Get vpp queue events + * Get vpp queue events that we can dequeue without blocking */ - q = smm->vpp_event_queues[thread_index]; - if (PREDICT_FALSE (q == 0)) - return 0; - - my_fifo_events = smm->free_event_vector[thread_index]; + mq = smm->vpp_event_queues[thread_index]; + fifo_events = smm->free_event_vector[thread_index]; + n_to_dequeue = svm_msg_q_size (mq); + pending_events = smm->pending_event_vector[thread_index]; - /* min number of events we can dequeue without blocking */ - n_to_dequeue = q->cursize; - my_pending_event_vector = smm->pending_event_vector[thread_index]; - - if (!n_to_dequeue && !vec_len (my_pending_event_vector) + if (!n_to_dequeue && !vec_len (pending_events) && !vec_len (smm->pending_disconnects[thread_index])) return 0; @@ -732,66 +770,75 @@ session_queue_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node, /* * If we didn't manage to process previous events try going * over them again without dequeuing new ones. + * XXX: Handle senders to sessions that can't keep up */ - /* XXX: Block senders to sessions that can't keep up */ - if (0 && vec_len (my_pending_event_vector) >= 100) + if (0 && vec_len (pending_events) >= 100) { clib_warning ("too many fifo events unsolved"); goto skip_dequeue; } - /* See you in the next life, don't be late */ - if (pthread_mutex_trylock (&q->mutex)) + /* See you in the next life, don't be late + * XXX: we may need priorities here */ + if (svm_msg_q_try_lock (mq)) return 0; for (i = 0; i < n_to_dequeue; i++) { - vec_add2 (my_fifo_events, e, 1); - svm_queue_sub_raw (q, (u8 *) e); + vec_add2 (fifo_events, e, 1); + svm_msg_q_sub_w_lock (mq, msg); + clib_memcpy (e, svm_msg_q_msg_data (mq, msg), sizeof (*e)); + svm_msg_q_free_msg (mq, msg); } - /* The other side of the connection is not polling */ - if (q->cursize < (q->maxsize / 8)) - (void) pthread_cond_broadcast (&q->condvar); - pthread_mutex_unlock (&q->mutex); + svm_msg_q_unlock (mq); - vec_append (my_fifo_events, my_pending_event_vector); - vec_append (my_fifo_events, smm->pending_disconnects[thread_index]); + vec_append (fifo_events, pending_events); + vec_append (fifo_events, smm->pending_disconnects[thread_index]); - _vec_len (my_pending_event_vector) = 0; - smm->pending_event_vector[thread_index] = my_pending_event_vector; + _vec_len (pending_events) = 0; + smm->pending_event_vector[thread_index] = pending_events; _vec_len (smm->pending_disconnects[thread_index]) = 0; skip_dequeue: - n_events = vec_len (my_fifo_events); + n_events = vec_len (fifo_events); for (i = 0; i < n_events; i++) { - stream_session_t *s0; /* $$$ prefetch 1 ahead maybe */ - session_fifo_event_t *e0; + stream_session_t *s; /* $$$ prefetch 1 ahead maybe */ + session_event_t *e; + u8 is_full; - e0 = &my_fifo_events[i]; - switch (e0->event_type) + e = &fifo_events[i]; + switch (e->event_type) { case FIFO_EVENT_APP_TX: + /* Don't try to send more that one frame per dispatch cycle */ if (n_tx_packets == VLIB_FRAME_SIZE) { - vec_add1 (smm->pending_event_vector[thread_index], *e0); + vec_add1 (smm->pending_event_vector[thread_index], *e); break; } - s0 = session_event_get_session (e0, thread_index); - if (PREDICT_FALSE (!s0)) + s = session_event_get_session (e, thread_index); + if (PREDICT_FALSE (!s)) { clib_warning ("It's dead, Jim!"); continue; } + is_full = svm_fifo_is_full (s->server_tx_fifo); /* Spray packets in per session type frames, since they go to * different nodes */ - rv = (smm->session_tx_fns[s0->session_type]) (vm, node, e0, s0, - &n_tx_packets); - /* Out of buffers */ - if (PREDICT_FALSE (rv < 0)) + rv = (smm->session_tx_fns[s->session_type]) (vm, node, e, s, + &n_tx_packets); + if (PREDICT_TRUE (rv == SESSION_TX_OK)) + { + /* Notify app there's tx space if not polling */ + if (PREDICT_FALSE (is_full + && !svm_fifo_has_event (s->server_tx_fifo))) + session_dequeue_notify (s); + } + else if (PREDICT_FALSE (rv == SESSION_TX_NO_BUFFERS)) { vlib_node_increment_counter (vm, node->node_index, SESSION_QUEUE_ERROR_NO_BUFFER, 1); @@ -801,42 +848,56 @@ skip_dequeue: case FIFO_EVENT_DISCONNECT: /* Make sure stream disconnects run after the pending list is * drained */ - s0 = session_get_from_handle (e0->session_handle); - if (!e0->postponed) + s = session_get_from_handle (e->session_handle); + if (!e->postponed) { - e0->postponed = 1; - vec_add1 (smm->pending_disconnects[thread_index], *e0); + e->postponed = 1; + vec_add1 (smm->pending_disconnects[thread_index], *e); continue; } /* If tx queue is still not empty, wait */ - if (svm_fifo_max_dequeue (s0->server_tx_fifo)) + if (svm_fifo_max_dequeue (s->server_tx_fifo)) { - vec_add1 (smm->pending_disconnects[thread_index], *e0); + vec_add1 (smm->pending_disconnects[thread_index], *e); continue; } - stream_session_disconnect_transport (s0); + stream_session_disconnect_transport (s); break; case FIFO_EVENT_BUILTIN_RX: - s0 = session_event_get_session (e0, thread_index); - if (PREDICT_FALSE (!s0)) + s = session_event_get_session (e, thread_index); + if (PREDICT_FALSE (!s)) continue; - svm_fifo_unset_event (s0->server_rx_fifo); - app = application_get (s0->app_index); - app->cb_fns.builtin_app_rx_callback (s0); + svm_fifo_unset_event (s->server_rx_fifo); + app_wrk = app_worker_get (s->app_wrk_index); + app = application_get (app_wrk->app_index); + app->cb_fns.builtin_app_rx_callback (s); break; case FIFO_EVENT_RPC: - fp = e0->rpc_args.fp; - (*fp) (e0->rpc_args.arg); + fp = e->rpc_args.fp; + (*fp) (e->rpc_args.arg); + break; + case SESSION_CTRL_EVT_DISCONNECTED: + session_mq_disconnected_handler (e->data); + break; + case SESSION_CTRL_EVT_ACCEPTED_REPLY: + session_mq_accepted_reply_handler (e->data); + break; + case SESSION_CTRL_EVT_CONNECTED_REPLY: + break; + case SESSION_CTRL_EVT_DISCONNECTED_REPLY: + session_mq_disconnected_reply_handler (e->data); + break; + case SESSION_CTRL_EVT_RESET_REPLY: + session_mq_reset_reply_handler (e->data); break; - default: - clib_warning ("unhandled event type %d", e0->event_type); + clib_warning ("unhandled event type %d", e->event_type); } } - _vec_len (my_fifo_events) = 0; - smm->free_event_vector[thread_index] = my_fifo_events; + _vec_len (fifo_events) = 0; + smm->free_event_vector[thread_index] = fifo_events; vlib_node_increment_counter (vm, session_queue_node.index, SESSION_QUEUE_ERROR_TX, n_tx_packets); @@ -859,6 +920,139 @@ VLIB_REGISTER_NODE (session_queue_node) = }; /* *INDENT-ON* */ +void +dump_thread_0_event_queue (void) +{ + session_manager_main_t *smm = vnet_get_session_manager_main (); + vlib_main_t *vm = &vlib_global_main; + u32 my_thread_index = vm->thread_index; + session_event_t _e, *e = &_e; + svm_msg_q_ring_t *ring; + stream_session_t *s0; + svm_msg_q_msg_t *msg; + svm_msg_q_t *mq; + int i, index; + + mq = smm->vpp_event_queues[my_thread_index]; + index = mq->q->head; + + for (i = 0; i < mq->q->cursize; i++) + { + msg = (svm_msg_q_msg_t *) (&mq->q->data[0] + mq->q->elsize * index); + ring = svm_msg_q_ring (mq, msg->ring_index); + clib_memcpy (e, svm_msg_q_msg_data (mq, msg), ring->elsize); + + switch (e->event_type) + { + case FIFO_EVENT_APP_TX: + s0 = session_event_get_session (e, my_thread_index); + fformat (stdout, "[%04d] TX session %d\n", i, s0->session_index); + break; + + case FIFO_EVENT_DISCONNECT: + s0 = session_get_from_handle (e->session_handle); + fformat (stdout, "[%04d] disconnect session %d\n", i, + s0->session_index); + break; + + case FIFO_EVENT_BUILTIN_RX: + s0 = session_event_get_session (e, my_thread_index); + fformat (stdout, "[%04d] builtin_rx %d\n", i, s0->session_index); + break; + + case FIFO_EVENT_RPC: + fformat (stdout, "[%04d] RPC call %llx with %llx\n", + i, (u64) (e->rpc_args.fp), (u64) (e->rpc_args.arg)); + break; + + default: + fformat (stdout, "[%04d] unhandled event type %d\n", + i, e->event_type); + break; + } + + index++; + + if (index == mq->q->maxsize) + index = 0; + } +} + +static u8 +session_node_cmp_event (session_event_t * e, svm_fifo_t * f) +{ + stream_session_t *s; + switch (e->event_type) + { + case FIFO_EVENT_APP_RX: + case FIFO_EVENT_APP_TX: + case FIFO_EVENT_BUILTIN_RX: + if (e->fifo == f) + return 1; + break; + case FIFO_EVENT_DISCONNECT: + break; + case FIFO_EVENT_RPC: + s = session_get_from_handle (e->session_handle); + if (!s) + { + clib_warning ("session has event but doesn't exist!"); + break; + } + if (s->server_rx_fifo == f || s->server_tx_fifo == f) + return 1; + break; + default: + break; + } + return 0; +} + +u8 +session_node_lookup_fifo_event (svm_fifo_t * f, session_event_t * e) +{ + session_manager_main_t *smm = vnet_get_session_manager_main (); + svm_msg_q_t *mq; + session_event_t *pending_event_vector, *evt; + int i, index, found = 0; + svm_msg_q_msg_t *msg; + svm_msg_q_ring_t *ring; + u8 thread_index; + + ASSERT (e); + thread_index = f->master_thread_index; + /* + * Search evt queue + */ + mq = smm->vpp_event_queues[thread_index]; + index = mq->q->head; + for (i = 0; i < mq->q->cursize; i++) + { + msg = (svm_msg_q_msg_t *) (&mq->q->data[0] + mq->q->elsize * index); + ring = svm_msg_q_ring (mq, msg->ring_index); + clib_memcpy (e, svm_msg_q_msg_data (mq, msg), ring->elsize); + found = session_node_cmp_event (e, f); + if (found) + return 1; + if (++index == mq->q->maxsize) + index = 0; + } + /* + * Search pending events vector + */ + pending_event_vector = smm->pending_event_vector[thread_index]; + vec_foreach (evt, pending_event_vector) + { + found = session_node_cmp_event (evt, f); + if (found) + { + clib_memcpy (e, evt, sizeof (*evt)); + break; + } + } + return found; +} + static clib_error_t * session_queue_exit (vlib_main_t * vm) {