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/pg/pg.h>
  25 #include <vnet/vxlan-gpe/vxlan_gpe.h>
  26
  27 vlib_node_registration_t vxlan_gpe_input_node;
  28
  29 /**
  30  * @brief Struct for VXLAN GPE decap packet tracing
  31  *
  32  */
  33 typedef struct {
  34   u32 next_index;
  35   u32 tunnel_index;
  36   u32 error;
  37 } vxlan_gpe_rx_trace_t;
  38
  39 /**
  40  * @brief Tracing function for VXLAN GPE packet decapsulation
  41  *
  42  * @param *s
  43  * @param *args
  44  *
  45  * @return *s
  46  *
  47  */
  48 static u8 * 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 * format_vxlan_gpe_with_length (u8 * s, va_list * args)
  77 {
  78   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  79   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  80
  81
  82   return s;
  83 }
  84
  85 /**
  86  * @brief Common processing for IPv4 and IPv6 VXLAN GPE decap dispatch functions
  87  *
  88  * It is worth noting that other than trivial UDP forwarding (transit), VXLAN GPE
  89  * tunnels are "terminate local". This means that there is no "TX" interface for this
  90  * decap case, so that field in the buffer_metadata can be "used for something else".
  91  * The something else in this case is, for the IPv4/IPv6 inner-packet type case, the
  92  * FIB index used to look up the inner-packet's adjacency.
  93  *
  94  *      vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
  95  *
  96  * @param *vm
  97  * @param *node
  98  * @param *from_frame
  99  * @param is_ip4
 100  *
 101  * @return from_frame->n_vectors
 102  *
 103  */
 104 always_inline uword
 105 vxlan_gpe_input (vlib_main_t * vm,
 106                      vlib_node_runtime_t * node,
 107                      vlib_frame_t * from_frame,
 108                                          u8 is_ip4)
 109 {
 110   u32 n_left_from, next_index, *from, *to_next;
 111   vxlan_gpe_main_t * ngm = &vxlan_gpe_main;
 112   vnet_main_t * vnm = ngm->vnet_main;
 113   vnet_interface_main_t * im = &vnm->interface_main;
 114   u32 last_tunnel_index = ~0;
 115   vxlan4_gpe_tunnel_key_t last_key4;
 116   vxlan6_gpe_tunnel_key_t last_key6;
 117   u32 pkts_decapsulated = 0;
 118   u32 cpu_index = os_get_cpu_number ();
 119   u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
 120
 121   if (is_ip4)
 122       memset (&last_key4, 0xff, sizeof(last_key4));
 123   else
 124       memset (&last_key6, 0xff, sizeof(last_key6));
 125
 126   from = vlib_frame_vector_args (from_frame);
 127   n_left_from = from_frame->n_vectors;
 128
 129   next_index = node->cached_next_index;
 130   stats_sw_if_index = node->runtime_data[0];
 131   stats_n_packets = stats_n_bytes = 0;
 132
 133   while (n_left_from > 0)
 134   {
 135     u32 n_left_to_next;
 136
 137     vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
 138
 139     while (n_left_from >= 4 && n_left_to_next >= 2)
 140     {
 141       u32 bi0, bi1;
 142       vlib_buffer_t * b0, *b1;
 143       u32 next0, next1;
 144       ip4_vxlan_gpe_header_t * iuvn4_0, *iuvn4_1;
 145       ip6_vxlan_gpe_header_t * iuvn6_0, *iuvn6_1;
 146       uword * p0, *p1;
 147       u32 tunnel_index0, tunnel_index1;
 148       vxlan_gpe_tunnel_t * t0, *t1;
 149       vxlan4_gpe_tunnel_key_t key4_0, key4_1;
 150       vxlan6_gpe_tunnel_key_t key6_0, key6_1;
 151       u32 error0, error1;
 152       u32 sw_if_index0, sw_if_index1, len0, len1;
 153
 154       /* Prefetch next iteration. */
 155       {
 156         vlib_buffer_t * p2, *p3;
 157
 158         p2 = vlib_get_buffer (vm, from[2]);
 159         p3 = vlib_get_buffer (vm, from[3]);
 160
 161         vlib_prefetch_buffer_header(p2, LOAD);
 162         vlib_prefetch_buffer_header(p3, LOAD);
 163
 164         CLIB_PREFETCH(p2->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 165         CLIB_PREFETCH(p3->data, 2*CLIB_CACHE_LINE_BYTES, LOAD);
 166       }
 167
 168       bi0 = from[0];
 169       bi1 = from[1];
 170       to_next[0] = bi0;
 171       to_next[1] = bi1;
 172       from += 2;
 173       to_next += 2;
 174       n_left_to_next -= 2;
 175       n_left_from -= 2;
 176
 177       b0 = vlib_get_buffer (vm, bi0);
 178       b1 = vlib_get_buffer (vm, bi1);
 179
 180       if (is_ip4)
 181       {
 182         /* udp leaves current_data pointing at the vxlan-gpe header */
 183         vlib_buffer_advance (b0, -(word) (sizeof(udp_header_t) + sizeof(ip4_header_t)));
 184         vlib_buffer_advance (b1, -(word) (sizeof(udp_header_t) + sizeof(ip4_header_t)));
 185
 186         iuvn4_0 = vlib_buffer_get_current (b0);
 187         iuvn4_1 = vlib_buffer_get_current (b1);
 188
 189         /* pop (ip, udp, vxlan) */
 190         vlib_buffer_advance (b0, sizeof(*iuvn4_0));
 191         vlib_buffer_advance (b1, sizeof(*iuvn4_1));
 192       }
 193       else
 194       {
 195         /* udp leaves current_data pointing at the vxlan-gpe header */
 196         vlib_buffer_advance (b0, -(word) (sizeof(udp_header_t) + sizeof(ip6_header_t)));
 197         vlib_buffer_advance (b1, -(word) (sizeof(udp_header_t) + sizeof(ip6_header_t)));
 198
 199         iuvn6_0 = vlib_buffer_get_current (b0);
 200         iuvn6_1 = vlib_buffer_get_current (b1);
 201
 202         /* pop (ip, udp, vxlan) */
 203         vlib_buffer_advance (b0, sizeof(*iuvn6_0));
 204         vlib_buffer_advance (b1, sizeof(*iuvn6_1));
 205       }
 206
 207       tunnel_index0 = ~0;
 208       tunnel_index1 = ~0;
 209       error0 = 0;
 210       error1 = 0;
 211
 212       if (is_ip4)
 213       {
 214         next0 =
 215             (iuvn4_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 216             ngm->decap_next_node_list[iuvn4_0->vxlan.protocol]: \
 217             VXLAN_GPE_INPUT_NEXT_DROP;
 218         next1 =
 219             (iuvn4_1->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 220             ngm->decap_next_node_list[iuvn4_1->vxlan.protocol]: \
 221             VXLAN_GPE_INPUT_NEXT_DROP;
 222
 223         key4_0.local = iuvn4_0->ip4.dst_address.as_u32;
 224         key4_1.local = iuvn4_1->ip4.dst_address.as_u32;
 225
 226         key4_0.remote = iuvn4_0->ip4.src_address.as_u32;
 227         key4_1.remote = iuvn4_1->ip4.src_address.as_u32;
 228
 229         key4_0.vni = iuvn4_0->vxlan.vni_res;
 230         key4_1.vni = iuvn4_1->vxlan.vni_res;
 231
 232         key4_0.pad = 0;
 233         key4_1.pad = 0;
 234       }
 235       else /* is_ip6 */
 236       {
 237         next0 = (iuvn6_0->vxlan.protocol < node->n_next_nodes) ?
 238                 iuvn6_0->vxlan.protocol : VXLAN_GPE_INPUT_NEXT_DROP;
 239         next1 = (iuvn6_1->vxlan.protocol < node->n_next_nodes) ?
 240                 iuvn6_1->vxlan.protocol : VXLAN_GPE_INPUT_NEXT_DROP;
 241
 242         key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
 243         key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
 244         key6_1.local.as_u64[0] = iuvn6_1->ip6.dst_address.as_u64[0];
 245         key6_1.local.as_u64[1] = iuvn6_1->ip6.dst_address.as_u64[1];
 246
 247         key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
 248         key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
 249         key6_1.remote.as_u64[0] = iuvn6_1->ip6.src_address.as_u64[0];
 250         key6_1.remote.as_u64[1] = iuvn6_1->ip6.src_address.as_u64[1];
 251
 252         key6_0.vni = iuvn6_0->vxlan.vni_res;
 253         key6_1.vni = iuvn6_1->vxlan.vni_res;
 254       }
 255
 256       /* Processing packet 0*/
 257       if (is_ip4)
 258       {
 259         /* Processing for key4_0 */
 260         if (PREDICT_FALSE((key4_0.as_u64[0] != last_key4.as_u64[0])
 261                 || (key4_0.as_u64[1] != last_key4.as_u64[1])))
 262         {
 263           p0 = hash_get_mem(ngm->vxlan4_gpe_tunnel_by_key, &key4_0);
 264
 265           if (p0 == 0)
 266           {
 267             error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 268             goto trace0;
 269           }
 270
 271           last_key4.as_u64[0] = key4_0.as_u64[0];
 272           last_key4.as_u64[1] = key4_0.as_u64[1];
 273           tunnel_index0 = last_tunnel_index = p0[0];
 274         }
 275         else
 276           tunnel_index0 = last_tunnel_index;
 277       }
 278       else /* is_ip6 */
 279       {
 280         next0 =
 281             (iuvn6_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 282             ngm->decap_next_node_list[iuvn6_0->vxlan.protocol]: \
 283             VXLAN_GPE_INPUT_NEXT_DROP;
 284         next1 =
 285             (iuvn6_1->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 286             ngm->decap_next_node_list[iuvn6_1->vxlan.protocol]: \
 287             VXLAN_GPE_INPUT_NEXT_DROP;
 288
 289         key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
 290         key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
 291         key6_1.local.as_u64[0] = iuvn6_1->ip6.dst_address.as_u64[0];
 292         key6_1.local.as_u64[1] = iuvn6_1->ip6.dst_address.as_u64[1];
 293
 294         key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
 295         key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
 296         key6_1.remote.as_u64[0] = iuvn6_1->ip6.src_address.as_u64[0];
 297         key6_1.remote.as_u64[1] = iuvn6_1->ip6.src_address.as_u64[1];
 298
 299         key6_0.vni = iuvn6_0->vxlan.vni_res;
 300         key6_1.vni = iuvn6_1->vxlan.vni_res;
 301
 302         /* Processing for key6_0 */
 303         if (PREDICT_FALSE(memcmp (&key6_0, &last_key6, sizeof(last_key6)) != 0))
 304         {
 305           p0 = hash_get_mem(ngm->vxlan6_gpe_tunnel_by_key, &key6_0);
 306
 307           if (p0 == 0)
 308           {
 309             error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 310             goto trace0;
 311           }
 312
 313           memcpy (&last_key6, &key6_0, sizeof(key6_0));
 314           tunnel_index0 = last_tunnel_index = p0[0];
 315         }
 316         else
 317           tunnel_index0 = last_tunnel_index;
 318       }
 319
 320       t0 = pool_elt_at_index(ngm->tunnels, tunnel_index0);
 321
 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       /**
 330        * ip[46] lookup in the configured FIB
 331        */
 332       vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
 333
 334       pkts_decapsulated++;
 335       stats_n_packets += 1;
 336       stats_n_bytes += len0;
 337
 338       if (PREDICT_FALSE(sw_if_index0 != stats_sw_if_index))
 339       {
 340         stats_n_packets -= 1;
 341         stats_n_bytes -= len0;
 342         if (stats_n_packets)
 343           vlib_increment_combined_counter (
 344               im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX,
 345               cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
 346         stats_n_packets = 1;
 347         stats_n_bytes = len0;
 348         stats_sw_if_index = sw_if_index0;
 349       }
 350
 351       trace0: b0->error = error0 ? node->errors[error0] : 0;
 352
 353       if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 354       {
 355         vxlan_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof(*tr));
 356         tr->next_index = next0;
 357         tr->error = error0;
 358         tr->tunnel_index = tunnel_index0;
 359       }
 360
 361       /* Process packet 1 */
 362       if (is_ip4)
 363       {
 364         /* Processing for key4_1 */
 365         if (PREDICT_FALSE(
 366             (key4_1.as_u64[0] != last_key4.as_u64[0])
 367                 || (key4_1.as_u64[1] != last_key4.as_u64[1])))
 368         {
 369           p1 = hash_get_mem(ngm->vxlan4_gpe_tunnel_by_key, &key4_1);
 370
 371           if (p1 == 0)
 372           {
 373             error1 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 374             goto trace1;
 375           }
 376
 377           last_key4.as_u64[0] = key4_1.as_u64[0];
 378           last_key4.as_u64[1] = key4_1.as_u64[1];
 379           tunnel_index1 = last_tunnel_index = p1[0];
 380         }
 381         else
 382           tunnel_index1 = last_tunnel_index;
 383       }
 384       else /* is_ip6 */
 385       {
 386         /* Processing for key6_1 */
 387         if (PREDICT_FALSE(memcmp (&key6_1, &last_key6, sizeof(last_key6)) != 0))
 388         {
 389           p1 = hash_get_mem(ngm->vxlan6_gpe_tunnel_by_key, &key6_1);
 390
 391           if (p1 == 0)
 392           {
 393             error1 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 394             goto trace1;
 395           }
 396
 397           memcpy (&last_key6, &key6_1, sizeof(key6_1));
 398           tunnel_index1 = last_tunnel_index = p1[0];
 399         }
 400         else
 401           tunnel_index1 = last_tunnel_index;
 402       }
 403
 404       t1 = pool_elt_at_index(ngm->tunnels, tunnel_index1);
 405
 406       sw_if_index1 = t1->sw_if_index;
 407       len1 = vlib_buffer_length_in_chain (vm, b1);
 408
 409       /* Required to make the l2 tag push / pop code work on l2 subifs */
 410       vnet_update_l2_len (b1);
 411
 412       /*
 413        * ip[46] lookup in the configured FIB
 414        */
 415       vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
 416
 417       pkts_decapsulated++;
 418       stats_n_packets += 1;
 419       stats_n_bytes += len1;
 420
 421       /* Batch stats increment on the same vxlan tunnel so counter
 422        is not incremented per packet */
 423       if (PREDICT_FALSE(sw_if_index1 != stats_sw_if_index))
 424       {
 425         stats_n_packets -= 1;
 426         stats_n_bytes -= len1;
 427         if (stats_n_packets)
 428           vlib_increment_combined_counter (
 429               im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX,
 430               cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
 431         stats_n_packets = 1;
 432         stats_n_bytes = len1;
 433         stats_sw_if_index = sw_if_index1;
 434       }
 435       vnet_buffer(b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
 436
 437       trace1: b1->error = error1 ? node->errors[error1] : 0;
 438
 439       if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
 440       {
 441         vxlan_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b1, sizeof(*tr));
 442         tr->next_index = next1;
 443         tr->error = error1;
 444         tr->tunnel_index = tunnel_index1;
 445       }
 446
 447       vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
 448                                       n_left_to_next, bi0, bi1, next0, next1);
 449     }
 450
 451     while (n_left_from > 0 && n_left_to_next > 0)
 452     {
 453       u32 bi0;
 454       vlib_buffer_t * b0;
 455       u32 next0;
 456       ip4_vxlan_gpe_header_t * iuvn4_0;
 457       ip6_vxlan_gpe_header_t * iuvn6_0;
 458       uword * p0;
 459       u32 tunnel_index0;
 460       vxlan_gpe_tunnel_t * t0;
 461       vxlan4_gpe_tunnel_key_t key4_0;
 462       vxlan6_gpe_tunnel_key_t key6_0;
 463       u32 error0;
 464       u32 sw_if_index0, len0;
 465
 466       bi0 = from[0];
 467       to_next[0] = bi0;
 468       from += 1;
 469       to_next += 1;
 470       n_left_from -= 1;
 471       n_left_to_next -= 1;
 472
 473       b0 = vlib_get_buffer (vm, bi0);
 474
 475       if (is_ip4)
 476       {
 477         /* udp leaves current_data pointing at the vxlan-gpe header */
 478         vlib_buffer_advance (
 479             b0, -(word) (sizeof(udp_header_t) + sizeof(ip4_header_t)));
 480
 481         iuvn4_0 = vlib_buffer_get_current (b0);
 482
 483         /* pop (ip, udp, vxlan) */
 484         vlib_buffer_advance (b0, sizeof(*iuvn4_0));
 485       }
 486       else
 487       {
 488         /* udp leaves current_data pointing at the vxlan-gpe header */
 489         vlib_buffer_advance (
 490             b0, -(word) (sizeof(udp_header_t) + sizeof(ip6_header_t)));
 491
 492         iuvn6_0 = vlib_buffer_get_current (b0);
 493
 494         /* pop (ip, udp, vxlan) */
 495         vlib_buffer_advance (b0, sizeof(*iuvn6_0));
 496       }
 497
 498       tunnel_index0 = ~0;
 499       error0 = 0;
 500
 501       if (is_ip4)
 502       {
 503         next0 =
 504             (iuvn4_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 505             ngm->decap_next_node_list[iuvn4_0->vxlan.protocol]: \
 506             VXLAN_GPE_INPUT_NEXT_DROP;
 507
 508         key4_0.local = iuvn4_0->ip4.dst_address.as_u32;
 509         key4_0.remote = iuvn4_0->ip4.src_address.as_u32;
 510         key4_0.vni = iuvn4_0->vxlan.vni_res;
 511         key4_0.pad = 0;
 512
 513         /* Processing for key4_0 */
 514         if (PREDICT_FALSE(
 515             (key4_0.as_u64[0] != last_key4.as_u64[0])
 516                 || (key4_0.as_u64[1] != last_key4.as_u64[1])))
 517         {
 518           p0 = hash_get_mem(ngm->vxlan4_gpe_tunnel_by_key, &key4_0);
 519
 520           if (p0 == 0)
 521           {
 522             error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 523             goto trace00;
 524           }
 525
 526           last_key4.as_u64[0] = key4_0.as_u64[0];
 527           last_key4.as_u64[1] = key4_0.as_u64[1];
 528           tunnel_index0 = last_tunnel_index = p0[0];
 529         }
 530         else
 531           tunnel_index0 = last_tunnel_index;
 532       }
 533       else /* is_ip6 */
 534       {
 535         next0 =
 536             (iuvn6_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX)?
 537             ngm->decap_next_node_list[iuvn6_0->vxlan.protocol]: \
 538             VXLAN_GPE_INPUT_NEXT_DROP;
 539
 540         key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
 541         key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
 542         key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
 543         key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
 544         key6_0.vni = iuvn6_0->vxlan.vni_res;
 545
 546         /* Processing for key6_0 */
 547         if (PREDICT_FALSE(memcmp (&key6_0, &last_key6, sizeof(last_key6)) != 0))
 548         {
 549           p0 = hash_get_mem(ngm->vxlan6_gpe_tunnel_by_key, &key6_0);
 550
 551           if (p0 == 0)
 552           {
 553             error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
 554             goto trace00;
 555           }
 556
 557           memcpy (&last_key6, &key6_0, sizeof(key6_0));
 558           tunnel_index0 = last_tunnel_index = p0[0];
 559         }
 560         else
 561           tunnel_index0 = last_tunnel_index;
 562       }
 563
 564       t0 = pool_elt_at_index(ngm->tunnels, tunnel_index0);
 565
 566
 567       sw_if_index0 = t0->sw_if_index;
 568       len0 = vlib_buffer_length_in_chain (vm, b0);
 569
 570       /* Required to make the l2 tag push / pop code work on l2 subifs */
 571       vnet_update_l2_len (b0);
 572
 573       /*
 574        * ip[46] lookup in the configured FIB
 575        */
 576       vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
 577
 578       pkts_decapsulated++;
 579       stats_n_packets += 1;
 580       stats_n_bytes += len0;
 581
 582       /* Batch stats increment on the same vxlan-gpe tunnel so counter
 583        is not incremented per packet */
 584       if (PREDICT_FALSE(sw_if_index0 != stats_sw_if_index))
 585       {
 586         stats_n_packets -= 1;
 587         stats_n_bytes -= len0;
 588         if (stats_n_packets)
 589           vlib_increment_combined_counter (
 590               im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX,
 591               cpu_index, stats_sw_if_index, stats_n_packets, stats_n_bytes);
 592         stats_n_packets = 1;
 593         stats_n_bytes = len0;
 594         stats_sw_if_index = sw_if_index0;
 595       }
 596
 597       trace00: b0->error = error0 ? node->errors[error0] : 0;
 598
 599       if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 600       {
 601         vxlan_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof(*tr));
 602         tr->next_index = next0;
 603         tr->error = error0;
 604         tr->tunnel_index = tunnel_index0;
 605       }
 606       vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
 607                                       n_left_to_next, bi0, next0);
 608     }
 609
 610     vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 611   }
 612   vlib_node_increment_counter (vm, vxlan_gpe_input_node.index,
 613                                VXLAN_GPE_ERROR_DECAPSULATED, pkts_decapsulated);
 614   /* Increment any remaining batch stats */
 615   if (stats_n_packets)
 616   {
 617     vlib_increment_combined_counter (
 618         im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_RX, cpu_index,
 619         stats_sw_if_index, stats_n_packets, stats_n_bytes);
 620     node->runtime_data[0] = stats_sw_if_index;
 621   }
 622   return from_frame->n_vectors;
 623 }
 624
 625 /**
 626  * @brief Graph processing dispatch function for IPv4 VXLAN GPE
 627  *
 628  * @node vxlan4-gpe-input
 629  * @param *vm
 630  * @param *node
 631  * @param *from_frame
 632  *
 633  * @return from_frame->n_vectors
 634  *
 635  */
 636 static uword
 637 vxlan4_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node,
 638                   vlib_frame_t * from_frame)
 639 {
 640   return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */1);
 641 }
 642
 643
 644 void
 645 vxlan_gpe_register_decap_protocol (u8 protocol_id, uword next_node_index)
 646 {
 647   vxlan_gpe_main_t *hm = &vxlan_gpe_main;
 648   hm->decap_next_node_list[protocol_id] = next_node_index;
 649   return;
 650 }
 651
 652 void
 653 vxlan_gpe_unregister_decap_protocol (u8 protocol_id, uword next_node_index)
 654 {
 655   vxlan_gpe_main_t *hm = &vxlan_gpe_main;
 656   hm->decap_next_node_list[protocol_id] = VXLAN_GPE_INPUT_NEXT_DROP;
 657   return;
 658 }
 659
 660
 661 /**
 662  * @brief Graph processing dispatch function for IPv6 VXLAN GPE
 663  *
 664  * @node vxlan6-gpe-input
 665  * @param *vm
 666  * @param *node
 667  * @param *from_frame
 668  *
 669  * @return from_frame->n_vectors - uword
 670  *
 671  */
 672 static uword
 673 vxlan6_gpe_input (vlib_main_t * vm, vlib_node_runtime_t * node,
 674                   vlib_frame_t * from_frame)
 675 {
 676   return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */0);
 677 }
 678
 679 /**
 680  * @brief VXLAN GPE error strings
 681  */
 682 static char * vxlan_gpe_error_strings[] = {
 683 #define vxlan_gpe_error(n,s) s,
 684 #include <vnet/vxlan-gpe/vxlan_gpe_error.def>
 685 #undef vxlan_gpe_error
 686 #undef _
 687 };
 688
 689 VLIB_REGISTER_NODE (vxlan4_gpe_input_node) = {
 690   .function = vxlan4_gpe_input,
 691   .name = "vxlan4-gpe-input",
 692   /* Takes a vector of packets. */
 693   .vector_size = sizeof (u32),
 694   .type = VLIB_NODE_TYPE_INTERNAL,
 695   .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
 696   .error_strings = vxlan_gpe_error_strings,
 697
 698   .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
 699   .next_nodes = {
 700 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
 701     foreach_vxlan_gpe_input_next
 702 #undef _
 703   },
 704
 705   .format_buffer = format_vxlan_gpe_with_length,
 706   .format_trace = format_vxlan_gpe_rx_trace,
 707   // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
 708 };
 709
 710 VLIB_NODE_FUNCTION_MULTIARCH (vxlan4_gpe_input_node, vxlan4_gpe_input);
 711
 712 VLIB_REGISTER_NODE (vxlan6_gpe_input_node) = {
 713   .function = vxlan6_gpe_input,
 714   .name = "vxlan6-gpe-input",
 715   /* Takes a vector of packets. */
 716   .vector_size = sizeof (u32),
 717   .type = VLIB_NODE_TYPE_INTERNAL,
 718   .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
 719   .error_strings = vxlan_gpe_error_strings,
 720
 721   .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
 722   .next_nodes = {
 723 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
 724     foreach_vxlan_gpe_input_next
 725 #undef _
 726   },
 727
 728   .format_buffer = format_vxlan_gpe_with_length,
 729   .format_trace = format_vxlan_gpe_rx_trace,
 730   // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
 731 };
 732
 733 VLIB_NODE_FUNCTION_MULTIARCH (vxlan6_gpe_input_node, vxlan6_gpe_input);