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 (l2_input_is_bridge(config) ||
114 l2_input_is_xconnect(config))
116 dd->dd_reinject = DVR_REINJECT_L2;
120 dd->dd_reinject = DVR_REINJECT_L3;
124 * enable the reinject into L2 path feature on the interface
126 if (DPO_PROTO_IP4 == dproto)
127 vnet_feature_enable_disable ("ip4-output", "ip4-dvr-reinject",
128 dd->dd_sw_if_index, 1, 0, 0);
129 else if (DPO_PROTO_IP6 == dproto)
130 vnet_feature_enable_disable ("ip6-output", "ip6-dvr-reinject",
131 dd->dd_sw_if_index, 1, 0, 0);
137 dd = dvr_dpo_get(dvr_dpo_db[dproto][sw_if_index]);
140 dpo_set(dpo, DPO_DVR, dproto, dvr_dpo_get_index(dd));
142 #endif /* CLIB_MARCH_VARIANT */
145 static clib_error_t *
146 dvr_dpo_interface_state_change (vnet_main_t * vnm,
155 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(
156 dvr_dpo_interface_state_change);
159 * @brief Registered callback for HW interface state changes
161 static clib_error_t *
162 dvr_dpo_hw_interface_state_change (vnet_main_t * vnm,
169 VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(
170 dvr_dpo_hw_interface_state_change);
172 static clib_error_t *
173 dvr_dpo_interface_delete (vnet_main_t * vnm,
180 VNET_SW_INTERFACE_ADD_DEL_FUNCTION(
181 dvr_dpo_interface_delete);
183 #ifndef CLIB_MARCH_VARIANT
185 format_dvr_reinject (u8* s, va_list *ap)
187 dvr_dpo_reinject_t ddr = va_arg(*ap, int);
191 case DVR_REINJECT_L2:
192 s = format (s, "l2");
194 case DVR_REINJECT_L3:
195 s = format (s, "l3");
202 format_dvr_dpo (u8* s, va_list *ap)
204 index_t index = va_arg(*ap, index_t);
205 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
206 vnet_main_t * vnm = vnet_get_main();
207 dvr_dpo_t *dd = dvr_dpo_get(index);
209 return (format(s, "%U-dvr-%U-dpo %U",
210 format_dpo_proto, dd->dd_proto,
211 format_vnet_sw_interface_name,
213 vnet_get_sw_interface(vnm, dd->dd_sw_if_index),
214 format_dvr_reinject, dd->dd_reinject));
218 dvr_dpo_mem_show (void)
220 fib_show_memory_usage("DVR",
221 pool_elts(dvr_dpo_pool),
222 pool_len(dvr_dpo_pool),
227 const static dpo_vft_t dvr_dpo_vft = {
228 .dv_lock = dvr_dpo_lock,
229 .dv_unlock = dvr_dpo_unlock,
230 .dv_format = format_dvr_dpo,
231 .dv_mem_show = dvr_dpo_mem_show,
235 * @brief The per-protocol VLIB graph nodes that are assigned to a glean
238 * this means that these graph nodes are ones from which a glean is the
239 * parent object in the DPO-graph.
241 const static char* const dvr_dpo_ip4_nodes[] =
246 const static char* const dvr_dpo_ip6_nodes[] =
252 const static char* const * const dvr_dpo_nodes[DPO_PROTO_NUM] =
254 [DPO_PROTO_IP4] = dvr_dpo_ip4_nodes,
255 [DPO_PROTO_IP6] = dvr_dpo_ip6_nodes,
259 dvr_dpo_module_init (void)
261 dpo_register(DPO_DVR,
265 #endif /* CLIB_MARCH_VARIANT */
268 * @brief Interface DPO trace data
270 typedef struct dvr_dpo_trace_t_
276 dvr_dpo_inline (vlib_main_t * vm,
277 vlib_node_runtime_t * node,
278 vlib_frame_t * from_frame,
281 u32 n_left_from, next_index, * from, * to_next;
282 ip_lookup_main_t *lm = (is_ip6?
283 &ip6_main.lookup_main:
284 &ip4_main.lookup_main);
286 from = vlib_frame_vector_args (from_frame);
287 n_left_from = from_frame->n_vectors;
289 next_index = node->cached_next_index;
291 while (n_left_from > 0)
295 vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
297 while (n_left_from >= 4 && n_left_to_next > 2)
299 const dvr_dpo_t *dd0, *dd1;
300 u32 bi0, ddi0, bi1, ddi1;
301 vlib_buffer_t *b0, *b1;
315 b0 = vlib_get_buffer (vm, bi0);
316 b1 = vlib_get_buffer (vm, bi1);
318 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
319 ddi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
320 dd0 = dvr_dpo_get(ddi0);
321 dd1 = dvr_dpo_get(ddi1);
323 vnet_buffer(b0)->sw_if_index[VLIB_TX] = dd0->dd_sw_if_index;
324 vnet_buffer(b1)->sw_if_index[VLIB_TX] = dd1->dd_sw_if_index;
326 len0 = ((u8*)vlib_buffer_get_current(b0) -
327 (u8*)ethernet_buffer_get_header(b0));
328 len1 = ((u8*)vlib_buffer_get_current(b1) -
329 (u8*)ethernet_buffer_get_header(b1));
330 vnet_buffer(b0)->l2.l2_len =
331 vnet_buffer(b0)->ip.save_rewrite_length =
333 vnet_buffer(b1)->l2.l2_len =
334 vnet_buffer(b1)->ip.save_rewrite_length =
337 b0->flags |= VNET_BUFFER_F_IS_DVR;
338 b1->flags |= VNET_BUFFER_F_IS_DVR;
340 vlib_buffer_advance(b0, -len0);
341 vlib_buffer_advance(b1, -len1);
343 vnet_feature_arc_start (lm->output_feature_arc_index,
344 dd0->dd_sw_if_index, &next0, b0);
345 vnet_feature_arc_start (lm->output_feature_arc_index,
346 dd1->dd_sw_if_index, &next1, b1);
348 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
350 dvr_dpo_trace_t *tr0;
352 tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
353 tr0->sw_if_index = dd0->dd_sw_if_index;
355 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
357 dvr_dpo_trace_t *tr1;
359 tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
360 tr1->sw_if_index = dd1->dd_sw_if_index;
363 vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
364 n_left_to_next, bi0, bi1,
368 while (n_left_from > 0 && n_left_to_next > 0)
370 const dvr_dpo_t * dd0;
384 b0 = vlib_get_buffer (vm, bi0);
386 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
387 dd0 = dvr_dpo_get(ddi0);
389 vnet_buffer(b0)->sw_if_index[VLIB_TX] = dd0->dd_sw_if_index;
392 * take that, rewind it back...
394 len0 = ((u8*)vlib_buffer_get_current(b0) -
395 (u8*)ethernet_buffer_get_header(b0));
396 vnet_buffer(b0)->l2.l2_len =
397 vnet_buffer(b0)->ip.save_rewrite_length =
399 b0->flags |= VNET_BUFFER_F_IS_DVR;
400 vlib_buffer_advance(b0, -len0);
403 * start processing the ipX output features
405 vnet_feature_arc_start(lm->output_feature_arc_index,
406 dd0->dd_sw_if_index, &next0, b0);
408 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
412 tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
413 tr->sw_if_index = dd0->dd_sw_if_index;
416 vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
420 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
422 return from_frame->n_vectors;
426 format_dvr_dpo_trace (u8 * s, va_list * args)
428 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
429 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
430 dvr_dpo_trace_t * t = va_arg (*args, dvr_dpo_trace_t *);
431 u32 indent = format_get_indent (s);
432 s = format (s, "%U sw_if_index:%d",
433 format_white_space, indent,
438 VLIB_NODE_FN (ip4_dvr_dpo_node) (vlib_main_t * vm,
439 vlib_node_runtime_t * node,
440 vlib_frame_t * from_frame)
442 return (dvr_dpo_inline(vm, node, from_frame, 0));
445 VLIB_NODE_FN (ip6_dvr_dpo_node) (vlib_main_t * vm,
446 vlib_node_runtime_t * node,
447 vlib_frame_t * from_frame)
449 return (dvr_dpo_inline(vm, node, from_frame, 1));
452 VLIB_REGISTER_NODE (ip4_dvr_dpo_node) = {
453 .name = "ip4-dvr-dpo",
454 .vector_size = sizeof (u32),
455 .format_trace = format_dvr_dpo_trace,
456 .sibling_of = "ip4-rewrite",
458 VLIB_REGISTER_NODE (ip6_dvr_dpo_node) = {
459 .name = "ip6-dvr-dpo",
460 .vector_size = sizeof (u32),
461 .format_trace = format_dvr_dpo_trace,
462 .sibling_of = "ip6-rewrite",
465 typedef enum dvr_reinject_next_t_
467 DVR_REINJECT_NEXT_L2,
468 DVR_REINJECT_NEXT_L3,
469 } dvr_reinject_next_t;
472 dvr_reinject_inline (vlib_main_t * vm,
473 vlib_node_runtime_t * node,
474 vlib_frame_t * from_frame)
476 u32 n_left_from, next_index, * from, * to_next;
478 from = vlib_frame_vector_args (from_frame);
479 n_left_from = from_frame->n_vectors;
481 next_index = node->cached_next_index;
483 while (n_left_from > 0)
487 vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
489 while (n_left_from >= 4 && n_left_to_next > 2)
491 dvr_reinject_next_t next0, next1;
492 const dvr_dpo_t *dd0, *dd1;
493 u32 bi0, bi1, ddi0, ddi1;
494 vlib_buffer_t *b0, *b1;
505 b0 = vlib_get_buffer (vm, bi0);
506 b1 = vlib_get_buffer (vm, bi1);
508 if (b0->flags & VNET_BUFFER_F_IS_DVR)
510 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
511 dd0 = dvr_dpo_get(ddi0);
512 next0 = (dd0->dd_reinject == DVR_REINJECT_L2 ?
513 DVR_REINJECT_NEXT_L2 :
514 DVR_REINJECT_NEXT_L3);
517 vnet_feature_next( &next0, b0);
519 if (b1->flags & VNET_BUFFER_F_IS_DVR)
521 ddi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
522 dd1 = dvr_dpo_get(ddi1);
523 next1 = (dd1->dd_reinject == DVR_REINJECT_L2 ?
524 DVR_REINJECT_NEXT_L2 :
525 DVR_REINJECT_NEXT_L3);
528 vnet_feature_next( &next1, b1);
530 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
532 dvr_dpo_trace_t *tr0;
534 tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
535 tr0->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_TX];
537 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
539 dvr_dpo_trace_t *tr1;
541 tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
542 tr1->sw_if_index = vnet_buffer(b1)->sw_if_index[VLIB_TX];
545 vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
546 n_left_to_next, bi0, bi1,
550 while (n_left_from > 0 && n_left_to_next > 0)
552 dvr_reinject_next_t next0;
553 const dvr_dpo_t *dd0;
564 b0 = vlib_get_buffer (vm, bi0);
566 if (b0->flags & VNET_BUFFER_F_IS_DVR)
568 ddi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
569 dd0 = dvr_dpo_get(ddi0);
570 next0 = (dd0->dd_reinject == DVR_REINJECT_L2 ?
571 DVR_REINJECT_NEXT_L2 :
572 DVR_REINJECT_NEXT_L3);
575 vnet_feature_next( &next0, b0);
577 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
581 tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
582 tr->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_TX];
585 vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
586 n_left_to_next, bi0, next0);
588 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
590 return from_frame->n_vectors;
593 VLIB_NODE_FN (ip4_dvr_reinject_node) (vlib_main_t * vm,
594 vlib_node_runtime_t * node,
595 vlib_frame_t * from_frame)
597 return (dvr_reinject_inline(vm, node, from_frame));
600 VLIB_NODE_FN (ip6_dvr_reinject_node) (vlib_main_t * vm,
601 vlib_node_runtime_t * node,
602 vlib_frame_t * from_frame)
604 return (dvr_reinject_inline(vm, node, from_frame));
607 VLIB_REGISTER_NODE (ip4_dvr_reinject_node) = {
608 .name = "ip4-dvr-reinject",
609 .vector_size = sizeof (u32),
610 .format_trace = format_dvr_dpo_trace,
614 [DVR_REINJECT_NEXT_L2] = "l2-output",
615 [DVR_REINJECT_NEXT_L3] = "interface-output",
619 VLIB_REGISTER_NODE (ip6_dvr_reinject_node) = {
620 .name = "ip6-dvr-reinject",
621 .vector_size = sizeof (u32),
622 .format_trace = format_dvr_dpo_trace,
626 [DVR_REINJECT_NEXT_L2] = "l2-output",
627 [DVR_REINJECT_NEXT_L3] = "interface-output",
631 VNET_FEATURE_INIT (ip4_dvr_reinject_feat_node, static) =
633 .arc_name = "ip4-output",
634 .node_name = "ip4-dvr-reinject",
635 .runs_after = VNET_FEATURES ("nat44-in2out-output",
636 "acl-plugin-out-ip4-fa"),
638 VNET_FEATURE_INIT (ip6_dvr_reinject_feat_node, static) =
640 .arc_name = "ip6-output",
641 .node_name = "ip6-dvr-reinject",
642 .runs_after = VNET_FEATURES ("acl-plugin-out-ip6-fa"),