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