FD.io VPP  v17.01.1-3-gc6833f8
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 
40 /**
41  * Array of char* names for the DPO types and protos
42  */
43 static const char* dpo_type_names[] = DPO_TYPES;
44 static const char* dpo_proto_names[] = DPO_PROTOS;
45 
46 /**
47  * @brief Vector of virtual function tables for the DPO types
48  *
49  * This is a vector so we can dynamically register new DPO types in plugins.
50  */
52 
53 /**
54  * @brief vector of graph node names associated with each DPO type and protocol.
55  *
56  * dpo_nodes[child_type][child_proto][node_X] = node_name;
57  * i.e.
58  * dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][0] = "ip4-lookup"
59  * dpo_node[DPO_LOAD_BALANCE][DPO_PROTO_IP4][1] = "ip4-load-balance"
60  *
61  * This is a vector so we can dynamically register new DPO types in plugins.
62  */
63 static const char* const * const ** dpo_nodes;
64 
65 /**
66  * @brief Vector of edge indicies from parent DPO nodes to child
67  *
68  * dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge_index
69  *
70  * This array is derived at init time from the dpo_nodes above. Note that
71  * the third dimension in dpo_nodes is lost, hence, the edge index from each
72  * node MUST be the same.
73  * Including both the child and parent protocol is required to support the
74  * case where it changes as the grapth is traversed, most notablly when an
75  * MPLS label is popped.
76  *
77  * Note that this array is child type specific, not child instance specific.
78  */
79 static u32 ****dpo_edges;
80 
81 /**
82  * @brief The DPO type value that can be assigend to the next dynamic
83  * type registration.
84  */
86 
89 {
90  switch (linkt)
91  {
92  case VNET_LINK_IP6:
93  return (DPO_PROTO_IP6);
94  case VNET_LINK_IP4:
95  return (DPO_PROTO_IP4);
96  case VNET_LINK_MPLS:
97  return (DPO_PROTO_MPLS);
98  case VNET_LINK_ETHERNET:
99  return (DPO_PROTO_ETHERNET);
100  case VNET_LINK_ARP:
101  break;
102  }
103  ASSERT(0);
104  return (0);
105 }
106 
107 u8 *
108 format_dpo_type (u8 * s, va_list * args)
109 {
110  dpo_type_t type = va_arg (*args, int);
111 
112  s = format(s, "%s", dpo_type_names[type]);
113 
114  return (s);
115 }
116 
117 u8 *
118 format_dpo_id (u8 * s, va_list * args)
119 {
120  dpo_id_t *dpo = va_arg (*args, dpo_id_t*);
121  u32 indent = va_arg (*args, u32);
122 
123  s = format(s, "[@%d]: ", dpo->dpoi_next_node);
124 
125  if (NULL != dpo_vfts[dpo->dpoi_type].dv_format)
126  {
127  return (format(s, "%U",
128  dpo_vfts[dpo->dpoi_type].dv_format,
129  dpo->dpoi_index,
130  indent));
131  }
132 
133  switch (dpo->dpoi_type)
134  {
135  case DPO_FIRST:
136  s = format(s, "unset");
137  break;
138  default:
139  s = format(s, "unknown");
140  break;
141  }
142  return (s);
143 }
144 
145 u8 *
146 format_dpo_proto (u8 * s, va_list * args)
147 {
148  dpo_proto_t proto = va_arg (*args, int);
149 
150  return (format(s, "%s", dpo_proto_names[proto]));
151 }
152 
153 void
156  dpo_proto_t proto,
157  index_t index)
158 {
159  dpo_id_t tmp = *dpo;
160 
161  dpo->dpoi_type = type;
162  dpo->dpoi_proto = proto,
163  dpo->dpoi_index = index;
164 
165  if (DPO_ADJACENCY == type)
166  {
167  /*
168  * set the adj subtype
169  */
170  ip_adjacency_t *adj;
171 
172  adj = adj_get(index);
173 
174  switch (adj->lookup_next_index)
175  {
176  case IP_LOOKUP_NEXT_ARP:
178  break;
181  break;
182  default:
183  break;
184  }
185  }
186  dpo_lock(dpo);
187  dpo_unlock(&tmp);
188 }
189 
190 void
192 {
193  dpo_id_t tmp = DPO_INVALID;
194 
195  /*
196  * use the atomic copy operation.
197  */
198  dpo_copy(dpo, &tmp);
199 }
200 
201 /**
202  * \brief
203  * Compare two Data-path objects
204  *
205  * like memcmp, return 0 is matching, !0 otherwise.
206  */
207 int
208 dpo_cmp (const dpo_id_t *dpo1,
209  const dpo_id_t *dpo2)
210 {
211  int res;
212 
213  res = dpo1->dpoi_type - dpo2->dpoi_type;
214 
215  if (0 != res) return (res);
216 
217  return (dpo1->dpoi_index - dpo2->dpoi_index);
218 }
219 
220 void
222  const dpo_id_t *src)
223 {
224  dpo_id_t tmp = *dst;
225 
226  /*
227  * the destination is written in a single u64 write - hence atomically w.r.t
228  * any packets inflight.
229  */
230  *((u64*)dst) = *(u64*)src;
231 
232  dpo_lock(dst);
233  dpo_unlock(&tmp);
234 }
235 
236 int
237 dpo_is_adj (const dpo_id_t *dpo)
238 {
239  return ((dpo->dpoi_type == DPO_ADJACENCY) ||
241  (dpo->dpoi_type == DPO_ADJACENCY_MIDCHAIN) ||
242  (dpo->dpoi_type == DPO_ADJACENCY_GLEAN));
243 }
244 
245 void
247  const dpo_vft_t *vft,
248  const char * const * const * nodes)
249 {
250  vec_validate(dpo_vfts, type);
251  dpo_vfts[type] = *vft;
252 
253  vec_validate(dpo_nodes, type);
254  dpo_nodes[type] = nodes;
255 }
256 
259  const char * const * const * nodes)
260 {
262 
263  dpo_register(type, vft, nodes);
264 
265  return (type);
266 }
267 
268 void
270 {
271  if (!dpo_id_is_valid(dpo))
272  return;
273 
274  dpo_vfts[dpo->dpoi_type].dv_lock(dpo);
275 }
276 
277 void
279 {
280  if (!dpo_id_is_valid(dpo))
281  return;
282 
283  dpo_vfts[dpo->dpoi_type].dv_unlock(dpo);
284 }
285 
286 
287 static u32
289  dpo_proto_t child_proto,
290  const dpo_id_t *parent_dpo)
291 {
292  dpo_proto_t parent_proto;
293  dpo_type_t parent_type;
294 
295  parent_type = parent_dpo->dpoi_type;
296  parent_proto = parent_dpo->dpoi_proto;
297 
298  vec_validate(dpo_edges, child_type);
299  vec_validate(dpo_edges[child_type], child_proto);
300  vec_validate(dpo_edges[child_type][child_proto], parent_type);
302  dpo_edges[child_type][child_proto][parent_type],
303  parent_proto, ~0);
304 
305  /*
306  * if the edge index has not yet been created for this node to node transistion
307  */
308  if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
309  {
310  vlib_node_t *parent_node, *child_node;
311  vlib_main_t *vm;
312  u32 edge ,pp, cc;
313 
314  vm = vlib_get_main();
315 
316  ASSERT(NULL != dpo_nodes[child_type]);
317  ASSERT(NULL != dpo_nodes[child_type][child_proto]);
318  ASSERT(NULL != dpo_nodes[parent_type]);
319  ASSERT(NULL != dpo_nodes[parent_type][parent_proto]);
320 
321  cc = 0;
322 
323  /*
324  * create a graph arc from each of the parent's registered node types,
325  * to each of the childs.
326  */
327  while (NULL != dpo_nodes[child_type][child_proto][cc])
328  {
329  child_node =
331  (u8*) dpo_nodes[child_type][child_proto][cc]);
332 
333  pp = 0;
334 
335  while (NULL != dpo_nodes[parent_type][parent_proto][pp])
336  {
337  parent_node =
339  (u8*) dpo_nodes[parent_type][parent_proto][pp]);
340 
341  edge = vlib_node_add_next(vm,
342  child_node->index,
343  parent_node->index);
344 
345  if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
346  {
347  dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge;
348  }
349  else
350  {
351  ASSERT(dpo_edges[child_type][child_proto][parent_type][parent_proto] == edge);
352  }
353  pp++;
354  }
355  cc++;
356  }
357  }
358 
359  return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
360 }
361 
362 /**
363  * @brief Stack one DPO object on another, and thus establish a child parent
364  * relationship. The VLIB graph arc used is taken from the parent and child types
365  * passed.
366  */
367 static void
369  dpo_id_t *dpo,
370  const dpo_id_t *parent)
371 {
372  /*
373  * in order to get an atomic update of the parent we create a temporary,
374  * from a copy of the child, and add the next_node. then we copy to the parent
375  */
376  dpo_id_t tmp = DPO_INVALID;
377  dpo_copy(&tmp, parent);
378 
379  /*
380  * get the edge index for the parent to child VLIB graph transisition
381  */
382  tmp.dpoi_next_node = edge;
383 
384  /*
385  * this update is atomic.
386  */
387  dpo_copy(dpo, &tmp);
388 
389  dpo_reset(&tmp);
390 }
391 
392 /**
393  * @brief Stack one DPO object on another, and thus establish a child-parent
394  * relationship. The VLIB graph arc used is taken from the parent and child types
395  * passed.
396  */
397 void
398 dpo_stack (dpo_type_t child_type,
399  dpo_proto_t child_proto,
400  dpo_id_t *dpo,
401  const dpo_id_t *parent)
402 {
403  dpo_stack_i(dpo_get_next_node(child_type, child_proto, parent), dpo, parent);
404 }
405 
406 /**
407  * @brief Stack one DPO object on another, and thus establish a child parent
408  * relationship. A new VLIB graph arc is created from the child node passed
409  * to the nodes registered by the parent. The VLIB infra will ensure this arc
410  * is added only once.
411  */
412 void
413 dpo_stack_from_node (u32 child_node_index,
414  dpo_id_t *dpo,
415  const dpo_id_t *parent)
416 {
417  dpo_proto_t parent_proto;
418  vlib_node_t *parent_node;
419  dpo_type_t parent_type;
420  vlib_main_t *vm;
421  u32 edge;
422 
423  parent_type = parent->dpoi_type;
424  parent_proto = parent->dpoi_proto;
425 
426  vm = vlib_get_main();
427 
428  ASSERT(NULL != dpo_nodes[parent_type]);
429  ASSERT(NULL != dpo_nodes[parent_type][parent_proto]);
430 
431  parent_node =
432  vlib_get_node_by_name(vm, (u8*) dpo_nodes[parent_type][parent_proto][0]);
433 
434  edge = vlib_node_add_next(vm,
435  child_node_index,
436  parent_node->index);
437 
438  dpo_stack_i(edge, dpo, parent);
439 }
440 
441 static clib_error_t *
443 {
452 
453  return (NULL);
454 }
455 
457 
458 static clib_error_t *
460  unformat_input_t * input,
461  vlib_cli_command_t * cmd)
462 {
463  dpo_vft_t *vft;
464 
465  vlib_cli_output (vm, "DPO memory");
466  vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals",
467  "Name","Size", "in-use", "allocated");
468 
469  vec_foreach(vft, dpo_vfts)
470  {
471  if (NULL != vft->dv_mem_show)
472  vft->dv_mem_show();
473  }
474 
475  return (NULL);
476 }
477 
478 /* *INDENT-OFF* */
479 /*?
480  * The '<em>sh dpo memory </em>' command displays the memory usage for each
481  * data-plane object type.
482  *
483  * @cliexpar
484  * @cliexstart{show dpo memory}
485  * DPO memory
486  * Name Size in-use /allocated totals
487  * load-balance 64 12 / 12 768/768
488  * Adjacency 256 1 / 1 256/256
489  * Receive 24 5 / 5 120/120
490  * Lookup 12 0 / 0 0/0
491  * Classify 12 0 / 0 0/0
492  * MPLS label 24 0 / 0 0/0
493  * @cliexend
494 ?*/
495 VLIB_CLI_COMMAND (show_fib_memory, static) = {
496  .path = "show dpo memory",
497  .function = dpo_memory_show,
498  .short_help = "show dpo memory",
499 };
500 /* *INDENT-ON* */
void dpo_unlock(dpo_id_t *dpo)
Release a reference counting lock on the DPO.
Definition: dpo.c:278
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
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:413
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:327
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:43
A virtual function table regisitered for a DPO type.
Definition: dpo.h:322
u8 * format_dpo_type(u8 *s, va_list *args)
format a DPO type
Definition: dpo.c:108
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
int dpo_is_adj(const dpo_id_t *dpo)
Return TRUE is the DPO is any type of adjacency.
Definition: dpo.c:237
bad routing header type(not 4)") sr_error (NO_MORE_SEGMENTS
static dpo_type_t dpo_dynamic
The DPO type value that can be assigend to the next dynamic type registration.
Definition: dpo.c:85
static int dpo_id_is_valid(const dpo_id_t *dpoi)
Return true if the DPO object is valid, i.e.
Definition: dpo.h:177
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:146
u32 index
Definition: node.h:237
IP unicast adjacency.
Definition: lookup.h:188
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:221
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 DPO_PROTOS
Definition: dpo.h:75
static const char * dpo_proto_names[]
Definition: dpo.c:44
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1063
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:117
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:246
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:88
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:288
void load_balance_module_init(void)
Definition: load_balance.c:811
#define DPO_TYPES
Definition: dpo.h:117
void receive_dpo_module_init(void)
Definition: receive_dpo.c:162
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:258
static u32 **** dpo_edges
Vector of edge indicies from parent DPO nodes to child.
Definition: dpo.c:79
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:138
void ip_null_dpo_module_init(void)
Definition: ip_null_dpo.c:405
Definition: dpo.h:112
dpo_type_t dpoi_type
the type
Definition: dpo.h:142
static const char *const *const ** dpo_nodes
vector of graph node names associated with each DPO type and protocol.
Definition: dpo.c:63
void classify_dpo_module_init(void)
Definition: classify_dpo.c:128
void dpo_lock(dpo_id_t *dpo)
Take a reference counting lock on the DPO.
Definition: dpo.c:269
void lookup_dpo_module_init(void)
Definition: lookup_dpo.c:1168
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:576
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: lookup.h:73
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:154
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
void mpls_label_dpo_module_init(void)
static clib_error_t * dpo_module_init(vlib_main_t *vm)
Definition: dpo.c:442
#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:51
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
This packets follow a mid-chain adjacency.
Definition: lookup.h:89
int dpo_cmp(const dpo_id_t *dpo1, const dpo_id_t *dpo2)
Compare two Data-path objects.
Definition: dpo.c:208
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:118
dpo_mem_show_t dv_mem_show
A show memory usage function.
Definition: dpo.h:339
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
static clib_error_t * dpo_memory_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: dpo.c:459
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:154
format_function_t * dv_format
A format function.
Definition: dpo.h:335
unsigned char u8
Definition: types.h:56
ip_lookup_next_t lookup_next_index
Definition: lookup.h:199
dpo_lock_fn_t dv_unlock
A reference counting unlock function.
Definition: dpo.h:331
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:165
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:146
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:191
#define vec_foreach(var, vec)
Vector iterator.
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:150
struct _unformat_input_t unformat_input_t
#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:445
void drop_dpo_module_init(void)
Definition: drop_dpo.c:103
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:368
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:398