src/vnet/vxlan/encap.c

   1
   2 /*
   3  * Copyright (c) 2015 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <vppinfra/error.h>
  17 #include <vppinfra/hash.h>
  18 #include <vnet/vnet.h>
  19 #include <vnet/ip/ip.h>
  20 #include <vnet/ethernet/ethernet.h>
  21 #include <vnet/interface_output.h>
  22 #include <vnet/vxlan/vxlan.h>
  23 #include <vnet/qos/qos_types.h>
  24 #include <vnet/adj/rewrite.h>
  25
  26 /* Statistics (not all errors) */
  27 #define foreach_vxlan_encap_error    \
  28 _(ENCAPSULATED, "good packets encapsulated")
  29
  30 static char *vxlan_encap_error_strings[] = {
  31 #define _(sym,string) string,
  32   foreach_vxlan_encap_error
  33 #undef _
  34 };
  35
  36 typedef enum
  37 {
  38 #define _(sym,str) VXLAN_ENCAP_ERROR_##sym,
  39   foreach_vxlan_encap_error
  40 #undef _
  41     VXLAN_ENCAP_N_ERROR,
  42 } vxlan_encap_error_t;
  43
  44 typedef enum
  45 {
  46   VXLAN_ENCAP_NEXT_DROP,
  47   VXLAN_ENCAP_N_NEXT,
  48 } vxlan_encap_next_t;
  49
  50 typedef struct
  51 {
  52   u32 tunnel_index;
  53   u32 vni;
  54 } vxlan_encap_trace_t;
  55
  56 #ifndef CLIB_MARCH_VARIANT
  57 u8 *
  58 format_vxlan_encap_trace (u8 * s, va_list * args)
  59 {
  60   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  61   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  62   vxlan_encap_trace_t *t = va_arg (*args, vxlan_encap_trace_t *);
  63
  64   s = format (s, "VXLAN encap to vxlan_tunnel%d vni %d",
  65               t->tunnel_index, t->vni);
  66   return s;
  67 }
  68 #endif
  69
  70 always_inline uword
  71 vxlan_encap_inline (vlib_main_t * vm,
  72                     vlib_node_runtime_t * node,
  73                     vlib_frame_t * from_frame, u8 is_ip4, u8 csum_offload)
  74 {
  75   u32 n_left_from, next_index, *from, *to_next;
  76   vxlan_main_t *vxm = &vxlan_main;
  77   vnet_main_t *vnm = vxm->vnet_main;
  78   vnet_interface_main_t *im = &vnm->interface_main;
  79   vlib_combined_counter_main_t *tx_counter =
  80     im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX;
  81   u32 pkts_encapsulated = 0;
  82   u32 thread_index = vlib_get_thread_index ();
  83   u32 sw_if_index0 = 0, sw_if_index1 = 0;
  84   u32 next0 = 0, next1 = 0;
  85   vxlan_tunnel_t *t0 = NULL, *t1 = NULL;
  86   index_t dpoi_idx0 = INDEX_INVALID, dpoi_idx1 = INDEX_INVALID;
  87   vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
  88   vlib_buffer_t **b = bufs;
  89
  90   from = vlib_frame_vector_args (from_frame);
  91   n_left_from = from_frame->n_vectors;
  92
  93   next_index = node->cached_next_index;
  94
  95   STATIC_ASSERT_SIZEOF (ip6_vxlan_header_t, 56);
  96   STATIC_ASSERT_SIZEOF (ip4_vxlan_header_t, 36);
  97
  98   u8 const underlay_hdr_len = is_ip4 ?
  99     sizeof (ip4_vxlan_header_t) : sizeof (ip6_vxlan_header_t);
 100   u16 const l3_len = is_ip4 ? sizeof (ip4_header_t) : sizeof (ip6_header_t);
 101   u32 const csum_flags = is_ip4 ? VNET_BUFFER_F_OFFLOAD_IP_CKSUM |
 102     VNET_BUFFER_F_IS_IP4 | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
 103     VNET_BUFFER_F_L3_HDR_OFFSET_VALID | VNET_BUFFER_F_L4_HDR_OFFSET_VALID :
 104     VNET_BUFFER_F_IS_IP6 | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
 105     VNET_BUFFER_F_L3_HDR_OFFSET_VALID | VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
 106   u32 const inner_packet_csum_offload_flags =
 107     VNET_BUFFER_F_OFFLOAD_IP_CKSUM | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
 108     VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
 109   u32 const inner_packet_removed_flags =
 110     VNET_BUFFER_F_IS_IP4 | VNET_BUFFER_F_IS_IP6 |
 111     VNET_BUFFER_F_L2_HDR_OFFSET_VALID | VNET_BUFFER_F_L3_HDR_OFFSET_VALID |
 112     VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
 113
 114   vlib_get_buffers (vm, from, bufs, n_left_from);
 115
 116   while (n_left_from > 0)
 117     {
 118       u32 n_left_to_next;
 119
 120       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 121
 122       while (n_left_from >= 4 && n_left_to_next >= 2)
 123         {
 124           /* Prefetch next iteration. */
 125           {
 126             vlib_prefetch_buffer_header (b[2], LOAD);
 127             vlib_prefetch_buffer_header (b[3], LOAD);
 128
 129             CLIB_PREFETCH (b[2]->data - CLIB_CACHE_LINE_BYTES,
 130                            2 * CLIB_CACHE_LINE_BYTES, LOAD);
 131             CLIB_PREFETCH (b[3]->data - CLIB_CACHE_LINE_BYTES,
 132                            2 * CLIB_CACHE_LINE_BYTES, LOAD);
 133           }
 134
 135           u32 bi0 = to_next[0] = from[0];
 136           u32 bi1 = to_next[1] = from[1];
 137           from += 2;
 138           to_next += 2;
 139           n_left_to_next -= 2;
 140           n_left_from -= 2;
 141
 142           vlib_buffer_t *b0 = b[0];
 143           vlib_buffer_t *b1 = b[1];
 144           b += 2;
 145
 146           u32 or_flags = b0->flags | b1->flags;
 147           if (csum_offload && (or_flags & inner_packet_csum_offload_flags))
 148             {
 149               /* Only calculate the non-GSO packet csum offload */
 150               if ((b0->flags & VNET_BUFFER_F_GSO) == 0)
 151                 {
 152                   vnet_calc_checksums_inline (vm, b0,
 153                                               b0->flags &
 154                                               VNET_BUFFER_F_IS_IP4,
 155                                               b0->flags &
 156                                               VNET_BUFFER_F_IS_IP6);
 157                   b0->flags &= ~inner_packet_removed_flags;
 158                 }
 159               if ((b1->flags & VNET_BUFFER_F_GSO) == 0)
 160                 {
 161                   vnet_calc_checksums_inline (vm, b1,
 162                                               b1->flags &
 163                                               VNET_BUFFER_F_IS_IP4,
 164                                               b1->flags &
 165                                               VNET_BUFFER_F_IS_IP6);
 166                   b1->flags &= ~inner_packet_removed_flags;
 167                 }
 168             }
 169
 170           u32 flow_hash0 = vnet_l2_compute_flow_hash (b0);
 171           u32 flow_hash1 = vnet_l2_compute_flow_hash (b1);
 172
 173           /* Get next node index and adj index from tunnel next_dpo */
 174           if (sw_if_index0 != vnet_buffer (b0)->sw_if_index[VLIB_TX])
 175             {
 176               sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 177               vnet_hw_interface_t *hi0 =
 178                 vnet_get_sup_hw_interface (vnm, sw_if_index0);
 179               t0 = &vxm->tunnels[hi0->dev_instance];
 180               /* Note: change to always set next0 if it may set to drop */
 181               next0 = t0->next_dpo.dpoi_next_node;
 182               dpoi_idx0 = t0->next_dpo.dpoi_index;
 183             }
 184
 185           /* Get next node index and adj index from tunnel next_dpo */
 186           if (sw_if_index1 != vnet_buffer (b1)->sw_if_index[VLIB_TX])
 187             {
 188               if (sw_if_index0 == vnet_buffer (b1)->sw_if_index[VLIB_TX])
 189                 {
 190                   sw_if_index1 = sw_if_index0;
 191                   t1 = t0;
 192                   next1 = next0;
 193                   dpoi_idx1 = dpoi_idx0;
 194                 }
 195               else
 196                 {
 197                   sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_TX];
 198                   vnet_hw_interface_t *hi1 =
 199                     vnet_get_sup_hw_interface (vnm, sw_if_index1);
 200                   t1 = &vxm->tunnels[hi1->dev_instance];
 201                   /* Note: change to always set next1 if it may set to drop */
 202                   next1 = t1->next_dpo.dpoi_next_node;
 203                   dpoi_idx1 = t1->next_dpo.dpoi_index;
 204                 }
 205             }
 206
 207           vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpoi_idx0;
 208           vnet_buffer (b1)->ip.adj_index[VLIB_TX] = dpoi_idx1;
 209
 210           ASSERT (t0->rewrite_header.data_bytes == underlay_hdr_len);
 211           ASSERT (t1->rewrite_header.data_bytes == underlay_hdr_len);
 212           vnet_rewrite_two_headers (*t0, *t1, vlib_buffer_get_current (b0),
 213                                     vlib_buffer_get_current (b1),
 214                                     underlay_hdr_len);
 215
 216           vlib_buffer_advance (b0, -underlay_hdr_len);
 217           vlib_buffer_advance (b1, -underlay_hdr_len);
 218
 219           u32 len0 = vlib_buffer_length_in_chain (vm, b0);
 220           u32 len1 = vlib_buffer_length_in_chain (vm, b1);
 221           u16 payload_l0 = clib_host_to_net_u16 (len0 - l3_len);
 222           u16 payload_l1 = clib_host_to_net_u16 (len1 - l3_len);
 223
 224           void *underlay0 = vlib_buffer_get_current (b0);
 225           void *underlay1 = vlib_buffer_get_current (b1);
 226
 227           ip4_header_t *ip4_0, *ip4_1;
 228           qos_bits_t ip4_0_tos = 0, ip4_1_tos = 0;
 229           ip6_header_t *ip6_0, *ip6_1;
 230           udp_header_t *udp0, *udp1;
 231           u8 *l3_0, *l3_1;
 232           if (is_ip4)
 233             {
 234               ip4_vxlan_header_t *hdr0 = underlay0;
 235               ip4_vxlan_header_t *hdr1 = underlay1;
 236
 237               /* Fix the IP4 checksum and length */
 238               ip4_0 = &hdr0->ip4;
 239               ip4_1 = &hdr1->ip4;
 240               ip4_0->length = clib_host_to_net_u16 (len0);
 241               ip4_1->length = clib_host_to_net_u16 (len1);
 242
 243               if (PREDICT_FALSE (b0->flags & VNET_BUFFER_F_QOS_DATA_VALID))
 244                 {
 245                   ip4_0_tos = vnet_buffer2 (b0)->qos.bits;
 246                   ip4_0->tos = ip4_0_tos;
 247                 }
 248               if (PREDICT_FALSE (b1->flags & VNET_BUFFER_F_QOS_DATA_VALID))
 249                 {
 250                   ip4_1_tos = vnet_buffer2 (b1)->qos.bits;
 251                   ip4_1->tos = ip4_1_tos;
 252                 }
 253
 254               l3_0 = (u8 *) ip4_0;
 255               l3_1 = (u8 *) ip4_1;
 256               udp0 = &hdr0->udp;
 257               udp1 = &hdr1->udp;
 258             }
 259           else                  /* ipv6 */
 260             {
 261               ip6_vxlan_header_t *hdr0 = underlay0;
 262               ip6_vxlan_header_t *hdr1 = underlay1;
 263
 264               /* Fix IP6 payload length */
 265               ip6_0 = &hdr0->ip6;
 266               ip6_1 = &hdr1->ip6;
 267               ip6_0->payload_length = payload_l0;
 268               ip6_1->payload_length = payload_l1;
 269
 270               l3_0 = (u8 *) ip6_0;
 271               l3_1 = (u8 *) ip6_1;
 272               udp0 = &hdr0->udp;
 273               udp1 = &hdr1->udp;
 274             }
 275
 276           /* Fix UDP length  and set source port */
 277           udp0->length = payload_l0;
 278           udp0->src_port = flow_hash0;
 279           udp1->length = payload_l1;
 280           udp1->src_port = flow_hash1;
 281
 282           if (csum_offload)
 283             {
 284               b0->flags |= csum_flags;
 285               vnet_buffer (b0)->l3_hdr_offset = l3_0 - b0->data;
 286               vnet_buffer (b0)->l4_hdr_offset = (u8 *) udp0 - b0->data;
 287               b1->flags |= csum_flags;
 288               vnet_buffer (b1)->l3_hdr_offset = l3_1 - b1->data;
 289               vnet_buffer (b1)->l4_hdr_offset = (u8 *) udp1 - b1->data;
 290             }
 291           /* IPv4 UDP checksum only if checksum offload is used */
 292           else if (is_ip4)
 293             {
 294               ip_csum_t sum0 = ip4_0->checksum;
 295               sum0 = ip_csum_update (sum0, 0, ip4_0->length, ip4_header_t,
 296                                      length /* changed member */ );
 297               if (PREDICT_FALSE (ip4_0_tos))
 298                 {
 299                   sum0 = ip_csum_update (sum0, 0, ip4_0_tos, ip4_header_t,
 300                                          tos /* changed member */ );
 301                 }
 302               ip4_0->checksum = ip_csum_fold (sum0);
 303               ip_csum_t sum1 = ip4_1->checksum;
 304               sum1 = ip_csum_update (sum1, 0, ip4_1->length, ip4_header_t,
 305                                      length /* changed member */ );
 306               if (PREDICT_FALSE (ip4_1_tos))
 307                 {
 308                   sum1 = ip_csum_update (sum1, 0, ip4_1_tos, ip4_header_t,
 309                                          tos /* changed member */ );
 310                 }
 311               ip4_1->checksum = ip_csum_fold (sum1);
 312             }
 313           /* IPv6 UDP checksum is mandatory */
 314           else
 315             {
 316               int bogus = 0;
 317
 318               udp0->checksum = ip6_tcp_udp_icmp_compute_checksum
 319                 (vm, b0, ip6_0, &bogus);
 320               ASSERT (bogus == 0);
 321               if (udp0->checksum == 0)
 322                 udp0->checksum = 0xffff;
 323               udp1->checksum = ip6_tcp_udp_icmp_compute_checksum
 324                 (vm, b1, ip6_1, &bogus);
 325               ASSERT (bogus == 0);
 326               if (udp1->checksum == 0)
 327                 udp1->checksum = 0xffff;
 328             }
 329
 330           /* save inner packet flow_hash for load-balance node */
 331           vnet_buffer (b0)->ip.flow_hash = flow_hash0;
 332           vnet_buffer (b1)->ip.flow_hash = flow_hash1;
 333
 334           if (sw_if_index0 == sw_if_index1)
 335             {
 336               vlib_increment_combined_counter (tx_counter, thread_index,
 337                                                sw_if_index0, 2, len0 + len1);
 338             }
 339           else
 340             {
 341               vlib_increment_combined_counter (tx_counter, thread_index,
 342                                                sw_if_index0, 1, len0);
 343               vlib_increment_combined_counter (tx_counter, thread_index,
 344                                                sw_if_index1, 1, len1);
 345             }
 346           pkts_encapsulated += 2;
 347
 348           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 349             {
 350               vxlan_encap_trace_t *tr =
 351                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 352               tr->tunnel_index = t0 - vxm->tunnels;
 353               tr->vni = t0->vni;
 354             }
 355
 356           if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
 357             {
 358               vxlan_encap_trace_t *tr =
 359                 vlib_add_trace (vm, node, b1, sizeof (*tr));
 360               tr->tunnel_index = t1 - vxm->tunnels;
 361               tr->vni = t1->vni;
 362             }
 363
 364           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 365                                            to_next, n_left_to_next,
 366                                            bi0, bi1, next0, next1);
 367         }
 368
 369       while (n_left_from > 0 && n_left_to_next > 0)
 370         {
 371           u32 bi0 = to_next[0] = from[0];
 372           from += 1;
 373           to_next += 1;
 374           n_left_from -= 1;
 375           n_left_to_next -= 1;
 376
 377           vlib_buffer_t *b0 = b[0];
 378           b += 1;
 379
 380           if (csum_offload && (b0->flags & inner_packet_csum_offload_flags))
 381             {
 382               /* Only calculate the non-GSO packet csum offload */
 383               if ((b0->flags & VNET_BUFFER_F_GSO) == 0)
 384                 {
 385                   vnet_calc_checksums_inline (vm, b0,
 386                                               b0->flags &
 387                                               VNET_BUFFER_F_IS_IP4,
 388                                               b0->flags &
 389                                               VNET_BUFFER_F_IS_IP6);
 390                   b0->flags &= ~inner_packet_removed_flags;
 391                 }
 392             }
 393
 394           u32 flow_hash0 = vnet_l2_compute_flow_hash (b0);
 395
 396           /* Get next node index and adj index from tunnel next_dpo */
 397           if (sw_if_index0 != vnet_buffer (b0)->sw_if_index[VLIB_TX])
 398             {
 399               sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 400               vnet_hw_interface_t *hi0 =
 401                 vnet_get_sup_hw_interface (vnm, sw_if_index0);
 402               t0 = &vxm->tunnels[hi0->dev_instance];
 403               /* Note: change to always set next0 if it may be set to drop */
 404               next0 = t0->next_dpo.dpoi_next_node;
 405               dpoi_idx0 = t0->next_dpo.dpoi_index;
 406             }
 407           vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpoi_idx0;
 408
 409           ASSERT (t0->rewrite_header.data_bytes == underlay_hdr_len);
 410           vnet_rewrite_one_header (*t0, vlib_buffer_get_current (b0),
 411                                    underlay_hdr_len);
 412
 413           vlib_buffer_advance (b0, -underlay_hdr_len);
 414           void *underlay0 = vlib_buffer_get_current (b0);
 415
 416           u32 len0 = vlib_buffer_length_in_chain (vm, b0);
 417           u16 payload_l0 = clib_host_to_net_u16 (len0 - l3_len);
 418
 419           udp_header_t *udp0;
 420           ip4_header_t *ip4_0;
 421           qos_bits_t ip4_0_tos = 0;
 422           ip6_header_t *ip6_0;
 423           u8 *l3_0;
 424           if (is_ip4)
 425             {
 426               ip4_vxlan_header_t *hdr = underlay0;
 427
 428               /* Fix the IP4 checksum and length */
 429               ip4_0 = &hdr->ip4;
 430               ip4_0->length = clib_host_to_net_u16 (len0);
 431
 432               if (PREDICT_FALSE (b0->flags & VNET_BUFFER_F_QOS_DATA_VALID))
 433                 {
 434                   ip4_0_tos = vnet_buffer2 (b0)->qos.bits;
 435                   ip4_0->tos = ip4_0_tos;
 436                 }
 437
 438               l3_0 = (u8 *) ip4_0;
 439               udp0 = &hdr->udp;
 440             }
 441           else                  /* ip6 path */
 442             {
 443               ip6_vxlan_header_t *hdr = underlay0;
 444
 445               /* Fix IP6 payload length */
 446               ip6_0 = &hdr->ip6;
 447               ip6_0->payload_length = payload_l0;
 448
 449               l3_0 = (u8 *) ip6_0;
 450               udp0 = &hdr->udp;
 451             }
 452
 453           /* Fix UDP length  and set source port */
 454           udp0->length = payload_l0;
 455           udp0->src_port = flow_hash0;
 456
 457           if (csum_offload)
 458             {
 459               b0->flags |= csum_flags;
 460               vnet_buffer (b0)->l3_hdr_offset = l3_0 - b0->data;
 461               vnet_buffer (b0)->l4_hdr_offset = (u8 *) udp0 - b0->data;
 462             }
 463           /* IPv4 UDP checksum only if checksum offload is used */
 464           else if (is_ip4)
 465             {
 466               ip_csum_t sum0 = ip4_0->checksum;
 467               sum0 = ip_csum_update (sum0, 0, ip4_0->length, ip4_header_t,
 468                                      length /* changed member */ );
 469               if (PREDICT_FALSE (ip4_0_tos))
 470                 {
 471                   sum0 = ip_csum_update (sum0, 0, ip4_0_tos, ip4_header_t,
 472                                          tos /* changed member */ );
 473                 }
 474               ip4_0->checksum = ip_csum_fold (sum0);
 475             }
 476           /* IPv6 UDP checksum is mandatory */
 477           else
 478             {
 479               int bogus = 0;
 480
 481               udp0->checksum = ip6_tcp_udp_icmp_compute_checksum
 482                 (vm, b0, ip6_0, &bogus);
 483               ASSERT (bogus == 0);
 484               if (udp0->checksum == 0)
 485                 udp0->checksum = 0xffff;
 486             }
 487
 488           /* reuse inner packet flow_hash for load-balance node */
 489           vnet_buffer (b0)->ip.flow_hash = flow_hash0;
 490
 491           vlib_increment_combined_counter (tx_counter, thread_index,
 492                                            sw_if_index0, 1, len0);
 493           pkts_encapsulated++;
 494
 495           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 496             {
 497               vxlan_encap_trace_t *tr =
 498                 vlib_add_trace (vm, node, b0, sizeof (*tr));
 499               tr->tunnel_index = t0 - vxm->tunnels;
 500               tr->vni = t0->vni;
 501             }
 502           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 503                                            to_next, n_left_to_next,
 504                                            bi0, next0);
 505         }
 506
 507       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 508     }
 509
 510   /* Do we still need this now that tunnel tx stats is kept? */
 511   vlib_node_increment_counter (vm, node->node_index,
 512                                VXLAN_ENCAP_ERROR_ENCAPSULATED,
 513                                pkts_encapsulated);
 514
 515   return from_frame->n_vectors;
 516 }
 517
 518 VLIB_NODE_FN (vxlan4_encap_node) (vlib_main_t * vm,
 519                                   vlib_node_runtime_t * node,
 520                                   vlib_frame_t * from_frame)
 521 {
 522   /* Disable chksum offload as setup overhead in tx node is not worthwhile
 523      for ip4 header checksum only, unless udp checksum is also required */
 524   return vxlan_encap_inline (vm, node, from_frame, /* is_ip4 */ 1,
 525                              /* csum_offload */ 0);
 526 }
 527
 528 VLIB_NODE_FN (vxlan6_encap_node) (vlib_main_t * vm,
 529                                   vlib_node_runtime_t * node,
 530                                   vlib_frame_t * from_frame)
 531 {
 532   /* Enable checksum offload for ip6 as udp checksum is mandatory, */
 533   return vxlan_encap_inline (vm, node, from_frame, /* is_ip4 */ 0,
 534                              /* csum_offload */ 1);
 535 }
 536
 537 /* *INDENT-OFF* */
 538 VLIB_REGISTER_NODE (vxlan4_encap_node) = {
 539   .name = "vxlan4-encap",
 540   .vector_size = sizeof (u32),
 541   .format_trace = format_vxlan_encap_trace,
 542   .type = VLIB_NODE_TYPE_INTERNAL,
 543   .n_errors = ARRAY_LEN(vxlan_encap_error_strings),
 544   .error_strings = vxlan_encap_error_strings,
 545   .n_next_nodes = VXLAN_ENCAP_N_NEXT,
 546   .next_nodes = {
 547         [VXLAN_ENCAP_NEXT_DROP] = "error-drop",
 548   },
 549 };
 550
 551 VLIB_REGISTER_NODE (vxlan6_encap_node) = {
 552   .name = "vxlan6-encap",
 553   .vector_size = sizeof (u32),
 554   .format_trace = format_vxlan_encap_trace,
 555   .type = VLIB_NODE_TYPE_INTERNAL,
 556   .n_errors = ARRAY_LEN(vxlan_encap_error_strings),
 557   .error_strings = vxlan_encap_error_strings,
 558   .n_next_nodes = VXLAN_ENCAP_N_NEXT,
 559   .next_nodes = {
 560         [VXLAN_ENCAP_NEXT_DROP] = "error-drop",
 561   },
 562 };
 563 /* *INDENT-ON* */
 564
 565 /*
 566  * fd.io coding-style-patch-verification: ON
 567  *
 568  * Local Variables:
 569  * eval: (c-set-style "gnu")
 570  * End:
 571  */