/*
* Copyright (c) 2016 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <vnet/dpo/interface_tx_dpo.h>
#include <vnet/adj/rewrite.h>
/*
* We do not lock nor unlock these DPOs since there is nothing to lock
* all we do is construct DPO object wrappers around a sw_if_index
*/
static void
interface_tx_dpo_lock (dpo_id_t *dpo)
{
}
static void
interface_tx_dpo_unlock (dpo_id_t *dpo)
{
}
/*
* interface_tx_dpo_add_or_lock
*
* construct DPO object wrappers around a sw_if_index
*/
void
interface_tx_dpo_add_or_lock (dpo_proto_t proto,
u32 sw_if_index,
dpo_id_t *dpo)
{
dpo_set(dpo, DPO_INTERFACE_TX, proto, sw_if_index);
}
u8*
format_interface_tx_dpo (u8* s, va_list *ap)
{
index_t index = va_arg(*ap, index_t);
CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
vnet_main_t * vnm = vnet_get_main();
return (format(s, "%U-tx-dpo:",
format_vnet_sw_interface_name,
vnm,
vnet_get_sw_interface(vnm, index)));
}
@media only all and (prefers-color-scheme: dark) {
.highlight .hll { background-color: #49483e }
.highlight .c { color: #75715e } /* Comment */
.highlight .err { color: #960050; background-color: #1e0010 } /* Error */
.highlight .k { color: #66d9ef } /* Keyword */
.highlight .l { color: #ae81ff } /* Literal */
.highlight .n { color: #f8f8f2 } /* Name */
.highlight .o { color: #f92672 } /* Operator */
.highlight .p { color: #f8f8f2 } /* Punctuation */
.highlight .ch { color: #75715e } /* Comment.Hashbang */
.highlight .cm { color: #75715e } /* Comment.Multiline */
.highlight .cp { color: #75715e } /* Comment.Preproc */
.highlight .cpf { color: #75715e } /* Comment.PreprocFile */
.highlight .c1 { color: #75715e } /* Comment.Single */
.highlight .cs { color: #75715e } /* Comment.Special */
.highlight .gd { color: #f92672 } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gi { color: #a6e22e } /* Generic.Inserted */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #75715e } /* Generic.Subheading */
.highlight .kc { color: #66d9ef } /* Keyword.Constant */
.highlight .kd { color: #66d9ef } /* Keyword.Declaration */
.highlight .kn { color: #f92672 } /* Keyword.Namespace */
.highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
.highlight .kr { color: #66d9ef } /* Keyword.Reserved */
.highlight .kt { color: #66d9ef } /* Keyword.Type */
.highlight .ld { color: #e6db74 } /* Literal.Date */
.highlight .m { color: #ae81ff } /* Literal.Number */
.highlight .s { color: #e6db74 } /* Literal.String */
.highlight .na { color: #a6e22e } /* Name.Attribute */
.highlight .nb { color: #f8f8f2 } /* Name.Builtin */
.highlight .nc { color: #a6e22e } /* Name.Class */
.highlight .no { color: #66d9ef } /* Name.Constant */
.highlight .nd { color: #a6e22e } /* Name.Decorator */
.highlight .ni { color: #f8f8f2 } /* Name.Entity */
.highlight .ne { color: #a6e22e } /* Name.Exception */
.highlight .nf { color: #a6e22e } /* Name.Function */
.highlight .nl { color: #f8f8f2 } /* Name.Label */
.highlight .nn { color: #f8f8f2 } /* Name.Namespace */
.highlight .nx { color: #a6e22e } /* Name.Other */
.highlight .py { color: #f8f8f2 } /* Name.Property */
.highlight .nt { color: #f92672 } /* Name.Tag */
.highlight .nv { color: #f8f8f2 } /* Name.Variable */
.highlight .ow { color: #f92672 } /* Operator.Word */
.highlight .w { color: #f8f8f2 } /* Text.Whitespace */
.highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
.highlight .mf { color: #ae81ff } /* Literal.Number.Float */
.highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
.highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
.highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
.highlight .sa { color: #e6db74 } /* Literal.String.Affix */
.highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
.highlight .sc { color: #e6db74 } /* Literal.String.Char */
.highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
.highlight .sd { color: #e6db74 } /* Literal.String.Doc */
.highlight .s2 { color: #e6db74 } /* Literal.String.Double */
.highlight .se { color: #ae81ff } /* Literal.String.Escape */
.highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
.highlight .si { color: #e6db74 } /* Literal.String.Interpol */
.highlight .sx { color: #e6db74 } /* Literal.String.Other */
.highlight .sr { color: #e6db74 } /* Literal.String.Regex */
.highlight .s1 { color: #e6db74 } /* Literal.String.Single */
.highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
.highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #a6e22e } /* Name.Function.Magic */
.highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
.highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
.highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
.highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
.highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */
}
@media (prefers-color-scheme: light) {
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
}
/*
* Copyright (c) 2016 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @brief
* A Data-Path Object is an object that represents actions that are
* applied to packets are they are switched through VPP's data-path.
*
* The DPO can be considered to be like is a base class that is specialised
* by other objects to provide concreate actions
*
* The VLIB graph nodes are graph of DPO types, the DPO graph is a graph of
* instances.
*/
#ifndef __DPO_H__
#define __DPO_H__
#include <vnet/vnet.h>
/**
* @brief An index for adjacencies.
* Alas 'C' is not typesafe enough to b0rk when a u32 is used instead of
* an index_t. However, for us humans, we can glean much more intent
* from the declaration
* foo barindex_t t);
* than we can from
* foo bar(u32 t);
*/
typedef u32 index_t;
/**
* @brief Invalid index - used when no index is known
* blazoned capitals INVALID speak volumes where ~0 does not.
*/
#define INDEX_INVALID ((index_t)(~0))
/**
* @brief Data path protocol.
* Actions performed on packets in the data-plane can be described and represented
* by protocol independent objects, i.e. ADJACENCY, but the spceifics actions
* required during ADJACENCY processing can be protocol dependent. For example,
* the adjacency rewrite node performs a ip4 checksum calculation, ip6 and MPLS
* do not, all 3 perform a TTL decrement. The VLIB graph nodes are thus protocol
* dependent, and thus each graph edge/arc is too.
* When programming a DPO's next node arc from child to parent it is thus required
* to know the parent's data-path protocol so the correct arc index can be used.
*/
typedef enum dpo_proto_t_
{
DPO_PROTO_IP4 = 0,
DPO_PROTO_IP6,
DPO_PROTO_MPLS,
DPO_PROTO_ETHERNET,
DPO_PROTO_BIER,
DPO_PROTO_NSH,
} __attribute__((packed)) dpo_proto_t;
#define DPO_PROTO_NUM ((dpo_proto_t)(DPO_PROTO_NSH+1))
#define DPO_PROTO_NONE ((dpo_proto_t)(DPO_PROTO_NUM+1))
#define DPO_PROTOS { \
[DPO_PROTO_IP4] = "ip4", \
[DPO_PROTO_IP6] = "ip6", \
[DPO_PROTO_ETHERNET] = "ethernet", \
[DPO_PROTO_MPLS] = "mpls", \
[DPO_PROTO_NSH] = "nsh", \
[DPO_PROTO_BIER] = "bier", \
}
#define FOR_EACH_DPO_PROTO(_proto) \
for (_proto = DPO_PROTO_IP4; \
_proto <= DPO_PROTO_NSH; \
_proto++)
/**
* @brief Common types of data-path objects
* New types can be dynamically added using dpo_register_new_type()
*/
typedef enum dpo_type_t_ {
/**
* A non-zero value first so we can spot unitialisation errors
*/
DPO_FIRST,
DPO_DROP,
DPO_IP_NULL,
DPO_PUNT,
/**
* @brief load-balancing over a choice of [un]equal cost paths
*/
DPO_LOAD_BALANCE,
DPO_REPLICATE,
DPO_ADJACENCY,
DPO_ADJACENCY_INCOMPLETE,
DPO_ADJACENCY_MIDCHAIN,
DPO_ADJACENCY_GLEAN,
DPO_ADJACENCY_MCAST,
DPO_ADJACENCY_MCAST_MIDCHAIN,
DPO_RECEIVE,
DPO_LOOKUP,
DPO_LISP_CP,
DPO_CLASSIFY,
DPO_MPLS_DISPOSITION_PIPE,
DPO_MPLS_DISPOSITION_UNIFORM,
DPO_MFIB_ENTRY,
DPO_INTERFACE_RX,
DPO_INTERFACE_TX,
DPO_DVR,
DPO_L3_PROXY,
DPO_BIER_TABLE,
DPO_BIER_FMASK,
DPO_BIER_IMP,
DPO_BIER_DISP_TABLE,
DPO_BIER_DISP_ENTRY,
DPO_IP6_LL,
DPO_LAST,
} __attribute__((packed)) dpo_type_t;
#define DPO_TYPE_NUM DPO_LAST
#define DPO_TYPES { \
[DPO_FIRST] = "dpo-invalid", \
[DPO_DROP] = "dpo-drop", \
[DPO_IP_NULL] = "dpo-ip-null", \
[DPO_PUNT] = "dpo-punt", \
[DPO_ADJACENCY] = "dpo-adjacency", \
[DPO_ADJACENCY_INCOMPLETE] = "dpo-adjacency-incomplete", \
[DPO_ADJACENCY_MIDCHAIN] = "dpo-adjacency-midcahin", \
[DPO_ADJACENCY_GLEAN] = "dpo-glean", \
[DPO_ADJACENCY_MCAST] = "dpo-adj-mcast", \
[DPO_ADJACENCY_MCAST_MIDCHAIN] = "dpo-adj-mcast-midchain", \
[DPO_RECEIVE] = "dpo-receive", \
[DPO_LOOKUP] = "dpo-lookup", \
[DPO_LOAD_BALANCE] = "dpo-load-balance", \
[DPO_REPLICATE] = "dpo-replicate", \
[DPO_LISP_CP] = "dpo-lisp-cp", \
[DPO_CLASSIFY] = "dpo-classify", \
[DPO_MPLS_DISPOSITION_PIPE] = "dpo-mpls-diposition-pipe", \
[DPO_MPLS_DISPOSITION_UNIFORM] = "dpo-mpls-diposition-uniform", \
[DPO_MFIB_ENTRY] = "dpo-mfib-entry", \
[DPO_INTERFACE_RX] = "dpo-interface-rx", \
[DPO_INTERFACE_TX] = "dpo-interface-tx", \
[DPO_DVR] = "dpo-dvr", \
[DPO_L3_PROXY] = "dpo-l3-proxy", \
[DPO_BIER_TABLE] = "bier-table", \
[DPO_BIER_FMASK] = "bier-fmask", \
[DPO_BIER_IMP] = "bier-imposition", \
[DPO_BIER_DISP_ENTRY] = "bier-disp-entry", \
[DPO_BIER_DISP_TABLE] = "bier-disp-table", \
[DPO_IP6_LL] = "ip6-link-local", \
}
/**
* @brief The identity of a DPO is a combination of its type and its
* instance number/index of objects of that type
*/
typedef struct dpo_id_t_ {
/**
* the type
*/
dpo_type_t dpoi_type;
/**
* the data-path protocol of the type.
*/
dpo_proto_t dpoi_proto;
/**
* The next VLIB node to follow.
*/
u16 dpoi_next_node;
/**
* the index of objects of that type
*/
index_t dpoi_index;
} __attribute__ ((aligned(sizeof(u64)))) dpo_id_t;
STATIC_ASSERT(sizeof(dpo_id_t) <= sizeof(u64),
"DPO ID is greater than sizeof u64 "
"atomic updates need to be revisited");
/**
* @brief An initialiser for DPOs declared on the stack.
* Thenext node is set to 0 since VLIB graph nodes should set 0 index to drop.
*/
#define DPO_INVALID \
{ \
.dpoi_type = DPO_FIRST, \
.dpoi_proto = DPO_PROTO_NONE, \
.dpoi_index = INDEX_INVALID, \
.dpoi_next_node = 0, \
}
/**
* @brief Return true if the DPO object is valid, i.e. has been initialised.
*/
static inline int
dpo_id_is_valid (const dpo_id_t *dpoi)
{
return (dpoi->dpoi_type != DPO_FIRST &&
dpoi->dpoi_index != INDEX_INVALID);
}
extern dpo_proto_t vnet_link_to_dpo_proto(vnet_link_t linkt);
/**
* @brief
* Take a reference counting lock on the DPO
*/
extern void dpo_lock(dpo_id_t *dpo);
/**
* @brief
* Release a reference counting lock on the DPO
*/
extern void dpo_unlock(dpo_id_t *dpo);
/**
* @brief
* Make an interpose DPO from an original
*/
extern void dpo_mk_interpose(const dpo_id_t *original,
const dpo_id_t *parent,
dpo_id_t *clone);
/**
* @brief Set/create a DPO ID
* The DPO will be locked.
*
* @param dpo
* The DPO object to configure
*
* @param type
* The dpo_type_t of the DPO
*
* @param proto
* The dpo_proto_t of the DPO
*
* @param index
* The type specific index of the DPO
*/
extern void dpo_set(dpo_id_t *dpo,
dpo_type_t type,
dpo_proto_t proto,
index_t index);
/**
* @brief reset a DPO ID
* The DPO will be unlocked.
*
* @param dpo
* The DPO object to reset
*/
extern void dpo_reset(dpo_id_t *dpo);
/**
* @brief compare two DPOs for equality
*/
extern int dpo_cmp(const dpo_id_t *dpo1,
const dpo_id_t *dpo2);
/**
* @brief
* atomic copy a data-plane object.
* This is safe to use when the dst DPO is currently switching packets
*/
extern void dpo_copy(dpo_id_t *dst,
const dpo_id_t *src);
/**
* @brief Return TRUE is the DPO is any type of adjacency
*/
extern int dpo_is_adj(const dpo_id_t *dpo);
/**
* @biref Format a DPO_id_t oject
*/
extern u8 *format_dpo_id(u8 * s, va_list * args);
/**
* @biref format a DPO type
*/
extern u8 *format_dpo_type(u8 * s, va_list * args);
/**
* @brief format a DPO protocol
*/
extern u8 *format_dpo_proto(u8 * s, va_list * args);
/**
* @brief format a DPO protocol
*/
extern vnet_link_t dpo_proto_to_link(dpo_proto_t dp);
/**
* @brief
* Set and stack a DPO.
* The DPO passed is set to the parent DPO and the necessary
* VLIB graph arcs are created. The child_type and child_proto
* are used to get the VLID nodes from which the arcs are added.
*
* @param child_type
* Child DPO type.
*
* @param child_proto
* Child DPO proto
*
* @parem dpo
* This is the DPO to stack and set.
*
* @paren parent_dpo
* The parent DPO to stack onto.
*/
extern void dpo_stack(dpo_type_t child_type,
dpo_proto_t child_proto,
dpo_id_t *dpo,
const dpo_id_t *parent_dpo);
/**
* @brief
* Set and stack a DPO.
* The DPO passed is set to the parent DPO and the necessary
* VLIB graph arcs are created, from the child_node passed.
*
* @param child_node
* The VLIB grpah node index to create an arc from to the parent
*
* @param dpo
* This is the DPO to stack and set.
*
* @param parent_dpo
* The parent DPO to stack onto.
*/
extern void dpo_stack_from_node(u32 child_node,
dpo_id_t *dpo,
const dpo_id_t *parent);
/**
* Get a uRPF interface for the DPO
*
* @param dpo
* The DPO from which to get the uRPF interface
*
* @return valid SW interface index or ~0
*/
extern u32 dpo_get_urpf(const dpo_id_t *dpo);
/**
* @brief A lock function registered for a DPO type
*/
typedef void (*dpo_lock_fn_t)(dpo_id_t *dpo);
/**
* @brief An unlock function registered for a DPO type
*/
typedef void (*dpo_unlock_fn_t)(dpo_id_t *dpo);
/**
* @brief An memory usage show command
*/
typedef void (*dpo_mem_show_t)(void);
/**
* @brief Given a DPO instance return a vector of node indices that
* the type/instance will use.
*/
typedef u32* (*dpo_get_next_node_t)(const dpo_id_t *dpo);
/**
* @brief Given a DPO instance return an interface that can
* be used in an uRPF check
*/
typedef u32 (*dpo_get_urpf_t)(const dpo_id_t *dpo);
/**
* @brief Called during FIB interposition when the originally
* registered DPO is used to 'clone' an instance for interposition
* at a particular location in the FIB graph.
* The parent is the next DPO in the chain that the clone will
* be used instead of. The clone may then choose to stack itself
* on the parent.
*/
typedef void (*dpo_mk_interpose_t)(const dpo_id_t *original,
const dpo_id_t *parent,
dpo_id_t *clone);
/**
* @brief A virtual function table regisitered for a DPO type
*/
typedef struct dpo_vft_t_
{
/**
* A reference counting lock function
*/
dpo_lock_fn_t dv_lock;
/**
* A reference counting unlock function
*/
dpo_lock_fn_t dv_unlock;
/**
* A format function
*/
format_function_t *dv_format;
/**
* A show memory usage function
*/
dpo_mem_show_t dv_mem_show;
/**
* A function to get the next VLIB node given an instance
* of the DPO. If this is null, then the node's name MUST be
* retreiveable from the nodes names array passed in the register
* function
*/
dpo_get_next_node_t dv_get_next_node;
/**
* Get uRPF interface
*/
dpo_get_urpf_t dv_get_urpf;
/**
* Signal on an interposed child that the parent has changed
*/
dpo_mk_interpose_t dv_mk_interpose;
} dpo_vft_t;
/**
* @brief For a given DPO type Register:
* - a virtual function table
* - a NULL terminated array of graph nodes from which that object type
* will originate packets, i.e. the nodes in which the object type will be
* the parent DPO in the DP graph. The ndoes are per-data-path protocol
* (see above).
*
* @param type
* The type being registered.
*
* @param vft
* The virtual function table to register for the type.
*
* @param nodes
* The string description of the per-protocol VLIB graph nodes.
*/
extern void dpo_register(dpo_type_t type,
const dpo_vft_t *vft,
const char * const * const * nodes);
/**
* @brief Create and register a new DPO type.
*
* This can be used by plugins to create new DPO types that are not listed
* in dpo_type_t enum
*
* @param vft
* The virtual function table to register for the type.
*
* @param nodes
* The string description of the per-protocol VLIB graph nodes.
*
* @return The new dpo_type_t
*/
extern dpo_type_t dpo_register_new_type(const dpo_vft_t *vft,
const char * const * const * nodes);
/**
* @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.
*
* @param child_type
* Child DPO type.
*
* @param child_proto
* Child DPO proto
*
* @param parent_type
* Parent DPO type.
*
* @param parent_proto
* Parent DPO proto
*
* @return The VLIB Graph node index
*/
extern 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);
#endif
