udp: refactor udp code
[vpp.git] / src / vnet / session / session_node.c
1 /*
2  * Copyright (c) 2017 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <math.h>
17 #include <vlib/vlib.h>
18 #include <vnet/vnet.h>
19 #include <vnet/tcp/tcp.h>
20 #include <vppinfra/elog.h>
21 #include <vnet/session/application.h>
22 #include <vnet/session/session_debug.h>
23 #include <vlibmemory/unix_shared_memory_queue.h>
24
25 vlib_node_registration_t session_queue_node;
26
27 typedef struct
28 {
29   u32 session_index;
30   u32 server_thread_index;
31 } session_queue_trace_t;
32
33 /* packet trace format function */
34 static u8 *
35 format_session_queue_trace (u8 * s, va_list * args)
36 {
37   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
38   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
39   session_queue_trace_t *t = va_arg (*args, session_queue_trace_t *);
40
41   s = format (s, "SESSION_QUEUE: session index %d, server thread index %d",
42               t->session_index, t->server_thread_index);
43   return s;
44 }
45
46 vlib_node_registration_t session_queue_node;
47
48 #define foreach_session_queue_error             \
49 _(TX, "Packets transmitted")                    \
50 _(TIMER, "Timer events")                        \
51 _(NO_BUFFER, "Out of buffers")
52
53 typedef enum
54 {
55 #define _(sym,str) SESSION_QUEUE_ERROR_##sym,
56   foreach_session_queue_error
57 #undef _
58     SESSION_QUEUE_N_ERROR,
59 } session_queue_error_t;
60
61 static char *session_queue_error_strings[] = {
62 #define _(sym,string) string,
63   foreach_session_queue_error
64 #undef _
65 };
66
67 static u32 session_type_to_next[] = {
68   SESSION_QUEUE_NEXT_TCP_IP4_OUTPUT,
69   SESSION_QUEUE_NEXT_IP4_LOOKUP,
70   SESSION_QUEUE_NEXT_TCP_IP6_OUTPUT,
71   SESSION_QUEUE_NEXT_IP6_LOOKUP,
72 };
73
74 always_inline void
75 session_tx_fifo_chain_tail (session_manager_main_t * smm, vlib_main_t * vm,
76                             u8 thread_index, svm_fifo_t * fifo,
77                             vlib_buffer_t * b0, u32 bi0, u8 n_bufs_per_seg,
78                             u32 left_from_seg, u32 * left_to_snd0,
79                             u16 * n_bufs, u32 * tx_offset, u16 deq_per_buf,
80                             u8 peek_data)
81 {
82   vlib_buffer_t *chain_b0, *prev_b0;
83   u32 chain_bi0, to_deq;
84   u16 len_to_deq0, n_bytes_read;
85   u8 *data0, j;
86
87   b0->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
88   b0->total_length_not_including_first_buffer = 0;
89
90   chain_bi0 = bi0;
91   chain_b0 = b0;
92   to_deq = left_from_seg;
93   for (j = 1; j < n_bufs_per_seg; j++)
94     {
95       prev_b0 = chain_b0;
96       len_to_deq0 = clib_min (to_deq, deq_per_buf);
97
98       *n_bufs -= 1;
99       chain_bi0 = smm->tx_buffers[thread_index][*n_bufs];
100       _vec_len (smm->tx_buffers[thread_index]) = *n_bufs;
101
102       chain_b0 = vlib_get_buffer (vm, chain_bi0);
103       chain_b0->current_data = 0;
104       data0 = vlib_buffer_get_current (chain_b0);
105       if (peek_data)
106         {
107           n_bytes_read = svm_fifo_peek (fifo, *tx_offset, len_to_deq0, data0);
108           *tx_offset += n_bytes_read;
109         }
110       else
111         {
112           n_bytes_read = svm_fifo_dequeue_nowait (fifo, len_to_deq0, data0);
113         }
114       ASSERT (n_bytes_read == len_to_deq0);
115       chain_b0->current_length = n_bytes_read;
116       b0->total_length_not_including_first_buffer += chain_b0->current_length;
117
118       /* update previous buffer */
119       prev_b0->next_buffer = chain_bi0;
120       prev_b0->flags |= VLIB_BUFFER_NEXT_PRESENT;
121
122       /* update current buffer */
123       chain_b0->next_buffer = 0;
124
125       to_deq -= n_bytes_read;
126       if (to_deq == 0)
127         break;
128     }
129   ASSERT (to_deq == 0
130           && b0->total_length_not_including_first_buffer == left_from_seg);
131   *left_to_snd0 -= left_from_seg;
132 }
133
134 always_inline int
135 session_tx_fifo_read_and_snd_i (vlib_main_t * vm, vlib_node_runtime_t * node,
136                                 session_manager_main_t * smm,
137                                 session_fifo_event_t * e0,
138                                 stream_session_t * s0, u32 thread_index,
139                                 int *n_tx_packets, u8 peek_data)
140 {
141   u32 n_trace = vlib_get_trace_count (vm, node);
142   u32 left_to_snd0, max_len_to_snd0, len_to_deq0, snd_space0;
143   u32 n_bufs_per_evt, n_frames_per_evt, n_bufs_per_frame;
144   transport_connection_t *tc0;
145   transport_proto_vft_t *transport_vft;
146   u32 next_index, next0, *to_next, n_left_to_next, bi0;
147   vlib_buffer_t *b0;
148   u32 tx_offset = 0, max_dequeue0, n_bytes_per_seg, left_for_seg;
149   u16 snd_mss0, n_bufs_per_seg, n_bufs;
150   u8 *data0;
151   int i, n_bytes_read;
152   u32 n_bytes_per_buf, deq_per_buf, deq_per_first_buf;
153   u32 buffers_allocated, buffers_allocated_this_call;
154
155   next_index = next0 = session_type_to_next[s0->session_type];
156
157   transport_vft = transport_protocol_get_vft (s0->session_type);
158   tc0 = transport_vft->get_connection (s0->connection_index, thread_index);
159
160   /* Make sure we have space to send and there's something to dequeue */
161   snd_mss0 = transport_vft->send_mss (tc0);
162   snd_space0 = transport_vft->send_space (tc0);
163
164   /* Can't make any progress */
165   if (snd_space0 == 0 || snd_mss0 == 0)
166     {
167       vec_add1 (smm->pending_event_vector[thread_index], *e0);
168       return 0;
169     }
170
171   /* Check how much we can pull. */
172   max_dequeue0 = svm_fifo_max_dequeue (s0->server_tx_fifo);
173
174   if (peek_data)
175     {
176       /* Offset in rx fifo from where to peek data */
177       tx_offset = transport_vft->tx_fifo_offset (tc0);
178       if (PREDICT_FALSE (tx_offset >= max_dequeue0))
179         max_dequeue0 = 0;
180       else
181         max_dequeue0 -= tx_offset;
182     }
183
184   /* Nothing to read return */
185   if (max_dequeue0 == 0)
186     {
187       svm_fifo_unset_event (s0->server_tx_fifo);
188       return 0;
189     }
190
191   /* Ensure we're not writing more than transport window allows */
192   if (max_dequeue0 < snd_space0)
193     {
194       /* Constrained by tx queue. Try to send only fully formed segments */
195       max_len_to_snd0 = (max_dequeue0 > snd_mss0) ?
196         max_dequeue0 - max_dequeue0 % snd_mss0 : max_dequeue0;
197       /* TODO Nagle ? */
198     }
199   else
200     {
201       /* Expectation is that snd_space0 is already a multiple of snd_mss */
202       max_len_to_snd0 = snd_space0;
203     }
204
205   n_bytes_per_buf = vlib_buffer_free_list_buffer_size
206     (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
207   ASSERT (n_bytes_per_buf > MAX_HDRS_LEN);
208   n_bytes_per_seg = MAX_HDRS_LEN + snd_mss0;
209   n_bufs_per_seg = ceil ((double) n_bytes_per_seg / n_bytes_per_buf);
210   n_bufs_per_evt = ceil ((double) max_len_to_snd0 / n_bytes_per_seg);
211   n_frames_per_evt = ceil ((double) n_bufs_per_evt / VLIB_FRAME_SIZE);
212   n_bufs_per_frame = n_bufs_per_seg * VLIB_FRAME_SIZE;
213
214   deq_per_buf = clib_min (snd_mss0, n_bytes_per_buf);
215   deq_per_first_buf = clib_min (snd_mss0, n_bytes_per_buf - MAX_HDRS_LEN);
216
217   n_bufs = vec_len (smm->tx_buffers[thread_index]);
218   left_to_snd0 = max_len_to_snd0;
219   for (i = 0; i < n_frames_per_evt; i++)
220     {
221       /* Make sure we have at least one full frame of buffers ready */
222       if (PREDICT_FALSE (n_bufs < n_bufs_per_frame))
223         {
224           vec_validate (smm->tx_buffers[thread_index],
225                         n_bufs + n_bufs_per_frame - 1);
226           buffers_allocated = 0;
227           do
228             {
229               buffers_allocated_this_call = vlib_buffer_alloc (vm,
230                                                                &smm->tx_buffers
231                                                                [thread_index]
232                                                                [n_bufs +
233                                                                 buffers_allocated],
234                                                                n_bufs_per_frame
235                                                                -
236                                                                buffers_allocated);
237               buffers_allocated += buffers_allocated_this_call;
238             }
239           while (buffers_allocated_this_call > 0
240                  && ((buffers_allocated + n_bufs < n_bufs_per_frame)));
241
242           n_bufs += buffers_allocated;
243           _vec_len (smm->tx_buffers[thread_index]) = n_bufs;
244
245           if (PREDICT_FALSE (n_bufs < n_bufs_per_frame))
246             {
247               vec_add1 (smm->pending_event_vector[thread_index], *e0);
248               return -1;
249             }
250           ASSERT (n_bufs >= n_bufs_per_frame);
251         }
252       /* Allow enqueuing of a new event */
253       svm_fifo_unset_event (s0->server_tx_fifo);
254
255       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
256       while (left_to_snd0 && n_left_to_next)
257         {
258           /*
259            * Handle first buffer in chain separately
260            */
261
262           /* Get free buffer */
263           ASSERT (n_bufs >= 1);
264           bi0 = smm->tx_buffers[thread_index][--n_bufs];
265           _vec_len (smm->tx_buffers[thread_index]) = n_bufs;
266
267           /* usual speculation, or the enqueue_x1 macro will barf */
268           to_next[0] = bi0;
269           to_next += 1;
270           n_left_to_next -= 1;
271
272           b0 = vlib_get_buffer (vm, bi0);
273           b0->error = 0;
274           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
275           b0->current_data = 0;
276           b0->total_length_not_including_first_buffer = 0;
277
278           len_to_deq0 = clib_min (left_to_snd0, deq_per_first_buf);
279           data0 = vlib_buffer_make_headroom (b0, MAX_HDRS_LEN);
280           if (peek_data)
281             {
282               n_bytes_read = svm_fifo_peek (s0->server_tx_fifo, tx_offset,
283                                             len_to_deq0, data0);
284               if (n_bytes_read <= 0)
285                 goto dequeue_fail;
286               /* Keep track of progress locally, transport is also supposed to
287                * increment it independently when pushing the header */
288               tx_offset += n_bytes_read;
289             }
290           else
291             {
292               n_bytes_read = svm_fifo_dequeue_nowait (s0->server_tx_fifo,
293                                                       len_to_deq0, data0);
294               if (n_bytes_read <= 0)
295                 goto dequeue_fail;
296             }
297
298           b0->current_length = n_bytes_read;
299
300           left_to_snd0 -= n_bytes_read;
301           *n_tx_packets = *n_tx_packets + 1;
302
303           /*
304            * Fill in the remaining buffers in the chain, if any
305            */
306           if (PREDICT_FALSE (n_bufs_per_seg > 1 && left_to_snd0))
307             {
308               left_for_seg = clib_min (snd_mss0 - n_bytes_read, left_to_snd0);
309               session_tx_fifo_chain_tail (smm, vm, thread_index,
310                                           s0->server_tx_fifo, b0, bi0,
311                                           n_bufs_per_seg, left_for_seg,
312                                           &left_to_snd0, &n_bufs, &tx_offset,
313                                           deq_per_buf, peek_data);
314             }
315
316           /* Ask transport to push header after current_length and
317            * total_length_not_including_first_buffer are updated */
318           transport_vft->push_header (tc0, b0);
319
320           /* *INDENT-OFF* */
321           SESSION_EVT_DBG(SESSION_EVT_DEQ, s0, ({
322               ed->data[0] = e0->event_id;
323               ed->data[1] = max_dequeue0;
324               ed->data[2] = len_to_deq0;
325               ed->data[3] = left_to_snd0;
326           }));
327           /* *INDENT-ON* */
328
329           VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
330           if (VLIB_BUFFER_TRACE_TRAJECTORY)
331             b0->pre_data[1] = 3;
332
333           if (PREDICT_FALSE (n_trace > 0))
334             {
335               session_queue_trace_t *t0;
336               vlib_trace_buffer (vm, node, next_index, b0,
337                                  1 /* follow_chain */ );
338               vlib_set_trace_count (vm, node, --n_trace);
339               t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
340               t0->session_index = s0->session_index;
341               t0->server_thread_index = s0->thread_index;
342             }
343
344           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
345                                            to_next, n_left_to_next,
346                                            bi0, next0);
347         }
348       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
349     }
350
351   /* If we couldn't dequeue all bytes mark as partially read */
352   if (max_len_to_snd0 < max_dequeue0)
353     {
354       /* If we don't already have new event */
355       if (svm_fifo_set_event (s0->server_tx_fifo))
356         {
357           vec_add1 (smm->pending_event_vector[thread_index], *e0);
358         }
359     }
360   return 0;
361
362 dequeue_fail:
363   /*
364    * Can't read from fifo. If we don't already have an event, save as partially
365    * read, return buff to free list and return
366    */
367   clib_warning ("dequeue fail");
368
369   if (svm_fifo_set_event (s0->server_tx_fifo))
370     {
371       vec_add1 (smm->pending_event_vector[thread_index], *e0);
372     }
373   vlib_put_next_frame (vm, node, next_index, n_left_to_next + 1);
374   _vec_len (smm->tx_buffers[thread_index]) += 1;
375
376   return 0;
377 }
378
379 int
380 session_tx_fifo_peek_and_snd (vlib_main_t * vm, vlib_node_runtime_t * node,
381                               session_manager_main_t * smm,
382                               session_fifo_event_t * e0,
383                               stream_session_t * s0, u32 thread_index,
384                               int *n_tx_pkts)
385 {
386   return session_tx_fifo_read_and_snd_i (vm, node, smm, e0, s0, thread_index,
387                                          n_tx_pkts, 1);
388 }
389
390 int
391 session_tx_fifo_dequeue_and_snd (vlib_main_t * vm, vlib_node_runtime_t * node,
392                                  session_manager_main_t * smm,
393                                  session_fifo_event_t * e0,
394                                  stream_session_t * s0, u32 thread_index,
395                                  int *n_tx_pkts)
396 {
397   return session_tx_fifo_read_and_snd_i (vm, node, smm, e0, s0, thread_index,
398                                          n_tx_pkts, 0);
399 }
400
401 always_inline stream_session_t *
402 session_event_get_session (session_fifo_event_t * e, u8 thread_index)
403 {
404   return session_get_if_valid (e->fifo->master_session_index, thread_index);
405 }
406
407 void
408 dump_thread_0_event_queue (void)
409 {
410   session_manager_main_t *smm = vnet_get_session_manager_main ();
411   vlib_main_t *vm = &vlib_global_main;
412   u32 my_thread_index = vm->thread_index;
413   session_fifo_event_t _e, *e = &_e;
414   stream_session_t *s0;
415   int i, index;
416   i8 *headp;
417
418   unix_shared_memory_queue_t *q;
419   q = smm->vpp_event_queues[my_thread_index];
420
421   index = q->head;
422
423   for (i = 0; i < q->cursize; i++)
424     {
425       headp = (i8 *) (&q->data[0] + q->elsize * index);
426       clib_memcpy (e, headp, q->elsize);
427
428       switch (e->event_type)
429         {
430         case FIFO_EVENT_APP_TX:
431           s0 = session_event_get_session (e, my_thread_index);
432           fformat (stdout, "[%04d] TX session %d\n", i, s0->session_index);
433           break;
434
435         case FIFO_EVENT_DISCONNECT:
436           s0 = session_get_from_handle (e->session_handle);
437           fformat (stdout, "[%04d] disconnect session %d\n", i,
438                    s0->session_index);
439           break;
440
441         case FIFO_EVENT_BUILTIN_RX:
442           s0 = session_event_get_session (e, my_thread_index);
443           fformat (stdout, "[%04d] builtin_rx %d\n", i, s0->session_index);
444           break;
445
446         case FIFO_EVENT_RPC:
447           fformat (stdout, "[%04d] RPC call %llx with %llx\n",
448                    i, (u64) (e->rpc_args.fp), (u64) (e->rpc_args.arg));
449           break;
450
451         default:
452           fformat (stdout, "[%04d] unhandled event type %d\n",
453                    i, e->event_type);
454           break;
455         }
456
457       index++;
458
459       if (index == q->maxsize)
460         index = 0;
461     }
462 }
463
464 static u8
465 session_node_cmp_event (session_fifo_event_t * e, svm_fifo_t * f)
466 {
467   stream_session_t *s;
468   switch (e->event_type)
469     {
470     case FIFO_EVENT_APP_RX:
471     case FIFO_EVENT_APP_TX:
472     case FIFO_EVENT_BUILTIN_RX:
473       if (e->fifo == f)
474         return 1;
475       break;
476     case FIFO_EVENT_DISCONNECT:
477       break;
478     case FIFO_EVENT_RPC:
479       s = session_get_from_handle (e->session_handle);
480       if (!s)
481         {
482           clib_warning ("session has event but doesn't exist!");
483           break;
484         }
485       if (s->server_rx_fifo == f || s->server_tx_fifo == f)
486         return 1;
487       break;
488     default:
489       break;
490     }
491   return 0;
492 }
493
494 u8
495 session_node_lookup_fifo_event (svm_fifo_t * f, session_fifo_event_t * e)
496 {
497   session_manager_main_t *smm = vnet_get_session_manager_main ();
498   unix_shared_memory_queue_t *q;
499   session_fifo_event_t *pending_event_vector, *evt;
500   int i, index, found = 0;
501   i8 *headp;
502   u8 thread_index;
503
504   ASSERT (e);
505   thread_index = f->master_thread_index;
506   /*
507    * Search evt queue
508    */
509   q = smm->vpp_event_queues[thread_index];
510   index = q->head;
511   for (i = 0; i < q->cursize; i++)
512     {
513       headp = (i8 *) (&q->data[0] + q->elsize * index);
514       clib_memcpy (e, headp, q->elsize);
515       found = session_node_cmp_event (e, f);
516       if (found)
517         break;
518       if (++index == q->maxsize)
519         index = 0;
520     }
521   /*
522    * Search pending events vector
523    */
524   pending_event_vector = smm->pending_event_vector[thread_index];
525   vec_foreach (evt, pending_event_vector)
526   {
527     found = session_node_cmp_event (evt, f);
528     if (found)
529       {
530         clib_memcpy (e, evt, sizeof (*evt));
531         break;
532       }
533   }
534   return found;
535 }
536
537 static uword
538 session_queue_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
539                        vlib_frame_t * frame)
540 {
541   session_manager_main_t *smm = vnet_get_session_manager_main ();
542   session_fifo_event_t *my_pending_event_vector, *pending_disconnects, *e;
543   session_fifo_event_t *my_fifo_events;
544   u32 n_to_dequeue, n_events;
545   unix_shared_memory_queue_t *q;
546   application_t *app;
547   int n_tx_packets = 0;
548   u32 my_thread_index = vm->thread_index;
549   int i, rv;
550   f64 now = vlib_time_now (vm);
551   void (*fp) (void *);
552
553   SESSION_EVT_DBG (SESSION_EVT_POLL_GAP_TRACK, smm, my_thread_index);
554
555   /*
556    *  Update TCP time
557    */
558   tcp_update_time (now, my_thread_index);
559
560   /*
561    * Get vpp queue events
562    */
563   q = smm->vpp_event_queues[my_thread_index];
564   if (PREDICT_FALSE (q == 0))
565     return 0;
566
567   my_fifo_events = smm->free_event_vector[my_thread_index];
568
569   /* min number of events we can dequeue without blocking */
570   n_to_dequeue = q->cursize;
571   my_pending_event_vector = smm->pending_event_vector[my_thread_index];
572   pending_disconnects = smm->pending_disconnects[my_thread_index];
573
574   if (!n_to_dequeue && !vec_len (my_pending_event_vector)
575       && !vec_len (pending_disconnects))
576     return 0;
577
578   SESSION_EVT_DBG (SESSION_EVT_DEQ_NODE, 0);
579
580   /*
581    * If we didn't manage to process previous events try going
582    * over them again without dequeuing new ones.
583    */
584   /* XXX: Block senders to sessions that can't keep up */
585   if (0 && vec_len (my_pending_event_vector) >= 100)
586     {
587       clib_warning ("too many fifo events unsolved");
588       goto skip_dequeue;
589     }
590
591   /* See you in the next life, don't be late */
592   if (pthread_mutex_trylock (&q->mutex))
593     return 0;
594
595   for (i = 0; i < n_to_dequeue; i++)
596     {
597       vec_add2 (my_fifo_events, e, 1);
598       unix_shared_memory_queue_sub_raw (q, (u8 *) e);
599     }
600
601   /* The other side of the connection is not polling */
602   if (q->cursize < (q->maxsize / 8))
603     (void) pthread_cond_broadcast (&q->condvar);
604   pthread_mutex_unlock (&q->mutex);
605
606   vec_append (my_fifo_events, my_pending_event_vector);
607   vec_append (my_fifo_events, smm->pending_disconnects[my_thread_index]);
608
609   _vec_len (my_pending_event_vector) = 0;
610   smm->pending_event_vector[my_thread_index] = my_pending_event_vector;
611   _vec_len (smm->pending_disconnects[my_thread_index]) = 0;
612
613 skip_dequeue:
614   n_events = vec_len (my_fifo_events);
615   for (i = 0; i < n_events; i++)
616     {
617       stream_session_t *s0;     /* $$$ prefetch 1 ahead maybe */
618       session_fifo_event_t *e0;
619
620       e0 = &my_fifo_events[i];
621
622       switch (e0->event_type)
623         {
624         case FIFO_EVENT_APP_TX:
625           s0 = session_event_get_session (e0, my_thread_index);
626
627           if (PREDICT_FALSE (!s0))
628             {
629               clib_warning ("It's dead, Jim!");
630               continue;
631             }
632           /* Can retransmit for closed sessions but can't do anything if
633            * session is not ready or closed */
634           if (PREDICT_FALSE (s0->session_state < SESSION_STATE_READY))
635             continue;
636           /* Spray packets in per session type frames, since they go to
637            * different nodes */
638           rv = (smm->session_tx_fns[s0->session_type]) (vm, node, smm, e0, s0,
639                                                         my_thread_index,
640                                                         &n_tx_packets);
641           /* Out of buffers */
642           if (PREDICT_FALSE (rv < 0))
643             {
644               vlib_node_increment_counter (vm, node->node_index,
645                                            SESSION_QUEUE_ERROR_NO_BUFFER, 1);
646               continue;
647             }
648           break;
649         case FIFO_EVENT_DISCONNECT:
650           /* Make sure disconnects run after the pending list is drained */
651           if (!e0->postponed)
652             {
653               e0->postponed = 1;
654               vec_add1 (smm->pending_disconnects[my_thread_index], *e0);
655               continue;
656             }
657           s0 = session_get_from_handle (e0->session_handle);
658           stream_session_disconnect (s0);
659           break;
660         case FIFO_EVENT_BUILTIN_RX:
661           s0 = session_event_get_session (e0, my_thread_index);
662           if (PREDICT_FALSE (!s0))
663             continue;
664           svm_fifo_unset_event (s0->server_rx_fifo);
665           app = application_get (s0->app_index);
666           app->cb_fns.builtin_server_rx_callback (s0);
667           break;
668         case FIFO_EVENT_RPC:
669           fp = e0->rpc_args.fp;
670           (*fp) (e0->rpc_args.arg);
671           break;
672
673         default:
674           clib_warning ("unhandled event type %d", e0->event_type);
675         }
676     }
677
678   _vec_len (my_fifo_events) = 0;
679   smm->free_event_vector[my_thread_index] = my_fifo_events;
680
681   vlib_node_increment_counter (vm, session_queue_node.index,
682                                SESSION_QUEUE_ERROR_TX, n_tx_packets);
683
684   SESSION_EVT_DBG (SESSION_EVT_DEQ_NODE, 1);
685
686   return n_tx_packets;
687 }
688
689 /* *INDENT-OFF* */
690 VLIB_REGISTER_NODE (session_queue_node) =
691 {
692   .function = session_queue_node_fn,
693   .name = "session-queue",
694   .format_trace = format_session_queue_trace,
695   .type = VLIB_NODE_TYPE_INPUT,
696   .n_errors = ARRAY_LEN (session_queue_error_strings),
697   .error_strings = session_queue_error_strings,
698   .n_next_nodes = SESSION_QUEUE_N_NEXT,
699   .state = VLIB_NODE_STATE_DISABLED,
700   .next_nodes =
701   {
702       [SESSION_QUEUE_NEXT_DROP] = "error-drop",
703       [SESSION_QUEUE_NEXT_IP4_LOOKUP] = "ip4-lookup",
704       [SESSION_QUEUE_NEXT_IP6_LOOKUP] = "ip6-lookup",
705       [SESSION_QUEUE_NEXT_TCP_IP4_OUTPUT] = "tcp4-output",
706       [SESSION_QUEUE_NEXT_TCP_IP6_OUTPUT] = "tcp6-output",
707   },
708 };
709 /* *INDENT-ON* */
710
711 /*
712  * fd.io coding-style-patch-verification: ON
713  *
714  * Local Variables:
715  * eval: (c-set-style "gnu")
716  * End:
717  */