vnet/vnet/nsh-vxlan-gpe/encap.c

   1 /*
   2  * Copyright (c) 2015 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 #include <vppinfra/error.h>
  16 #include <vppinfra/hash.h>
  17 #include <vnet/vnet.h>
  18 #include <vnet/ip/ip.h>
  19 #include <vnet/ethernet/ethernet.h>
  20 #include <vnet/nsh-vxlan-gpe/nsh_vxlan_gpe.h>
  21
  22 /* Statistics (not really errors) */
  23 #define foreach_nsh_vxlan_gpe_encap_error    \
  24 _(ENCAPSULATED, "good packets encapsulated")
  25
  26 static char * nsh_vxlan_gpe_encap_error_strings[] = {
  27 #define _(sym,string) string,
  28   foreach_nsh_vxlan_gpe_encap_error
  29 #undef _
  30 };
  31
  32 typedef enum {
  33 #define _(sym,str) NSH_VXLAN_GPE_ENCAP_ERROR_##sym,
  34     foreach_nsh_vxlan_gpe_encap_error
  35 #undef _
  36     NSH_VXLAN_GPE_ENCAP_N_ERROR,
  37 } nsh_vxlan_gpe_encap_error_t;
  38
  39 typedef enum {
  40     NSH_VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP,
  41     NSH_VXLAN_GPE_ENCAP_NEXT_DROP,
  42     NSH_VXLAN_GPE_ENCAP_N_NEXT,
  43 } nsh_vxlan_gpe_encap_next_t;
  44
  45 typedef struct {
  46   u32 tunnel_index;
  47 } nsh_vxlan_gpe_encap_trace_t;
  48
  49 u8 * format_nsh_vxlan_gpe_encap_trace (u8 * s, va_list * args)
  50 {
  51   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  52   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  53   nsh_vxlan_gpe_encap_trace_t * t
  54       = va_arg (*args, nsh_vxlan_gpe_encap_trace_t *);
  55
  56   s = format (s, "NSH-VXLAN-ENCAP: tunnel %d", t->tunnel_index);
  57   return s;
  58 }
  59
  60 #define foreach_fixed_header_offset             \
  61 _(0) _(1) _(2) _(3) _(4) _(5) _(6)
  62
  63 static uword
  64 nsh_vxlan_gpe_encap (vlib_main_t * vm,
  65                vlib_node_runtime_t * node,
  66                vlib_frame_t * from_frame)
  67 {
  68   u32 n_left_from, next_index, * from, * to_next;
  69   nsh_vxlan_gpe_main_t * ngm = &nsh_vxlan_gpe_main;
  70   vnet_main_t * vnm = ngm->vnet_main;
  71   vnet_interface_main_t * im = &vnm->interface_main;
  72   u32 pkts_encapsulated = 0;
  73   u16 old_l0 = 0, old_l1 = 0;
  74   u32 cpu_index = os_get_cpu_number();
  75   u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
  76
  77   from = vlib_frame_vector_args (from_frame);
  78   n_left_from = from_frame->n_vectors;
  79
  80   next_index = node->cached_next_index;
  81   stats_sw_if_index = node->runtime_data[0];
  82   stats_n_packets = stats_n_bytes = 0;
  83
  84   while (n_left_from > 0)
  85     {
  86       u32 n_left_to_next;
  87
  88       vlib_get_next_frame (vm, node, next_index,
  89                            to_next, n_left_to_next);
  90
  91       while (n_left_from >= 4 && n_left_to_next >= 2)
  92         {
  93           u32 bi0, bi1;
  94           vlib_buffer_t * b0, * b1;
  95           u32 next0 = NSH_VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP;
  96           u32 next1 = NSH_VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP;
  97           u32 sw_if_index0, sw_if_index1, len0, len1;
  98           vnet_hw_interface_t * hi0, * hi1;
  99           ip4_header_t * ip0, * ip1;
 100           udp_header_t * udp0, * udp1;
 101           u64 * copy_src0, * copy_dst0;
 102           u64 * copy_src1, * copy_dst1;
 103           u32 * copy_src_last0, * copy_dst_last0;
 104           u32 * copy_src_last1, * copy_dst_last1;
 105           nsh_vxlan_gpe_tunnel_t * t0, * t1;
 106           u16 new_l0, new_l1;
 107           ip_csum_t sum0, sum1;
 108
 109           /* Prefetch next iteration. */
 110           {
 111             vlib_buffer_t * p2, * p3;
 112
 113             p2 = vlib_get_buffer (vm, from[2]);
 114             p3 = vlib_get_buffer (vm, from[3]);
 115
 116             vlib_prefetch_buffer_header (p2, LOAD);
 117             vlib_prefetch_buffer_header (p3, LOAD);
 118
 119             CLIB_PREFETCH (p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 120             CLIB_PREFETCH (p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 121           }
 122
 123           bi0 = from[0];
 124           bi1 = from[1];
 125           to_next[0] = bi0;
 126           to_next[1] = bi1;
 127           from += 2;
 128           to_next += 2;
 129           n_left_to_next -= 2;
 130           n_left_from -= 2;
 131
 132           b0 = vlib_get_buffer (vm, bi0);
 133           b1 = vlib_get_buffer (vm, bi1);
 134
 135           /* 1-wide cache? */
 136           sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX];
 137           sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_TX];
 138           hi0 = vnet_get_sup_hw_interface
 139             (vnm, vnet_buffer(b0)->sw_if_index[VLIB_TX]);
 140           hi1 = vnet_get_sup_hw_interface
 141             (vnm, vnet_buffer(b1)->sw_if_index[VLIB_TX]);
 142
 143           t0 = pool_elt_at_index (ngm->tunnels, hi0->dev_instance);
 144           t1 = pool_elt_at_index (ngm->tunnels, hi1->dev_instance);
 145
 146           ASSERT(vec_len(t0->rewrite) >= 24);
 147           ASSERT(vec_len(t1->rewrite) >= 24);
 148
 149           /* Apply the rewrite string. $$$$ vnet_rewrite? */
 150           vlib_buffer_advance (b0, -(word)_vec_len(t0->rewrite));
 151           vlib_buffer_advance (b1, -(word)_vec_len(t1->rewrite));
 152
 153           ip0 = vlib_buffer_get_current(b0);
 154           ip1 = vlib_buffer_get_current(b1);
 155           /* Copy the fixed header */
 156           copy_dst0 = (u64 *) ip0;
 157           copy_src0 = (u64 *) t0->rewrite;
 158           copy_dst1 = (u64 *) ip1;
 159           copy_src1 = (u64 *) t1->rewrite;
 160
 161           ASSERT (sizeof (ip4_vxlan_gpe_and_nsh_header_t) == 60);
 162
 163           /* Copy first 56 octets 8-bytes at a time */
 164 #define _(offs) copy_dst0[offs] = copy_src0[offs];
 165           foreach_fixed_header_offset;
 166 #undef _
 167 #define _(offs) copy_dst1[offs] = copy_src1[offs];
 168           foreach_fixed_header_offset;
 169 #undef _
 170
 171           /* Last 4 octets. Hopefully gcc will be our friend */
 172           copy_dst_last0 = (u32 *)(&copy_dst0[7]);
 173           copy_src_last0 = (u32 *)(&copy_src0[7]);
 174           copy_dst_last1 = (u32 *)(&copy_dst1[7]);
 175           copy_src_last1 = (u32 *)(&copy_src1[7]);
 176
 177           copy_dst_last0[0] = copy_src_last0[0];
 178           copy_dst_last1[0] = copy_src_last1[0];
 179
 180           /* If there are TLVs to copy, do so */
 181           if (PREDICT_FALSE (_vec_len(t0->rewrite) > 64))
 182             clib_memcpy (&copy_dst0[3], t0->rewrite + 64 ,
 183                     _vec_len (t0->rewrite)-64);
 184
 185           if (PREDICT_FALSE (_vec_len(t1->rewrite) > 64))
 186             clib_memcpy (&copy_dst0[3], t1->rewrite + 64 ,
 187                     _vec_len (t1->rewrite)-64);
 188
 189           /* fix the <bleep>ing outer-IP checksum */
 190           sum0 = ip0->checksum;
 191           /* old_l0 always 0, see the rewrite setup */
 192           new_l0 =
 193             clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0));
 194
 195           sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
 196                                  length /* changed member */);
 197           ip0->checksum = ip_csum_fold (sum0);
 198           ip0->length = new_l0;
 199
 200           sum1 = ip1->checksum;
 201           /* old_l1 always 0, see the rewrite setup */
 202           new_l1 =
 203             clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b1));
 204
 205           sum1 = ip_csum_update (sum1, old_l1, new_l1, ip4_header_t,
 206                                  length /* changed member */);
 207           ip1->checksum = ip_csum_fold (sum1);
 208           ip1->length = new_l1;
 209
 210           /* Fix UDP length */
 211           udp0 = (udp_header_t *)(ip0+1);
 212           new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0)
 213                                          - sizeof (*ip0));
 214           udp1 = (udp_header_t *)(ip1+1);
 215           new_l1 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b1)
 216                                          - sizeof (*ip1));
 217
 218           udp0->length = new_l0;
 219           udp1->length = new_l1;
 220
 221           /* Reset to look up tunnel partner in the configured FIB */
 222           vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index;
 223           vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->encap_fib_index;
 224           vnet_buffer(b0)->sw_if_index[VLIB_RX] = sw_if_index0;
 225           vnet_buffer(b1)->sw_if_index[VLIB_RX] = sw_if_index1;
 226           pkts_encapsulated += 2;
 227
 228           len0 = vlib_buffer_length_in_chain(vm, b0);
 229           len1 = vlib_buffer_length_in_chain(vm, b0);
 230           stats_n_packets += 2;
 231           stats_n_bytes += len0 + len1;
 232
 233           /* Batch stats increment on the same vxlan tunnel so counter is not
 234            incremented per packet. Note stats are still incremented for deleted
 235            and admin-down tunnel where packets are dropped. It is not worthwhile
 236            to check for this rare case and affect normal path performance. */
 237           if (PREDICT_FALSE(
 238               (sw_if_index0 != stats_sw_if_index)
 239                   || (sw_if_index1 != stats_sw_if_index))) {
 240             stats_n_packets -= 2;
 241             stats_n_bytes -= len0 + len1;
 242             if (sw_if_index0 == sw_if_index1) {
 243               if (stats_n_packets)
 244                 vlib_increment_combined_counter(
 245                     im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX,
 246                     cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
 247               stats_sw_if_index = sw_if_index0;
 248               stats_n_packets = 2;
 249               stats_n_bytes = len0 + len1;
 250             } else {
 251               vlib_increment_combined_counter(
 252                   im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX,
 253                   cpu_index, sw_if_index0, 1, len0);
 254               vlib_increment_combined_counter(
 255                   im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX,
 256                   cpu_index, sw_if_index1, 1, len1);
 257             }
 258           }
 259
 260           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 261             {
 262               nsh_vxlan_gpe_encap_trace_t *tr =
 263                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 264               tr->tunnel_index = t0 - ngm->tunnels;
 265             }
 266
 267           if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
 268             {
 269               nsh_vxlan_gpe_encap_trace_t *tr =
 270                 vlib_add_trace (vm, node, b1, sizeof (*tr));
 271               tr->tunnel_index = t1 - ngm->tunnels;
 272             }
 273
 274           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 275                                            to_next, n_left_to_next,
 276                                            bi0, bi1, next0, next1);
 277         }
 278
 279       while (n_left_from > 0 && n_left_to_next > 0)
 280         {
 281           u32 bi0;
 282           vlib_buffer_t * b0;
 283           u32 next0 = NSH_VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP;
 284       u32 sw_if_index0, len0;
 285           vnet_hw_interface_t * hi0;
 286           ip4_header_t * ip0;
 287           udp_header_t * udp0;
 288           u64 * copy_src0, * copy_dst0;
 289           u32 * copy_src_last0, * copy_dst_last0;
 290           nsh_vxlan_gpe_tunnel_t * t0;
 291           u16 new_l0;
 292           ip_csum_t sum0;
 293
 294           bi0 = from[0];
 295           to_next[0] = bi0;
 296           from += 1;
 297           to_next += 1;
 298           n_left_from -= 1;
 299           n_left_to_next -= 1;
 300
 301           b0 = vlib_get_buffer (vm, bi0);
 302
 303           /* 1-wide cache? */
 304           sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX];
 305           hi0 = vnet_get_sup_hw_interface
 306             (vnm, vnet_buffer(b0)->sw_if_index[VLIB_TX]);
 307
 308           t0 = pool_elt_at_index (ngm->tunnels, hi0->dev_instance);
 309
 310           ASSERT(vec_len(t0->rewrite) >= 24);
 311
 312           /* Apply the rewrite string. $$$$ vnet_rewrite? */
 313           vlib_buffer_advance (b0, -(word)_vec_len(t0->rewrite));
 314
 315           ip0 = vlib_buffer_get_current(b0);
 316           /* Copy the fixed header */
 317           copy_dst0 = (u64 *) ip0;
 318           copy_src0 = (u64 *) t0->rewrite;
 319
 320           ASSERT (sizeof (ip4_vxlan_gpe_and_nsh_header_t) == 60);
 321
 322           /* Copy first 56 octets 8-bytes at a time */
 323 #define _(offs) copy_dst0[offs] = copy_src0[offs];
 324           foreach_fixed_header_offset;
 325 #undef _
 326           /* Last 4 octets. Hopefully gcc will be our friend */
 327           copy_dst_last0 = (u32 *)(&copy_dst0[7]);
 328           copy_src_last0 = (u32 *)(&copy_src0[7]);
 329
 330           copy_dst_last0[0] = copy_src_last0[0];
 331
 332           /* If there are TLVs to copy, do so */
 333           if (PREDICT_FALSE (_vec_len(t0->rewrite) > 64))
 334             clib_memcpy (&copy_dst0[3], t0->rewrite + 64 ,
 335                     _vec_len (t0->rewrite)-64);
 336
 337           /* fix the <bleep>ing outer-IP checksum */
 338           sum0 = ip0->checksum;
 339           /* old_l0 always 0, see the rewrite setup */
 340           new_l0 =
 341             clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0));
 342
 343           sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
 344                                  length /* changed member */);
 345           ip0->checksum = ip_csum_fold (sum0);
 346           ip0->length = new_l0;
 347
 348           /* Fix UDP length */
 349           udp0 = (udp_header_t *)(ip0+1);
 350           new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0)
 351                                          - sizeof (*ip0));
 352
 353           udp0->length = new_l0;
 354
 355           /* Reset to look up tunnel partner in the configured FIB */
 356           vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index;
 357           vnet_buffer(b0)->sw_if_index[VLIB_RX] = sw_if_index0;
 358           pkts_encapsulated ++;
 359
 360           len0 = vlib_buffer_length_in_chain(vm, b0);
 361           stats_n_packets += 1;
 362           stats_n_bytes += len0;
 363
 364           /* Batch stats increment on the same vxlan tunnel so counter is not
 365            incremented per packet. Note stats are still incremented for deleted
 366            and admin-down tunnel where packets are dropped. It is not worthwhile
 367            to check for this rare case and affect normal path performance. */
 368           if (PREDICT_FALSE(sw_if_index0 != stats_sw_if_index)) {
 369             stats_n_packets -= 1;
 370             stats_n_bytes -= len0;
 371             if (stats_n_packets)
 372               vlib_increment_combined_counter(
 373                   im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX,
 374                   cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
 375             stats_n_packets = 1;
 376             stats_n_bytes = len0;
 377             stats_sw_if_index = sw_if_index0;
 378           }
 379           if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 380             {
 381               nsh_vxlan_gpe_encap_trace_t *tr =
 382                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 383               tr->tunnel_index = t0 - ngm->tunnels;
 384             }
 385           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 386                                            to_next, n_left_to_next,
 387                                            bi0, next0);
 388         }
 389
 390       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 391     }
 392   vlib_node_increment_counter (vm, node->node_index,
 393                                NSH_VXLAN_GPE_ENCAP_ERROR_ENCAPSULATED,
 394                                pkts_encapsulated);
 395   /* Increment any remaining batch stats */
 396   if (stats_n_packets) {
 397     vlib_increment_combined_counter(
 398         im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX, cpu_index,
 399         stats_sw_if_index, stats_n_packets, stats_n_bytes);
 400     node->runtime_data[0] = stats_sw_if_index;
 401   }
 402
 403   return from_frame->n_vectors;
 404 }
 405
 406 VLIB_REGISTER_NODE (nsh_vxlan_gpe_encap_node) = {
 407   .function = nsh_vxlan_gpe_encap,
 408   .name = "nsh-vxlan-gpe-encap",
 409   .vector_size = sizeof (u32),
 410   .format_trace = format_nsh_vxlan_gpe_encap_trace,
 411   .type = VLIB_NODE_TYPE_INTERNAL,
 412
 413   .n_errors = ARRAY_LEN(nsh_vxlan_gpe_encap_error_strings),
 414   .error_strings = nsh_vxlan_gpe_encap_error_strings,
 415
 416   .n_next_nodes = NSH_VXLAN_GPE_ENCAP_N_NEXT,
 417
 418   .next_nodes = {
 419         [NSH_VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP] = "ip4-lookup",
 420         [NSH_VXLAN_GPE_ENCAP_NEXT_DROP] = "error-drop",
 421   },
 422 };