FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
decap.c
Go to the documentation of this file.
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>
26 
27 /**
28  * @brief Struct for VXLAN GPE decap packet tracing
29  *
30  */
31 typedef struct
32 {
37 
38 /**
39  * @brief Tracing function for VXLAN GPE packet decapsulation
40  *
41  * @param *s
42  * @param *args
43  *
44  * @return *s
45  *
46  */
47 static u8 *
48 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 *
77 format_vxlan_gpe_with_length (u8 * s, va_list * args)
78 {
79  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
80  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
81 
82 
83  return s;
84 }
85 
86 /**
87  * @brief Common processing for IPv4 and IPv6 VXLAN GPE decap dispatch functions
88  *
89  * It is worth noting that other than trivial UDP forwarding (transit), VXLAN GPE
90  * tunnels are "terminate local". This means that there is no "TX" interface for this
91  * decap case, so that field in the buffer_metadata can be "used for something else".
92  * The something else in this case is, for the IPv4/IPv6 inner-packet type case, the
93  * FIB index used to look up the inner-packet's adjacency.
94  *
95  * vnet_buffer(b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
96  *
97  * @param *vm
98  * @param *node
99  * @param *from_frame
100  * @param is_ip4
101  *
102  * @return from_frame->n_vectors
103  *
104  */
107  vlib_node_runtime_t * node,
108  vlib_frame_t * from_frame, u8 is_ip4)
109 {
110  u32 n_left_from, next_index, *from, *to_next;
112  vnet_main_t *vnm = nngm->vnet_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 ip4_pkts_decapsulated = 0;
118  u32 ip6_pkts_decapsulated = 0;
119  u32 thread_index = vm->thread_index;
120  u32 stats_sw_if_index, stats_n_packets, stats_n_bytes;
121 
122  if (is_ip4)
123  clib_memset (&last_key4, 0xff, sizeof (last_key4));
124  else
125  clib_memset (&last_key6, 0xff, sizeof (last_key6));
126 
127  from = vlib_frame_vector_args (from_frame);
128  n_left_from = from_frame->n_vectors;
129 
130  next_index = node->cached_next_index;
131  stats_sw_if_index = node->runtime_data[0];
132  stats_n_packets = stats_n_bytes = 0;
133 
134  while (n_left_from > 0)
135  {
136  u32 n_left_to_next;
137 
138  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
139 
140  while (n_left_from >= 4 && n_left_to_next >= 2)
141  {
142  u32 bi0, bi1;
143  vlib_buffer_t *b0, *b1;
144  u32 next0, next1;
145  ip4_vxlan_gpe_header_t *iuvn4_0, *iuvn4_1;
146  ip6_vxlan_gpe_header_t *iuvn6_0, *iuvn6_1;
147  uword *p0, *p1;
148  u32 tunnel_index0, tunnel_index1;
149  vxlan_gpe_tunnel_t *t0, *t1;
150  vxlan4_gpe_tunnel_key_t key4_0, key4_1;
151  vxlan6_gpe_tunnel_key_t key6_0, key6_1;
152  u32 error0, error1;
153  u32 sw_if_index0, sw_if_index1, len0, len1;
154 
155  /* Prefetch next iteration. */
156  {
157  vlib_buffer_t *p2, *p3;
158 
159  p2 = vlib_get_buffer (vm, from[2]);
160  p3 = vlib_get_buffer (vm, from[3]);
161 
162  vlib_prefetch_buffer_header (p2, LOAD);
163  vlib_prefetch_buffer_header (p3, LOAD);
164 
165  CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
166  CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
167  }
168 
169  bi0 = from[0];
170  bi1 = from[1];
171  to_next[0] = bi0;
172  to_next[1] = bi1;
173  from += 2;
174  to_next += 2;
175  n_left_to_next -= 2;
176  n_left_from -= 2;
177 
178  b0 = vlib_get_buffer (vm, bi0);
179  b1 = vlib_get_buffer (vm, bi1);
180 
181  if (is_ip4)
182  {
183  /* udp leaves current_data pointing at the vxlan-gpe header */
185  -(word) (sizeof (udp_header_t) +
186  sizeof (ip4_header_t)));
188  -(word) (sizeof (udp_header_t) +
189  sizeof (ip4_header_t)));
190 
191  iuvn4_0 = vlib_buffer_get_current (b0);
192  iuvn4_1 = vlib_buffer_get_current (b1);
193 
194  /* pop (ip, udp, vxlan) */
195  vlib_buffer_advance (b0, sizeof (*iuvn4_0));
196  vlib_buffer_advance (b1, sizeof (*iuvn4_1));
197  }
198  else
199  {
200  /* udp leaves current_data pointing at the vxlan-gpe header */
202  -(word) (sizeof (udp_header_t) +
203  sizeof (ip6_header_t)));
205  -(word) (sizeof (udp_header_t) +
206  sizeof (ip6_header_t)));
207 
208  iuvn6_0 = vlib_buffer_get_current (b0);
209  iuvn6_1 = vlib_buffer_get_current (b1);
210 
211  /* pop (ip, udp, vxlan) */
212  vlib_buffer_advance (b0, sizeof (*iuvn6_0));
213  vlib_buffer_advance (b1, sizeof (*iuvn6_1));
214  }
215 
216  tunnel_index0 = ~0;
217  tunnel_index1 = ~0;
218  error0 = 0;
219  error1 = 0;
220 
221  if (is_ip4)
222  {
223  next0 =
224  (iuvn4_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
225  nngm->decap_next_node_list[iuvn4_0->vxlan.protocol] :
226  VXLAN_GPE_INPUT_NEXT_DROP;
227  next1 =
228  (iuvn4_1->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
229  nngm->decap_next_node_list[iuvn4_1->vxlan.protocol] :
230  VXLAN_GPE_INPUT_NEXT_DROP;
231 
232  key4_0.local = iuvn4_0->ip4.dst_address.as_u32;
233  key4_1.local = iuvn4_1->ip4.dst_address.as_u32;
234 
235  key4_0.remote = iuvn4_0->ip4.src_address.as_u32;
236  key4_1.remote = iuvn4_1->ip4.src_address.as_u32;
237 
238  key4_0.vni = iuvn4_0->vxlan.vni_res;
239  key4_1.vni = iuvn4_1->vxlan.vni_res;
240 
241  key4_0.pad = 0;
242  key4_1.pad = 0;
243  }
244  else /* is_ip6 */
245  {
246  next0 = (iuvn6_0->vxlan.protocol < node->n_next_nodes) ?
247  iuvn6_0->vxlan.protocol : VXLAN_GPE_INPUT_NEXT_DROP;
248  next1 = (iuvn6_1->vxlan.protocol < node->n_next_nodes) ?
249  iuvn6_1->vxlan.protocol : VXLAN_GPE_INPUT_NEXT_DROP;
250 
251  key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
252  key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
253  key6_1.local.as_u64[0] = iuvn6_1->ip6.dst_address.as_u64[0];
254  key6_1.local.as_u64[1] = iuvn6_1->ip6.dst_address.as_u64[1];
255 
256  key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
257  key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
258  key6_1.remote.as_u64[0] = iuvn6_1->ip6.src_address.as_u64[0];
259  key6_1.remote.as_u64[1] = iuvn6_1->ip6.src_address.as_u64[1];
260 
261  key6_0.vni = iuvn6_0->vxlan.vni_res;
262  key6_1.vni = iuvn6_1->vxlan.vni_res;
263  }
264 
265  /* Processing packet 0 */
266  if (is_ip4)
267  {
268  /* Processing for key4_0 */
269  if (PREDICT_FALSE ((key4_0.as_u64[0] != last_key4.as_u64[0])
270  || (key4_0.as_u64[1] !=
271  last_key4.as_u64[1])))
272  {
273  p0 = hash_get_mem (nngm->vxlan4_gpe_tunnel_by_key, &key4_0);
274 
275  if (p0 == 0)
276  {
277  error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
278  goto trace0;
279  }
280 
281  last_key4.as_u64[0] = key4_0.as_u64[0];
282  last_key4.as_u64[1] = key4_0.as_u64[1];
283  tunnel_index0 = last_tunnel_index = p0[0];
284  }
285  else
286  tunnel_index0 = last_tunnel_index;
287  }
288  else /* is_ip6 */
289  {
290  next0 =
291  (iuvn6_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
292  nngm->decap_next_node_list[iuvn6_0->vxlan.protocol] :
293  VXLAN_GPE_INPUT_NEXT_DROP;
294  next1 =
295  (iuvn6_1->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
296  nngm->decap_next_node_list[iuvn6_1->vxlan.protocol] :
297  VXLAN_GPE_INPUT_NEXT_DROP;
298 
299  key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
300  key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
301  key6_1.local.as_u64[0] = iuvn6_1->ip6.dst_address.as_u64[0];
302  key6_1.local.as_u64[1] = iuvn6_1->ip6.dst_address.as_u64[1];
303 
304  key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
305  key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
306  key6_1.remote.as_u64[0] = iuvn6_1->ip6.src_address.as_u64[0];
307  key6_1.remote.as_u64[1] = iuvn6_1->ip6.src_address.as_u64[1];
308 
309  key6_0.vni = iuvn6_0->vxlan.vni_res;
310  key6_1.vni = iuvn6_1->vxlan.vni_res;
311 
312  /* Processing for key6_0 */
313  if (PREDICT_FALSE
314  (memcmp (&key6_0, &last_key6, sizeof (last_key6)) != 0))
315  {
316  p0 = hash_get_mem (nngm->vxlan6_gpe_tunnel_by_key, &key6_0);
317 
318  if (p0 == 0)
319  {
320  error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
321  goto trace0;
322  }
323 
324  memcpy (&last_key6, &key6_0, sizeof (key6_0));
325  tunnel_index0 = last_tunnel_index = p0[0];
326  }
327  else
328  tunnel_index0 = last_tunnel_index;
329  }
330 
331  t0 = pool_elt_at_index (nngm->tunnels, tunnel_index0);
332 
333 
334  sw_if_index0 = t0->sw_if_index;
335  len0 = vlib_buffer_length_in_chain (vm, b0);
336 
337  /* Required to make the l2 tag push / pop code work on l2 subifs */
338  vnet_update_l2_len (b0);
339 
340  /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
341  vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
342 
343  /**
344  * ip[46] lookup in the configured FIB
345  */
346  vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
347 
348  if (is_ip4)
349  ip4_pkts_decapsulated++;
350  else
351  ip6_pkts_decapsulated++;
352 
353  stats_n_packets += 1;
354  stats_n_bytes += len0;
355 
356  if (PREDICT_FALSE (sw_if_index0 != stats_sw_if_index))
357  {
358  stats_n_packets -= 1;
359  stats_n_bytes -= len0;
360  if (stats_n_packets)
363  thread_index,
364  stats_sw_if_index,
365  stats_n_packets,
366  stats_n_bytes);
367  stats_n_packets = 1;
368  stats_n_bytes = len0;
369  stats_sw_if_index = sw_if_index0;
370  }
371 
372  trace0:b0->error = error0 ? node->errors[error0] : 0;
373 
374  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
375  {
377  vlib_add_trace (vm, node, b0, sizeof (*tr));
378  tr->next_index = next0;
379  tr->error = error0;
380  tr->tunnel_index = tunnel_index0;
381  }
382 
383  /* Process packet 1 */
384  if (is_ip4)
385  {
386  /* Processing for key4_1 */
387  if (PREDICT_FALSE ((key4_1.as_u64[0] != last_key4.as_u64[0])
388  || (key4_1.as_u64[1] !=
389  last_key4.as_u64[1])))
390  {
391  p1 = hash_get_mem (nngm->vxlan4_gpe_tunnel_by_key, &key4_1);
392 
393  if (p1 == 0)
394  {
395  error1 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
396  goto trace1;
397  }
398 
399  last_key4.as_u64[0] = key4_1.as_u64[0];
400  last_key4.as_u64[1] = key4_1.as_u64[1];
401  tunnel_index1 = last_tunnel_index = p1[0];
402  }
403  else
404  tunnel_index1 = last_tunnel_index;
405  }
406  else /* is_ip6 */
407  {
408  /* Processing for key6_1 */
409  if (PREDICT_FALSE
410  (memcmp (&key6_1, &last_key6, sizeof (last_key6)) != 0))
411  {
412  p1 = hash_get_mem (nngm->vxlan6_gpe_tunnel_by_key, &key6_1);
413 
414  if (p1 == 0)
415  {
416  error1 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
417  goto trace1;
418  }
419 
420  memcpy (&last_key6, &key6_1, sizeof (key6_1));
421  tunnel_index1 = last_tunnel_index = p1[0];
422  }
423  else
424  tunnel_index1 = last_tunnel_index;
425  }
426 
427  t1 = pool_elt_at_index (nngm->tunnels, tunnel_index1);
428 
429  sw_if_index1 = t1->sw_if_index;
430  len1 = vlib_buffer_length_in_chain (vm, b1);
431 
432  /* Required to make the l2 tag push / pop code work on l2 subifs */
433  vnet_update_l2_len (b1);
434 
435  /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
436  vnet_buffer (b1)->sw_if_index[VLIB_RX] = t1->sw_if_index;
437 
438  /*
439  * ip[46] lookup in the configured FIB
440  */
441  vnet_buffer (b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
442 
443  if (is_ip4)
444  ip4_pkts_decapsulated++;
445  else
446  ip6_pkts_decapsulated++;
447 
448  stats_n_packets += 1;
449  stats_n_bytes += len1;
450 
451  /* Batch stats increment on the same vxlan tunnel so counter
452  is not incremented per packet */
453  if (PREDICT_FALSE (sw_if_index1 != stats_sw_if_index))
454  {
455  stats_n_packets -= 1;
456  stats_n_bytes -= len1;
457  if (stats_n_packets)
460  thread_index,
461  stats_sw_if_index,
462  stats_n_packets,
463  stats_n_bytes);
464  stats_n_packets = 1;
465  stats_n_bytes = len1;
466  stats_sw_if_index = sw_if_index1;
467  }
468  vnet_buffer (b1)->sw_if_index[VLIB_TX] = t1->decap_fib_index;
469 
470  trace1:b1->error = error1 ? node->errors[error1] : 0;
471 
472  if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
473  {
475  vlib_add_trace (vm, node, b1, sizeof (*tr));
476  tr->next_index = next1;
477  tr->error = error1;
478  tr->tunnel_index = tunnel_index1;
479  }
480 
481  vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
482  n_left_to_next, bi0, bi1, next0,
483  next1);
484  }
485 
486  while (n_left_from > 0 && n_left_to_next > 0)
487  {
488  u32 bi0;
489  vlib_buffer_t *b0;
490  u32 next0;
491  ip4_vxlan_gpe_header_t *iuvn4_0;
492  ip6_vxlan_gpe_header_t *iuvn6_0;
493  uword *p0;
494  u32 tunnel_index0;
495  vxlan_gpe_tunnel_t *t0;
496  vxlan4_gpe_tunnel_key_t key4_0;
497  vxlan6_gpe_tunnel_key_t key6_0;
498  u32 error0;
499  u32 sw_if_index0, len0;
500 
501  bi0 = from[0];
502  to_next[0] = bi0;
503  from += 1;
504  to_next += 1;
505  n_left_from -= 1;
506  n_left_to_next -= 1;
507 
508  b0 = vlib_get_buffer (vm, bi0);
509 
510  if (is_ip4)
511  {
512  /* udp leaves current_data pointing at the vxlan-gpe header */
514  -(word) (sizeof (udp_header_t) +
515  sizeof (ip4_header_t)));
516 
517  iuvn4_0 = vlib_buffer_get_current (b0);
518 
519  /* pop (ip, udp, vxlan) */
520  vlib_buffer_advance (b0, sizeof (*iuvn4_0));
521  }
522  else
523  {
524  /* udp leaves current_data pointing at the vxlan-gpe header */
526  -(word) (sizeof (udp_header_t) +
527  sizeof (ip6_header_t)));
528 
529  iuvn6_0 = vlib_buffer_get_current (b0);
530 
531  /* pop (ip, udp, vxlan) */
532  vlib_buffer_advance (b0, sizeof (*iuvn6_0));
533  }
534 
535  tunnel_index0 = ~0;
536  error0 = 0;
537 
538  if (is_ip4)
539  {
540  next0 =
541  (iuvn4_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
542  nngm->decap_next_node_list[iuvn4_0->vxlan.protocol] :
543  VXLAN_GPE_INPUT_NEXT_DROP;
544 
545  key4_0.local = iuvn4_0->ip4.dst_address.as_u32;
546  key4_0.remote = iuvn4_0->ip4.src_address.as_u32;
547  key4_0.vni = iuvn4_0->vxlan.vni_res;
548  key4_0.pad = 0;
549 
550  /* Processing for key4_0 */
551  if (PREDICT_FALSE ((key4_0.as_u64[0] != last_key4.as_u64[0])
552  || (key4_0.as_u64[1] !=
553  last_key4.as_u64[1])))
554  {
555  p0 = hash_get_mem (nngm->vxlan4_gpe_tunnel_by_key, &key4_0);
556 
557  if (p0 == 0)
558  {
559  error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
560  goto trace00;
561  }
562 
563  last_key4.as_u64[0] = key4_0.as_u64[0];
564  last_key4.as_u64[1] = key4_0.as_u64[1];
565  tunnel_index0 = last_tunnel_index = p0[0];
566  }
567  else
568  tunnel_index0 = last_tunnel_index;
569  }
570  else /* is_ip6 */
571  {
572  next0 =
573  (iuvn6_0->vxlan.protocol < VXLAN_GPE_PROTOCOL_MAX) ?
574  nngm->decap_next_node_list[iuvn6_0->vxlan.protocol] :
575  VXLAN_GPE_INPUT_NEXT_DROP;
576 
577  key6_0.local.as_u64[0] = iuvn6_0->ip6.dst_address.as_u64[0];
578  key6_0.local.as_u64[1] = iuvn6_0->ip6.dst_address.as_u64[1];
579  key6_0.remote.as_u64[0] = iuvn6_0->ip6.src_address.as_u64[0];
580  key6_0.remote.as_u64[1] = iuvn6_0->ip6.src_address.as_u64[1];
581  key6_0.vni = iuvn6_0->vxlan.vni_res;
582 
583  /* Processing for key6_0 */
584  if (PREDICT_FALSE
585  (memcmp (&key6_0, &last_key6, sizeof (last_key6)) != 0))
586  {
587  p0 = hash_get_mem (nngm->vxlan6_gpe_tunnel_by_key, &key6_0);
588 
589  if (p0 == 0)
590  {
591  error0 = VXLAN_GPE_ERROR_NO_SUCH_TUNNEL;
592  goto trace00;
593  }
594 
595  memcpy (&last_key6, &key6_0, sizeof (key6_0));
596  tunnel_index0 = last_tunnel_index = p0[0];
597  }
598  else
599  tunnel_index0 = last_tunnel_index;
600  }
601 
602  t0 = pool_elt_at_index (nngm->tunnels, tunnel_index0);
603 
604 
605  sw_if_index0 = t0->sw_if_index;
606  len0 = vlib_buffer_length_in_chain (vm, b0);
607 
608  /* Required to make the l2 tag push / pop code work on l2 subifs */
609  vnet_update_l2_len (b0);
610 
611  /* Set packet input sw_if_index to unicast VXLAN tunnel for learning */
612  vnet_buffer (b0)->sw_if_index[VLIB_RX] = t0->sw_if_index;
613 
614  /*
615  * ip[46] lookup in the configured FIB
616  */
617  vnet_buffer (b0)->sw_if_index[VLIB_TX] = t0->decap_fib_index;
618 
619  if (is_ip4)
620  ip4_pkts_decapsulated++;
621  else
622  ip6_pkts_decapsulated++;
623 
624  stats_n_packets += 1;
625  stats_n_bytes += len0;
626 
627  /* Batch stats increment on the same vxlan-gpe tunnel so counter
628  is not incremented per packet */
629  if (PREDICT_FALSE (sw_if_index0 != stats_sw_if_index))
630  {
631  stats_n_packets -= 1;
632  stats_n_bytes -= len0;
633  if (stats_n_packets)
636  thread_index,
637  stats_sw_if_index,
638  stats_n_packets,
639  stats_n_bytes);
640  stats_n_packets = 1;
641  stats_n_bytes = len0;
642  stats_sw_if_index = sw_if_index0;
643  }
644 
645  trace00:b0->error = error0 ? node->errors[error0] : 0;
646 
647  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
648  {
650  vlib_add_trace (vm, node, b0, sizeof (*tr));
651  tr->next_index = next0;
652  tr->error = error0;
653  tr->tunnel_index = tunnel_index0;
654  }
655  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
656  n_left_to_next, bi0, next0);
657  }
658 
659  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
660  }
662  VXLAN_GPE_ERROR_DECAPSULATED,
663  ip4_pkts_decapsulated);
665  VXLAN_GPE_ERROR_DECAPSULATED,
666  ip6_pkts_decapsulated);
667  /* Increment any remaining batch stats */
668  if (stats_n_packets)
669  {
672  thread_index, stats_sw_if_index,
673  stats_n_packets, stats_n_bytes);
674  node->runtime_data[0] = stats_sw_if_index;
675  }
676  return from_frame->n_vectors;
677 }
678 
679 /**
680  * @brief Graph processing dispatch function for IPv4 VXLAN GPE
681  *
682  * @node vxlan4-gpe-input
683  * @param *vm
684  * @param *node
685  * @param *from_frame
686  *
687  * @return from_frame->n_vectors
688  *
689  */
691  vlib_node_runtime_t * node,
692  vlib_frame_t * from_frame)
693 {
694  return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */ 1);
695 }
696 
697 #ifndef CLIB_MARCH_VARIANT
698 void
699 vxlan_gpe_register_decap_protocol (u8 protocol_id, uword next_node_index)
700 {
702  hm->decap_next_node_list[protocol_id] = next_node_index;
703  return;
704 }
705 
706 void
707 vxlan_gpe_unregister_decap_protocol (u8 protocol_id, uword next_node_index)
708 {
710  hm->decap_next_node_list[protocol_id] = VXLAN_GPE_INPUT_NEXT_DROP;
711  return;
712 }
713 #endif /* CLIB_MARCH_VARIANT */
714 
715 /**
716  * @brief Graph processing dispatch function for IPv6 VXLAN GPE
717  *
718  * @node vxlan6-gpe-input
719  * @param *vm
720  * @param *node
721  * @param *from_frame
722  *
723  * @return from_frame->n_vectors - uword
724  *
725  */
727  vlib_node_runtime_t * node,
728  vlib_frame_t * from_frame)
729 {
730  return vxlan_gpe_input (vm, node, from_frame, /* is_ip4 */ 0);
731 }
732 
733 /**
734  * @brief VXLAN GPE error strings
735  */
736 static char *vxlan_gpe_error_strings[] = {
737 #define vxlan_gpe_error(n,s) s,
739 #undef vxlan_gpe_error
740 #undef _
741 };
742 
743 /* *INDENT-OFF* */
745  .name = "vxlan4-gpe-input",
746  /* Takes a vector of packets. */
747  .vector_size = sizeof (u32),
748  .type = VLIB_NODE_TYPE_INTERNAL,
749  .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
750  .error_strings = vxlan_gpe_error_strings,
751 
752  .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
753  .next_nodes = {
754 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
756 #undef _
757  },
758 
759  .format_buffer = format_vxlan_gpe_with_length,
760  .format_trace = format_vxlan_gpe_rx_trace,
761  // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
762 };
763 /* *INDENT-ON* */
764 
765 /* *INDENT-OFF* */
767  .name = "vxlan6-gpe-input",
768  /* Takes a vector of packets. */
769  .vector_size = sizeof (u32),
770  .type = VLIB_NODE_TYPE_INTERNAL,
771  .n_errors = ARRAY_LEN(vxlan_gpe_error_strings),
772  .error_strings = vxlan_gpe_error_strings,
773 
774  .n_next_nodes = VXLAN_GPE_INPUT_N_NEXT,
775  .next_nodes = {
776 #define _(s,n) [VXLAN_GPE_INPUT_NEXT_##s] = n,
778 #undef _
779  },
780 
781  .format_buffer = format_vxlan_gpe_with_length,
782  .format_trace = format_vxlan_gpe_rx_trace,
783  // $$$$ .unformat_buffer = unformat_vxlan_gpe_header,
784 };
785 /* *INDENT-ON* */
786 
787 typedef enum
788 {
793 
796  vlib_node_runtime_t * node,
797  vlib_frame_t * frame, u32 is_ip4)
798 {
800  u32 *from, *to_next, n_left_from, n_left_to_next, next_index;
801  vlib_node_runtime_t *error_node =
803  ip4_address_t addr4; /* last IPv4 address matching a local VTEP address */
804  ip6_address_t addr6; /* last IPv6 address matching a local VTEP address */
805 
806  from = vlib_frame_vector_args (frame);
807  n_left_from = frame->n_vectors;
808  next_index = node->cached_next_index;
809 
810  if (node->flags & VLIB_NODE_FLAG_TRACE)
811  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
812 
813  if (is_ip4)
814  addr4.data_u32 = ~0;
815  else
816  ip6_address_set_zero (&addr6);
817 
818  while (n_left_from > 0)
819  {
820  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
821 
822  while (n_left_from >= 4 && n_left_to_next >= 2)
823  {
824  vlib_buffer_t *b0, *b1;
825  ip4_header_t *ip40, *ip41;
826  ip6_header_t *ip60, *ip61;
827  udp_header_t *udp0, *udp1;
828  u32 bi0, ip_len0, udp_len0, flags0, next0;
829  u32 bi1, ip_len1, udp_len1, flags1, next1;
830  i32 len_diff0, len_diff1;
831  u8 error0, good_udp0, proto0;
832  u8 error1, good_udp1, proto1;
833 
834  /* Prefetch next iteration. */
835  {
836  vlib_buffer_t *p2, *p3;
837 
838  p2 = vlib_get_buffer (vm, from[2]);
839  p3 = vlib_get_buffer (vm, from[3]);
840 
841  vlib_prefetch_buffer_header (p2, LOAD);
842  vlib_prefetch_buffer_header (p3, LOAD);
843 
844  CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
845  CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
846  }
847 
848  bi0 = to_next[0] = from[0];
849  bi1 = to_next[1] = from[1];
850  from += 2;
851  n_left_from -= 2;
852  to_next += 2;
853  n_left_to_next -= 2;
854 
855  b0 = vlib_get_buffer (vm, bi0);
856  b1 = vlib_get_buffer (vm, bi1);
857  if (is_ip4)
858  {
859  ip40 = vlib_buffer_get_current (b0);
860  ip41 = vlib_buffer_get_current (b1);
861  }
862  else
863  {
864  ip60 = vlib_buffer_get_current (b0);
865  ip61 = vlib_buffer_get_current (b1);
866  }
867 
868  /* Setup packet for next IP feature */
869  vnet_feature_next (&next0, b0);
870  vnet_feature_next (&next1, b1);
871 
872  if (is_ip4)
873  {
874  proto0 = ip40->protocol;
875  proto1 = ip41->protocol;
876  }
877  else
878  {
879  proto0 = ip60->protocol;
880  proto1 = ip61->protocol;
881  }
882 
883  /* Process packet 0 */
884  if (proto0 != IP_PROTOCOL_UDP)
885  goto exit0; /* not UDP packet */
886 
887  if (is_ip4)
888  udp0 = ip4_next_header (ip40);
889  else
890  udp0 = ip6_next_header (ip60);
891 
892  if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_VXLAN_GPE))
893  goto exit0; /* not VXLAN packet */
894 
895  /* Validate DIP against VTEPs */
896  if (is_ip4)
897  {
898  if (addr4.as_u32 != ip40->dst_address.as_u32)
899  {
900  if (!hash_get (ngm->vtep4, ip40->dst_address.as_u32))
901  goto exit0; /* no local VTEP for VXLAN packet */
902  addr4 = ip40->dst_address;
903  }
904  }
905  else
906  {
907  if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
908  {
909  if (!hash_get_mem (ngm->vtep6, &ip60->dst_address))
910  goto exit0; /* no local VTEP for VXLAN packet */
911  addr6 = ip60->dst_address;
912  }
913  }
914 
915  flags0 = b0->flags;
916  good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
917 
918  /* Don't verify UDP checksum for packets with explicit zero checksum. */
919  good_udp0 |= udp0->checksum == 0;
920 
921  /* Verify UDP length */
922  if (is_ip4)
923  ip_len0 = clib_net_to_host_u16 (ip40->length);
924  else
925  ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
926  udp_len0 = clib_net_to_host_u16 (udp0->length);
927  len_diff0 = ip_len0 - udp_len0;
928 
929  /* Verify UDP checksum */
930  if (PREDICT_FALSE (!good_udp0))
931  {
932  if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
933  {
934  if (is_ip4)
935  flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
936  else
937  flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
938  good_udp0 =
939  (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
940  }
941  }
942 
943  if (is_ip4)
944  {
945  error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
946  error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
947  }
948  else
949  {
950  error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
951  error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
952  }
953 
954  next0 = error0 ?
956  b0->error = error0 ? error_node->errors[error0] : 0;
957 
958  /* vxlan_gpe-input node expect current at VXLAN header */
959  if (is_ip4)
961  sizeof (ip4_header_t) +
962  sizeof (udp_header_t));
963  else
965  sizeof (ip6_header_t) +
966  sizeof (udp_header_t));
967 
968  exit0:
969  /* Process packet 1 */
970  if (proto1 != IP_PROTOCOL_UDP)
971  goto exit1; /* not UDP packet */
972 
973  if (is_ip4)
974  udp1 = ip4_next_header (ip41);
975  else
976  udp1 = ip6_next_header (ip61);
977 
978  if (udp1->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_VXLAN_GPE))
979  goto exit1; /* not VXLAN packet */
980 
981  /* Validate DIP against VTEPs */
982  if (is_ip4)
983  {
984  if (addr4.as_u32 != ip41->dst_address.as_u32)
985  {
986  if (!hash_get (ngm->vtep4, ip41->dst_address.as_u32))
987  goto exit1; /* no local VTEP for VXLAN packet */
988  addr4 = ip41->dst_address;
989  }
990  }
991  else
992  {
993  if (!ip6_address_is_equal (&addr6, &ip61->dst_address))
994  {
995  if (!hash_get_mem (ngm->vtep6, &ip61->dst_address))
996  goto exit1; /* no local VTEP for VXLAN packet */
997  addr6 = ip61->dst_address;
998  }
999  }
1000 
1001  flags1 = b1->flags;
1002  good_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1003 
1004  /* Don't verify UDP checksum for packets with explicit zero checksum. */
1005  good_udp1 |= udp1->checksum == 0;
1006 
1007  /* Verify UDP length */
1008  if (is_ip4)
1009  ip_len1 = clib_net_to_host_u16 (ip41->length);
1010  else
1011  ip_len1 = clib_net_to_host_u16 (ip61->payload_length);
1012  udp_len1 = clib_net_to_host_u16 (udp1->length);
1013  len_diff1 = ip_len1 - udp_len1;
1014 
1015  /* Verify UDP checksum */
1016  if (PREDICT_FALSE (!good_udp1))
1017  {
1018  if ((flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
1019  {
1020  if (is_ip4)
1021  flags1 = ip4_tcp_udp_validate_checksum (vm, b1);
1022  else
1023  flags1 = ip6_tcp_udp_icmp_validate_checksum (vm, b1);
1024  good_udp1 =
1025  (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1026  }
1027  }
1028 
1029  if (is_ip4)
1030  {
1031  error1 = good_udp1 ? 0 : IP4_ERROR_UDP_CHECKSUM;
1032  error1 = (len_diff1 >= 0) ? error1 : IP4_ERROR_UDP_LENGTH;
1033  }
1034  else
1035  {
1036  error1 = good_udp1 ? 0 : IP6_ERROR_UDP_CHECKSUM;
1037  error1 = (len_diff1 >= 0) ? error1 : IP6_ERROR_UDP_LENGTH;
1038  }
1039 
1040  next1 = error1 ?
1042  b1->error = error1 ? error_node->errors[error1] : 0;
1043 
1044  /* vxlan_gpe-input node expect current at VXLAN header */
1045  if (is_ip4)
1046  vlib_buffer_advance (b1,
1047  sizeof (ip4_header_t) +
1048  sizeof (udp_header_t));
1049  else
1050  vlib_buffer_advance (b1,
1051  sizeof (ip6_header_t) +
1052  sizeof (udp_header_t));
1053 
1054  exit1:
1055  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
1056  to_next, n_left_to_next,
1057  bi0, bi1, next0, next1);
1058  }
1059 
1060  while (n_left_from > 0 && n_left_to_next > 0)
1061  {
1062  vlib_buffer_t *b0;
1063  ip4_header_t *ip40;
1064  ip6_header_t *ip60;
1065  udp_header_t *udp0;
1066  u32 bi0, ip_len0, udp_len0, flags0, next0;
1067  i32 len_diff0;
1068  u8 error0, good_udp0, proto0;
1069 
1070  bi0 = to_next[0] = from[0];
1071  from += 1;
1072  n_left_from -= 1;
1073  to_next += 1;
1074  n_left_to_next -= 1;
1075 
1076  b0 = vlib_get_buffer (vm, bi0);
1077  if (is_ip4)
1078  ip40 = vlib_buffer_get_current (b0);
1079  else
1080  ip60 = vlib_buffer_get_current (b0);
1081 
1082  /* Setup packet for next IP feature */
1083  vnet_feature_next (&next0, b0);
1084 
1085  if (is_ip4)
1086  proto0 = ip40->protocol;
1087  else
1088  proto0 = ip60->protocol;
1089 
1090  if (proto0 != IP_PROTOCOL_UDP)
1091  goto exit; /* not UDP packet */
1092 
1093  if (is_ip4)
1094  udp0 = ip4_next_header (ip40);
1095  else
1096  udp0 = ip6_next_header (ip60);
1097 
1098  if (udp0->dst_port != clib_host_to_net_u16 (UDP_DST_PORT_VXLAN_GPE))
1099  goto exit; /* not VXLAN packet */
1100 
1101  /* Validate DIP against VTEPs */
1102  if (is_ip4)
1103  {
1104  if (addr4.as_u32 != ip40->dst_address.as_u32)
1105  {
1106  if (!hash_get (ngm->vtep4, ip40->dst_address.as_u32))
1107  goto exit; /* no local VTEP for VXLAN packet */
1108  addr4 = ip40->dst_address;
1109  }
1110  }
1111  else
1112  {
1113  if (!ip6_address_is_equal (&addr6, &ip60->dst_address))
1114  {
1115  if (!hash_get_mem (ngm->vtep6, &ip60->dst_address))
1116  goto exit; /* no local VTEP for VXLAN packet */
1117  addr6 = ip60->dst_address;
1118  }
1119  }
1120 
1121  flags0 = b0->flags;
1122  good_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1123 
1124  /* Don't verify UDP checksum for packets with explicit zero checksum. */
1125  good_udp0 |= udp0->checksum == 0;
1126 
1127  /* Verify UDP length */
1128  if (is_ip4)
1129  ip_len0 = clib_net_to_host_u16 (ip40->length);
1130  else
1131  ip_len0 = clib_net_to_host_u16 (ip60->payload_length);
1132  udp_len0 = clib_net_to_host_u16 (udp0->length);
1133  len_diff0 = ip_len0 - udp_len0;
1134 
1135  /* Verify UDP checksum */
1136  if (PREDICT_FALSE (!good_udp0))
1137  {
1138  if ((flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED) == 0)
1139  {
1140  if (is_ip4)
1141  flags0 = ip4_tcp_udp_validate_checksum (vm, b0);
1142  else
1143  flags0 = ip6_tcp_udp_icmp_validate_checksum (vm, b0);
1144  good_udp0 =
1145  (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1146  }
1147  }
1148 
1149  if (is_ip4)
1150  {
1151  error0 = good_udp0 ? 0 : IP4_ERROR_UDP_CHECKSUM;
1152  error0 = (len_diff0 >= 0) ? error0 : IP4_ERROR_UDP_LENGTH;
1153  }
1154  else
1155  {
1156  error0 = good_udp0 ? 0 : IP6_ERROR_UDP_CHECKSUM;
1157  error0 = (len_diff0 >= 0) ? error0 : IP6_ERROR_UDP_LENGTH;
1158  }
1159 
1160  next0 = error0 ?
1162  b0->error = error0 ? error_node->errors[error0] : 0;
1163 
1164  /* vxlan_gpe-input node expect current at VXLAN header */
1165  if (is_ip4)
1166  vlib_buffer_advance (b0,
1167  sizeof (ip4_header_t) +
1168  sizeof (udp_header_t));
1169  else
1170  vlib_buffer_advance (b0,
1171  sizeof (ip6_header_t) +
1172  sizeof (udp_header_t));
1173 
1174  exit:
1175  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1176  to_next, n_left_to_next,
1177  bi0, next0);
1178  }
1179 
1180  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1181  }
1182 
1183  return frame->n_vectors;
1184 }
1185 
1187  vlib_node_runtime_t * node,
1188  vlib_frame_t * frame)
1189 {
1190  return ip_vxlan_gpe_bypass_inline (vm, node, frame, /* is_ip4 */ 1);
1191 }
1192 
1193 /* *INDENT-OFF* */
1195  .name = "ip4-vxlan-gpe-bypass",
1196  .vector_size = sizeof (u32),
1197 
1198  .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
1199  .next_nodes = {
1200  [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
1201  [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan4-gpe-input",
1202  },
1203 
1204  .format_buffer = format_ip4_header,
1205  .format_trace = format_ip4_forward_next_trace,
1206 };
1207 /* *INDENT-ON* */
1208 
1209 #ifndef CLIB_MARCH_VARIANT
1210 /* Dummy init function to get us linked in. */
1211 clib_error_t *
1213 {
1214  return 0;
1215 }
1216 
1218 #endif /* CLIB_MARCH_VARIANT */
1219 
1221  vlib_node_runtime_t * node,
1222  vlib_frame_t * frame)
1223 {
1224  return ip_vxlan_gpe_bypass_inline (vm, node, frame, /* is_ip4 */ 0);
1225 }
1226 
1227 /* *INDENT-OFF* */
1229  .name = "ip6-vxlan-gpe-bypass",
1230  .vector_size = sizeof (u32),
1231 
1232  .n_next_nodes = IP_VXLAN_BYPASS_N_NEXT,
1233  .next_nodes = {
1234  [IP_VXLAN_BYPASS_NEXT_DROP] = "error-drop",
1235  [IP_VXLAN_BYPASS_NEXT_VXLAN] = "vxlan6-gpe-input",
1236  },
1237 
1238  .format_buffer = format_ip6_header,
1239  .format_trace = format_ip6_forward_next_trace,
1240 };
1241 /* *INDENT-ON* */
1242 
1243 #ifndef CLIB_MARCH_VARIANT
1244 /* Dummy init function to get us linked in. */
1245 clib_error_t *
1247 {
1248  return 0;
1249 }
1250 
1252 #endif /* CLIB_MARCH_VARIANT */
1253 
1254 /*
1255  * fd.io coding-style-patch-verification: ON
1256  *
1257  * Local Variables:
1258  * eval: (c-set-style "gnu")
1259  * End:
1260  */
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
uword * vxlan6_gpe_tunnel_by_key
lookup IPv6 VXLAN GPE tunnel by key
Definition: vxlan_gpe.h:204
#define CLIB_UNUSED(x)
Definition: clib.h:82
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:220
u8 runtime_data[0]
Function dependent node-runtime data.
Definition: node.h:521
vlib_node_registration_t vxlan4_gpe_input_node
(constructor) VLIB_REGISTER_NODE (vxlan4_gpe_input_node)
Definition: decap.c:744
vnet_interface_main_t interface_main
Definition: vnet.h:56
format_function_t format_ip4_header
Definition: format.h:83
Struct for VXLAN GPE decap packet tracing.
Definition: decap.c:31
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
ip_vxlan_bypass_next_t
Definition: decap.c:455
VXLAN GPE definitions.
u32 thread_index
Definition: main.h:197
u8 data[0]
Packet data.
Definition: buffer.h:181
vlib_node_registration_t vxlan6_gpe_input_node
(constructor) VLIB_REGISTER_NODE (vxlan6_gpe_input_node)
Definition: decap.c:766
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define VLIB_NODE_FN(node)
Definition: node.h:201
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:468
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:366
unsigned char u8
Definition: types.h:56
vnet_main_t * vnet_main
State convenience vnet_main_t.
Definition: vxlan_gpe.h:221
i64 word
Definition: types.h:111
static char * vxlan_gpe_error_strings[]
VXLAN GPE error strings.
Definition: decap.c:736
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
#define always_inline
Definition: clib.h:98
ip4_address_t dst_address
Definition: ip4_packet.h:170
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:824
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:203
static void * ip4_next_header(ip4_header_t *i)
Definition: ip4_packet.h:241
unsigned int u32
Definition: types.h:88
void vxlan_gpe_register_decap_protocol(u8 protocol_id, uword next_node_index)
Definition: decap.c:699
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
#define hash_get(h, key)
Definition: hash.h:249
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
vlib_node_registration_t ip4_input_node
Global ip4 input node.
Definition: ip4_input.c:317
static uword vxlan_gpe_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 is_ip4)
Common processing for IPv4 and IPv6 VXLAN GPE decap dispatch functions.
Definition: decap.c:106
Struct for VXLAN GPE tunnel.
Definition: vxlan_gpe.h:102
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
vxlan_gpe_main_t vxlan_gpe_main
Definition: vxlan_gpe.c:45
#define PREDICT_FALSE(x)
Definition: clib.h:111
u32 ip4_tcp_udp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
Definition: ip4_forward.c:1189
#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:218
#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:338
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1150
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u16 n_vectors
Definition: node.h:395
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
vlib_main_t * vm
Definition: buffer.c:312
static void ip6_address_set_zero(ip6_address_t *a)
Definition: ip6_packet.h:278
clib_error_t * ip4_vxlan_gpe_bypass_init(vlib_main_t *vm)
Definition: decap.c:1212
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:295
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:89
#define ARRAY_LEN(x)
Definition: clib.h:62
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:458
static void * ip6_next_header(ip6_header_t *i)
Definition: ip6_packet.h:412
#define foreach_vxlan_gpe_input_next
next nodes for VXLAN GPE input
Definition: vxlan_gpe.h:171
signed int i32
Definition: types.h:77
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:513
static u8 * format_vxlan_gpe_with_length(u8 *s, va_list *args)
Tracing function for VXLAN GPE packet decapsulation including length.
Definition: decap.c:77
Struct for VXLAN GPE node state.
Definition: vxlan_gpe.h:196
vlib_node_registration_t ip4_vxlan_gpe_bypass_node
(constructor) VLIB_REGISTER_NODE (ip4_vxlan_gpe_bypass_node)
Definition: decap.c:1194
clib_error_t * ip6_vxlan_gpe_bypass_init(vlib_main_t *vm)
Definition: decap.c:1246
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:248
uword decap_next_node_list[VXLAN_GPE_PROTOCOL_MAX]
List of next nodes for the decap indexed on protocol.
Definition: vxlan_gpe.h:224
format_function_t format_ip6_header
Definition: format.h:97
static uword ip6_address_is_equal(const ip6_address_t *a, const ip6_address_t *b)
Definition: ip6_packet.h:242
vxlan_gpe_tunnel_t * tunnels
vector of encap tunnel instances
Definition: vxlan_gpe.h:199
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
void vxlan_gpe_unregister_decap_protocol(u8 protocol_id, uword next_node_index)
Definition: decap.c:707
Definition: defs.h:47
uword * vxlan4_gpe_tunnel_by_key
lookup IPv4 VXLAN GPE tunnel by key
Definition: vxlan_gpe.h:202
u32 decap_fib_index
FIB indices - inner IP packet lookup here.
Definition: vxlan_gpe.h:126
u16 payload_length
Definition: ip6_packet.h:376
u32 ip6_tcp_udp_icmp_validate_checksum(vlib_main_t *vm, vlib_buffer_t *p0)
Definition: ip6_forward.c:1031
static void vnet_update_l2_len(vlib_buffer_t *b)
Definition: l2_input.h:226
void ip4_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
Definition: ip4_forward.c:1040
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:244
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
Definition: ip4_forward.c:990
vlib_node_registration_t ip6_vxlan_gpe_bypass_node
(constructor) VLIB_REGISTER_NODE (ip6_vxlan_gpe_bypass_node)
Definition: decap.c:1228
#define hash_get_mem(h, key)
Definition: hash.h:269
#define vnet_buffer(b)
Definition: buffer.h:369
u32 sw_if_index
vnet intfc sw_if_index
Definition: vxlan_gpe.h:134
u16 flags
Copy of main node flags.
Definition: node.h:507
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:301
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static u8 * format_vxlan_gpe_rx_trace(u8 *s, va_list *args)
Tracing function for VXLAN GPE packet decapsulation.
Definition: decap.c:48
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
Definition: defs.h:46
ip6_address_t dst_address
Definition: ip6_packet.h:385
static uword ip_vxlan_gpe_bypass_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u32 is_ip4)
Definition: decap.c:795
u8 * format_ip6_forward_next_trace(u8 *s, va_list *args)
Definition: ip6_forward.c:803