X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fdpo%2Fdpo.c;h=d8342ff17aece30979ce9695bc0c8895c49ba4f6;hb=8f5fef2c7;hp=7658132d47ac04c465b56c024b98e5d3478e6848;hpb=5f3fcb96296a4769f55f60270e10c6294c604db9;p=vpp.git diff --git a/src/vnet/dpo/dpo.c b/src/vnet/dpo/dpo.c index 7658132d47a..d8342ff17ae 100644 --- a/src/vnet/dpo/dpo.c +++ b/src/vnet/dpo/dpo.c @@ -16,13 +16,15 @@ * @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. */ +// clang-format off + #include #include #include @@ -40,8 +42,10 @@ #include #include #include -#include +#include #include +#include +#include /** * Array of char* names for the DPO types and protos @@ -77,7 +81,7 @@ static const char* const * const ** dpo_nodes; * 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. @@ -85,7 +89,7 @@ static const char* const * const ** dpo_nodes; 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; @@ -122,6 +126,7 @@ dpo_proto_to_link (dpo_proto_t dp) 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); @@ -151,20 +156,22 @@ format_dpo_id (u8 * s, va_list * args) 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); } @@ -257,16 +264,18 @@ void 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 @@ -274,6 +283,9 @@ dpo_is_adj (const dpo_id_t *dpo) { 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)); } @@ -301,6 +313,18 @@ dpo_default_get_next_node (const dpo_id_t *dpo) 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, @@ -312,6 +336,10 @@ dpo_register (dpo_type_t type, { 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; @@ -328,6 +356,17 @@ dpo_register_new_type (const dpo_vft_t *vft, 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) { @@ -358,6 +397,18 @@ dpo_get_urpf(const dpo_id_t *dpo) return (~0); } +u16 +dpo_get_mtu(const dpo_id_t *dpo) +{ + if (dpo_id_is_valid(dpo) && + (NULL != dpo_vfts[dpo->dpoi_type].dv_get_mtu)) + { + return (dpo_vfts[dpo->dpoi_type].dv_get_mtu(dpo)); + } + + return (0xffff); +} + static u32 dpo_get_next_node (dpo_type_t child_type, dpo_proto_t child_proto, @@ -377,7 +428,7 @@ 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]) { @@ -430,6 +481,21 @@ dpo_get_next_node (dpo_type_t child_type, 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 @@ -448,7 +514,7 @@ dpo_stack_i (u32 edge, 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; @@ -519,6 +585,9 @@ dpo_stack_from_node (u32 child_node_index, } } dpo_stack_i(edge, dpo, parent); + + /* should free this local vector to avoid memory leak */ + vec_free(parent_indices); } static clib_error_t * @@ -532,17 +601,24 @@ dpo_module_init (vlib_main_t * vm) 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, @@ -587,3 +663,5 @@ VLIB_CLI_COMMAND (show_fib_memory, static) = { .short_help = "show dpo memory", }; /* *INDENT-ON* */ + +// clang-format on