src/plugins/ct6/ct6_out2in.c

   1 /*
   2  * ct6_out2in.c - ip6 connection tracker, inside-to-outside path
   3  *
   4  * Copyright (c) 2019 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <vlib/vlib.h>
  18 #include <vnet/vnet.h>
  19 #include <vppinfra/error.h>
  20 #include <ct6/ct6.h>
  21
  22 typedef struct
  23 {
  24   u32 sw_if_index;
  25   u32 next_index;
  26   u32 session_index;
  27 } ct6_out2in_trace_t;
  28
  29 #ifndef CLIB_MARCH_VARIANT
  30
  31 /* packet trace format function */
  32 static u8 *
  33 format_ct6_out2in_trace (u8 * s, va_list * args)
  34 {
  35   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  36   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  37   ct6_out2in_trace_t *t = va_arg (*args, ct6_out2in_trace_t *);
  38
  39   s = format (s, "CT6_OUT2IN: sw_if_index %d, next index %d session %d\n",
  40               t->sw_if_index, t->next_index, t->session_index);
  41   return s;
  42 }
  43
  44 vlib_node_registration_t ct6_out2in_node;
  45
  46 #endif /* CLIB_MARCH_VARIANT */
  47
  48 #define foreach_ct6_out2in_error                \
  49 _(PROCESSED, "ct6 packets processed")           \
  50 _(NO_SESSION, "ct6 no session drops")
  51
  52
  53 typedef enum
  54 {
  55 #define _(sym,str) CT6_OUT2IN_ERROR_##sym,
  56   foreach_ct6_out2in_error
  57 #undef _
  58     CT6_OUT2IN_N_ERROR,
  59 } ct6_out2in_error_t;
  60
  61 #ifndef CLIB_MARCH_VARIANT
  62 static char *ct6_out2in_error_strings[] = {
  63 #define _(sym,string) string,
  64   foreach_ct6_out2in_error
  65 #undef _
  66 };
  67 #endif /* CLIB_MARCH_VARIANT */
  68
  69 typedef enum
  70 {
  71   CT6_OUT2IN_NEXT_DROP,
  72   CT6_OUT2IN_N_NEXT,
  73 } ct6_next_t;
  74
  75 always_inline uword
  76 ct6_out2in_inline (vlib_main_t * vm,
  77                    vlib_node_runtime_t * node, vlib_frame_t * frame,
  78                    int is_trace)
  79 {
  80   u32 n_left_from, *from;
  81   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
  82   u16 nexts[VLIB_FRAME_SIZE], *next;
  83   ct6_main_t *cmp = &ct6_main;
  84   u32 my_thread_index = vm->thread_index;
  85   f64 now = vlib_time_now (vm);
  86   u32 dropped = 0;
  87
  88   from = vlib_frame_vector_args (frame);
  89   n_left_from = frame->n_vectors;
  90
  91   vlib_get_buffers (vm, from, bufs, n_left_from);
  92   b = bufs;
  93   next = nexts;
  94
  95 #if 0
  96   while (n_left_from >= 4)
  97     {
  98       /* Prefetch next iteration. */
  99       if (PREDICT_TRUE (n_left_from >= 8))
 100         {
 101           vlib_prefetch_buffer_header (b[4], STORE);
 102           vlib_prefetch_buffer_header (b[5], STORE);
 103           vlib_prefetch_buffer_header (b[6], STORE);
 104           vlib_prefetch_buffer_header (b[7], STORE);
 105           CLIB_PREFETCH (b[4]->data, CLIB_CACHE_LINE_BYTES, STORE);
 106           CLIB_PREFETCH (b[5]->data, CLIB_CACHE_LINE_BYTES, STORE);
 107           CLIB_PREFETCH (b[6]->data, CLIB_CACHE_LINE_BYTES, STORE);
 108           CLIB_PREFETCH (b[7]->data, CLIB_CACHE_LINE_BYTES, STORE);
 109         }
 110
 111       /* $$$$ process 4x pkts right here */
 112       next[0] = 0;
 113       next[1] = 0;
 114       next[2] = 0;
 115       next[3] = 0;
 116
 117       if (is_trace)
 118         {
 119           if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
 120             {
 121               ct6_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
 122               t->next_index = next[0];
 123               t->sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
 124             }
 125           if (b[1]->flags & VLIB_BUFFER_IS_TRACED)
 126             {
 127               ct6_trace_t *t = vlib_add_trace (vm, node, b[1], sizeof (*t));
 128               t->next_index = next[1];
 129               t->sw_if_index = vnet_buffer (b[1])->sw_if_index[VLIB_RX];
 130             }
 131           if (b[2]->flags & VLIB_BUFFER_IS_TRACED)
 132             {
 133               ct6_trace_t *t = vlib_add_trace (vm, node, b[2], sizeof (*t));
 134               t->next_index = next[2];
 135               t->sw_if_index = vnet_buffer (b[2])->sw_if_index[VLIB_RX];
 136             }
 137           if (b[3]->flags & VLIB_BUFFER_IS_TRACED)
 138             {
 139               ct6_trace_t *t = vlib_add_trace (vm, node, b[3], sizeof (*t));
 140               t->next_index = next[3];
 141               t->sw_if_index = vnet_buffer (b[3])->sw_if_index[VLIB_RX];
 142             }
 143         }
 144
 145       b += 4;
 146       next += 4;
 147       n_left_from -= 4;
 148     }
 149 #endif
 150
 151   while (n_left_from > 0)
 152     {
 153       clib_bihash_kv_48_8_t kvp0;
 154       ct6_session_key_t *key0;
 155       ct6_session_t *s0;
 156       u32 session_index0 = ~0;
 157       u32 next0;
 158
 159       ip6_header_t *ip0;
 160       udp_header_t *udp0;
 161
 162       /* Are we having fun yet? */
 163       vnet_feature_next (&next0, b[0]);
 164       next[0] = next0;
 165
 166       ip0 = vlib_buffer_get_current (b[0]);
 167
 168       /*
 169        * Pass non-global unicast traffic
 170        */
 171       if (PREDICT_FALSE (!ip6_address_is_global_unicast (&ip0->src_address)
 172                          ||
 173                          !ip6_address_is_global_unicast (&ip0->src_address)))
 174         goto trace0;
 175       /* Pass non-udp, non-tcp traffic */
 176       if (PREDICT_FALSE (ip0->protocol != IP_PROTOCOL_TCP &&
 177                          ip0->protocol != IP_PROTOCOL_UDP))
 178         goto trace0;
 179
 180       udp0 = ip6_next_header (ip0);
 181
 182       /*
 183        * See if we know about this flow.
 184        */
 185       key0 = (ct6_session_key_t *) & kvp0;
 186       clib_memcpy_fast (&key0->src, &ip0->src_address,
 187                         sizeof (ip6_address_t));
 188       clib_memcpy_fast (&key0->dst, &ip0->dst_address,
 189                         sizeof (ip6_address_t));
 190       key0->as_u64[4] = 0;
 191       key0->as_u64[5] = 0;
 192       key0->sport = udp0->src_port;
 193       key0->dport = udp0->dst_port;
 194       key0->proto = ip0->protocol;
 195
 196       /* Do we know about this session? */
 197       if (clib_bihash_search_48_8 (&cmp->session_hash, &kvp0, &kvp0) < 0)
 198         {
 199           /* Bad engineer, no donut for you... */
 200           next[0] = CT6_OUT2IN_NEXT_DROP;
 201           b[0]->error = node->errors[CT6_OUT2IN_ERROR_NO_SESSION];
 202           dropped++;
 203           goto trace0;
 204         }
 205       else
 206         {
 207           s0 = pool_elt_at_index (cmp->sessions[my_thread_index], kvp0.value);
 208           session_index0 = kvp0.value;
 209           ct6_update_session_hit (cmp, s0, now);
 210         }
 211
 212     trace0:
 213       if (is_trace)
 214         {
 215           if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
 216             {
 217               ct6_out2in_trace_t *t =
 218                 vlib_add_trace (vm, node, b[0], sizeof (*t));
 219               t->next_index = next[0];
 220               t->sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
 221               t->session_index = session_index0;
 222             }
 223         }
 224
 225       b += 1;
 226       next += 1;
 227       n_left_from -= 1;
 228     }
 229
 230   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
 231
 232   vlib_node_increment_counter (vm, node->node_index,
 233                                CT6_OUT2IN_ERROR_PROCESSED, frame->n_vectors);
 234   vlib_node_increment_counter (vm, node->node_index,
 235                                CT6_OUT2IN_ERROR_NO_SESSION, dropped);
 236
 237   return frame->n_vectors;
 238 }
 239
 240 VLIB_NODE_FN (ct6_out2in_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 241                                 vlib_frame_t * frame)
 242 {
 243   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
 244     return ct6_out2in_inline (vm, node, frame, 1 /* is_trace */ );
 245   else
 246     return ct6_out2in_inline (vm, node, frame, 0 /* is_trace */ );
 247 }
 248
 249 /* *INDENT-OFF* */
 250 #ifndef CLIB_MARCH_VARIANT
 251 VLIB_REGISTER_NODE (ct6_out2in_node) =
 252 {
 253   .name = "ct6-out2in",
 254   .vector_size = sizeof (u32),
 255   .format_trace = format_ct6_out2in_trace,
 256   .type = VLIB_NODE_TYPE_INTERNAL,
 257
 258   .n_errors = ARRAY_LEN(ct6_out2in_error_strings),
 259   .error_strings = ct6_out2in_error_strings,
 260
 261   .n_next_nodes = CT6_OUT2IN_N_NEXT,
 262
 263   /* edit / add dispositions here */
 264   .next_nodes = {
 265         [CT6_OUT2IN_NEXT_DROP] = "error-drop",
 266   },
 267 };
 268 #endif /* CLIB_MARCH_VARIANT */
 269 /* *INDENT-ON* */
 270
 271 /*
 272  * fd.io coding-style-patch-verification: ON
 273  *
 274  * Local Variables:
 275  * eval: (c-set-style "gnu")
 276  * End:
 277  */