FD.io VPP  v21.01.1
Vector Packet Processing
encap.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /**
16  * @file
17  * @brief Functions for encapsulating VXLAN GPE tunnels
18  *
19 */
20 #include <vppinfra/error.h>
21 #include <vppinfra/hash.h>
22 #include <vnet/vnet.h>
23 #include <vnet/ip/ip.h>
24 #include <vnet/ethernet/ethernet.h>
25 #include <vnet/udp/udp_inlines.h>
27 
28 /** Statistics (not really errors) */
29 #define foreach_vxlan_gpe_encap_error \
30 _(ENCAPSULATED, "good packets encapsulated")
31 
32 /**
33  * @brief VXLAN GPE encap error strings
34  */
36 #define _(sym,string) string,
38 #undef _
39 };
40 
41 /**
42  * @brief Struct for VXLAN GPE errors/counters
43  */
44 typedef enum
45 {
46 #define _(sym,str) VXLAN_GPE_ENCAP_ERROR_##sym,
48 #undef _
51 
52 /**
53  * @brief Struct for tracing VXLAN GPE encapsulated packets
54  */
55 typedef struct
56 {
59 
60 /**
61  * @brief Trace of packets encapsulated in VXLAN GPE
62  *
63  * @param *s
64  * @param *args
65  *
66  * @return *s
67  *
68  */
69 u8 *
70 format_vxlan_gpe_encap_trace (u8 * s, va_list * args)
71 {
72  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
73  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
74  vxlan_gpe_encap_trace_t *t = va_arg (*args, vxlan_gpe_encap_trace_t *);
75 
76  s = format (s, "VXLAN-GPE-ENCAP: tunnel %d", t->tunnel_index);
77  return s;
78 }
79 
80 /**
81  * @brief Instantiates UDP + VXLAN-GPE header then set next node to IP4|6 lookup
82  *
83  * @param *ngm
84  * @param *b0
85  * @param *t0 contains rewrite header
86  * @param *next0 relative index of next dispatch function (next node)
87  * @param is_v4 Is this IPv4? (or IPv6)
88  *
89  */
90 always_inline void
92  vxlan_gpe_tunnel_t * t0, u32 * next0, u8 is_v4)
93 {
94  ASSERT (sizeof (ip4_vxlan_gpe_header_t) == 36);
95  ASSERT (sizeof (ip6_vxlan_gpe_header_t) == 56);
96 
97  ip_udp_encap_one (ngm->vlib_main, b0, t0->rewrite, t0->rewrite_size, is_v4);
98  next0[0] = t0->encap_next_node;
99 }
100 
101 /**
102  * @brief Instantiates UDP + VXLAN-GPE header then set next node to IP4|6 lookup for two packets
103  *
104  * @param *ngm
105  * @param *b0 Packet0
106  * @param *b1 Packet1
107  * @param *t0 contains rewrite header for Packet0
108  * @param *t1 contains rewrite header for Packet1
109  * @param *next0 relative index of next dispatch function (next node) for Packet0
110  * @param *next1 relative index of next dispatch function (next node) for Packet1
111  * @param is_v4 Is this IPv4? (or IPv6)
112  *
113  */
114 always_inline void
117  vxlan_gpe_tunnel_t * t1, u32 * next0,
118  u32 * next1, u8 is_v4)
119 {
120  ASSERT (sizeof (ip4_vxlan_gpe_header_t) == 36);
121  ASSERT (sizeof (ip6_vxlan_gpe_header_t) == 56);
122 
123  ip_udp_encap_one (ngm->vlib_main, b0, t0->rewrite, t0->rewrite_size, is_v4);
124  ip_udp_encap_one (ngm->vlib_main, b1, t1->rewrite, t1->rewrite_size, is_v4);
125  next0[0] = next1[0] = t0->encap_next_node;
126 }
127 
128 /**
129  * @brief Common processing for IPv4 and IPv6 VXLAN GPE encap dispatch functions
130  *
131  * It is worth noting that other than trivial UDP forwarding (transit), VXLAN GPE
132  * tunnels are "establish local". This means that we don't have a TX interface as yet
133  * as we need to look up where the outer-header dest is. By setting the TX index in the
134  * buffer metadata to the encap FIB, we can do a lookup to get the adjacency and real TX.
135  *
136  * vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->encap_fib_index;
137  *
138  * @node vxlan-gpe-input
139  * @param *vm
140  * @param *node
141  * @param *from_frame
142  *
143  * @return from_frame->n_vectors
144  *
145  */
146 static uword
148  vlib_node_runtime_t * node, vlib_frame_t * from_frame)
149 {
150  u32 n_left_from, next_index, *from, *to_next;
152  vnet_main_t *vnm = ngm->vnet_main;
154  u32 pkts_encapsulated = 0;
155  u32 thread_index = vm->thread_index;
156  u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
157  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
158 
159  from = vlib_frame_vector_args (from_frame);
160  n_left_from = from_frame->n_vectors;
161 
162  next_index = node->cached_next_index;
163  stats_sw_if_index = node->runtime_data[0];
164  stats_n_packets = stats_n_bytes = 0;
165  vlib_get_buffers (vm, from, bufs, n_left_from);
166 
167  while (n_left_from > 0)
168  {
169  u32 n_left_to_next;
170  u32 sw_if_index0 = ~0, sw_if_index1 = ~0, len0, len1;
171  vnet_hw_interface_t *hi0, *hi1;
172  vxlan_gpe_tunnel_t *t0 = NULL, *t1 = NULL;
173  u8 is_ip4_0 = 0, is_ip4_1 = 0;
174 
175  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
176 
177  while (n_left_from >= 4 && n_left_to_next >= 2)
178  {
179  u32 bi0, bi1;
180  u32 next0, next1;
181 
182  next0 = next1 = VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP;
183 
184  /* Prefetch next iteration. */
185  {
186  vlib_prefetch_buffer_header (b[2], LOAD);
187  vlib_prefetch_buffer_header (b[3], LOAD);
188 
190  2 * CLIB_CACHE_LINE_BYTES, LOAD);
192  2 * CLIB_CACHE_LINE_BYTES, LOAD);
193  }
194 
195  bi0 = from[0];
196  bi1 = from[1];
197  to_next[0] = bi0;
198  to_next[1] = bi1;
199  from += 2;
200  to_next += 2;
201  n_left_to_next -= 2;
202  n_left_from -= 2;
203 
204  /* get the flag "is_ip4" */
205  if (sw_if_index0 != vnet_buffer (b[0])->sw_if_index[VLIB_TX])
206  {
207  sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
208  hi0 =
210  vnet_buffer (b[0])->sw_if_index
211  [VLIB_TX]);
212  t0 = pool_elt_at_index (ngm->tunnels, hi0->dev_instance);
213  is_ip4_0 = (t0->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
214  }
215 
216  /* get the flag "is_ip4" */
217  if (sw_if_index1 != vnet_buffer (b[1])->sw_if_index[VLIB_TX])
218  {
219  if (sw_if_index0 == vnet_buffer (b[1])->sw_if_index[VLIB_TX])
220  {
221  sw_if_index1 = sw_if_index0;
222  hi1 = hi0;
223  t1 = t0;
224  is_ip4_1 = is_ip4_0;
225  }
226  else
227  {
228  sw_if_index1 = vnet_buffer (b[1])->sw_if_index[VLIB_TX];
229  hi1 =
231  vnet_buffer (b[1])->sw_if_index
232  [VLIB_TX]);
233  t1 = pool_elt_at_index (ngm->tunnels, hi1->dev_instance);
234  is_ip4_1 = (t1->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
235  }
236  }
237 
238  if (PREDICT_TRUE (is_ip4_0 == is_ip4_1))
239  {
240  vxlan_gpe_encap_two_inline (ngm, b[0], b[1], t0, t1, &next0,
241  &next1, is_ip4_0);
242  }
243  else
244  {
245  vxlan_gpe_encap_one_inline (ngm, b[0], t0, &next0, is_ip4_0);
246  vxlan_gpe_encap_one_inline (ngm, b[1], t1, &next1, is_ip4_1);
247  }
248 
249  /* Reset to look up tunnel partner in the configured FIB */
250  vnet_buffer (b[0])->sw_if_index[VLIB_TX] = t0->encap_fib_index;
251  vnet_buffer (b[1])->sw_if_index[VLIB_TX] = t1->encap_fib_index;
252  vnet_buffer (b[0])->sw_if_index[VLIB_RX] = sw_if_index0;
253  vnet_buffer (b[1])->sw_if_index[VLIB_RX] = sw_if_index1;
254  pkts_encapsulated += 2;
255 
256  len0 = vlib_buffer_length_in_chain (vm, b[0]);
257  len1 = vlib_buffer_length_in_chain (vm, b[1]);
258  stats_n_packets += 2;
259  stats_n_bytes += len0 + len1;
260 
261  /* Batch stats increment on the same vxlan tunnel so counter is not
262  incremented per packet. Note stats are still incremented for deleted
263  and admin-down tunnel where packets are dropped. It is not worthwhile
264  to check for this rare case and affect normal path performance. */
265  if (PREDICT_FALSE ((sw_if_index0 != stats_sw_if_index)
266  || (sw_if_index1 != stats_sw_if_index)))
267  {
268  stats_n_packets -= 2;
269  stats_n_bytes -= len0 + len1;
270  if (sw_if_index0 == sw_if_index1)
271  {
272  if (stats_n_packets)
275  VNET_INTERFACE_COUNTER_TX, thread_index,
276  stats_sw_if_index, stats_n_packets, stats_n_bytes);
277  stats_sw_if_index = sw_if_index0;
278  stats_n_packets = 2;
279  stats_n_bytes = len0 + len1;
280  }
281  else
282  {
284  +
286  thread_index, sw_if_index0,
287  1, len0);
289  +
291  thread_index, sw_if_index1,
292  1, len1);
293  }
294  }
295 
296  if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
297  {
299  vlib_add_trace (vm, node, b[0], sizeof (*tr));
300  tr->tunnel_index = t0 - ngm->tunnels;
301  }
302 
303  if (PREDICT_FALSE (b[1]->flags & VLIB_BUFFER_IS_TRACED))
304  {
305  vxlan_gpe_encap_trace_t *tr = vlib_add_trace (vm, node, b[1],
306  sizeof (*tr));
307  tr->tunnel_index = t1 - ngm->tunnels;
308  }
309  b += 2;
310 
311  vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
312  n_left_to_next, bi0, bi1, next0,
313  next1);
314  }
315 
316  while (n_left_from > 0 && n_left_to_next > 0)
317  {
318  u32 bi0;
320 
321  bi0 = from[0];
322  to_next[0] = bi0;
323  from += 1;
324  to_next += 1;
325  n_left_from -= 1;
326  n_left_to_next -= 1;
327 
328  /* get the flag "is_ip4" */
329  if (sw_if_index0 != vnet_buffer (b[0])->sw_if_index[VLIB_TX])
330  {
331  sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
332  hi0 =
334  vnet_buffer (b[0])->sw_if_index
335  [VLIB_TX]);
336 
337  t0 = pool_elt_at_index (ngm->tunnels, hi0->dev_instance);
338 
339  is_ip4_0 = (t0->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
340  }
341 
342  vxlan_gpe_encap_one_inline (ngm, b[0], t0, &next0, is_ip4_0);
343 
344  /* Reset to look up tunnel partner in the configured FIB */
345  vnet_buffer (b[0])->sw_if_index[VLIB_TX] = t0->encap_fib_index;
346  vnet_buffer (b[0])->sw_if_index[VLIB_RX] = sw_if_index0;
347  pkts_encapsulated++;
348 
349  len0 = vlib_buffer_length_in_chain (vm, b[0]);
350  stats_n_packets += 1;
351  stats_n_bytes += len0;
352 
353  /* Batch stats increment on the same vxlan tunnel so counter is not
354  * incremented per packet. Note stats are still incremented for deleted
355  * and admin-down tunnel where packets are dropped. It is not worthwhile
356  * to check for this rare case and affect normal path performance. */
357  if (PREDICT_FALSE (sw_if_index0 != stats_sw_if_index))
358  {
359  stats_n_packets -= 1;
360  stats_n_bytes -= len0;
361  if (stats_n_packets)
364  thread_index,
365  stats_sw_if_index,
366  stats_n_packets,
367  stats_n_bytes);
368  stats_n_packets = 1;
369  stats_n_bytes = len0;
370  stats_sw_if_index = sw_if_index0;
371  }
372  if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
373  {
374  vxlan_gpe_encap_trace_t *tr = vlib_add_trace (vm, node, b[0],
375  sizeof (*tr));
376  tr->tunnel_index = t0 - ngm->tunnels;
377  }
378  b += 1;
379 
380  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
381  n_left_to_next, bi0, next0);
382  }
383 
384  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
385  }
387  VXLAN_GPE_ENCAP_ERROR_ENCAPSULATED,
388  pkts_encapsulated);
389  /* Increment any remaining batch stats */
390  if (stats_n_packets)
391  {
394  thread_index, stats_sw_if_index,
395  stats_n_packets, stats_n_bytes);
396  node->runtime_data[0] = stats_sw_if_index;
397  }
398 
399  return from_frame->n_vectors;
400 }
401 
402 /* *INDENT-OFF* */
404  .function = vxlan_gpe_encap,
405  .name = "vxlan-gpe-encap",
406  .vector_size = sizeof (u32),
407  .format_trace = format_vxlan_gpe_encap_trace,
409 
411  .error_strings = vxlan_gpe_encap_error_strings,
412 
413  .n_next_nodes = VXLAN_GPE_ENCAP_N_NEXT,
414 
415  .next_nodes = {
416  [VXLAN_GPE_ENCAP_NEXT_IP4_LOOKUP] = "ip4-lookup",
417  [VXLAN_GPE_ENCAP_NEXT_IP6_LOOKUP] = "ip6-lookup",
418  [VXLAN_GPE_ENCAP_NEXT_DROP] = "error-drop",
419  },
420 };
421 /* *INDENT-ON* */
422 
423 
424 /*
425  * fd.io coding-style-patch-verification: ON
426  *
427  * Local Variables:
428  * eval: (c-set-style "gnu")
429  * End:
430  */
vxlan_gpe_encap_error_t
Struct for VXLAN GPE errors/counters.
Definition: encap.c:44
#define CLIB_UNUSED(x)
Definition: clib.h:87
u32 flags
flags
Definition: vxlan_gpe.h:138
static void vxlan_gpe_encap_two_inline(vxlan_gpe_main_t *ngm, vlib_buffer_t *b0, vlib_buffer_t *b1, vxlan_gpe_tunnel_t *t0, vxlan_gpe_tunnel_t *t1, u32 *next0, u32 *next1, u8 is_v4)
Instantiates UDP + VXLAN-GPE header then set next node to IP4|6 lookup for two packets.
Definition: encap.c:115
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
Struct for tracing VXLAN GPE encapsulated packets.
Definition: encap.c:55
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
u8 runtime_data[0]
Function dependent node-runtime data.
Definition: node.h:519
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
vnet_interface_main_t interface_main
Definition: vnet.h:65
#define PREDICT_TRUE(x)
Definition: clib.h:122
VXLAN GPE definitions.
u32 thread_index
Definition: main.h:250
vlib_main_t * vm
Definition: in2out_ed.c:1580
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
#define foreach_vxlan_gpe_encap_error
Statistics (not really errors)
Definition: encap.c:29
unsigned char u8
Definition: types.h:56
vnet_main_t * vnet_main
State convenience vnet_main_t.
Definition: vxlan_gpe.h:221
u8 data[128]
Definition: ipsec_types.api:90
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
u8 * rewrite
Rewrite string.
Definition: vxlan_gpe.h:109
vl_api_fib_path_type_t type
Definition: fib_types.api:123
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:546
Struct for VXLAN GPE tunnel.
Definition: vxlan_gpe.h:103
vxlan_gpe_main_t vxlan_gpe_main
Definition: vxlan_gpe.c:47
vlib_main_t * vlib_main
State convenience vlib_main_t.
Definition: vxlan_gpe.h:219
#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
vlib_node_registration_t vxlan_gpe_encap_node
(constructor) VLIB_REGISTER_NODE (vxlan_gpe_encap_node)
Definition: encap.c:403
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1231
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:170
u16 n_vectors
Definition: node.h:397
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
#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 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)
u8 rewrite_size
rewrite size for dynamic plugins like iOAM
Definition: vxlan_gpe.h:141
Struct for VXLAN GPE node state.
Definition: vxlan_gpe.h:197
vxlan_gpe_tunnel_t * tunnels
vector of encap tunnel instances
Definition: vxlan_gpe.h:200
Definition: defs.h:47
static uword vxlan_gpe_encap(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Common processing for IPv4 and IPv6 VXLAN GPE encap dispatch functions.
Definition: encap.c:147
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
static char * vxlan_gpe_encap_error_strings[]
VXLAN GPE encap error strings.
Definition: encap.c:35
u32 encap_fib_index
FIB indices - tunnel partner lookup here.
Definition: vxlan_gpe.h:125
#define vnet_buffer(b)
Definition: buffer.h:417
uword encap_next_node
Next node after VxLAN-GPE encap.
Definition: vxlan_gpe.h:144
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
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
static void vxlan_gpe_encap_one_inline(vxlan_gpe_main_t *ngm, vlib_buffer_t *b0, vxlan_gpe_tunnel_t *t0, u32 *next0, u8 is_v4)
Instantiates UDP + VXLAN-GPE header then set next node to IP4|6 lookup.
Definition: encap.c:91
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
#define VXLAN_GPE_TUNNEL_IS_IPV4
Flags for vxlan_gpe_tunnel_t.
Definition: vxlan_gpe.h:169
static void ip_udp_encap_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 *ec0, word ec_len, u8 is_ip4)
Definition: udp_inlines.h:99
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
Definition: defs.h:46
u8 * format_vxlan_gpe_encap_trace(u8 *s, va_list *args)
Trace of packets encapsulated in VXLAN GPE.
Definition: encap.c:70