src/vnet/udp/udp_input.c

   1 /*
   2  * Copyright (c) 2016 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 <vlib/vlib.h>
  17 #include <vnet/vnet.h>
  18 #include <vnet/pg/pg.h>
  19 #include <vnet/ip/ip.h>
  20
  21 #include <vnet/udp/udp.h>
  22 #include <vppinfra/hash.h>
  23 #include <vppinfra/error.h>
  24 #include <vppinfra/elog.h>
  25
  26 #include <vnet/udp/udp_packet.h>
  27
  28 #include <vlibmemory/api.h>
  29 #include "../session/application_interface.h"
  30
  31 vlib_node_registration_t udp4_uri_input_node;
  32
  33 typedef struct
  34 {
  35   u32 session;
  36   u32 disposition;
  37   u32 thread_index;
  38 } udp4_uri_input_trace_t;
  39
  40 /* packet trace format function */
  41 static u8 *
  42 format_udp4_uri_input_trace (u8 * s, va_list * args)
  43 {
  44   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  45   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  46   udp4_uri_input_trace_t *t = va_arg (*args, udp4_uri_input_trace_t *);
  47
  48   s = format (s, "UDP4_URI_INPUT: session %d, disposition %d, thread %d",
  49               t->session, t->disposition, t->thread_index);
  50   return s;
  51 }
  52
  53 typedef enum
  54 {
  55   UDP4_URI_INPUT_NEXT_DROP,
  56   UDP4_URI_INPUT_N_NEXT,
  57 } udp4_uri_input_next_t;
  58
  59 static char *udp4_uri_input_error_strings[] = {
  60 #define _(sym,string) string,
  61   foreach_session_input_error
  62 #undef _
  63 };
  64
  65 static uword
  66 udp4_uri_input_node_fn (vlib_main_t * vm,
  67                         vlib_node_runtime_t * node, vlib_frame_t * frame)
  68 {
  69   u32 n_left_from, *from, *to_next;
  70   udp4_uri_input_next_t next_index;
  71   udp_uri_main_t *um = vnet_get_udp_main ();
  72   session_manager_main_t *smm = vnet_get_session_manager_main ();
  73   u32 my_thread_index = vm->cpu_index;
  74   u8 my_enqueue_epoch;
  75   u32 *session_indices_to_enqueue;
  76   static u32 serial_number;
  77   int i;
  78
  79   my_enqueue_epoch = ++smm->current_enqueue_epoch[my_thread_index];
  80
  81   from = vlib_frame_vector_args (frame);
  82   n_left_from = frame->n_vectors;
  83   next_index = node->cached_next_index;
  84
  85   while (n_left_from > 0)
  86     {
  87       u32 n_left_to_next;
  88
  89       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
  90
  91       while (n_left_from > 0 && n_left_to_next > 0)
  92         {
  93           u32 bi0;
  94           vlib_buffer_t *b0;
  95           u32 next0 = UDP4_URI_INPUT_NEXT_DROP;
  96           u32 error0 = SESSION_ERROR_ENQUEUED;
  97           udp_header_t *udp0;
  98           ip4_header_t *ip0;
  99           stream_session_t *s0;
 100           svm_fifo_t *f0;
 101           u16 udp_len0;
 102           u8 *data0;
 103
 104           /* speculatively enqueue b0 to the current next frame */
 105           bi0 = from[0];
 106           to_next[0] = bi0;
 107           from += 1;
 108           to_next += 1;
 109           n_left_from -= 1;
 110           n_left_to_next -= 1;
 111
 112           b0 = vlib_get_buffer (vm, bi0);
 113
 114           /* udp_local hands us a pointer to the udp data */
 115
 116           data0 = vlib_buffer_get_current (b0);
 117           udp0 = (udp_header_t *) (data0 - sizeof (*udp0));
 118
 119           /* $$$$ fixme: udp_local doesn't do ip options correctly anyhow */
 120           ip0 = (ip4_header_t *) (((u8 *) udp0) - sizeof (*ip0));
 121           s0 = 0;
 122
 123           /* lookup session */
 124           s0 = stream_session_lookup4 (&ip0->dst_address, &ip0->src_address,
 125                                        udp0->dst_port, udp0->src_port,
 126                                        SESSION_TYPE_IP4_UDP, my_thread_index);
 127
 128           /* no listener */
 129           if (PREDICT_FALSE (s0 == 0))
 130             {
 131               error0 = SESSION_ERROR_NO_LISTENER;
 132               goto trace0;
 133             }
 134
 135           f0 = s0->server_rx_fifo;
 136
 137           /* established hit */
 138           if (PREDICT_TRUE (s0->session_state == SESSION_STATE_READY))
 139             {
 140               udp_len0 = clib_net_to_host_u16 (udp0->length);
 141
 142               if (PREDICT_FALSE (udp_len0 > svm_fifo_max_enqueue (f0)))
 143                 {
 144                   error0 = SESSION_ERROR_FIFO_FULL;
 145                   goto trace0;
 146                 }
 147
 148               svm_fifo_enqueue_nowait (f0, 0 /* pid */ ,
 149                                        udp_len0 - sizeof (*udp0),
 150                                        (u8 *) (udp0 + 1));
 151
 152               b0->error = node->errors[SESSION_ERROR_ENQUEUED];
 153
 154               /* We need to send an RX event on this fifo */
 155               if (s0->enqueue_epoch != my_enqueue_epoch)
 156                 {
 157                   s0->enqueue_epoch = my_enqueue_epoch;
 158
 159                   vec_add1 (smm->session_indices_to_enqueue_by_thread
 160                             [my_thread_index],
 161                             s0 - smm->sessions[my_thread_index]);
 162                 }
 163             }
 164           /* listener hit */
 165           else if (s0->session_state == SESSION_STATE_LISTENING)
 166             {
 167               udp_connection_t *us;
 168               int rv;
 169
 170               error0 = SESSION_ERROR_NOT_READY;
 171
 172               /*
 173                * create udp transport session
 174                */
 175               pool_get (um->udp_sessions[my_thread_index], us);
 176
 177               us->mtu = 1024;   /* $$$$ policy */
 178
 179               us->c_lcl_ip4.as_u32 = ip0->dst_address.as_u32;
 180               us->c_rmt_ip4.as_u32 = ip0->src_address.as_u32;
 181               us->c_lcl_port = udp0->dst_port;
 182               us->c_rmt_port = udp0->src_port;
 183               us->c_proto = SESSION_TYPE_IP4_UDP;
 184               us->c_c_index = us - um->udp_sessions[my_thread_index];
 185
 186               /*
 187                * create stream session and attach the udp session to it
 188                */
 189               rv = stream_session_accept (&us->connection, s0->session_index,
 190                                           SESSION_TYPE_IP4_UDP,
 191                                           1 /*notify */ );
 192               if (rv)
 193                 error0 = rv;
 194
 195             }
 196           else
 197             {
 198
 199               error0 = SESSION_ERROR_NOT_READY;
 200               goto trace0;
 201             }
 202
 203         trace0:
 204           b0->error = node->errors[error0];
 205
 206           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
 207                              && (b0->flags & VLIB_BUFFER_IS_TRACED)))
 208             {
 209               udp4_uri_input_trace_t *t =
 210                 vlib_add_trace (vm, node, b0, sizeof (*t));
 211
 212               t->session = ~0;
 213               if (s0)
 214                 t->session = s0 - smm->sessions[my_thread_index];
 215               t->disposition = error0;
 216               t->thread_index = my_thread_index;
 217             }
 218
 219           /* verify speculative enqueue, maybe switch current next frame */
 220           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 221                                            to_next, n_left_to_next,
 222                                            bi0, next0);
 223         }
 224
 225       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 226     }
 227
 228   /* Send enqueue events */
 229
 230   session_indices_to_enqueue =
 231     smm->session_indices_to_enqueue_by_thread[my_thread_index];
 232
 233   for (i = 0; i < vec_len (session_indices_to_enqueue); i++)
 234     {
 235       session_fifo_event_t evt;
 236       unix_shared_memory_queue_t *q;
 237       stream_session_t *s0;
 238       application_t *server0;
 239
 240       /* Get session */
 241       s0 = pool_elt_at_index (smm->sessions[my_thread_index],
 242                               session_indices_to_enqueue[i]);
 243
 244       /* Get session's server */
 245       server0 = application_get (s0->app_index);
 246
 247       /* Fabricate event */
 248       evt.fifo = s0->server_rx_fifo;
 249       evt.event_type = FIFO_EVENT_SERVER_RX;
 250       evt.event_id = serial_number++;
 251       evt.enqueue_length = svm_fifo_max_dequeue (s0->server_rx_fifo);
 252
 253       /* Built-in server? Deliver the goods... */
 254       if (server0->cb_fns.builtin_server_rx_callback)
 255         {
 256           server0->cb_fns.builtin_server_rx_callback (s0, &evt);
 257           continue;
 258         }
 259
 260       /* Add event to server's event queue */
 261       q = server0->event_queue;
 262
 263       /* Don't block for lack of space */
 264       if (PREDICT_TRUE (q->cursize < q->maxsize))
 265         unix_shared_memory_queue_add (server0->event_queue, (u8 *) & evt,
 266                                       0 /* do wait for mutex */ );
 267       else
 268         {
 269           vlib_node_increment_counter (vm, udp4_uri_input_node.index,
 270                                        SESSION_ERROR_FIFO_FULL, 1);
 271         }
 272       if (1)
 273         {
 274           ELOG_TYPE_DECLARE (e) =
 275           {
 276           .format = "evt-enqueue: id %d length %d",.format_args = "i4i4",};
 277           struct
 278           {
 279             u32 data[2];
 280           } *ed;
 281           ed = ELOG_DATA (&vlib_global_main.elog_main, e);
 282           ed->data[0] = evt.event_id;
 283           ed->data[1] = evt.enqueue_length;
 284         }
 285     }
 286
 287   vec_reset_length (session_indices_to_enqueue);
 288
 289   smm->session_indices_to_enqueue_by_thread[my_thread_index] =
 290     session_indices_to_enqueue;
 291
 292   return frame->n_vectors;
 293 }
 294
 295 VLIB_REGISTER_NODE (udp4_uri_input_node) =
 296 {
 297   .function = udp4_uri_input_node_fn,.name = "udp4-uri-input",.vector_size =
 298     sizeof (u32),.format_trace = format_udp4_uri_input_trace,.type =
 299     VLIB_NODE_TYPE_INTERNAL,.n_errors =
 300     ARRAY_LEN (udp4_uri_input_error_strings),.error_strings =
 301     udp4_uri_input_error_strings,.n_next_nodes = UDP4_URI_INPUT_N_NEXT,
 302     /* edit / add dispositions here */
 303     .next_nodes =
 304   {
 305   [UDP4_URI_INPUT_NEXT_DROP] = "error-drop",}
 306 ,};
 307
 308 /*
 309  * fd.io coding-style-patch-verification: ON
 310  *
 311  * Local Variables:
 312  * eval: (c-set-style "gnu")
 313  * End:
 314  */