FD.io VPP  v21.01.1
Vector Packet Processing
encap.c
Go to the documentation of this file.
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,
33 #undef _
34 };
35 
36 typedef enum
37 {
38 #define _(sym,str) VXLAN_ENCAP_ERROR_##sym,
40 #undef _
43 
44 typedef enum
45 {
49 
50 typedef struct
51 {
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 
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;
79  vlib_combined_counter_main_t *tx_counter =
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;
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 
130  2 * CLIB_CACHE_LINE_BYTES, LOAD);
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  {
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  {
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);
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 
319  (vm, b0, ip6_0, &bogus);
320  ASSERT (bogus == 0);
321  if (udp0->checksum == 0)
322  udp0->checksum = 0xffff;
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  {
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);
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 
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? */
512  VXLAN_ENCAP_ERROR_ENCAPSULATED,
513  pkts_encapsulated);
514 
515  return from_frame->n_vectors;
516 }
517 
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 
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* */
539  .name = "vxlan4-encap",
540  .vector_size = sizeof (u32),
541  .format_trace = format_vxlan_encap_trace,
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 
552  .name = "vxlan6-encap",
553  .vector_size = sizeof (u32),
554  .format_trace = format_vxlan_encap_trace,
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  */
#define vnet_rewrite_one_header(rw0, p0, most_likely_size)
Definition: rewrite.h:216
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
#define CLIB_UNUSED(x)
Definition: clib.h:87
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:239
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
#define vnet_buffer2(b)
Definition: buffer.h:481
vnet_interface_main_t interface_main
Definition: vnet.h:65
vxlan_encap_next_t
Definition: encap.c:44
u8 * format_vxlan_encap_trace(u8 *s, va_list *args)
Definition: encap.c:58
vxlan_encap_error_t
Definition: encap.c:36
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
vlib_node_registration_t vxlan6_encap_node
(constructor) VLIB_REGISTER_NODE (vxlan6_encap_node)
Definition: encap.c:551
uword ip_csum_t
Definition: ip_packet.h:246
vlib_main_t * vm
Definition: in2out_ed.c:1580
#define VLIB_NODE_FN(node)
Definition: node.h:203
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:402
unsigned char u8
Definition: types.h:56
u8 data[128]
Definition: ipsec_types.api:90
#define foreach_vxlan_encap_error
Definition: encap.c:27
vnet_main_t * vnet_main
Definition: vxlan.h:181
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:882
description fragment has unexpected format
Definition: map.api:433
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:207
const cJSON *const b
Definition: cJSON.h:255
unsigned int u32
Definition: types.h:88
#define VLIB_FRAME_SIZE
Definition: node.h:378
vl_api_fib_path_type_t type
Definition: fib_types.api:123
unsigned short u16
Definition: types.h:57
static u32 vnet_l2_compute_flow_hash(vlib_buffer_t *b)
Definition: l2_input.h:338
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:233
vxlan_main_t vxlan_main
Definition: vxlan.c:45
#define PREDICT_FALSE(x)
Definition: clib.h:121
#define always_inline
Definition: ipsec.h:28
u32 node_index
Node index.
Definition: node.h:488
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:224
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:391
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1231
vlib_node_registration_t vxlan4_encap_node
(constructor) VLIB_REGISTER_NODE (vxlan4_encap_node)
Definition: encap.c:538
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:170
u16 n_vectors
Definition: node.h:397
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:219
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
u8 data[]
Packet data.
Definition: buffer.h:181
static uword vxlan_encap_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 is_ip4, u8 csum_offload)
Definition: encap.c:71
#define ARRAY_LEN(x)
Definition: clib.h:67
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:483
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1580
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
Definition: ip6_forward.c:1099
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:511
#define ASSERT(truth)
ip_dscp_t tos
Definition: ip4_packet.h:96
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:252
char const int length
Definition: cJSON.h:163
Definition: defs.h:47
u16 payload_length
Definition: ip6_packet.h:301
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:188
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:297
#define ip_csum_update(sum, old, new, type, field)
Definition: ip_packet.h:296
A collection of combined counters.
Definition: counter.h:207
static_always_inline void vnet_calc_checksums_inline(vlib_main_t *vm, vlib_buffer_t *b, int is_ip4, int is_ip6)
#define vnet_buffer(b)
Definition: buffer.h:417
dpo_id_t next_dpo
Definition: vxlan.h:87
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace.c:634
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:184
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
Definition: buffer_funcs.h:280
#define vnet_rewrite_two_headers(rw0, rw1, p0, p1, most_likely_size)
Definition: rewrite.h:220
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
#define STATIC_ASSERT_SIZEOF(d, s)
static char * vxlan_encap_error_strings[]
Definition: encap.c:30
vxlan_tunnel_t * tunnels
Definition: vxlan.h:159
u8 qos_bits_t
Type, er, safety for us water based entities.
Definition: qos_types.h:68
static u16 ip_csum_fold(ip_csum_t c)
Definition: ip_packet.h:302
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34