2 * Copyright (c) 2016 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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vnet/dpo/dvr_dpo.h>
17 #include <vnet/fib/fib_node.h>
18 #include <vnet/ip/ip.h>
19 #include <vnet/ethernet/ethernet.h>
20 #include <vnet/l2/l2_input.h>
22 #ifndef CLIB_MARCH_VARIANT
23 dvr_dpo_t *dvr_dpo_pool;
26 * The 'DB' of DVR DPOs.
27 * There is one per-interface per-L3 proto, so this is a per-interface vector
29 static index_t *dvr_dpo_db[DPO_PROTO_NUM];
36 pool_get(dvr_dpo_pool, dd);
41 static inline dvr_dpo_t *
42 dvr_dpo_get_from_dpo (const dpo_id_t *dpo)
44 ASSERT(DPO_DVR == dpo->dpoi_type);
46 return (dvr_dpo_get(dpo->dpoi_index));
50 dvr_dpo_get_index (dvr_dpo_t *dd)
52 return (dd - dvr_dpo_pool);
56 dvr_dpo_lock (dpo_id_t *dpo)
60 dd = dvr_dpo_get_from_dpo(dpo);
65 dvr_dpo_unlock (dpo_id_t *dpo)
69 dd = dvr_dpo_get_from_dpo(dpo);
72 if (0 == dd->dd_locks)
74 if (DPO_PROTO_IP4 == dd->dd_proto)
76 vnet_feature_enable_disable ("ip4-output", "ip4-dvr-reinject",
77 dd->dd_sw_if_index, 0, 0, 0);
81 vnet_feature_enable_disable ("ip6-output", "ip6-dvr-reinject",
82 dd->dd_sw_if_index, 0, 0, 0);
85 dvr_dpo_db[dd->dd_proto][dd->dd_sw_if_index] = INDEX_INVALID;
86 pool_put(dvr_dpo_pool, dd);
91 dvr_dpo_add_or_lock (u32 sw_if_index,
95 l2_input_config_t *config;
98 vec_validate_init_empty(dvr_dpo_db[dproto],
102 if (INDEX_INVALID == dvr_dpo_db[dproto][sw_if_index])
104 dd = dvr_dpo_alloc();
106 dd->dd_sw_if_index = sw_if_index;
107 dd->dd_proto = dproto;
109 dvr_dpo_db[dproto][sw_if_index] = dvr_dpo_get_index(dd);
111 config = l2input_intf_config (sw_if_index);
113 if (config->bridge || config->xconnect)
115 dd->dd_reinject = DVR_REINJECT_L2;
119 dd->dd_reinject = DVR_REINJECT_L3;
123 * enable the reinject into L2 path feature on the interface
125 if (DPO_PROTO_IP4 == dproto)
126 vnet_feature_enable_disable ("ip4-output", "ip4-dvr-reinject",
127 dd->dd_sw_if_index, 1, 0, 0);
128 else if (DPO_PROTO_IP6 == dproto)
129 vnet_feature_enable_disable ("ip6-output", "ip6-dvr-reinject",
130 dd->dd_sw_if_index, 1, 0, 0);
136 dd = dvr_dpo_get(dvr_dpo_db[dproto][sw_if_index]);
139 dpo_set(dpo, DPO_DVR, dproto, dvr_dpo_get_index(dd));
141 #endif /* CLIB_MARCH_VARIANT */
144 static clib_error_t *
145 dvr_dpo_interface_state_change (vnet_main_t * vnm,
154 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(
155 dvr_dpo_interface_state_change);
158 * @brief Registered callback for HW interface state changes
160 static clib_error_t *
161 dvr_dpo_hw_interface_state_change (vnet_main_t * vnm,
168 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(
169 dvr_dpo_hw_interface_state_change);
171 static clib_error_t *
172 dvr_dpo_interface_delete (vnet_main_t * vnm,
179 VNET_SW_INTERFACE_ADD_DEL_FUNCTION(
180 dvr_dpo_interface_delete);
182 #ifndef CLIB_MARCH_VARIANT
184 format_dvr_reinject (u8* s, va_list *ap)
186 dvr_dpo_reinject_t ddr = va_arg(*ap, int);
190 case DVR_REINJECT_L2:
191 s = format (s, "l2");
193 case DVR_REINJECT_L3:
194 s = format (s, "l3");
201 format_dvr_dpo (u8* s, va_list *ap)
203 index_t index = va_arg(*ap, index_t);
204 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
205 vnet_main_t * vnm = vnet_get_main();
206 dvr_dpo_t *dd = dvr_dpo_get(index);
208 return (format(s, "%U-dvr-%U-dpo %U",
209 format_dpo_proto, dd->dd_proto,
210 format_vnet_sw_interface_name,
212 vnet_get_sw_interface(vnm, dd->dd_sw_if_index),
213 format_dvr_reinject, dd->dd_reinject));
217 dvr_dpo_mem_show (void)
219 fib_show_memory_usage("DVR",
220 pool_elts(dvr_dpo_pool),
221 pool_len(dvr_dpo_pool),
226 const static dpo_vft_t dvr_dpo_vft = {
227 .dv_lock = dvr_dpo_lock,
228 .dv_unlock = dvr_dpo_unlock,
229 .dv_format = format_dvr_dpo,
230 .dv_mem_show = dvr_dpo_mem_show,
234 * @brief The per-protocol VLIB graph nodes that are assigned to a glean
237 * this means that these graph nodes are ones from which a glean is the
238 * parent object in the DPO-graph.
240 const static char* const dvr_dpo_ip4_nodes[] =
245 const static char* const dvr_dpo_ip6_nodes[] =
251 const static char* const * const dvr_dpo_nodes[DPO_PROTO_NUM] =
253 [DPO_PROTO_IP4] = dvr_dpo_ip4_nodes,
254 [DPO_PROTO_IP6] = dvr_dpo_ip6_nodes,
258 dvr_dpo_module_init (void)
260 dpo_register(DPO_DVR,
264 #endif /* CLIB_MARCH_VARIANT */
267 * @brief Interface DPO trace data
269 typedef struct dvr_dpo_trace_t_
275 dvr_dpo_inline (vlib_main_t * vm,
276 vlib_node_runtime_t * node,
277 vlib_frame_t * from_frame,
280 u32 n_left_from, next_index, * from, * to_next;
281 ip_lookup_main_t *lm = (is_ip6?
282 &ip6_main.lookup_main:
283 &ip4_main.lookup_main);
285 from = vlib_frame_vector_args (from_frame);
286 n_left_from = from_frame->n_vectors;
288 next_index = node->cached_next_index;
290 while (n_left_from > 0)
294 vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
296 while (n_left_from >= 4 && n_left_to_next > 2)
298 const dvr_dpo_t *dd0, *dd1;
299 u32 bi0, ddi0, bi1, ddi1;
300 vlib_buffer_t *b0, *b1;
314 b0 = vlib_get_buffer (vm, bi0);
315 b1 = vlib_get_buffer (vm, bi1);
317 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
318 ddi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
319 dd0 = dvr_dpo_get(ddi0);
320 dd1 = dvr_dpo_get(ddi1);
322 vnet_buffer(b0)->sw_if_index[VLIB_TX] = dd0->dd_sw_if_index;
323 vnet_buffer(b1)->sw_if_index[VLIB_TX] = dd1->dd_sw_if_index;
325 len0 = ((u8*)vlib_buffer_get_current(b0) -
326 (u8*)ethernet_buffer_get_header(b0));
327 len1 = ((u8*)vlib_buffer_get_current(b1) -
328 (u8*)ethernet_buffer_get_header(b1));
329 vnet_buffer(b0)->l2.l2_len =
330 vnet_buffer(b0)->ip.save_rewrite_length =
332 vnet_buffer(b1)->l2.l2_len =
333 vnet_buffer(b1)->ip.save_rewrite_length =
336 b0->flags |= VNET_BUFFER_F_IS_DVR;
337 b1->flags |= VNET_BUFFER_F_IS_DVR;
339 vlib_buffer_advance(b0, -len0);
340 vlib_buffer_advance(b1, -len1);
342 vnet_feature_arc_start (lm->output_feature_arc_index,
343 dd0->dd_sw_if_index, &next0, b0);
344 vnet_feature_arc_start (lm->output_feature_arc_index,
345 dd1->dd_sw_if_index, &next1, b1);
347 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
349 dvr_dpo_trace_t *tr0;
351 tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
352 tr0->sw_if_index = dd0->dd_sw_if_index;
354 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
356 dvr_dpo_trace_t *tr1;
358 tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
359 tr1->sw_if_index = dd1->dd_sw_if_index;
362 vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
363 n_left_to_next, bi0, bi1,
367 while (n_left_from > 0 && n_left_to_next > 0)
369 const dvr_dpo_t * dd0;
383 b0 = vlib_get_buffer (vm, bi0);
385 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
386 dd0 = dvr_dpo_get(ddi0);
388 vnet_buffer(b0)->sw_if_index[VLIB_TX] = dd0->dd_sw_if_index;
391 * take that, rewind it back...
393 len0 = ((u8*)vlib_buffer_get_current(b0) -
394 (u8*)ethernet_buffer_get_header(b0));
395 vnet_buffer(b0)->l2.l2_len =
396 vnet_buffer(b0)->ip.save_rewrite_length =
398 b0->flags |= VNET_BUFFER_F_IS_DVR;
399 vlib_buffer_advance(b0, -len0);
402 * start processing the ipX output features
404 vnet_feature_arc_start(lm->output_feature_arc_index,
405 dd0->dd_sw_if_index, &next0, b0);
407 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
411 tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
412 tr->sw_if_index = dd0->dd_sw_if_index;
415 vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
419 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
421 return from_frame->n_vectors;
425 format_dvr_dpo_trace (u8 * s, va_list * args)
427 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
428 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
429 dvr_dpo_trace_t * t = va_arg (*args, dvr_dpo_trace_t *);
430 u32 indent = format_get_indent (s);
431 s = format (s, "%U sw_if_index:%d",
432 format_white_space, indent,
437 VLIB_NODE_FN (ip4_dvr_dpo_node) (vlib_main_t * vm,
438 vlib_node_runtime_t * node,
439 vlib_frame_t * from_frame)
441 return (dvr_dpo_inline(vm, node, from_frame, 0));
444 VLIB_NODE_FN (ip6_dvr_dpo_node) (vlib_main_t * vm,
445 vlib_node_runtime_t * node,
446 vlib_frame_t * from_frame)
448 return (dvr_dpo_inline(vm, node, from_frame, 1));
451 VLIB_REGISTER_NODE (ip4_dvr_dpo_node) = {
452 .name = "ip4-dvr-dpo",
453 .vector_size = sizeof (u32),
454 .format_trace = format_dvr_dpo_trace,
455 .sibling_of = "ip4-rewrite",
457 VLIB_REGISTER_NODE (ip6_dvr_dpo_node) = {
458 .name = "ip6-dvr-dpo",
459 .vector_size = sizeof (u32),
460 .format_trace = format_dvr_dpo_trace,
461 .sibling_of = "ip6-rewrite",
464 typedef enum dvr_reinject_next_t_
466 DVR_REINJECT_NEXT_L2,
467 DVR_REINJECT_NEXT_L3,
468 } dvr_reinject_next_t;
471 dvr_reinject_inline (vlib_main_t * vm,
472 vlib_node_runtime_t * node,
473 vlib_frame_t * from_frame)
475 u32 n_left_from, next_index, * from, * to_next;
477 from = vlib_frame_vector_args (from_frame);
478 n_left_from = from_frame->n_vectors;
480 next_index = node->cached_next_index;
482 while (n_left_from > 0)
486 vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
488 while (n_left_from >= 4 && n_left_to_next > 2)
490 dvr_reinject_next_t next0, next1;
491 const dvr_dpo_t *dd0, *dd1;
492 u32 bi0, bi1, ddi0, ddi1;
493 vlib_buffer_t *b0, *b1;
504 b0 = vlib_get_buffer (vm, bi0);
505 b1 = vlib_get_buffer (vm, bi1);
507 if (b0->flags & VNET_BUFFER_F_IS_DVR)
509 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
510 dd0 = dvr_dpo_get(ddi0);
511 next0 = (dd0->dd_reinject == DVR_REINJECT_L2 ?
512 DVR_REINJECT_NEXT_L2 :
513 DVR_REINJECT_NEXT_L3);
516 vnet_feature_next( &next0, b0);
518 if (b1->flags & VNET_BUFFER_F_IS_DVR)
520 ddi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
521 dd1 = dvr_dpo_get(ddi1);
522 next1 = (dd1->dd_reinject == DVR_REINJECT_L2 ?
523 DVR_REINJECT_NEXT_L2 :
524 DVR_REINJECT_NEXT_L3);
527 vnet_feature_next( &next1, b1);
529 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
531 dvr_dpo_trace_t *tr0;
533 tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
534 tr0->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_TX];
536 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
538 dvr_dpo_trace_t *tr1;
540 tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
541 tr1->sw_if_index = vnet_buffer(b1)->sw_if_index[VLIB_TX];
544 vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
545 n_left_to_next, bi0, bi1,
549 while (n_left_from > 0 && n_left_to_next > 0)
551 dvr_reinject_next_t next0;
552 const dvr_dpo_t *dd0;
563 b0 = vlib_get_buffer (vm, bi0);
565 if (b0->flags & VNET_BUFFER_F_IS_DVR)
567 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
568 dd0 = dvr_dpo_get(ddi0);
569 next0 = (dd0->dd_reinject == DVR_REINJECT_L2 ?
570 DVR_REINJECT_NEXT_L2 :
571 DVR_REINJECT_NEXT_L3);
574 vnet_feature_next( &next0, b0);
576 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
580 tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
581 tr->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_TX];
584 vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
585 n_left_to_next, bi0, next0);
587 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
589 return from_frame->n_vectors;
592 VLIB_NODE_FN (ip4_dvr_reinject_node) (vlib_main_t * vm,
593 vlib_node_runtime_t * node,
594 vlib_frame_t * from_frame)
596 return (dvr_reinject_inline(vm, node, from_frame));
599 VLIB_NODE_FN (ip6_dvr_reinject_node) (vlib_main_t * vm,
600 vlib_node_runtime_t * node,
601 vlib_frame_t * from_frame)
603 return (dvr_reinject_inline(vm, node, from_frame));
606 VLIB_REGISTER_NODE (ip4_dvr_reinject_node) = {
607 .name = "ip4-dvr-reinject",
608 .vector_size = sizeof (u32),
609 .format_trace = format_dvr_dpo_trace,
613 [DVR_REINJECT_NEXT_L2] = "l2-output",
614 [DVR_REINJECT_NEXT_L3] = "interface-output",
618 VLIB_REGISTER_NODE (ip6_dvr_reinject_node) = {
619 .name = "ip6-dvr-reinject",
620 .vector_size = sizeof (u32),
621 .format_trace = format_dvr_dpo_trace,
625 [DVR_REINJECT_NEXT_L2] = "l2-output",
626 [DVR_REINJECT_NEXT_L3] = "interface-output",
630 VNET_FEATURE_INIT (ip4_dvr_reinject_feat_node, static) =
632 .arc_name = "ip4-output",
633 .node_name = "ip4-dvr-reinject",
634 .runs_after = VNET_FEATURES ("nat44-in2out-output",
635 "acl-plugin-out-ip4-fa"),
637 VNET_FEATURE_INIT (ip6_dvr_reinject_feat_node, static) =
639 .arc_name = "ip6-output",
640 .node_name = "ip6-dvr-reinject",
641 .runs_after = VNET_FEATURES ("acl-plugin-out-ip6-fa"),