src/vnet/vxlan/decap.c

   1 /*
   2  * decap.c: vxlan tunnel decap packet processing
   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 #include <vlib/vlib.h>
  19 #include <vnet/pg/pg.h>
  20 #include <vnet/vxlan/vxlan.h>
  21
  22 vlib_node_registration_t vxlan4_input_node;
  23 vlib_node_registration_t vxlan6_input_node;
  24
  25 typedef struct
  26 {
  27   u32 next_index;
  28   u32 tunnel_index;
  29   u32 error;
  30   u32 vni;
  31 } vxlan_rx_trace_t;
  32
  33 static u8 *
  34 format_vxlan_rx_trace (u8 * s, va_list * args)
  35 {
  36   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  37   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  38   vxlan_rx_trace_t *t = va_arg (*args, vxlan_rx_trace_t *);
  39
  40   if (t->tunnel_index == ~0)
  41     return format (s, "VXLAN decap error - tunnel for vni %d does not exist",
  42                    t->vni);
  43   return format (s, "VXLAN decap from vxlan_tunnel%d vni %d next %d error %d",
  44                  t->tunnel_index, t->vni, t->next_index, t->error);
  45 }
  46
  47 always_inline u32
  48 buf_fib_index (vlib_buffer_t * b, u32 is_ip4)
  49 {
  50   u32 sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
  51   if (sw_if_index != (u32) ~ 0)
  52     return sw_if_index;
  53
  54   u32 *fib_index_by_sw_if_index = is_ip4 ?
  55     ip4_main.fib_index_by_sw_if_index : ip6_main.fib_index_by_sw_if_index;
  56   sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
  57
  58   return vec_elt (fib_index_by_sw_if_index, sw_if_index);
  59 }
  60
  61 typedef vxlan4_tunnel_key_t last_tunnel_cache4;
  62
  63 always_inline vxlan_tunnel_t *
  64 vxlan4_find_tunnel (vxlan_main_t * vxm, last_tunnel_cache4 * cache,
  65                     u32 fib_index, ip4_header_t * ip4_0,
  66                     vxlan_header_t * vxlan0, vxlan_tunnel_t ** stats_t0)
  67 {
  68   /* Make sure VXLAN tunnel exist according to packet SIP and VNI */
  69   vxlan4_tunnel_key_t key4;
  70   key4.key[1] = ((u64) fib_index << 32) | vxlan0->vni_reserved;
  71
  72   if (PREDICT_FALSE (key4.key[1] != cache->key[1] ||
  73                      ip4_0->src_address.as_u32 != (u32) cache->key[0]))
  74     {
  75       key4.key[0] = ip4_0->src_address.as_u32;
  76       int rv =
  77         clib_bihash_search_inline_16_8 (&vxm->vxlan4_tunnel_by_key, &key4);
  78       if (PREDICT_FALSE (rv != 0))
  79         return 0;
  80
  81       *cache = key4;
  82     }
  83   vxlan_tunnel_t *t0 = pool_elt_at_index (vxm->tunnels, cache->value);
  84
  85   /* Validate VXLAN tunnel SIP against packet DIP */
  86   if (PREDICT_TRUE (ip4_0->dst_address.as_u32 == t0->src.ip4.as_u32))
  87     *stats_t0 = t0;
  88   else
  89     {
  90       /* try multicast */
  91       if (PREDICT_TRUE (!ip4_address_is_multicast (&ip4_0->dst_address)))
  92         return 0;
  93
  94       key4.key[0] = ip4_0->dst_address.as_u32;
  95       /* Make sure mcast VXLAN tunnel exist by packet DIP and VNI */
  96       int rv =
  97         clib_bihash_search_inline_16_8 (&vxm->vxlan4_tunnel_by_key, &key4);
  98       if (PREDICT_FALSE (rv != 0))
  99         return 0;
 100
 101       *stats_t0 = pool_elt_at_index (vxm->tunnels, key4.value);
 102     }
 103
 104   return t0;
 105 }
 106
 107 typedef vxlan6_tunnel_key_t last_tunnel_cache6;
 108
 109 always_inline vxlan_tunnel_t *
 110 vxlan6_find_tunnel (vxlan_main_t * vxm, last_tunnel_cache6 * cache,
 111                     u32 fib_index, ip6_header_t * ip6_0,
 112                     vxlan_header_t * vxlan0, vxlan_tunnel_t ** stats_t0)
 113 {
 114   /* Make sure VXLAN tunnel exist according to packet SIP and VNI */
 115   vxlan6_tunnel_key_t key6 = {
 116     .key = {
 117             [0] = ip6_0->src_address.as_u64[0],
 118             [1] = ip6_0->src_address.as_u64[1],
 119             [2] = (((u64) fib_index) << 32) | vxlan0->vni_reserved,
 120             }
 121   };
 122
 123   if (PREDICT_FALSE
 124       (clib_bihash_key_compare_24_8 (key6.key, cache->key) == 0))
 125     {
 126       int rv =
 127         clib_bihash_search_inline_24_8 (&vxm->vxlan6_tunnel_by_key, &key6);
 128       if (PREDICT_FALSE (rv != 0))
 129         return 0;
 130
 131       *cache = key6;
 132     }
 133   vxlan_tunnel_t *t0 = pool_elt_at_index (vxm->tunnels, cache->value);
 134
 135   /* Validate VXLAN tunnel SIP against packet DIP */
 136   if (PREDICT_TRUE (ip6_address_is_equal (&ip6_0->dst_address, &t0->src.ip6)))
 137     *stats_t0 = t0;
 138   else
 139     {
 140       /* try multicast */
 141       if (PREDICT_TRUE (!ip6_address_is_multicast (&ip6_0->dst_address)))
 142         return 0;
 143
 144       /* Make sure mcast VXLAN tunnel exist by packet DIP and VNI */
 145       key6.key[0] = ip6_0->dst_address.as_u64[0];
 146       key6.key[1] = ip6_0->dst_address.as_u64[1];
 147       int rv =
 148         clib_bihash_search_inline_24_8 (&vxm->vxlan6_tunnel_by_key, &key6);
 149       if (PREDICT_FALSE (rv != 0))
 150         return 0;
 151
 152       *stats_t0 = pool_elt_at_index (vxm->tunnels, key6.value);
 153     }
 154
 155   return t0;
 156 }
 157
 158 always_inline uword
 159 vxlan_input (vlib_main_t * vm,
 160              vlib_node_runtime_t * node,
 161              vlib_frame_t * from_frame, u32 is_ip4)
 162 {
 163   vxlan_main_t *vxm = &vxlan_main;
 164   vnet_main_t *vnm = vxm->vnet_main;
 165   vnet_interface_main_t *im = &vnm->interface_main;
 166   vlib_combined_counter_main_t *rx_counter =
 167     im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX;
 168   vlib_combined_counter_main_t *drop_counter =
 169     im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_DROP;
 170   last_tunnel_cache4 last4;
 171   last_tunnel_cache6 last6;
 172   u32 pkts_decapsulated = 0;
 173   u32 thread_index = vlib_get_thread_index ();
 174
 175   if (is_ip4)
 176     memset (&last4, 0xff, sizeof last4);
 177   else
 178     memset (&last6, 0xff, sizeof last6);
 179
 180   u32 next_index = node->cached_next_index;
 181
 182   u32 *from = vlib_frame_vector_args (from_frame);
 183   u32 n_left_from = from_frame->n_vectors;
 184
 185   while (n_left_from > 0)
 186     {
 187       u32 *to_next, n_left_to_next;
 188       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 189
 190       while (n_left_from >= 4 && n_left_to_next >= 2)
 191         {
 192           /* Prefetch next iteration. */
 193           {
 194             vlib_buffer_t *p2, *p3;
 195
 196             p2 = vlib_get_buffer (vm, from[2]);
 197             p3 = vlib_get_buffer (vm, from[3]);
 198
 199             vlib_prefetch_buffer_header (p2, LOAD);
 200             vlib_prefetch_buffer_header (p3, LOAD);
 201
 202             CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 203             CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 204           }
 205
 206           u32 bi0 = to_next[0] = from[0];
 207           u32 bi1 = to_next[1] = from[1];
 208           from += 2;
 209           to_next += 2;
 210           n_left_to_next -= 2;
 211           n_left_from -= 2;
 212
 213           vlib_buffer_t *b0, *b1;
 214           b0 = vlib_get_buffer (vm, bi0);
 215           b1 = vlib_get_buffer (vm, bi1);
 216
 217           /* udp leaves current_data pointing at the vxlan header */
 218           void *cur0 = vlib_buffer_get_current (b0);
 219           void *cur1 = vlib_buffer_get_current (b1);
 220           vxlan_header_t *vxlan0 = cur0;
 221           vxlan_header_t *vxlan1 = cur1;
 222
 223           ip4_header_t *ip4_0, *ip4_1;
 224           ip6_header_t *ip6_0, *ip6_1;
 225           if (is_ip4)
 226             {
 227               ip4_0 = cur0 - sizeof (udp_header_t) - sizeof (ip4_header_t);
 228               ip4_1 = cur1 - sizeof (udp_header_t) - sizeof (ip4_header_t);
 229             }
 230           else
 231             {
 232               ip6_0 = cur0 - sizeof (udp_header_t) - sizeof (ip6_header_t);
 233               ip6_1 = cur1 - sizeof (udp_header_t) - sizeof (ip6_header_t);
 234             }
 235
 236           /* pop vxlan */
 237           vlib_buffer_advance (b0, sizeof *vxlan0);
 238           vlib_buffer_advance (b1, sizeof *vxlan1);
 239
 240           u32 fi0 = buf_fib_index (b0, is_ip4);
 241           u32 fi1 = buf_fib_index (b1, is_ip4);
 242
 243           vxlan_tunnel_t *t0, *stats_t0;
 244           vxlan_tunnel_t *t1, *stats_t1;
 245           if (is_ip4)
 246             {
 247               t0 =
 248                 vxlan4_find_tunnel (vxm, &last4, fi0, ip4_0, vxlan0,
 249                                     &stats_t0);
 250               t1 =
 251                 vxlan4_find_tunnel (vxm, &last4, fi1, ip4_1, vxlan1,
 252                                     &stats_t1);
 253             }
 254           else
 255             {
 256               t0 =
 257                 vxlan6_find_tunnel (vxm, &last6, fi0, ip6_0, vxlan0,
 258                                     &stats_t0);
 259               t1 =
 260                 vxlan6_find_tunnel (vxm, &last6, fi1, ip6_1, vxlan1,
 261                                     &stats_t1);
 262             }
 263
 264           u32 len0 = vlib_buffer_length_in_chain (vm, b0);
 265           u32 len1 = vlib_buffer_length_in_chain (vm, b1);
 266
 267           u32 next0, next1;
 268           u8 error0 = 0, error1 = 0;
 269           /* Validate VXLAN tunnel encap-fib index agaist packet */
 270           if (PREDICT_FALSE (t0 == 0 || vxlan0->flags != VXLAN_FLAGS_I))
 271             {
 272               next0 = VXLAN_INPUT_NEXT_DROP;
 273
 274               if (t0 != 0 && vxlan0->flags != VXLAN_FLAGS_I)
 275                 {
 276                   error0 = VXLAN_ERROR_BAD_FLAGS;
 277                   vlib_increment_combined_counter
 278                     (drop_counter, thread_index, stats_t0->sw_if_index, 1,
 279                      len0);
 280                 }
 281               else
 282                 error0 = VXLAN_ERROR_NO_SUCH_TUNNEL;
 283               b0->error = node->errors[error0];
 284             }
 285           else
 286             {
 287               next0 = t0->decap_next_index;
 288
 289               /* Required to make the l2 tag push / pop code work on l2 subifs */
 290               if (PREDICT_TRUE (next0 == VXLAN_INPUT_NEXT_L2_INPUT))
 291                 vnet_update_l2_len (b0);
 292
 293               /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 294               vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
 295               vlib_increment_combined_counter
 296                 (rx_counter, thread_index, stats_t0->sw_if_index, 1, len0);
 297               pkts_decapsulated++;
 298             }
 299
 300           /* Validate VXLAN tunnel encap-fib index agaist packet */
 301           if (PREDICT_FALSE (t1 == 0 || vxlan1->flags != VXLAN_FLAGS_I))
 302             {
 303               next1 = VXLAN_INPUT_NEXT_DROP;
 304
 305               if (t1 != 0 && vxlan1->flags != VXLAN_FLAGS_I)
 306                 {
 307                   error1 = VXLAN_ERROR_BAD_FLAGS;
 308                   vlib_increment_combined_counter
 309                     (drop_counter, thread_index, stats_t1->sw_if_index, 1,
 310                      len1);
 311                 }
 312               else
 313                 error1 = VXLAN_ERROR_NO_SUCH_TUNNEL;
 314               b1->error = node->errors[error1];
 315             }
 316           else
 317             {
 318               next1 = t1->decap_next_index;
 319
 320               /* Required to make the l2 tag push / pop code work on l2 subifs */
 321               if (PREDICT_TRUE (next1 == VXLAN_INPUT_NEXT_L2_INPUT))
 322                 vnet_update_l2_len (b1);
 323
 324               /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 325               vnet_buffer (b1)->sw_if_index[VLIB_RX] = t1->sw_if_index;
 326               pkts_decapsulated++;
 327
 328               vlib_increment_combined_counter
 329                 (rx_counter, thread_index, stats_t1->sw_if_index, 1, len1);
 330             }
 331
 332           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 333             {
 334               vxlan_rx_trace_t *tr =
 335                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 336               tr->next_index = next0;
 337               tr->error = error0;
 338               tr->tunnel_index = t0 == 0 ? ~0 : t0 - vxm->tunnels;
 339               tr->vni = vnet_get_vni (vxlan0);
 340             }
 341           if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
 342             {
 343               vxlan_rx_trace_t *tr =
 344                 vlib_add_trace (vm, node, b1, sizeof (*tr));
 345               tr->next_index = next1;
 346               tr->error = error1;
 347               tr->tunnel_index = t1 == 0 ? ~0 : t1 - vxm->tunnels;
 348               tr->vni = vnet_get_vni (vxlan1);
 349             }
 350
 351           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 352                                            to_next, n_left_to_next,
 353                                            bi0, bi1, next0, next1);
 354         }
 355
 356       while (n_left_from > 0 && n_left_to_next > 0)
 357         {
 358           u32 bi0 = to_next[0] = from[0];
 359           from += 1;
 360           to_next += 1;
 361           n_left_from -= 1;
 362           n_left_to_next -= 1;
 363
 364           vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
 365
 366           /* udp leaves current_data pointing at the vxlan header */
 367           void *cur0 = vlib_buffer_get_current (b0);
 368           vxlan_header_t *vxlan0 = cur0;
 369           ip4_header_t *ip4_0;
 370           ip6_header_t *ip6_0;
 371           if (is_ip4)
 372             ip4_0 = cur0 - sizeof (udp_header_t) - sizeof (ip4_header_t);
 373           else
 374             ip6_0 = cur0 - sizeof (udp_header_t) - sizeof (ip6_header_t);
 375
 376           /* pop (ip, udp, vxlan) */
 377           vlib_buffer_advance (b0, sizeof (*vxlan0));
 378
 379           u32 fi0 = buf_fib_index (b0, is_ip4);
 380
 381           vxlan_tunnel_t *t0, *stats_t0;
 382           if (is_ip4)
 383             t0 =
 384               vxlan4_find_tunnel (vxm, &last4, fi0, ip4_0, vxlan0, &stats_t0);
 385           else
 386             t0 =
 387               vxlan6_find_tunnel (vxm, &last6, fi0, ip6_0, vxlan0, &stats_t0);
 388
 389           uword len0 = vlib_buffer_length_in_chain (vm, b0);
 390
 391           u32 next0;
 392           u8 error0 = 0;
 393           /* Validate VXLAN tunnel encap-fib index agaist packet */
 394           if (PREDICT_FALSE (t0 == 0 || vxlan0->flags != VXLAN_FLAGS_I))
 395             {
 396               next0 = VXLAN_INPUT_NEXT_DROP;
 397
 398               if (t0 != 0 && vxlan0->flags != VXLAN_FLAGS_I)
 399                 {
 400                   error0 = VXLAN_ERROR_BAD_FLAGS;
 401                   vlib_increment_combined_counter
 402                     (drop_counter, thread_index, stats_t0->sw_if_index, 1,
 403                      len0);
 404                 }
 405               else
 406                 error0 = VXLAN_ERROR_NO_SUCH_TUNNEL;
 407               b0->error = node->errors[error0];
 408             }
 409           else
 410             {
 411               next0 = t0->decap_next_index;
 412
 413               /* Required to make the l2 tag push / pop code work on l2 subifs */
 414               if (PREDICT_TRUE (next0 == VXLAN_INPUT_NEXT_L2_INPUT))
 415                 vnet_update_l2_len (b0);
 416
 417               /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
 418               vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
 419               pkts_decapsulated++;
 420
 421               vlib_increment_combined_counter
 422                 (rx_counter, thread_index, stats_t0->sw_if_index, 1, len0);
 423             }
 424
 425           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 426             {
 427               vxlan_rx_trace_t *tr
 428                 = vlib_add_trace (vm, node, b0, sizeof (*tr));
 429               tr->next_index = next0;
 430               tr->error = error0;
 431               tr->tunnel_index = t0 == 0 ? ~0 : t0 - vxm->tunnels;
 432               tr->vni = vnet_get_vni (vxlan0);
 433             }
 434           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 435                                            to_next, n_left_to_next,
 436                                            bi0, next0);
 437         }
 438
 439       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 440     }
 441   /* Do we still need this now that tunnel tx stats is kept? */
 442   u32 node_idx = is_ip4 ? vxlan4_input_node.index : vxlan6_input_node.index;
 443   vlib_node_increment_counter (vm, node_idx, VXLAN_ERROR_DECAPSULATED,
 444                                pkts_decapsulated);
 445
 446   return from_frame->n_vectors;
 447 }
 448
 449 static uword
 450 vxlan4_input (vlib_main_t * vm,
 451               vlib_node_runtime_t * node, vlib_frame_t * from_frame)
 452 {
 453   return vxlan_input (vm, node, from_frame, /* is_ip4 */ 1);
 454 }
 455
 456 static uword
 457 vxlan6_input (vlib_main_t * vm,
 458               vlib_node_runtime_t * node, vlib_frame_t * from_frame)
 459 {
 460   return vxlan_input (vm, node, from_frame, /* is_ip4 */ 0);
 461 }
 462
 463 static char *vxlan_error_strings[] = {
 464 #define vxlan_error(n,s) s,
 465 #include <vnet/vxlan/vxlan_error.def>
 466 #undef vxlan_error
 467 #undef _
 468 };
 469
 470 /* *INDENT-OFF* */
 471 VLIB_REGISTER_NODE (vxlan4_input_node) =
 472 {
 473   .function = vxlan4_input,
 474   .name = "vxlan4-input",
 475   .vector_size = sizeof (u32),
 476   .n_errors = VXLAN_N_ERROR,
 477   .error_strings = vxlan_error_strings,
 478   .n_next_nodes = VXLAN_INPUT_N_NEXT,
 479   .format_trace = format_vxlan_rx_trace,
 480   .next_nodes = {
 481 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n,
 482     foreach_vxlan_input_next
 483 #undef _
 484   },
 485 };
 486 VLIB_NODE_FUNCTION_MULTIARCH (vxlan4_input_node, vxlan4_input)
 487
 488 VLIB_REGISTER_NODE (vxlan6_input_node) =
 489 {
 490   .function = vxlan6_input,
 491   .name = "vxlan6-input",
 492   .vector_size = sizeof (u32),
 493   .n_errors = VXLAN_N_ERROR,
 494   .error_strings = vxlan_error_strings,
 495   .n_next_nodes = VXLAN_INPUT_N_NEXT,
 496   .next_nodes = {
 497 #define _(s,n) [VXLAN_INPUT_NEXT_##s] = n,
 498     foreach_vxlan_input_next
 499 #undef _
 500   },
 501   .format_trace = format_vxlan_rx_trace,
 502 };
 503 VLIB_NODE_FUNCTION_MULTIARCH (vxlan6_input_node, vxlan6_input)
 504 /* *INDENT-ON* */
 505
 506 typedef enum
 507 {
 508   IP_VXLAN_BYPASS_NEXT_DROP,
 509   IP_VXLAN_BYPASS_NEXT_VXLAN,
 510   IP_VXLAN_BYPASS_N_NEXT,
 511 } ip_vxan_bypass_next_t;
 512
 513 always_inline uword
 514 ip_vxlan_bypass_inline (vlib_main_t * vm,
 515                         vlib_node_runtime_t * node,
 516                         vlib_frame_t * frame, u32 is_ip4)
 517 {
 518   vxlan_main_t *vxm = &vxlan_main;
 519   u32 *from, *to_next, n_left_from, n_left_to_next, next_index;
 520   vlib_node_runtime_t *error_node =
 521     vlib_node_get_runtime (vm, ip4_input_node.index);
 522   ip4_address_t addr4;          /* last IPv4 address matching a local VTEP address */
 523   ip6_address_t addr6;          /* last IPv6 address matching a local VTEP address */
 524
 525   from = vlib_frame_vector_args (frame);
 526   n_left_from = frame->n_vectors;
 527   next_index = node->cached_next_index;
 528
 529   if (node->flags & VLIB_NODE_FLAG_TRACE)
 530     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 531
 532   if (is_ip4)
 533     addr4.data_u32 = ~0;
 534   else
 535     ip6_address_set_zero (&addr6);
 536
 537   while (n_left_from > 0)
 538     {
 539       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 540
 541       while (n_left_from >= 4 && n_left_to_next >= 2)
 542         {
 543           vlib_buffer_t *b0, *b1;
 544           ip4_header_t *ip40, *ip41;
 545           ip6_header_t *ip60, *ip61;
 546           udp_header_t *udp0, *udp1;
 547           u32 bi0, ip_len0, udp_len0, flags0, next0;
 548           u32 bi1, ip_len1, udp_len1, flags1, next1;
 549           i32 len_diff0, len_diff1;
 550           u8 error0, good_udp0, proto0;
 551           u8 error1, good_udp1, proto1;
 552
 553           /* Prefetch next iteration. */
 554           {
 555             vlib_buffer_t *p2, *p3;
 556
 557             p2 = vlib_get_buffer (vm, from[2]);
 558             p3 = vlib_get_buffer (vm, from[3]);
 559
 560             vlib_prefetch_buffer_header (p2, LOAD);
 561             vlib_prefetch_buffer_header (p3, LOAD);
 562
 563             CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 564             CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
 565           }
 566
 567           bi0 = to_next[0] = from[0];
 568           bi1 = to_next[1] = from[1];
 569           from += 2;
 570           n_left_from -= 2;
 571           to_next += 2;
 572           n_left_to_next -= 2;
 573
 574           b0 = vlib_get_buffer (vm, bi0);
 575           b1 = vlib_get_buffer (vm, bi1);
 576           if (is_ip4)
 577             {
 578               ip40 = vlib_buffer_get_current (b0);
 579               ip41 = vlib_buffer_get_current (b1);
 580             }
 581           else
 582             {
 583               ip60 = vlib_buffer_get_current (b0);
 584               ip61 = vlib_buffer_get_current (b1);
 585             }
 586
 587           /* Setup packet for next IP feature */
 588           vnet_feature_next (&next0, b0);
 589           vnet_feature_next (&next1, b1);
 590
 591           if (is_ip4)
 592             {
 593               /* Treat IP frag packets as "experimental" protocol for now
 594                  until support of IP frag reassembly is implemented */
 595               proto0 = ip4_is_fragment (ip40) ? 0xfe : ip40->protocol;
 596               proto1 = ip4_is_fragment (ip41) ? 0xfe : ip41->protocol;
 597             }
 598           else
 599             {
 600               proto0 = ip60->protocol;
 601               proto1 = ip61->protocol;
 602             }
 603
 604           /* Process packet 0 */
 605           if (proto0 != IP_PROTOCOL_UDP)
 606             goto exit0;         /* not UDP packet */
 607
 608           if (is_ip4)
 609             udp0 = ip4_next_header (ip40);
 610           else
 611             udp0 = ip6_next_header (ip60);
 612
 613           if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
 614             goto exit0;         /* not VXLAN packet */
 615
 616           /* Validate DIP against VTEPs */
 617           if (is_ip4)
 618             {
 619               if (addr4.as_u32 != ip40->dst_address.as_u32)
 620                 {
 621                   if (!hash_get (vxm->vtep4, ip40->dst_address.as_u32))
 622                     goto exit0; /* no local VTEP for VXLAN packet */
 623                   addr4 = ip40->dst_address;
 624                 }
 625             }
 626           else
 627             {
 628               if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
 629                 {
 630                   if (!hash_get_mem (vxm->vtep6, &ip60->dst_address))
 631                     goto exit0; /* no local VTEP for VXLAN packet */
 632                   addr6 = ip60->dst_address;
 633                 }
 634             }
 635
 636           flags0 = b0->flags;
 637           good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 638
 639           /* Don't verify UDP checksum for packets with explicit zero checksum. */
 640           good_udp0 |= udp0->checksum == 0;
 641
 642           /* Verify UDP length */
 643           if (is_ip4)
 644             ip_len0 = clib_net_to_host_u16 (ip40->length);
 645           else
 646             ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
 647           udp_len0 = clib_net_to_host_u16 (udp0->length);
 648           len_diff0 = ip_len0 - udp_len0;
 649
 650           /* Verify UDP checksum */
 651           if (PREDICT_FALSE (!good_udp0))
 652             {
 653               if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
 654                 {
 655                   if (is_ip4)
 656                     flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
 657                   else
 658                     flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
 659                   good_udp0 =
 660                     (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 661                 }
 662             }
 663
 664           if (is_ip4)
 665             {
 666               error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
 667               error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
 668             }
 669           else
 670             {
 671               error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
 672               error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
 673             }
 674
 675           next0 = error0 ?
 676             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
 677           b0->error = error0 ? error_node->errors[error0] : 0;
 678
 679           /* vxlan-input node expect current at VXLAN header */
 680           if (is_ip4)
 681             vlib_buffer_advance (b0,
 682                                  sizeof (ip4_header_t) +
 683                                  sizeof (udp_header_t));
 684           else
 685             vlib_buffer_advance (b0,
 686                                  sizeof (ip6_header_t) +
 687                                  sizeof (udp_header_t));
 688
 689         exit0:
 690           /* Process packet 1 */
 691           if (proto1 != IP_PROTOCOL_UDP)
 692             goto exit1;         /* not UDP packet */
 693
 694           if (is_ip4)
 695             udp1 = ip4_next_header (ip41);
 696           else
 697             udp1 = ip6_next_header (ip61);
 698
 699           if (udp1->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
 700             goto exit1;         /* not VXLAN packet */
 701
 702           /* Validate DIP against VTEPs */
 703           if (is_ip4)
 704             {
 705               if (addr4.as_u32 != ip41->dst_address.as_u32)
 706                 {
 707                   if (!hash_get (vxm->vtep4, ip41->dst_address.as_u32))
 708                     goto exit1; /* no local VTEP for VXLAN packet */
 709                   addr4 = ip41->dst_address;
 710                 }
 711             }
 712           else
 713             {
 714               if (!ip6_address_is_equal (&addr6, &ip61->dst_address))
 715                 {
 716                   if (!hash_get_mem (vxm->vtep6, &ip61->dst_address))
 717                     goto exit1; /* no local VTEP for VXLAN packet */
 718                   addr6 = ip61->dst_address;
 719                 }
 720             }
 721
 722           flags1 = b1->flags;
 723           good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 724
 725           /* Don't verify UDP checksum for packets with explicit zero checksum. */
 726           good_udp1 |= udp1->checksum == 0;
 727
 728           /* Verify UDP length */
 729           if (is_ip4)
 730             ip_len1 = clib_net_to_host_u16 (ip41->length);
 731           else
 732             ip_len1 = clib_net_to_host_u16 (ip61->payload_length);
 733           udp_len1 = clib_net_to_host_u16 (udp1->length);
 734           len_diff1 = ip_len1 - udp_len1;
 735
 736           /* Verify UDP checksum */
 737           if (PREDICT_FALSE (!good_udp1))
 738             {
 739               if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
 740                 {
 741                   if (is_ip4)
 742                     flags1 = ip4_tcp_udp_validate_checksum (vm, b1);
 743                   else
 744                     flags1 = ip6_tcp_udp_icmp_validate_checksum (vm, b1);
 745                   good_udp1 =
 746                     (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 747                 }
 748             }
 749
 750           if (is_ip4)
 751             {
 752               error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
 753               error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
 754             }
 755           else
 756             {
 757               error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
 758               error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
 759             }
 760
 761           next1 = error1 ?
 762             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
 763           b1->error = error1 ? error_node->errors[error1] : 0;
 764
 765           /* vxlan-input node expect current at VXLAN header */
 766           if (is_ip4)
 767             vlib_buffer_advance (b1,
 768                                  sizeof (ip4_header_t) +
 769                                  sizeof (udp_header_t));
 770           else
 771             vlib_buffer_advance (b1,
 772                                  sizeof (ip6_header_t) +
 773                                  sizeof (udp_header_t));
 774
 775         exit1:
 776           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 777                                            to_next, n_left_to_next,
 778                                            bi0, bi1, next0, next1);
 779         }
 780
 781       while (n_left_from > 0 && n_left_to_next > 0)
 782         {
 783           vlib_buffer_t *b0;
 784           ip4_header_t *ip40;
 785           ip6_header_t *ip60;
 786           udp_header_t *udp0;
 787           u32 bi0, ip_len0, udp_len0, flags0, next0;
 788           i32 len_diff0;
 789           u8 error0, good_udp0, proto0;
 790
 791           bi0 = to_next[0] = from[0];
 792           from += 1;
 793           n_left_from -= 1;
 794           to_next += 1;
 795           n_left_to_next -= 1;
 796
 797           b0 = vlib_get_buffer (vm, bi0);
 798           if (is_ip4)
 799             ip40 = vlib_buffer_get_current (b0);
 800           else
 801             ip60 = vlib_buffer_get_current (b0);
 802
 803           /* Setup packet for next IP feature */
 804           vnet_feature_next (&next0, b0);
 805
 806           if (is_ip4)
 807             /* Treat IP4 frag packets as "experimental" protocol for now
 808                until support of IP frag reassembly is implemented */
 809             proto0 = ip4_is_fragment (ip40) ? 0xfe : ip40->protocol;
 810           else
 811             proto0 = ip60->protocol;
 812
 813           if (proto0 != IP_PROTOCOL_UDP)
 814             goto exit;          /* not UDP packet */
 815
 816           if (is_ip4)
 817             udp0 = ip4_next_header (ip40);
 818           else
 819             udp0 = ip6_next_header (ip60);
 820
 821           if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_vxlan))
 822             goto exit;          /* not VXLAN packet */
 823
 824           /* Validate DIP against VTEPs */
 825           if (is_ip4)
 826             {
 827               if (addr4.as_u32 != ip40->dst_address.as_u32)
 828                 {
 829                   if (!hash_get (vxm->vtep4, ip40->dst_address.as_u32))
 830                     goto exit;  /* no local VTEP for VXLAN packet */
 831                   addr4 = ip40->dst_address;
 832                 }
 833             }
 834           else
 835             {
 836               if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
 837                 {
 838                   if (!hash_get_mem (vxm->vtep6, &ip60->dst_address))
 839                     goto exit;  /* no local VTEP for VXLAN packet */
 840                   addr6 = ip60->dst_address;
 841                 }
 842             }
 843
 844           flags0 = b0->flags;
 845           good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 846
 847           /* Don't verify UDP checksum for packets with explicit zero checksum. */
 848           good_udp0 |= udp0->checksum == 0;
 849
 850           /* Verify UDP length */
 851           if (is_ip4)
 852             ip_len0 = clib_net_to_host_u16 (ip40->length);
 853           else
 854             ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
 855           udp_len0 = clib_net_to_host_u16 (udp0->length);
 856           len_diff0 = ip_len0 - udp_len0;
 857
 858           /* Verify UDP checksum */
 859           if (PREDICT_FALSE (!good_udp0))
 860             {
 861               if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
 862                 {
 863                   if (is_ip4)
 864                     flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
 865                   else
 866                     flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
 867                   good_udp0 =
 868                     (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
 869                 }
 870             }
 871
 872           if (is_ip4)
 873             {
 874               error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
 875               error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
 876             }
 877           else
 878             {
 879               error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
 880               error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
 881             }
 882
 883           next0 = error0 ?
 884             IP_VXLAN_BYPASS_NEXT_DROP : IP_VXLAN_BYPASS_NEXT_VXLAN;
 885           b0->error = error0 ? error_node->errors[error0] : 0;
 886
 887           /* vxlan-input node expect current at VXLAN header */
 888           if (is_ip4)
 889             vlib_buffer_advance (b0,
 890                                  sizeof (ip4_header_t) +
 891                                  sizeof (udp_header_t));
 892           else
 893             vlib_buffer_advance (b0,
 894                                  sizeof (ip6_header_t) +
 895                                  sizeof (udp_header_t));
 896
 897         exit:
 898           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 899                                            to_next, n_left_to_next,
 900                                            bi0, next0);
 901         }
 902
 903       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 904     }
 905
 906   return frame->n_vectors;
 907 }
 908
 909 static uword
 910 ip4_vxlan_bypass (vlib_main_t * vm,
 911                   vlib_node_runtime_t * node, vlib_frame_t * frame)
 912 {
 913   return ip_vxlan_bypass_inline (vm, node, frame, /* is_ip4 */ 1);
 914 }
 915
 916 /* *INDENT-OFF* */
 917 VLIB_REGISTER_NODE (ip4_vxlan_bypass_node) =
 918 {
 919   .function = ip4_vxlan_bypass,
 920   .name = "ip4-vxlan-bypass",
 921   .vector_size = sizeof (u32),
 922   .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
 923   .next_nodes = {
 924           [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
 925           [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan4-input",
 926   },
 927   .format_buffer = format_ip4_header,
 928   .format_trace = format_ip4_forward_next_trace,
 929 };
 930
 931 VLIB_NODE_FUNCTION_MULTIARCH (ip4_vxlan_bypass_node, ip4_vxlan_bypass)
 932 /* *INDENT-ON* */
 933
 934 /* Dummy init function to get us linked in. */
 935 clib_error_t *
 936 ip4_vxlan_bypass_init (vlib_main_t * vm)
 937 {
 938   return 0;
 939 }
 940
 941 VLIB_INIT_FUNCTION (ip4_vxlan_bypass_init);
 942
 943 static uword
 944 ip6_vxlan_bypass (vlib_main_t * vm,
 945                   vlib_node_runtime_t * node, vlib_frame_t * frame)
 946 {
 947   return ip_vxlan_bypass_inline (vm, node, frame, /* is_ip4 */ 0);
 948 }
 949
 950 /* *INDENT-OFF* */
 951 VLIB_REGISTER_NODE (ip6_vxlan_bypass_node) =
 952 {
 953   .function = ip6_vxlan_bypass,
 954   .name = "ip6-vxlan-bypass",
 955   .vector_size = sizeof (u32),
 956   .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
 957   .next_nodes = {
 958     [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
 959     [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan6-input",
 960   },
 961   .format_buffer = format_ip6_header,
 962   .format_trace = format_ip6_forward_next_trace,
 963 };
 964
 965 VLIB_NODE_FUNCTION_MULTIARCH (ip6_vxlan_bypass_node, ip6_vxlan_bypass)
 966 /* *INDENT-ON* */
 967
 968 /* Dummy init function to get us linked in. */
 969 clib_error_t *
 970 ip6_vxlan_bypass_init (vlib_main_t * vm)
 971 {
 972   return 0;
 973 }
 974
 975 VLIB_INIT_FUNCTION (ip6_vxlan_bypass_init);
 976
 977 #define foreach_vxlan_flow_input_next        \
 978 _(DROP, "error-drop")                           \
 979 _(L2_INPUT, "l2-input")
 980
 981 typedef enum
 982 {
 983 #define _(s,n) VXLAN_FLOW_NEXT_##s,
 984   foreach_vxlan_flow_input_next
 985 #undef _
 986     VXLAN_FLOW_N_NEXT,
 987 } vxlan_flow_input_next_t;
 988
 989 #define foreach_vxlan_flow_error                                        \
 990   _(NONE, "no error")                                                   \
 991   _(IP_CHECKSUM_ERROR, "Rx ip checksum errors")                         \
 992   _(IP_HEADER_ERROR, "Rx ip header errors")                             \
 993   _(UDP_CHECKSUM_ERROR, "Rx udp checksum errors")                               \
 994   _(UDP_LENGTH_ERROR, "Rx udp length errors")
 995
 996 typedef enum
 997 {
 998 #define _(f,s) VXLAN_FLOW_ERROR_##f,
 999   foreach_vxlan_flow_error
1000 #undef _
1001     VXLAN_FLOW_N_ERROR,
1002 } vxlan_flow_error_t;
1003
1004 static char *vxlan_flow_error_strings[] = {
1005 #define _(n,s) s,
1006   foreach_vxlan_flow_error
1007 #undef _
1008 };
1009
1010
1011 static_always_inline u8
1012 vxlan_validate_udp_csum (vlib_main_t * vm, vlib_buffer_t * b)
1013 {
1014   u32 flags = b->flags;
1015   enum
1016   { offset =
1017       sizeof (ip4_header_t) + sizeof (udp_header_t) + sizeof (vxlan_header_t),
1018   };
1019
1020   /* Verify UDP checksum */
1021   if ((flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
1022     {
1023       vlib_buffer_advance (b, -offset);
1024       flags = ip4_tcp_udp_validate_checksum (vm, b);
1025       vlib_buffer_advance (b, offset);
1026     }
1027
1028   return (flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1029 }
1030
1031 static_always_inline u8
1032 vxlan_check_udp_csum (vlib_main_t * vm, vlib_buffer_t * b)
1033 {
1034   ip4_vxlan_header_t *hdr = vlib_buffer_get_current (b) - sizeof *hdr;
1035   udp_header_t *udp = &hdr->udp;
1036   /* Don't verify UDP checksum for packets with explicit zero checksum. */
1037   u8 good_csum = (b->flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0 ||
1038     udp->checksum == 0;
1039
1040   return !good_csum;
1041 }
1042
1043 static_always_inline u8
1044 vxlan_check_ip (vlib_buffer_t * b, u16 payload_len)
1045 {
1046   ip4_vxlan_header_t *hdr = vlib_buffer_get_current (b) - sizeof *hdr;
1047   u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
1048   u16 expected = payload_len + sizeof *hdr;
1049   return ip_len > expected || hdr->ip4.ttl == 0
1050     || hdr->ip4.ip_version_and_header_length != 0x45;
1051 }
1052
1053 static_always_inline u8
1054 vxlan_check_ip_udp_len (vlib_buffer_t * b)
1055 {
1056   ip4_vxlan_header_t *hdr = vlib_buffer_get_current (b) - sizeof *hdr;
1057   u16 ip_len = clib_net_to_host_u16 (hdr->ip4.length);
1058   u16 udp_len = clib_net_to_host_u16 (hdr->udp.length);
1059   return udp_len > ip_len;
1060 }
1061
1062 static_always_inline u8
1063 vxlan_err_code (u8 ip_err0, u8 udp_err0, u8 csum_err0)
1064 {
1065   u8 error0 = VXLAN_FLOW_ERROR_NONE;
1066   if (ip_err0)
1067     error0 = VXLAN_FLOW_ERROR_IP_HEADER_ERROR;
1068   if (udp_err0)
1069     error0 = VXLAN_FLOW_ERROR_UDP_LENGTH_ERROR;
1070   if (csum_err0)
1071     error0 = VXLAN_FLOW_ERROR_UDP_CHECKSUM_ERROR;
1072   return error0;
1073 }
1074
1075 VLIB_NODE_FN (vxlan4_flow_input_node) (vlib_main_t * vm,
1076                                        vlib_node_runtime_t * node,
1077                                        vlib_frame_t * f)
1078 {
1079   enum
1080   { payload_offset = sizeof (ip4_vxlan_header_t) };
1081
1082   vxlan_main_t *vxm = &vxlan_main;
1083   vnet_interface_main_t *im = &vnet_main.interface_main;
1084   vlib_combined_counter_main_t *rx_counter[VXLAN_FLOW_N_NEXT] = {
1085     [VXLAN_FLOW_NEXT_DROP] =
1086       im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_DROP,
1087     [VXLAN_FLOW_NEXT_L2_INPUT] =
1088       im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX,
1089   };
1090   u32 thread_index = vlib_get_thread_index ();
1091
1092   u32 *from = vlib_frame_vector_args (f);
1093   u32 n_left_from = f->n_vectors;
1094   u32 next_index = VXLAN_FLOW_NEXT_L2_INPUT;
1095
1096   while (n_left_from > 0)
1097     {
1098       u32 n_left_to_next, *to_next;
1099
1100       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1101
1102       while (n_left_from > 3 && n_left_to_next > 3)
1103         {
1104           u32 bi0 = to_next[0] = from[0];
1105           u32 bi1 = to_next[1] = from[1];
1106           u32 bi2 = to_next[2] = from[2];
1107           u32 bi3 = to_next[3] = from[3];
1108           from += 4;
1109           n_left_from -= 4;
1110           to_next += 4;
1111           n_left_to_next -= 4;
1112
1113           vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
1114           vlib_buffer_t *b1 = vlib_get_buffer (vm, bi1);
1115           vlib_buffer_t *b2 = vlib_get_buffer (vm, bi2);
1116           vlib_buffer_t *b3 = vlib_get_buffer (vm, bi3);
1117
1118           vlib_buffer_advance (b0, payload_offset);
1119           vlib_buffer_advance (b1, payload_offset);
1120           vlib_buffer_advance (b2, payload_offset);
1121           vlib_buffer_advance (b3, payload_offset);
1122
1123           u16 len0 = vlib_buffer_length_in_chain (vm, b0);
1124           u16 len1 = vlib_buffer_length_in_chain (vm, b1);
1125           u16 len2 = vlib_buffer_length_in_chain (vm, b2);
1126           u16 len3 = vlib_buffer_length_in_chain (vm, b3);
1127
1128           u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT, next1 =
1129             VXLAN_FLOW_NEXT_L2_INPUT, next2 =
1130             VXLAN_FLOW_NEXT_L2_INPUT, next3 = VXLAN_FLOW_NEXT_L2_INPUT;
1131
1132           u8 ip_err0 = vxlan_check_ip (b0, len0);
1133           u8 ip_err1 = vxlan_check_ip (b1, len1);
1134           u8 ip_err2 = vxlan_check_ip (b2, len2);
1135           u8 ip_err3 = vxlan_check_ip (b3, len3);
1136           u8 ip_err = ip_err0 | ip_err1 | ip_err2 | ip_err3;
1137
1138           u8 udp_err0 = vxlan_check_ip_udp_len (b0);
1139           u8 udp_err1 = vxlan_check_ip_udp_len (b1);
1140           u8 udp_err2 = vxlan_check_ip_udp_len (b2);
1141           u8 udp_err3 = vxlan_check_ip_udp_len (b3);
1142           u8 udp_err = udp_err0 | udp_err1 | udp_err2 | udp_err3;
1143
1144           u8 csum_err0 = vxlan_check_udp_csum (vm, b0);
1145           u8 csum_err1 = vxlan_check_udp_csum (vm, b1);
1146           u8 csum_err2 = vxlan_check_udp_csum (vm, b2);
1147           u8 csum_err3 = vxlan_check_udp_csum (vm, b3);
1148           u8 csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1149
1150           if (PREDICT_FALSE (csum_err))
1151             {
1152               if (csum_err0)
1153                 csum_err0 = !vxlan_validate_udp_csum (vm, b0);
1154               if (csum_err1)
1155                 csum_err1 = !vxlan_validate_udp_csum (vm, b1);
1156               if (csum_err2)
1157                 csum_err2 = !vxlan_validate_udp_csum (vm, b2);
1158               if (csum_err3)
1159                 csum_err3 = !vxlan_validate_udp_csum (vm, b3);
1160               csum_err = csum_err0 | csum_err1 | csum_err2 | csum_err3;
1161             }
1162
1163           if (PREDICT_FALSE (ip_err || udp_err || csum_err))
1164             {
1165               if (ip_err0 || udp_err0 || csum_err0)
1166                 {
1167                   next0 = VXLAN_FLOW_NEXT_DROP;
1168                   u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
1169                   b0->error = node->errors[error0];
1170                 }
1171               if (ip_err1 || udp_err1 || csum_err1)
1172                 {
1173                   next1 = VXLAN_FLOW_NEXT_DROP;
1174                   u8 error1 = vxlan_err_code (ip_err1, udp_err1, csum_err1);
1175                   b1->error = node->errors[error1];
1176                 }
1177               if (ip_err2 || udp_err2 || csum_err2)
1178                 {
1179                   next2 = VXLAN_FLOW_NEXT_DROP;
1180                   u8 error2 = vxlan_err_code (ip_err2, udp_err2, csum_err2);
1181                   b2->error = node->errors[error2];
1182                 }
1183               if (ip_err3 || udp_err3 || csum_err3)
1184                 {
1185                   next3 = VXLAN_FLOW_NEXT_DROP;
1186                   u8 error3 = vxlan_err_code (ip_err3, udp_err3, csum_err3);
1187                   b3->error = node->errors[error3];
1188                 }
1189             }
1190
1191           vnet_update_l2_len (b0);
1192           vnet_update_l2_len (b1);
1193           vnet_update_l2_len (b2);
1194           vnet_update_l2_len (b3);
1195
1196           ASSERT (b0->flow_id != 0);
1197           ASSERT (b1->flow_id != 0);
1198           ASSERT (b2->flow_id != 0);
1199           ASSERT (b3->flow_id != 0);
1200
1201           u32 t_index0 = b0->flow_id - vxm->flow_id_start;
1202           u32 t_index1 = b1->flow_id - vxm->flow_id_start;
1203           u32 t_index2 = b2->flow_id - vxm->flow_id_start;
1204           u32 t_index3 = b3->flow_id - vxm->flow_id_start;
1205
1206           vxlan_tunnel_t *t0 = &vxm->tunnels[t_index0];
1207           vxlan_tunnel_t *t1 = &vxm->tunnels[t_index1];
1208           vxlan_tunnel_t *t2 = &vxm->tunnels[t_index2];
1209           vxlan_tunnel_t *t3 = &vxm->tunnels[t_index3];
1210
1211           /* flow id consumed */
1212           b0->flow_id = 0;
1213           b1->flow_id = 0;
1214           b2->flow_id = 0;
1215           b3->flow_id = 0;
1216
1217           u32 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX] =
1218             t0->sw_if_index;
1219           u32 sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX] =
1220             t1->sw_if_index;
1221           u32 sw_if_index2 = vnet_buffer (b2)->sw_if_index[VLIB_RX] =
1222             t2->sw_if_index;
1223           u32 sw_if_index3 = vnet_buffer (b3)->sw_if_index[VLIB_RX] =
1224             t3->sw_if_index;
1225
1226           vlib_increment_combined_counter (rx_counter[next0], thread_index,
1227                                            sw_if_index0, 1, len0);
1228           vlib_increment_combined_counter (rx_counter[next1], thread_index,
1229                                            sw_if_index1, 1, len1);
1230           vlib_increment_combined_counter (rx_counter[next2], thread_index,
1231                                            sw_if_index2, 1, len2);
1232           vlib_increment_combined_counter (rx_counter[next3], thread_index,
1233                                            sw_if_index3, 1, len3);
1234
1235           u32 flags = b0->flags | b1->flags | b2->flags | b3->flags;
1236
1237           if (PREDICT_FALSE (flags & VLIB_BUFFER_IS_TRACED))
1238             {
1239               if (b0->flags & VLIB_BUFFER_IS_TRACED)
1240                 {
1241                   vxlan_rx_trace_t *tr =
1242                     vlib_add_trace (vm, node, b0, sizeof *tr);
1243                   u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
1244                   tr->next_index = next0;
1245                   tr->error = error0;
1246                   tr->tunnel_index = t_index0;
1247                   tr->vni = t0->vni;
1248                 }
1249               if (b1->flags & VLIB_BUFFER_IS_TRACED)
1250                 {
1251                   vxlan_rx_trace_t *tr =
1252                     vlib_add_trace (vm, node, b1, sizeof *tr);
1253                   u8 error1 = vxlan_err_code (ip_err1, udp_err1, csum_err1);
1254                   tr->next_index = next1;
1255                   tr->error = error1;
1256                   tr->tunnel_index = t_index1;
1257                   tr->vni = t1->vni;
1258                 }
1259               if (b2->flags & VLIB_BUFFER_IS_TRACED)
1260                 {
1261                   vxlan_rx_trace_t *tr =
1262                     vlib_add_trace (vm, node, b2, sizeof *tr);
1263                   u8 error2 = vxlan_err_code (ip_err2, udp_err2, csum_err2);
1264                   tr->next_index = next2;
1265                   tr->error = error2;
1266                   tr->tunnel_index = t_index2;
1267                   tr->vni = t2->vni;
1268                 }
1269               if (b3->flags & VLIB_BUFFER_IS_TRACED)
1270                 {
1271                   vxlan_rx_trace_t *tr =
1272                     vlib_add_trace (vm, node, b3, sizeof *tr);
1273                   u8 error3 = vxlan_err_code (ip_err3, udp_err3, csum_err3);
1274                   tr->next_index = next3;
1275                   tr->error = error3;
1276                   tr->tunnel_index = t_index3;
1277                   tr->vni = t3->vni;
1278                 }
1279             }
1280           vlib_validate_buffer_enqueue_x4
1281             (vm, node, next_index, to_next, n_left_to_next,
1282              bi0, bi1, bi2, bi3, next0, next1, next2, next3);
1283         }
1284       while (n_left_from > 0 && n_left_to_next > 0)
1285         {
1286           u32 bi0 = to_next[0] = from[0];
1287           from++;
1288           n_left_from--;
1289           to_next++;
1290           n_left_to_next--;
1291
1292           vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
1293           vlib_buffer_advance (b0, payload_offset);
1294
1295           u16 len0 = vlib_buffer_length_in_chain (vm, b0);
1296           u32 next0 = VXLAN_FLOW_NEXT_L2_INPUT;
1297
1298           u8 ip_err0 = vxlan_check_ip (b0, len0);
1299           u8 udp_err0 = vxlan_check_ip_udp_len (b0);
1300           u8 csum_err0 = vxlan_check_udp_csum (vm, b0);
1301
1302           if (csum_err0)
1303             csum_err0 = !vxlan_validate_udp_csum (vm, b0);
1304           if (ip_err0 || udp_err0 || csum_err0)
1305             {
1306               next0 = VXLAN_FLOW_NEXT_DROP;
1307               u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
1308               b0->error = node->errors[error0];
1309             }
1310
1311           vnet_update_l2_len (b0);
1312
1313           ASSERT (b0->flow_id != 0);
1314           u32 t_index0 = b0->flow_id - vxm->flow_id_start;
1315           vxlan_tunnel_t *t0 = &vxm->tunnels[t_index0];
1316           b0->flow_id = 0;
1317
1318           u32 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX] =
1319             t0->sw_if_index;
1320           vlib_increment_combined_counter (rx_counter[next0], thread_index,
1321                                            sw_if_index0, 1, len0);
1322
1323           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1324             {
1325               vxlan_rx_trace_t *tr =
1326                 vlib_add_trace (vm, node, b0, sizeof *tr);
1327               u8 error0 = vxlan_err_code (ip_err0, udp_err0, csum_err0);
1328               tr->next_index = next0;
1329               tr->error = error0;
1330               tr->tunnel_index = t_index0;
1331               tr->vni = t0->vni;
1332             }
1333           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1334                                            to_next, n_left_to_next,
1335                                            bi0, next0);
1336         }
1337
1338       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1339     }
1340
1341   return f->n_vectors;
1342 }
1343
1344 /* *INDENT-OFF* */
1345 #ifndef CLIB_MULTIARCH_VARIANT
1346 VLIB_REGISTER_NODE (vxlan4_flow_input_node) = {
1347   .name = "vxlan-flow-input",
1348   .type = VLIB_NODE_TYPE_INTERNAL,
1349   .vector_size = sizeof (u32),
1350
1351   .format_trace = format_vxlan_rx_trace,
1352
1353   .n_errors = VXLAN_FLOW_N_ERROR,
1354   .error_strings = vxlan_flow_error_strings,
1355
1356   .n_next_nodes = VXLAN_FLOW_N_NEXT,
1357   .next_nodes = {
1358 #define _(s,n) [VXLAN_FLOW_NEXT_##s] = n,
1359     foreach_vxlan_flow_input_next
1360 #undef _
1361   },
1362 };
1363 #endif
1364 /* *INDENT-ON* */
1365
1366 /*
1367  * fd.io coding-style-patch-verification: ON
1368  *
1369  * Local Variables:
1370  * eval: (c-set-style "gnu")
1371  * End:
1372  */