FD.io VPP  v18.01.2-1-g9b554f3
Vector Packet Processing
dpo.c
Go to the documentation of this file.
1 /*
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:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
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.
14  */
15 /**
16  * @brief
17  * A Data-Path Object is an object that represents actions that are
18  * applied to packets are they are switched through VPP.
19  *
20  * The DPO is a base class that is specialised by other objects to provide
21  * concreate actions
22  *
23  * The VLIB graph nodes are graph of types, the DPO graph is a graph of instances.
24  */
25 
26 #include <vnet/dpo/dpo.h>
27 #include <vnet/ip/lookup.h>
28 #include <vnet/ip/format.h>
29 #include <vnet/adj/adj.h>
30 
31 #include <vnet/dpo/load_balance.h>
33 #include <vnet/dpo/lookup_dpo.h>
34 #include <vnet/dpo/drop_dpo.h>
35 #include <vnet/dpo/receive_dpo.h>
36 #include <vnet/dpo/punt_dpo.h>
37 #include <vnet/dpo/classify_dpo.h>
38 #include <vnet/dpo/ip_null_dpo.h>
39 #include <vnet/dpo/replicate_dpo.h>
43 #include <vnet/dpo/l2_bridge_dpo.h>
44 #include <vnet/dpo/l3_proxy_dpo.h>
45 
46 /**
47  * Array of char* names for the DPO types and protos
48  */
49 static const char* dpo_type_names[] = DPO_TYPES;
50 static const char* dpo_proto_names[] = DPO_PROTOS;
51 
52 /**
53  * @brief Vector of virtual function tables for the DPO types
54  *
55  * This is a vector so we can dynamically register new DPO types in plugins.
56  */
58 
59 /**
60  * @brief vector of graph node names associated with each DPO type and protocol.
61  *
62  * dpo_nodes[child_type][child_proto][node_X] = node_name;
63  * i.e.
64  * dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][0] = "ip4-lookup"
65  * dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][1] = "ip4-load-balance"
66  *
67  * This is a vector so we can dynamically register new DPO types in plugins.
68  */
69 static const char* const * const ** dpo_nodes;
70 
71 /**
72  * @brief Vector of edge indicies from parent DPO nodes to child
73  *
74  * dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge_index
75  *
76  * This array is derived at init time from the dpo_nodes above. Note that
77  * the third dimension in dpo_nodes is lost, hence, the edge index from each
78  * node MUST be the same.
79  * Including both the child and parent protocol is required to support the
80  * case where it changes as the grapth is traversed, most notablly when an
81  * MPLS label is popped.
82  *
83  * Note that this array is child type specific, not child instance specific.
84  */
85 static u32 ****dpo_edges;
86 
87 /**
88  * @brief The DPO type value that can be assigend to the next dynamic
89  * type registration.
90  */
92 
95 {
96  switch (linkt)
97  {
98  case VNET_LINK_IP6:
99  return (DPO_PROTO_IP6);
100  case VNET_LINK_IP4:
101  return (DPO_PROTO_IP4);
102  case VNET_LINK_MPLS:
103  return (DPO_PROTO_MPLS);
104  case VNET_LINK_ETHERNET:
105  return (DPO_PROTO_ETHERNET);
106  case VNET_LINK_NSH:
107  return (DPO_PROTO_NSH);
108  case VNET_LINK_ARP:
109  break;
110  }
111  ASSERT(0);
112  return (0);
113 }
114 
117 {
118  switch (dp)
119  {
120  case DPO_PROTO_IP6:
121  return (VNET_LINK_IP6);
122  case DPO_PROTO_IP4:
123  return (VNET_LINK_IP4);
124  case DPO_PROTO_MPLS:
125  case DPO_PROTO_BIER:
126  return (VNET_LINK_MPLS);
127  case DPO_PROTO_ETHERNET:
128  return (VNET_LINK_ETHERNET);
129  case DPO_PROTO_NSH:
130  return (VNET_LINK_NSH);
131  }
132  return (~0);
133 }
134 
135 u8 *
136 format_dpo_type (u8 * s, va_list * args)
137 {
138  dpo_type_t type = va_arg (*args, int);
139 
140  s = format(s, "%s", dpo_type_names[type]);
141 
142  return (s);
143 }
144 
145 u8 *
146 format_dpo_id (u8 * s, va_list * args)
147 {
148  dpo_id_t *dpo = va_arg (*args, dpo_id_t*);
149  u32 indent = va_arg (*args, u32);
150 
151  s = format(s, "[@%d]: ", dpo->dpoi_next_node);
152 
153  if (NULL != dpo_vfts[dpo->dpoi_type].dv_format)
154  {
155  return (format(s, "%U",
156  dpo_vfts[dpo->dpoi_type].dv_format,
157  dpo->dpoi_index,
158  indent));
159  }
160 
161  switch (dpo->dpoi_type)
162  {
163  case DPO_FIRST:
164  s = format(s, "unset");
165  break;
166  default:
167  s = format(s, "unknown");
168  break;
169  }
170  return (s);
171 }
172 
173 u8 *
174 format_dpo_proto (u8 * s, va_list * args)
175 {
176  dpo_proto_t proto = va_arg (*args, int);
177 
178  return (format(s, "%s", dpo_proto_names[proto]));
179 }
180 
181 void
183  dpo_type_t type,
184  dpo_proto_t proto,
185  index_t index)
186 {
187  dpo_id_t tmp = *dpo;
188 
189  dpo->dpoi_type = type;
190  dpo->dpoi_proto = proto,
191  dpo->dpoi_index = index;
192 
193  if (DPO_ADJACENCY == type)
194  {
195  /*
196  * set the adj subtype
197  */
198  ip_adjacency_t *adj;
199 
200  adj = adj_get(index);
201 
202  switch (adj->lookup_next_index)
203  {
204  case IP_LOOKUP_NEXT_ARP:
206  break;
209  break;
212  break;
215  break;
218  break;
219  default:
220  break;
221  }
222  }
223  dpo_lock(dpo);
224  dpo_unlock(&tmp);
225 }
226 
227 void
229 {
230  dpo_id_t tmp = DPO_INVALID;
231 
232  /*
233  * use the atomic copy operation.
234  */
235  dpo_copy(dpo, &tmp);
236 }
237 
238 /**
239  * \brief
240  * Compare two Data-path objects
241  *
242  * like memcmp, return 0 is matching, !0 otherwise.
243  */
244 int
245 dpo_cmp (const dpo_id_t *dpo1,
246  const dpo_id_t *dpo2)
247 {
248  int res;
249 
250  res = dpo1->dpoi_type - dpo2->dpoi_type;
251 
252  if (0 != res) return (res);
253 
254  return (dpo1->dpoi_index - dpo2->dpoi_index);
255 }
256 
257 void
259  const dpo_id_t *src)
260 {
261  dpo_id_t tmp = *dst;
262 
263  /*
264  * the destination is written in a single u64 write - hence atomically w.r.t
265  * any packets inflight.
266  */
267  *((u64*)dst) = *(u64*)src;
268 
269  dpo_lock(dst);
270  dpo_unlock(&tmp);
271 }
272 
273 int
274 dpo_is_adj (const dpo_id_t *dpo)
275 {
276  return ((dpo->dpoi_type == DPO_ADJACENCY) ||
278  (dpo->dpoi_type == DPO_ADJACENCY_MIDCHAIN) ||
279  (dpo->dpoi_type == DPO_ADJACENCY_GLEAN));
280 }
281 
282 static u32 *
284 {
285  u32 *node_indices = NULL;
286  const char *node_name;
287  u32 ii = 0;
288 
289  node_name = dpo_nodes[dpo->dpoi_type][dpo->dpoi_proto][ii];
290  while (NULL != node_name)
291  {
292  vlib_node_t *node;
293 
294  node = vlib_get_node_by_name(vlib_get_main(), (u8*) node_name);
295  ASSERT(NULL != node);
296  vec_add1(node_indices, node->index);
297 
298  ++ii;
299  node_name = dpo_nodes[dpo->dpoi_type][dpo->dpoi_proto][ii];
300  }
301 
302  return (node_indices);
303 }
304 
305 void
307  const dpo_vft_t *vft,
308  const char * const * const * nodes)
309 {
310  vec_validate(dpo_vfts, type);
311  dpo_vfts[type] = *vft;
312  if (NULL == dpo_vfts[type].dv_get_next_node)
313  {
315  }
316 
317  vec_validate(dpo_nodes, type);
318  dpo_nodes[type] = nodes;
319 }
320 
323  const char * const * const * nodes)
324 {
325  dpo_type_t type = dpo_dynamic++;
326 
327  dpo_register(type, vft, nodes);
328 
329  return (type);
330 }
331 
332 void
334 {
335  if (!dpo_id_is_valid(dpo))
336  return;
337 
338  dpo_vfts[dpo->dpoi_type].dv_lock(dpo);
339 }
340 
341 void
343 {
344  if (!dpo_id_is_valid(dpo))
345  return;
346 
347  dpo_vfts[dpo->dpoi_type].dv_unlock(dpo);
348 }
349 
350 u32
352 {
353  if (dpo_id_is_valid(dpo) &&
354  (NULL != dpo_vfts[dpo->dpoi_type].dv_get_urpf))
355  {
356  return (dpo_vfts[dpo->dpoi_type].dv_get_urpf(dpo));
357  }
358 
359  return (~0);
360 }
361 
362 static u32
364  dpo_proto_t child_proto,
365  const dpo_id_t *parent_dpo)
366 {
367  dpo_proto_t parent_proto;
368  dpo_type_t parent_type;
369 
370  parent_type = parent_dpo->dpoi_type;
371  parent_proto = parent_dpo->dpoi_proto;
372 
373  vec_validate(dpo_edges, child_type);
374  vec_validate(dpo_edges[child_type], child_proto);
375  vec_validate(dpo_edges[child_type][child_proto], parent_type);
377  dpo_edges[child_type][child_proto][parent_type],
378  parent_proto, ~0);
379 
380  /*
381  * if the edge index has not yet been created for this node to node transistion
382  */
383  if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
384  {
385  vlib_node_t *child_node;
386  u32 *parent_indices;
387  vlib_main_t *vm;
388  u32 edge, *pi, cc;
389 
390  vm = vlib_get_main();
391 
392  ASSERT(NULL != dpo_vfts[parent_type].dv_get_next_node);
393  ASSERT(NULL != dpo_nodes[child_type]);
394  ASSERT(NULL != dpo_nodes[child_type][child_proto]);
395 
396  cc = 0;
397  parent_indices = dpo_vfts[parent_type].dv_get_next_node(parent_dpo);
398 
400 
401  /*
402  * create a graph arc from each of the child's registered node types,
403  * to each of the parent's.
404  */
405  while (NULL != dpo_nodes[child_type][child_proto][cc])
406  {
407  child_node =
409  (u8*) dpo_nodes[child_type][child_proto][cc]);
410 
411  vec_foreach(pi, parent_indices)
412  {
413  edge = vlib_node_add_next(vm, child_node->index, *pi);
414 
415  if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
416  {
417  dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge;
418  }
419  else
420  {
421  ASSERT(dpo_edges[child_type][child_proto][parent_type][parent_proto] == edge);
422  }
423  }
424  cc++;
425  }
426 
428  vec_free(parent_indices);
429  }
430 
431  return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
432 }
433 
434 /**
435  * @brief Stack one DPO object on another, and thus establish a child parent
436  * relationship. The VLIB graph arc used is taken from the parent and child types
437  * passed.
438  */
439 static void
441  dpo_id_t *dpo,
442  const dpo_id_t *parent)
443 {
444  /*
445  * in order to get an atomic update of the parent we create a temporary,
446  * from a copy of the child, and add the next_node. then we copy to the parent
447  */
448  dpo_id_t tmp = DPO_INVALID;
449  dpo_copy(&tmp, parent);
450 
451  /*
452  * get the edge index for the parent to child VLIB graph transisition
453  */
454  tmp.dpoi_next_node = edge;
455 
456  /*
457  * this update is atomic.
458  */
459  dpo_copy(dpo, &tmp);
460 
461  dpo_reset(&tmp);
462 }
463 
464 /**
465  * @brief Stack one DPO object on another, and thus establish a child-parent
466  * relationship. The VLIB graph arc used is taken from the parent and child types
467  * passed.
468  */
469 void
470 dpo_stack (dpo_type_t child_type,
471  dpo_proto_t child_proto,
472  dpo_id_t *dpo,
473  const dpo_id_t *parent)
474 {
475  dpo_stack_i(dpo_get_next_node(child_type, child_proto, parent), dpo, parent);
476 }
477 
478 /**
479  * @brief Stack one DPO object on another, and thus establish a child parent
480  * relationship. A new VLIB graph arc is created from the child node passed
481  * to the nodes registered by the parent. The VLIB infra will ensure this arc
482  * is added only once.
483  */
484 void
485 dpo_stack_from_node (u32 child_node_index,
486  dpo_id_t *dpo,
487  const dpo_id_t *parent)
488 {
489  dpo_type_t parent_type;
490  u32 *parent_indices;
491  vlib_main_t *vm;
492  u32 edge, *pi;
493 
494  edge = 0;
495  parent_type = parent->dpoi_type;
496  vm = vlib_get_main();
497 
498  ASSERT(NULL != dpo_vfts[parent_type].dv_get_next_node);
499  parent_indices = dpo_vfts[parent_type].dv_get_next_node(parent);
500  ASSERT(parent_indices);
501 
502  /*
503  * This loop is purposefully written with the worker thread lock in the
504  * inner loop because;
505  * 1) the likelihood that the edge does not exist is smaller
506  * 2) the likelihood there is more than one node is even smaller
507  * so we are optimising for not need to take the lock
508  */
509  vec_foreach(pi, parent_indices)
510  {
511  edge = vlib_node_get_next(vm, child_node_index, *pi);
512 
513  if (~0 == edge)
514  {
516 
517  edge = vlib_node_add_next(vm, child_node_index, *pi);
518 
520  }
521  }
522  dpo_stack_i(edge, dpo, parent);
523 }
524 
525 static clib_error_t *
527 {
542 
543  return (NULL);
544 }
545 
547 
548 static clib_error_t *
550  unformat_input_t * input,
551  vlib_cli_command_t * cmd)
552 {
553  dpo_vft_t *vft;
554 
555  vlib_cli_output (vm, "DPO memory");
556  vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals",
557  "Name","Size", "in-use", "allocated");
558 
559  vec_foreach(vft, dpo_vfts)
560  {
561  if (NULL != vft->dv_mem_show)
562  vft->dv_mem_show();
563  }
564 
565  return (NULL);
566 }
567 
568 /* *INDENT-OFF* */
569 /*?
570  * The '<em>sh dpo memory </em>' command displays the memory usage for each
571  * data-plane object type.
572  *
573  * @cliexpar
574  * @cliexstart{show dpo memory}
575  * DPO memory
576  * Name Size in-use /allocated totals
577  * load-balance 64 12 / 12 768/768
578  * Adjacency 256 1 / 1 256/256
579  * Receive 24 5 / 5 120/120
580  * Lookup 12 0 / 0 0/0
581  * Classify 12 0 / 0 0/0
582  * MPLS label 24 0 / 0 0/0
583  * @cliexend
584 ?*/
585 VLIB_CLI_COMMAND (show_fib_memory, static) = {
586  .path = "show dpo memory",
587  .function = dpo_memory_show,
588  .short_help = "show dpo memory",
589 };
590 /* *INDENT-ON* */
void dpo_unlock(dpo_id_t *dpo)
Release a reference counting lock on the DPO.
Definition: dpo.c:342
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:432
void dpo_stack_from_node(u32 child_node_index, dpo_id_t *dpo, const dpo_id_t *parent)
Stack one DPO object on another, and thus establish a child parent relationship.
Definition: dpo.c:485
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:382
static const char * dpo_type_names[]
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.c:49
A virtual function table regisitered for a DPO type.
Definition: dpo.h:377
u8 * format_dpo_type(u8 *s, va_list *args)
format a DPO type
Definition: dpo.c:136
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
Definition: dpo.c:274
static dpo_type_t dpo_dynamic
The DPO type value that can be assigend to the next dynamic type registration.
Definition: dpo.c:91
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:205
dpo_get_urpf_t dv_get_urpf
Get uRPF interface.
Definition: dpo.h:405
void l3_proxy_dpo_module_init(void)
Definition: l3_proxy_dpo.c:172
Multicast Adjacency.
Definition: adj.h:82
Definitions for all things IP (v4|v6) unicast and multicast lookup related.
#define NULL
Definition: clib.h:55
dpo_proto_t dpoi_proto
the data-path protocol of the type.
Definition: dpo.h:174
u32 index
Definition: node.h:237
IP unicast adjacency.
Definition: adj.h:174
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:258
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
#define DPO_PROTOS
Definition: dpo.h:73
u32 dpo_get_urpf(const dpo_id_t *dpo)
Get a uRPF interface for the DPO.
Definition: dpo.c:351
static const char * dpo_proto_names[]
Definition: dpo.c:50
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1108
#define vlib_worker_thread_barrier_sync(X)
Definition: threads.h:212
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:365
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:306
enum dpo_type_t_ dpo_type_t
Common types of data-path objects New types can be dynamically added using dpo_register_new_type() ...
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
dpo_proto_t vnet_link_to_dpo_proto(vnet_link_t linkt)
Definition: dpo.c:94
static u32 dpo_get_next_node(dpo_type_t child_type, dpo_proto_t child_proto, const dpo_id_t *parent_dpo)
Definition: dpo.c:363
void load_balance_module_init(void)
Definition: load_balance.c:846
#define DPO_TYPES
Definition: dpo.h:131
void receive_dpo_module_init(void)
Definition: receive_dpo.c:167
unsigned long u64
Definition: types.h:89
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
dpo_type_t dpo_register_new_type(const dpo_vft_t *vft, const char *const *const *nodes)
Create and register a new DPO type.
Definition: dpo.c:322
static u32 * dpo_default_get_next_node(const dpo_id_t *dpo)
Definition: dpo.c:283
static u32 **** dpo_edges
Vector of edge indicies from parent DPO nodes to child.
Definition: dpo.c:85
dpo_get_next_node_t dv_get_next_node
A function to get the next VLIB node given an instance of the DPO.
Definition: dpo.h:401
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:166
void ip_null_dpo_module_init(void)
Definition: ip_null_dpo.c:405
void interface_rx_dpo_module_init(void)
Definition: dpo.h:126
dpo_type_t dpoi_type
the type
Definition: dpo.h:170
static const char *const *const ** dpo_nodes
vector of graph node names associated with each DPO type and protocol.
Definition: dpo.c:69
struct _unformat_input_t unformat_input_t
void classify_dpo_module_init(void)
Definition: classify_dpo.c:128
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
Definition: adj.h:68
void dpo_lock(dpo_id_t *dpo)
Take a reference counting lock on the DPO.
Definition: dpo.c:333
void lookup_dpo_module_init(void)
Definition: lookup_dpo.c:1404
void l2_bridge_dpo_module_init(void)
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: adj.h:63
vlib_main_t * vm
Definition: buffer.c:283
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
Multicast Midchain Adjacency.
Definition: adj.h:86
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:182
void mpls_disp_dpo_module_init(void)
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
This packets follow a mid-chain adjacency.
Definition: adj.h:76
void mpls_label_dpo_module_init(void)
static clib_error_t * dpo_module_init(vlib_main_t *vm)
Definition: dpo.c:526
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static dpo_vft_t * dpo_vfts
Vector of virtual function tables for the DPO types.
Definition: dpo.c:57
vnet_link_t dpo_proto_to_link(dpo_proto_t dp)
format a DPO protocol
Definition: dpo.c:116
void interface_tx_dpo_module_init(void)
void punt_dpo_module_init(void)
Definition: punt_dpo.c:97
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
A non-zero value first so we can spot unitialisation errors.
Definition: dpo.h:95
int dpo_cmp(const dpo_id_t *dpo1, const dpo_id_t *dpo2)
Compare two Data-path objects.
Definition: dpo.c:245
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:146
dpo_mem_show_t dv_mem_show
A show memory usage function.
Definition: dpo.h:394
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
uword vlib_node_get_next(vlib_main_t *vm, uword node_index, uword next_node_index)
Definition: node.c:184
static clib_error_t * dpo_memory_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: dpo.c:549
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:182
format_function_t * dv_format
A format function.
Definition: dpo.h:390
unsigned char u8
Definition: types.h:56
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:189
dpo_lock_fn_t dv_unlock
A reference counting unlock function.
Definition: dpo.h:386
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:193
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:174
void vlib_worker_thread_barrier_release(vlib_main_t *vm)
Definition: threads.c:1491
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:228
#define vec_foreach(var, vec)
Vector iterator.
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:178
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:481
void drop_dpo_module_init(void)
Definition: drop_dpo.c:115
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
static void dpo_stack_i(u32 edge, dpo_id_t *dpo, const dpo_id_t *parent)
Stack one DPO object on another, and thus establish a child parent relationship.
Definition: dpo.c:440
void replicate_module_init(void)
void dpo_stack(dpo_type_t child_type, dpo_proto_t child_proto, dpo_id_t *dpo, const dpo_id_t *parent)
Stack one DPO object on another, and thus establish a child-parent relationship.
Definition: dpo.c:470