* @brief
* A Data-Path Object is an object that represents actions that are
* applied to packets are they are switched through VPP.
- *
+ *
* The DPO is a base class that is specialised by other objects to provide
- * concreate actions
+ * concrete actions
*
* The VLIB graph nodes are graph of types, the DPO graph is a graph of instances.
*/
#include <vnet/dpo/interface_rx_dpo.h>
#include <vnet/dpo/interface_tx_dpo.h>
#include <vnet/dpo/mpls_disposition.h>
-#include <vnet/dpo/l2_bridge_dpo.h>
+#include <vnet/dpo/dvr_dpo.h>
+#include <vnet/dpo/l3_proxy_dpo.h>
+#include <vnet/dpo/ip6_ll_dpo.h>
+#include <vnet/dpo/pw_cw.h>
/**
* Array of char* names for the DPO types and protos
* the third dimension in dpo_nodes is lost, hence, the edge index from each
* node MUST be the same.
* Including both the child and parent protocol is required to support the
- * case where it changes as the grapth is traversed, most notablly when an
+ * case where it changes as the graph is traversed, most notably when an
* MPLS label is popped.
*
* Note that this array is child type specific, not child instance specific.
static u32 ****dpo_edges;
/**
- * @brief The DPO type value that can be assigend to the next dynamic
+ * @brief The DPO type value that can be assigned to the next dynamic
* type registration.
*/
static dpo_type_t dpo_dynamic = DPO_LAST;
case DPO_PROTO_IP4:
return (VNET_LINK_IP4);
case DPO_PROTO_MPLS:
+ case DPO_PROTO_BIER:
return (VNET_LINK_MPLS);
case DPO_PROTO_ETHERNET:
return (VNET_LINK_ETHERNET);
if (NULL != dpo_vfts[dpo->dpoi_type].dv_format)
{
- return (format(s, "%U",
- dpo_vfts[dpo->dpoi_type].dv_format,
- dpo->dpoi_index,
- indent));
+ s = format(s, "%U",
+ dpo_vfts[dpo->dpoi_type].dv_format,
+ dpo->dpoi_index,
+ indent);
}
-
- switch (dpo->dpoi_type)
+ else
{
- case DPO_FIRST:
- s = format(s, "unset");
- break;
- default:
- s = format(s, "unknown");
- break;
+ switch (dpo->dpoi_type)
+ {
+ case DPO_FIRST:
+ s = format(s, "unset");
+ break;
+ default:
+ s = format(s, "unknown");
+ break;
+ }
}
return (s);
}
dpo_copy (dpo_id_t *dst,
const dpo_id_t *src)
{
- dpo_id_t tmp = *dst;
+ dpo_id_t tmp = {
+ .as_u64 = dst->as_u64
+ };
/*
* the destination is written in a single u64 write - hence atomically w.r.t
* any packets inflight.
*/
- *((u64*)dst) = *(u64*)src;
+ dst->as_u64 = src->as_u64;
dpo_lock(dst);
- dpo_unlock(&tmp);
+ dpo_unlock(&tmp);
}
int
{
return ((dpo->dpoi_type == DPO_ADJACENCY) ||
(dpo->dpoi_type == DPO_ADJACENCY_INCOMPLETE) ||
+ (dpo->dpoi_type == DPO_ADJACENCY_GLEAN) ||
+ (dpo->dpoi_type == DPO_ADJACENCY_MCAST) ||
+ (dpo->dpoi_type == DPO_ADJACENCY_MCAST_MIDCHAIN) ||
(dpo->dpoi_type == DPO_ADJACENCY_MIDCHAIN) ||
(dpo->dpoi_type == DPO_ADJACENCY_GLEAN));
}
return (node_indices);
}
+/**
+ * A default variant of the make interpose function that just returns
+ * the original
+ */
+static void
+dpo_default_mk_interpose (const dpo_id_t *original,
+ const dpo_id_t *parent,
+ dpo_id_t *clone)
+{
+ dpo_copy(clone, original);
+}
+
void
dpo_register (dpo_type_t type,
const dpo_vft_t *vft,
{
dpo_vfts[type].dv_get_next_node = dpo_default_get_next_node;
}
+ if (NULL == dpo_vfts[type].dv_mk_interpose)
+ {
+ dpo_vfts[type].dv_mk_interpose = dpo_default_mk_interpose;
+ }
vec_validate(dpo_nodes, type);
dpo_nodes[type] = nodes;
return (type);
}
+void
+dpo_mk_interpose (const dpo_id_t *original,
+ const dpo_id_t *parent,
+ dpo_id_t *clone)
+{
+ if (!dpo_id_is_valid(original))
+ return;
+
+ dpo_vfts[original->dpoi_type].dv_mk_interpose(original, parent, clone);
+}
+
void
dpo_lock (dpo_id_t *dpo)
{
dpo_vfts[dpo->dpoi_type].dv_unlock(dpo);
}
+u32
+dpo_get_urpf(const dpo_id_t *dpo)
+{
+ if (dpo_id_is_valid(dpo) &&
+ (NULL != dpo_vfts[dpo->dpoi_type].dv_get_urpf))
+ {
+ return (dpo_vfts[dpo->dpoi_type].dv_get_urpf(dpo));
+ }
+
+ return (~0);
+}
static u32
dpo_get_next_node (dpo_type_t child_type,
parent_proto, ~0);
/*
- * if the edge index has not yet been created for this node to node transistion
+ * if the edge index has not yet been created for this node to node transition
*/
if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
{
return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
}
+/**
+ * @brief return already stacked up next node index for a given
+ * child_type/child_proto and parent_type/patent_proto.
+ * The VLIB graph arc used is taken from the parent and child types
+ * passed.
+ */
+u32
+dpo_get_next_node_by_type_and_proto (dpo_type_t child_type,
+ dpo_proto_t child_proto,
+ dpo_type_t parent_type,
+ dpo_proto_t parent_proto)
+{
+ return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
+}
+
/**
* @brief Stack one DPO object on another, and thus establish a child parent
* relationship. The VLIB graph arc used is taken from the parent and child types
dpo_copy(&tmp, parent);
/*
- * get the edge index for the parent to child VLIB graph transisition
+ * get the edge index for the parent to child VLIB graph transition
*/
tmp.dpoi_next_node = edge;
}
}
dpo_stack_i(edge, dpo, parent);
+
+ /* should free this local vector to avoid memory leak */
+ vec_free(parent_indices);
}
static clib_error_t *
classify_dpo_module_init();
lookup_dpo_module_init();
ip_null_dpo_module_init();
+ ip6_ll_dpo_module_init();
replicate_module_init();
interface_rx_dpo_module_init();
interface_tx_dpo_module_init();
mpls_disp_dpo_module_init();
- l2_bridge_dpo_module_init();
+ dvr_dpo_module_init();
+ l3_proxy_dpo_module_init();
+ pw_cw_dpo_module_init();
return (NULL);
}
-VLIB_INIT_FUNCTION(dpo_module_init);
+/* *INDENT-OFF* */
+VLIB_INIT_FUNCTION(dpo_module_init) =
+{
+ .runs_before = VLIB_INITS ("ip_main_init"),
+};
+/* *INDENT-ON* */
static clib_error_t *
dpo_memory_show (vlib_main_t * vm,