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