src/vnet/vxlan-gpe/decap.c

   1 /*
   2  * decap.c - decapsulate VXLAN GPE
   3  *
   4  * Copyright (c) 2013 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 /**
  18  *  @file
  19  *  @brief Functions for decapsulating VXLAN GPE tunnels
  20  *
  21 */
  22
  23 #include <vlib/vlib.h>
  24 #include <vnet/udp/udp_local.h>
  25 #include <vnet/vxlan-gpe/vxlan_gpe.h>
  26
  27 /**
  28  * @brief Struct for VXLAN GPE decap packet tracing
  29  *
  30  */
  31 typedef struct
  32 {
  33   u32 next_index;
  34   u32 tunnel_index;
  35   u32 error;
  36 } vxlan_gpe_rx_trace_t;
  37
  38 /**
  39  * @brief Tracing function for VXLAN GPE packet decapsulation
  40  *
  41  * @param *s
  42  * @param *args
  43  *
  44  * @return *s
  45  *
  46  */
  47 static u8 *
  48 format_vxlan_gpe_rx_trace (u8 * s, va_list * args)
  49 {
  50   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  51   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  52   vxlan_gpe_rx_trace_t *t = va_arg (*args, vxlan_gpe_rx_trace_t *);
  53
  54   if (t->tunnel_index != ~0)
  55     {
  56       s = format (s, "VXLAN-GPE: tunnel %d next %d error %d", t->tunnel_index,
  57                   t->next_index, t->error);
  58     }
  59   else
  60     {
  61       s = format (s, "VXLAN-GPE: no tunnel next %d error %d\n", t->next_index,
  62                   t->error);
  63     }
  64   return s;
  65 }
  66
  67 /**
  68  * @brief Tracing function for VXLAN GPE packet decapsulation including length
  69  *
  70  * @param *s
  71  * @param *args
  72  *
  73  * @return *s
  74  *
  75  */
  76 static u8 *
  77 format_vxlan_gpe_with_length (u8 * s, va_list * args)
  78 {
  79   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  80   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  81
  82   return s;
  83 }
  84
  85 typedef struct
  86 {
  87   vxlan4_gpe_tunnel_key_t key;
  88   vxlan_gpe_decap_info_t val;
  89 } vxlan4_gpe_tunnel_cache_t;
  90
  91 static const vxlan_gpe_decap_info_t decap_not_found = {
  92   .tunnel_index = ~0,
  93   .next_index = VXLAN_GPE_INPUT_NEXT_DROP,
  94   .error = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL
  95 };
  96
  97 always_inline vxlan_gpe_decap_info_t
  98 vxlan4_gpe_find_tunnel (vxlan_gpe_main_t *nngm,
  99                         vxlan4_gpe_tunnel_cache_t *cache,
 100                         ip4_vxlan_gpe_header_t *iuvn4_0)
 101 {
 102   /* Make sure VXLAN GPE tunnel exist according to packet S/D IP, UDP port and
 103    * VNI */
 104   vxlan4_gpe_tunnel_key_t key4 = {
 105     .local = iuvn4_0->ip4.dst_address.as_u32,
 106     .remote = iuvn4_0->ip4.src_address.as_u32,
 107     .vni = iuvn4_0->vxlan.vni_res,
 108     .port = (u32) iuvn4_0->udp.dst_port,
 109   };
 110
 111   if (PREDICT_TRUE (key4.as_u64[0] == cache->key.as_u64[0] &&
 112                     key4.as_u64[1] == cache->key.as_u64[1]))
 113     {
 114       /* cache hit */
 115       return cache->val;
 116     }
 117
 118   uword *p = hash_get_mem (nngm->vxlan4_gpe_tunnel_by_key, &key4);
 119   if (PREDICT_TRUE (p != 0))
 120     {
 121       u32 next = (iuvn4_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
 122                    nngm->decap_next_node_list[iuvn4_0->vxlan.protocol] :
 123                    VXLAN_GPE_INPUT_NEXT_DROP;
 124
 125       cache->key.as_u64[0] = key4.as_u64[0];
 126       cache->key.as_u64[1] = key4.as_u64[1];
 127
 128       cache->val.error = 0;
 129       cache->val.tunnel_index = p[0];
 130       cache->val.next_index = next;
 131
 132       return cache->val;
 133     }
 134
 135   return decap_not_found;
 136 }
 137
 138 typedef struct
 139 {
 140   vxlan6_gpe_tunnel_key_t key;
 141   vxlan_gpe_decap_info_t val;
 142 } vxlan6_gpe_tunnel_cache_t;
 143
 144 always_inline vxlan_gpe_decap_info_t
 145 vxlan6_gpe_find_tunnel (vxlan_gpe_main_t *nngm,
 146                         vxlan6_gpe_tunnel_cache_t *cache,
 147                         ip6_vxlan_gpe_header_t *iuvn6_0)
 148 {
 149   /* Make sure VXLAN GPE tunnel exist according to packet S/D IP, UDP port and
 150    * VNI */
 151   vxlan6_gpe_tunnel_key_t key6;
 152
 153   ip6_address_copy (&key6.local, &iuvn6_0->ip6.dst_address);
 154   ip6_address_copy (&key6.remote, &iuvn6_0->ip6.src_address);
 155   key6.vni = iuvn6_0->vxlan.vni_res;
 156   key6.port = iuvn6_0->udp.dst_port;
 157
 158   if (PREDICT_TRUE (memcmp (&key6, &cache->key, sizeof (cache->key)) == 0))
 159     {
 160       /* cache hit */
 161       return cache->val;
 162     }
 163
 164   uword *p = hash_get_mem (nngm->vxlan6_gpe_tunnel_by_key, &key6);
 165   if (PREDICT_TRUE (p != 0))
 166     {
 167       u32 next = (iuvn6_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
 168                    nngm->decap_next_node_list[iuvn6_0->vxlan.protocol] :
 169                    VXLAN_GPE_INPUT_NEXT_DROP;
 170
 171       clib_memcpy_fast (&cache->key, &key6, sizeof (key6));
 172       cache->val.error = 0;
 173       cache->val.tunnel_index = p[0];
 174       cache->val.next_index = next;
 175
 176       return cache->val;
 177     }
 178
 179   return decap_not_found;
 180 }
 181
 182 /**
 183  * @brief Common processing for IPv4 and IPv6 VXLAN GPE decap dispatch functions
 184  *
 185  * It is worth noting that other than trivial UDP forwarding (transit), VXLAN GPE
 186  * tunnels are "terminate local". This means that there is no "TX" interface for this
 187  * decap case, so that field in the buffer_metadata can be "used for something else".
 188  * The something else in this case is, for the IPv4/IPv6 inner-packet type case, the
 189  * FIB index used to look up the inner-packet's adjacency.
 190  *
 191  *      vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
 192  *
 193  * @param *vm
 194  * @param *node
 195  * @param *from_frame
 196  * @param is_ip4
 197  *
 198  * @return from_frame->n_vectors
 199  *
 200  */
 201 always_inline uword
 202 vxlan_gpe_input (vlib_main_t * vm,
 203                  vlib_node_runtime_t * node,
 204                  vlib_frame_t * from_frame, u8 is_ip4)
 205 {
 206   u32 n_left_from, next_index, *from, *to_next;
 207   vxlan_gpe_main_t *nngm = &vxlan_gpe_main;
 208   vnet_main_t *vnm = nngm->vnet_main;
 209   vnet_interface_main_t *im = &vnm->interface_main;
 210   vxlan4_gpe_tunnel_cache_t last4;
 211   vxlan6_gpe_tunnel_cache_t last6;
 212   u32 pkts_decapsulated = 0;
 213   u32 thread_index = vm->thread_index;
 214   u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
 215
 216   if (is_ip4)
 217     clib_memset (&last4, 0xff, sizeof (last4));
 218   else
 219     clib_memset (&last6, 0xff, sizeof (last6));
 220
 221   from = vlib_frame_vector_args (from_frame);
 222   n_left_from = from_frame->n_vectors;
 223
 224   next_index = node->cached_next_index;
 225   stats_sw_if_index = node->runtime_data[0];
 226   stats_n_packets = stats_n_bytes = 0;
 227
 228   while (n_left_from > 0)
 229     {
 230       u32 n_left_to_next;
 231
 232       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 233
 234       while (n_left_from >= 4 && n_left_to_next >= 2)
 235         {
 236           u32 bi0, bi1;
 237           vlib_buffer_t *b0, *b1;
 238           u32 next0, next1;
 239           ip4_vxlan_gpe_header_t *iuvn4_0, *iuvn4_1;
 240           ip6_vxlan_gpe_header_t *iuvn6_0, *iuvn6_1;
 241           vxlan_gpe_decap_info_t di0, di1;
 242           vxlan_gpe_tunnel_t *t0, *t1;
 243           u32 error0, error1;
 244           u32 sw_if_index0, sw_if_index1, len0, len1;
 245
 246           /* Prefetch next iteration. */
 247           {
 248             vlib_buffer_t *p2, *p3;
 249
 250             p2 = vlib_get_buffer (vm, from[2]);
 251             p3 = vlib_get_buffer (vm, from[3]);
 252
 253             vlib_prefetch_buffer_header (p2, LOAD);
 254             vlib_prefetch_buffer_header (p3, LOAD);
 255
 256             CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 257             CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 258           }
 259
 260           bi0 = from[0];
 261           bi1 = from[1];
 262           to_next[0] = bi0;
 263           to_next[1] = bi1;
 264           from += 2;
 265           to_next += 2;
 266           n_left_to_next -= 2;
 267           n_left_from -= 2;
 268
 269           b0 = vlib_get_buffer (vm, bi0);
 270           b1 = vlib_get_buffer (vm, bi1);
 271
 272           if (is_ip4)
 273             {
 274               /* udp leaves current_data pointing at the vxlan-gpe header */
 275               vlib_buffer_advance (b0,
 276                                    -(word) (sizeof (udp_header_t) +
 277                                             sizeof (ip4_header_t)));
 278               vlib_buffer_advance (b1,
 279                                    -(word) (sizeof (udp_header_t) +
 280                                             sizeof (ip4_header_t)));
 281
 282               iuvn4_0 = vlib_buffer_get_current (b0);
 283               iuvn4_1 = vlib_buffer_get_current (b1);
 284
 285               /* pop (ip, udp, vxlan) */
 286               vlib_buffer_advance (b0, sizeof (*iuvn4_0));
 287               vlib_buffer_advance (b1, sizeof (*iuvn4_1));
 288
 289               di0 = vxlan4_gpe_find_tunnel (nngm, &last4, iuvn4_0);
 290               di1 = vxlan4_gpe_find_tunnel (nngm, &last4, iuvn4_1);
 291             }
 292           else
 293             {
 294               /* udp leaves current_data pointing at the vxlan-gpe header */
 295               vlib_buffer_advance (b0,
 296                                    -(word) (sizeof (udp_header_t) +
 297                                             sizeof (ip6_header_t)));
 298               vlib_buffer_advance (b1,
 299                                    -(word) (sizeof (udp_header_t) +
 300                                             sizeof (ip6_header_t)));
 301
 302               iuvn6_0 = vlib_buffer_get_current (b0);
 303               iuvn6_1 = vlib_buffer_get_current (b1);
 304
 305               /* pop (ip, udp, vxlan) */
 306               vlib_buffer_advance (b0, sizeof (*iuvn6_0));
 307               vlib_buffer_advance (b1, sizeof (*iuvn6_1));
 308
 309               di0 = vxlan6_gpe_find_tunnel (nngm, &last6, iuvn6_0);
 310               di1 = vxlan6_gpe_find_tunnel (nngm, &last6, iuvn6_1);
 311             }
 312
 313           /* Process packet 0 */
 314           next0 = di0.next_index;
 315           error0 = di0.error;
 316           if (error0 != 0)
 317             {
 318               goto trace0;
 319             }
 320
 321           t0 = pool_elt_at_index (nngm->tunnels, di0.tunnel_index);
 322
 323           sw_if_index0 = t0->sw_if_index;
 324           len0 = vlib_buffer_length_in_chain (vm, b0);
 325
 326           /* Required to make the l2 tag push / pop code work on l2 subifs */
 327           vnet_update_l2_len (b0);
 328
 329           /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 330           vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
 331
 332       /**
 333        * ip[46] lookup in the configured FIB
 334        */
 335           vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
 336
 337           pkts_decapsulated++;
 338           stats_n_packets += 1;
 339           stats_n_bytes += len0;
 340
 341           if (PREDICT_FALSE (sw_if_index0 != stats_sw_if_index))
 342             {
 343               stats_n_packets -= 1;
 344               stats_n_bytes -= len0;
 345               if (stats_n_packets)
 346                 vlib_increment_combined_counter (im->combined_sw_if_counters +
 347                                                  VNET_INTERFACE_COUNTER_RX,
 348                                                  thread_index,
 349                                                  stats_sw_if_index,
 350                                                  stats_n_packets,
 351                                                  stats_n_bytes);
 352               stats_n_packets = 1;
 353               stats_n_bytes = len0;
 354               stats_sw_if_index = sw_if_index0;
 355             }
 356
 357         trace0:b0->error = error0 ? node->errors[error0] : 0;
 358
 359           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 360             {
 361               vxlan_gpe_rx_trace_t *tr =
 362                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 363               tr->next_index = next0;
 364               tr->error = error0;
 365               tr->tunnel_index = di0.tunnel_index;
 366             }
 367
 368           /* Process packet 1 */
 369           next1 = di1.next_index;
 370           error1 = di1.error;
 371           if (error1 != 0)
 372             {
 373               goto trace1;
 374             }
 375
 376           t1 = pool_elt_at_index (nngm->tunnels, di1.tunnel_index);
 377
 378           sw_if_index1 = t1->sw_if_index;
 379           len1 = vlib_buffer_length_in_chain (vm, b1);
 380
 381           /* Required to make the l2 tag push / pop code work on l2 subifs */
 382           vnet_update_l2_len (b1);
 383
 384           /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 385           vnet_buffer (b1)->sw_if_index[VLIB_RX] = t1->sw_if_index;
 386
 387           /*
 388            * ip[46] lookup in the configured FIB
 389            */
 390           vnet_buffer (b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
 391
 392           pkts_decapsulated++;
 393           stats_n_packets += 1;
 394           stats_n_bytes += len1;
 395
 396           /* Batch stats increment on the same vxlan tunnel so counter
 397              is not incremented per packet */
 398           if (PREDICT_FALSE (sw_if_index1 != stats_sw_if_index))
 399             {
 400               stats_n_packets -= 1;
 401               stats_n_bytes -= len1;
 402               if (stats_n_packets)
 403                 vlib_increment_combined_counter (im->combined_sw_if_counters +
 404                                                  VNET_INTERFACE_COUNTER_RX,
 405                                                  thread_index,
 406                                                  stats_sw_if_index,
 407                                                  stats_n_packets,
 408                                                  stats_n_bytes);
 409               stats_n_packets = 1;
 410               stats_n_bytes = len1;
 411               stats_sw_if_index = sw_if_index1;
 412             }
 413           vnet_buffer (b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
 414
 415         trace1:b1->error = error1 ? node->errors[error1] : 0;
 416
 417           if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
 418             {
 419               vxlan_gpe_rx_trace_t *tr =
 420                 vlib_add_trace (vm, node, b1, sizeof (*tr));
 421               tr->next_index = next1;
 422               tr->error = error1;
 423               tr->tunnel_index = di1.tunnel_index;
 424             }
 425
 426           vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
 427                                            n_left_to_next, bi0, bi1, next0,
 428                                            next1);
 429         }
 430
 431       while (n_left_from > 0 && n_left_to_next > 0)
 432         {
 433           u32 bi0;
 434           vlib_buffer_t *b0;
 435           u32 next0;
 436           ip4_vxlan_gpe_header_t *iuvn4_0;
 437           ip6_vxlan_gpe_header_t *iuvn6_0;
 438           vxlan_gpe_decap_info_t di0;
 439           vxlan_gpe_tunnel_t *t0;
 440           u32 error0;
 441           u32 sw_if_index0, len0;
 442
 443           bi0 = from[0];
 444           to_next[0] = bi0;
 445           from += 1;
 446           to_next += 1;
 447           n_left_from -= 1;
 448           n_left_to_next -= 1;
 449
 450           b0 = vlib_get_buffer (vm, bi0);
 451
 452           if (is_ip4)
 453             {
 454               /* udp leaves current_data pointing at the vxlan-gpe header */
 455               vlib_buffer_advance (b0,
 456                                    -(word) (sizeof (udp_header_t) +
 457                                             sizeof (ip4_header_t)));
 458
 459               iuvn4_0 = vlib_buffer_get_current (b0);
 460
 461               /* pop (ip, udp, vxlan) */
 462               vlib_buffer_advance (b0, sizeof (*iuvn4_0));
 463
 464               di0 = vxlan4_gpe_find_tunnel (nngm, &last4, iuvn4_0);
 465             }
 466           else
 467             {
 468               /* udp leaves current_data pointing at the vxlan-gpe header */
 469               vlib_buffer_advance (b0,
 470                                    -(word) (sizeof (udp_header_t) +
 471                                             sizeof (ip6_header_t)));
 472
 473               iuvn6_0 = vlib_buffer_get_current (b0);
 474
 475               /* pop (ip, udp, vxlan) */
 476               vlib_buffer_advance (b0, sizeof (*iuvn6_0));
 477
 478               di0 = vxlan6_gpe_find_tunnel (nngm, &last6, iuvn6_0);
 479                 }
 480
 481           next0 = di0.next_index;
 482           error0 = di0.error;
 483           if (error0 != 0)
 484             {
 485               goto trace00;
 486             }
 487
 488           t0 = pool_elt_at_index (nngm->tunnels, di0.tunnel_index);
 489
 490           sw_if_index0 = t0->sw_if_index;
 491           len0 = vlib_buffer_length_in_chain (vm, b0);
 492
 493           /* Required to make the l2 tag push / pop code work on l2 subifs */
 494           vnet_update_l2_len (b0);
 495
 496           /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 497           vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
 498
 499           /*
 500            * ip[46] lookup in the configured FIB
 501            */
 502           vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
 503
 504           pkts_decapsulated++;
 505           stats_n_packets += 1;
 506           stats_n_bytes += len0;
 507
 508           /* Batch stats increment on the same vxlan-gpe tunnel so counter
 509              is not incremented per packet */
 510           if (PREDICT_FALSE (sw_if_index0 != stats_sw_if_index))
 511             {
 512               stats_n_packets -= 1;
 513               stats_n_bytes -= len0;
 514               if (stats_n_packets)
 515                 vlib_increment_combined_counter (im->combined_sw_if_counters +
 516                                                  VNET_INTERFACE_COUNTER_RX,
 517                                                  thread_index,
 518                                                  stats_sw_if_index,
 519                                                  stats_n_packets,
 520                                                  stats_n_bytes);
 521               stats_n_packets = 1;
 522               stats_n_bytes = len0;
 523               stats_sw_if_index = sw_if_index0;
 524             }
 525
 526         trace00:b0->error = error0 ? node->errors[error0] : 0;
 527
 528           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 529             {
 530               vxlan_gpe_rx_trace_t *tr =
 531                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 532               tr->next_index = next0;
 533               tr->error = error0;
 534               tr->tunnel_index = di0.tunnel_index;
 535             }
 536           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 537                                            n_left_to_next, bi0, next0);
 538         }
 539
 540       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 541     }
 542
 543   vlib_node_increment_counter (vm,
 544                                is_ip4 ? vxlan4_gpe_input_node.index :
 545                                vxlan6_gpe_input_node.index,
 546                                VXLAN_GPE_ERROR_DECAPSULATED,
 547                                pkts_decapsulated);
 548
 549   /* Increment any remaining batch stats */
 550   if (stats_n_packets)
 551     {
 552       vlib_increment_combined_counter (im->combined_sw_if_counters +
 553                                        VNET_INTERFACE_COUNTER_RX,
 554                                        thread_index, stats_sw_if_index,
 555                                        stats_n_packets, stats_n_bytes);
 556       node->runtime_data[0] = stats_sw_if_index;
 557     }
 558   return from_frame->n_vectors;
 559 }
 560
 561 /**
 562  * @brief Graph processing dispatch function for IPv4 VXLAN GPE
 563  *
 564  * @node vxlan4-gpe-input
 565  * @param *vm
 566  * @param *node
 567  * @param *from_frame
 568  *
 569  * @return from_frame->n_vectors
 570  *
 571  */
 572 VLIB_NODE_FN (vxlan4_gpe_input_node) (vlib_main_t * vm,
 573                                       vlib_node_runtime_t * node,
 574                                       vlib_frame_t * from_frame)
 575 {
 576   return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */ 1);
 577 }
 578
 579 #ifndef CLIB_MARCH_VARIANT
 580 void
 581 vxlan_gpe_register_decap_protocol (u8 protocol_id, uword next_node_index)
 582 {
 583   vxlan_gpe_main_t *hm = &vxlan_gpe_main;
 584   hm->decap_next_node_list[protocol_id] = next_node_index;
 585   return;
 586 }
 587
 588 void
 589 vxlan_gpe_unregister_decap_protocol (u8 protocol_id, uword next_node_index)
 590 {
 591   vxlan_gpe_main_t *hm = &vxlan_gpe_main;
 592   hm->decap_next_node_list[protocol_id] = VXLAN_GPE_INPUT_NEXT_DROP;
 593   return;
 594 }
 595 #endif /* CLIB_MARCH_VARIANT */
 596
 597 /**
 598  * @brief Graph processing dispatch function for IPv6 VXLAN GPE
 599  *
 600  * @node vxlan6-gpe-input
 601  * @param *vm
 602  * @param *node
 603  * @param *from_frame
 604  *
 605  * @return from_frame->n_vectors - uword
 606  *
 607  */
 608 VLIB_NODE_FN (vxlan6_gpe_input_node) (vlib_main_t * vm,
 609                                       vlib_node_runtime_t * node,
 610                                       vlib_frame_t * from_frame)
 611 {
 612   return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */ 0);
 613 }
 614
 615 /**
 616  * @brief VXLAN GPE error strings
 617  */
 618 static char *vxlan_gpe_error_strings[] = {
 619 #define vxlan_gpe_error(n,s) s,
 620 #include <vnet/vxlan-gpe/vxlan_gpe_error.def>
 621 #undef vxlan_gpe_error
 622 #undef _
 623 };
 624
 625 VLIB_REGISTER_NODE (vxlan4_gpe_input_node) = {
 626   .name = "vxlan4-gpe-input",
 627   /* Takes a vector of packets. */
 628   .vector_size = sizeof (u32),
 629   .type = VLIB_NODE_TYPE_INTERNAL,
 630   .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
 631   .error_strings = vxlan_gpe_error_strings,
 632
 633   .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
 634   .next_nodes = {
 635 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
 636     foreach_vxlan_gpe_input_next
 637 #undef _
 638   },
 639
 640   .format_buffer = format_vxlan_gpe_with_length,
 641   .format_trace = format_vxlan_gpe_rx_trace,
 642   // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
 643 };
 644
 645 VLIB_REGISTER_NODE (vxlan6_gpe_input_node) = {
 646   .name = "vxlan6-gpe-input",
 647   /* Takes a vector of packets. */
 648   .vector_size = sizeof (u32),
 649   .type = VLIB_NODE_TYPE_INTERNAL,
 650   .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
 651   .error_strings = vxlan_gpe_error_strings,
 652
 653   .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
 654   .next_nodes = {
 655 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
 656     foreach_vxlan_gpe_input_next
 657 #undef _
 658   },
 659
 660   .format_buffer = format_vxlan_gpe_with_length,
 661   .format_trace = format_vxlan_gpe_rx_trace,
 662   // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
 663 };
 664
 665 typedef enum
 666 {
 667   IP_VXLAN_BYPASS_NEXT_DROP,
 668   IP_VXLAN_BYPASS_NEXT_VXLAN,
 669   IP_VXLAN_BYPASS_N_NEXT,
 670 } ip_vxlan_bypass_next_t;
 671
 672 always_inline uword
 673 ip_vxlan_gpe_bypass_inline (vlib_main_t * vm,
 674                             vlib_node_runtime_t * node,
 675                             vlib_frame_t * frame, u32 is_ip4)
 676 {
 677   vxlan_gpe_main_t *ngm = &vxlan_gpe_main;
 678   u32 *from, *to_next, n_left_from, n_left_to_next, next_index;
 679   vlib_node_runtime_t *error_node =
 680     vlib_node_get_runtime (vm, ip4_input_node.index);
 681   vtep4_key_t last_vtep4;       /* last IPv4 address / fib index
 682                                    matching a local VTEP address */
 683   vtep6_key_t last_vtep6;       /* last IPv6 address / fib index
 684                                    matching a local VTEP address */
 685   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
 686
 687   vxlan4_gpe_tunnel_cache_t last4;
 688   vxlan6_gpe_tunnel_cache_t last6;
 689
 690   from = vlib_frame_vector_args (frame);
 691   n_left_from = frame->n_vectors;
 692   next_index = node->cached_next_index;
 693
 694   vlib_get_buffers (vm, from, bufs, n_left_from);
 695
 696   if (node->flags & VLIB_NODE_FLAG_TRACE)
 697     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 698
 699   if (is_ip4)
 700     {
 701       vtep4_key_init (&last_vtep4);
 702       clib_memset (&last4, 0xff, sizeof last4);
 703     }
 704   else
 705     {
 706       vtep6_key_init (&last_vtep6);
 707       clib_memset (&last6, 0xff, sizeof last6);
 708     }
 709
 710   while (n_left_from > 0)
 711     {
 712       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 713
 714       while (n_left_from >= 4 && n_left_to_next >= 2)
 715         {
 716           vlib_buffer_t *b0, *b1;
 717           ip4_header_t *ip40, *ip41;
 718           ip6_header_t *ip60, *ip61;
 719           udp_header_t *udp0, *udp1;
 720           ip4_vxlan_gpe_header_t *iuvn4_0, *iuvn4_1;
 721           ip6_vxlan_gpe_header_t *iuvn6_0, *iuvn6_1;
 722           vxlan_gpe_decap_info_t di0, di1;
 723           u32 bi0, ip_len0, udp_len0, flags0, next0;
 724           u32 bi1, ip_len1, udp_len1, flags1, next1;
 725           i32 len_diff0, len_diff1;
 726           u8 error0, good_udp0, proto0;
 727           u8 error1, good_udp1, proto1;
 728
 729           /* Prefetch next iteration. */
 730           {
 731             vlib_prefetch_buffer_header (b[2], LOAD);
 732             vlib_prefetch_buffer_header (b[3], LOAD);
 733
 734             CLIB_PREFETCH (b[2]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 735             CLIB_PREFETCH (b[3]->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 736           }
 737
 738           bi0 = to_next[0] = from[0];
 739           bi1 = to_next[1] = from[1];
 740           from += 2;
 741           n_left_from -= 2;
 742           to_next += 2;
 743           n_left_to_next -= 2;
 744
 745           b0 = b[0];
 746           b1 = b[1];
 747           b += 2;
 748           if (is_ip4)
 749             {
 750               ip40 = vlib_buffer_get_current (b0);
 751               ip41 = vlib_buffer_get_current (b1);
 752             }
 753           else
 754             {
 755               ip60 = vlib_buffer_get_current (b0);
 756               ip61 = vlib_buffer_get_current (b1);
 757             }
 758
 759           /* Setup packet for next IP feature */
 760           vnet_feature_next (&next0, b0);
 761           vnet_feature_next (&next1, b1);
 762
 763           if (is_ip4)
 764             {
 765               proto0 = ip40->protocol;
 766               proto1 = ip41->protocol;
 767             }
 768           else
 769             {
 770               proto0 = ip60->protocol;
 771               proto1 = ip61->protocol;
 772             }
 773
 774           /* Process packet 0 */
 775           if (proto0 != IP_PROTOCOL_UDP)
 776             goto exit0;         /* not UDP packet */
 777
 778           if (is_ip4)
 779             {
 780               udp0 = ip4_next_header (ip40);
 781               iuvn4_0 = vlib_buffer_get_current (b0);
 782               di0 = vxlan4_gpe_find_tunnel (ngm, &last4, iuvn4_0);
 783             }
 784           else
 785             {
 786               udp0 = ip6_next_header (ip60);
 787               iuvn6_0 = vlib_buffer_get_current (b0);
 788               di0 = vxlan6_gpe_find_tunnel (ngm, &last6, iuvn6_0);
 789             }
 790
 791           if (PREDICT_FALSE (di0.tunnel_index == ~0))
 792             goto exit0; /* unknown interface */
 793
 794           /* Validate DIP against VTEPs */
 795           if (is_ip4)
 796             {
 797 #ifdef CLIB_HAVE_VEC512
 798               if (!vtep4_check_vector (&ngm->vtep_table, b0, ip40, &last_vtep4,
 799                                        &ngm->vtep4_u512))
 800 #else
 801               if (!vtep4_check (&ngm->vtep_table, b0, ip40, &last_vtep4))
 802 #endif
 803                 goto exit0;     /* no local VTEP for VXLAN packet */
 804             }
 805           else
 806             {
 807               if (!vtep6_check (&ngm->vtep_table, b0, ip60, &last_vtep6))
 808                 goto exit0;     /* no local VTEP for VXLAN packet */
 809             }
 810
 811           flags0 = b0->flags;
 812           good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 813
 814           /* Don't verify UDP checksum for packets with explicit zero checksum. */
 815           good_udp0 |= udp0->checksum == 0;
 816
 817           /* Verify UDP length */
 818           if (is_ip4)
 819             ip_len0 = clib_net_to_host_u16 (ip40->length);
 820           else
 821             ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
 822           udp_len0 = clib_net_to_host_u16 (udp0->length);
 823           len_diff0 = ip_len0 - udp_len0;
 824
 825           /* Verify UDP checksum */
 826           if (PREDICT_FALSE (!good_udp0))
 827             {
 828               if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
 829                 {
 830                   if (is_ip4)
 831                     flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
 832                   else
 833                     flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
 834                   good_udp0 =
 835                     (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 836                 }
 837             }
 838
 839           if (is_ip4)
 840             {
 841               error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
 842               error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
 843             }
 844           else
 845             {
 846               error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
 847               error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
 848             }
 849
 850           next0 = error0 ?
 851             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
 852           b0->error = error0 ? error_node->errors[error0] : 0;
 853
 854           /* vxlan_gpe-input node expect current at VXLAN header */
 855           if (is_ip4)
 856             vlib_buffer_advance (b0,
 857                                  sizeof (ip4_header_t) +
 858                                  sizeof (udp_header_t));
 859           else
 860             vlib_buffer_advance (b0,
 861                                  sizeof (ip6_header_t) +
 862                                  sizeof (udp_header_t));
 863
 864         exit0:
 865           /* Process packet 1 */
 866           if (proto1 != IP_PROTOCOL_UDP)
 867             goto exit1;         /* not UDP packet */
 868
 869           if (is_ip4)
 870             {
 871               udp1 = ip4_next_header (ip41);
 872               iuvn4_1 = vlib_buffer_get_current (b1);
 873               di1 = vxlan4_gpe_find_tunnel (ngm, &last4, iuvn4_1);
 874             }
 875           else
 876             {
 877               udp1 = ip6_next_header (ip61);
 878               iuvn6_1 = vlib_buffer_get_current (b1);
 879               di1 = vxlan6_gpe_find_tunnel (ngm, &last6, iuvn6_1);
 880             }
 881
 882           if (PREDICT_FALSE (di1.tunnel_index == ~0))
 883             goto exit1; /* unknown interface */
 884
 885           /* Validate DIP against VTEPs */
 886           if (is_ip4)
 887             {
 888 #ifdef CLIB_HAVE_VEC512
 889               if (!vtep4_check_vector (&ngm->vtep_table, b1, ip41, &last_vtep4,
 890                                        &ngm->vtep4_u512))
 891 #else
 892               if (!vtep4_check (&ngm->vtep_table, b1, ip41, &last_vtep4))
 893 #endif
 894                 goto exit1;     /* no local VTEP for VXLAN packet */
 895             }
 896           else
 897             {
 898               if (!vtep6_check (&ngm->vtep_table, b1, ip61, &last_vtep6))
 899                 goto exit1;     /* no local VTEP for VXLAN packet */
 900             }
 901
 902           flags1 = b1->flags;
 903           good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 904
 905           /* Don't verify UDP checksum for packets with explicit zero checksum. */
 906           good_udp1 |= udp1->checksum == 0;
 907
 908           /* Verify UDP length */
 909           if (is_ip4)
 910             ip_len1 = clib_net_to_host_u16 (ip41->length);
 911           else
 912             ip_len1 = clib_net_to_host_u16 (ip61->payload_length);
 913           udp_len1 = clib_net_to_host_u16 (udp1->length);
 914           len_diff1 = ip_len1 - udp_len1;
 915
 916           /* Verify UDP checksum */
 917           if (PREDICT_FALSE (!good_udp1))
 918             {
 919               if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
 920                 {
 921                   if (is_ip4)
 922                     flags1 = ip4_tcp_udp_validate_checksum (vm, b1);
 923                   else
 924                     flags1 = ip6_tcp_udp_icmp_validate_checksum (vm, b1);
 925                   good_udp1 =
 926                     (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 927                 }
 928             }
 929
 930           if (is_ip4)
 931             {
 932               error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
 933               error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
 934             }
 935           else
 936             {
 937               error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
 938               error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
 939             }
 940
 941           next1 = error1 ?
 942             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
 943           b1->error = error1 ? error_node->errors[error1] : 0;
 944
 945           /* vxlan_gpe-input node expect current at VXLAN header */
 946           if (is_ip4)
 947             vlib_buffer_advance (b1,
 948                                  sizeof (ip4_header_t) +
 949                                  sizeof (udp_header_t));
 950           else
 951             vlib_buffer_advance (b1,
 952                                  sizeof (ip6_header_t) +
 953                                  sizeof (udp_header_t));
 954
 955         exit1:
 956           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 957                                            to_next, n_left_to_next,
 958                                            bi0, bi1, next0, next1);
 959         }
 960
 961       while (n_left_from > 0 && n_left_to_next > 0)
 962         {
 963           vlib_buffer_t *b0;
 964           ip4_header_t *ip40;
 965           ip6_header_t *ip60;
 966           udp_header_t *udp0;
 967           ip4_vxlan_gpe_header_t *iuvn4_0;
 968           ip6_vxlan_gpe_header_t *iuvn6_0;
 969           vxlan_gpe_decap_info_t di0;
 970           u32 bi0, ip_len0, udp_len0, flags0, next0;
 971           i32 len_diff0;
 972           u8 error0, good_udp0, proto0;
 973
 974           bi0 = to_next[0] = from[0];
 975           from += 1;
 976           n_left_from -= 1;
 977           to_next += 1;
 978           n_left_to_next -= 1;
 979
 980           b0 = b[0];
 981           b++;
 982           if (is_ip4)
 983             ip40 = vlib_buffer_get_current (b0);
 984           else
 985             ip60 = vlib_buffer_get_current (b0);
 986
 987           /* Setup packet for next IP feature */
 988           vnet_feature_next (&next0, b0);
 989
 990           if (is_ip4)
 991             proto0 = ip40->protocol;
 992           else
 993             proto0 = ip60->protocol;
 994
 995           if (proto0 != IP_PROTOCOL_UDP)
 996             goto exit;          /* not UDP packet */
 997
 998           if (is_ip4)
 999             {
1000               udp0 = ip4_next_header (ip40);
1001               iuvn4_0 = vlib_buffer_get_current (b0);
1002               di0 = vxlan4_gpe_find_tunnel (ngm, &last4, iuvn4_0);
1003             }
1004           else
1005             {
1006               udp0 = ip6_next_header (ip60);
1007               iuvn6_0 = vlib_buffer_get_current (b0);
1008               di0 = vxlan6_gpe_find_tunnel (ngm, &last6, iuvn6_0);
1009             }
1010
1011           if (PREDICT_FALSE (di0.tunnel_index == ~0))
1012             goto exit; /* unknown interface */
1013
1014           /* Validate DIP against VTEPs */
1015
1016           if (is_ip4)
1017             {
1018 #ifdef CLIB_HAVE_VEC512
1019               if (!vtep4_check_vector (&ngm->vtep_table, b0, ip40, &last_vtep4,
1020                                        &ngm->vtep4_u512))
1021 #else
1022               if (!vtep4_check (&ngm->vtep_table, b0, ip40, &last_vtep4))
1023 #endif
1024                 goto exit;      /* no local VTEP for VXLAN packet */
1025             }
1026           else
1027             {
1028               if (!vtep6_check (&ngm->vtep_table, b0, ip60, &last_vtep6))
1029                 goto exit;      /* no local VTEP for VXLAN packet */
1030             }
1031
1032           flags0 = b0->flags;
1033           good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1034
1035           /* Don't verify UDP checksum for packets with explicit zero checksum. */
1036           good_udp0 |= udp0->checksum == 0;
1037
1038           /* Verify UDP length */
1039           if (is_ip4)
1040             ip_len0 = clib_net_to_host_u16 (ip40->length);
1041           else
1042             ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
1043           udp_len0 = clib_net_to_host_u16 (udp0->length);
1044           len_diff0 = ip_len0 - udp_len0;
1045
1046           /* Verify UDP checksum */
1047           if (PREDICT_FALSE (!good_udp0))
1048             {
1049               if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
1050                 {
1051                   if (is_ip4)
1052                     flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
1053                   else
1054                     flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
1055                   good_udp0 =
1056                     (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1057                 }
1058             }
1059
1060           if (is_ip4)
1061             {
1062               error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
1063               error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
1064             }
1065           else
1066             {
1067               error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
1068               error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
1069             }
1070
1071           next0 = error0 ?
1072             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
1073           b0->error = error0 ? error_node->errors[error0] : 0;
1074
1075           /* vxlan_gpe-input node expect current at VXLAN header */
1076           if (is_ip4)
1077             vlib_buffer_advance (b0,
1078                                  sizeof (ip4_header_t) +
1079                                  sizeof (udp_header_t));
1080           else
1081             vlib_buffer_advance (b0,
1082                                  sizeof (ip6_header_t) +
1083                                  sizeof (udp_header_t));
1084
1085         exit:
1086           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1087                                            to_next, n_left_to_next,
1088                                            bi0, next0);
1089         }
1090
1091       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1092     }
1093
1094   return frame->n_vectors;
1095 }
1096
1097 VLIB_NODE_FN (ip4_vxlan_gpe_bypass_node) (vlib_main_t * vm,
1098                                           vlib_node_runtime_t * node,
1099                                           vlib_frame_t * frame)
1100 {
1101   return ip_vxlan_gpe_bypass_inline (vm, node, frame, /* is_ip4 */ 1);
1102 }
1103
1104 VLIB_REGISTER_NODE (ip4_vxlan_gpe_bypass_node) = {
1105   .name = "ip4-vxlan-gpe-bypass",
1106   .vector_size = sizeof (u32),
1107
1108   .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
1109   .next_nodes = {
1110     [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
1111     [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan4-gpe-input",
1112   },
1113
1114   .format_buffer = format_ip4_header,
1115   .format_trace = format_ip4_forward_next_trace,
1116 };
1117
1118 #ifndef CLIB_MARCH_VARIANT
1119 /* Dummy init function to get us linked in. */
1120 clib_error_t *
1121 ip4_vxlan_gpe_bypass_init (vlib_main_t * vm)
1122 {
1123   return 0;
1124 }
1125
1126 VLIB_INIT_FUNCTION (ip4_vxlan_gpe_bypass_init);
1127 #endif /* CLIB_MARCH_VARIANT */
1128
1129 VLIB_NODE_FN (ip6_vxlan_gpe_bypass_node) (vlib_main_t * vm,
1130                                           vlib_node_runtime_t * node,
1131                                           vlib_frame_t * frame)
1132 {
1133   return ip_vxlan_gpe_bypass_inline (vm, node, frame, /* is_ip4 */ 0);
1134 }
1135
1136 VLIB_REGISTER_NODE (ip6_vxlan_gpe_bypass_node) = {
1137   .name = "ip6-vxlan-gpe-bypass",
1138   .vector_size = sizeof (u32),
1139
1140   .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
1141   .next_nodes = {
1142     [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
1143     [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan6-gpe-input",
1144   },
1145
1146   .format_buffer = format_ip6_header,
1147   .format_trace = format_ip6_forward_next_trace,
1148 };
1149
1150 #ifndef CLIB_MARCH_VARIANT
1151 /* Dummy init function to get us linked in. */
1152 clib_error_t *
1153 ip6_vxlan_gpe_bypass_init (vlib_main_t * vm)
1154 {
1155   return 0;
1156 }
1157
1158 VLIB_INIT_FUNCTION (ip6_vxlan_gpe_bypass_init);
1159 #endif /* CLIB_MARCH_VARIANT */
1160
1161 /*
1162  * fd.io coding-style-patch-verification: ON
1163  *
1164  * Local Variables:
1165  * eval: (c-set-style "gnu")
1166  * End:
1167  */