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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * A Data-Path Object is an object that represents actions that are
18 * applied to packets are they are switched through VPP.
20 * The DPO is a base class that is specialised by other objects to provide
23 * The VLIB graph nodes are graph of types, the DPO graph is a graph of instances.
26 #include <vnet/dpo/dpo.h>
27 #include <vnet/ip/lookup.h>
28 #include <vnet/ip/format.h>
29 #include <vnet/adj/adj.h>
31 #include <vnet/dpo/load_balance.h>
32 #include <vnet/dpo/mpls_label_dpo.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>
41 #include <vnet/dpo/mpls_disposition.h>
44 * Array of char* names for the DPO types and protos
46 static const char* dpo_type_names[] = DPO_TYPES;
47 static const char* dpo_proto_names[] = DPO_PROTOS;
50 * @brief Vector of virtual function tables for the DPO types
52 * This is a vector so we can dynamically register new DPO types in plugins.
54 static dpo_vft_t *dpo_vfts;
57 * @brief vector of graph node names associated with each DPO type and protocol.
59 * dpo_nodes[child_type][child_proto][node_X] = node_name;
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"
64 * This is a vector so we can dynamically register new DPO types in plugins.
66 static const char* const * const ** dpo_nodes;
69 * @brief Vector of edge indicies from parent DPO nodes to child
71 * dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge_index
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.
80 * Note that this array is child type specific, not child instance specific.
82 static u32 ****dpo_edges;
85 * @brief The DPO type value that can be assigend to the next dynamic
88 static dpo_type_t dpo_dynamic = DPO_LAST;
91 vnet_link_to_dpo_proto (vnet_link_t linkt)
96 return (DPO_PROTO_IP6);
98 return (DPO_PROTO_IP4);
100 return (DPO_PROTO_MPLS);
101 case VNET_LINK_ETHERNET:
102 return (DPO_PROTO_ETHERNET);
104 return (DPO_PROTO_NSH);
113 dpo_proto_to_link (dpo_proto_t dp)
118 return (VNET_LINK_IP6);
120 return (VNET_LINK_IP4);
122 return (VNET_LINK_MPLS);
123 case DPO_PROTO_ETHERNET:
124 return (VNET_LINK_ETHERNET);
126 return (VNET_LINK_NSH);
132 format_dpo_type (u8 * s, va_list * args)
134 dpo_type_t type = va_arg (*args, int);
136 s = format(s, "%s", dpo_type_names[type]);
142 format_dpo_id (u8 * s, va_list * args)
144 dpo_id_t *dpo = va_arg (*args, dpo_id_t*);
145 u32 indent = va_arg (*args, u32);
147 s = format(s, "[@%d]: ", dpo->dpoi_next_node);
149 if (NULL != dpo_vfts[dpo->dpoi_type].dv_format)
151 return (format(s, "%U",
152 dpo_vfts[dpo->dpoi_type].dv_format,
157 switch (dpo->dpoi_type)
160 s = format(s, "unset");
163 s = format(s, "unknown");
170 format_dpo_proto (u8 * s, va_list * args)
172 dpo_proto_t proto = va_arg (*args, int);
174 return (format(s, "%s", dpo_proto_names[proto]));
178 dpo_set (dpo_id_t *dpo,
185 dpo->dpoi_type = type;
186 dpo->dpoi_proto = proto,
187 dpo->dpoi_index = index;
189 if (DPO_ADJACENCY == type)
192 * set the adj subtype
196 adj = adj_get(index);
198 switch (adj->lookup_next_index)
200 case IP_LOOKUP_NEXT_ARP:
201 dpo->dpoi_type = DPO_ADJACENCY_INCOMPLETE;
203 case IP_LOOKUP_NEXT_MIDCHAIN:
204 dpo->dpoi_type = DPO_ADJACENCY_MIDCHAIN;
206 case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
207 dpo->dpoi_type = DPO_ADJACENCY_MCAST_MIDCHAIN;
209 case IP_LOOKUP_NEXT_MCAST:
210 dpo->dpoi_type = DPO_ADJACENCY_MCAST;
212 case IP_LOOKUP_NEXT_GLEAN:
213 dpo->dpoi_type = DPO_ADJACENCY_GLEAN;
224 dpo_reset (dpo_id_t *dpo)
226 dpo_id_t tmp = DPO_INVALID;
229 * use the atomic copy operation.
236 * Compare two Data-path objects
238 * like memcmp, return 0 is matching, !0 otherwise.
241 dpo_cmp (const dpo_id_t *dpo1,
242 const dpo_id_t *dpo2)
246 res = dpo1->dpoi_type - dpo2->dpoi_type;
248 if (0 != res) return (res);
250 return (dpo1->dpoi_index - dpo2->dpoi_index);
254 dpo_copy (dpo_id_t *dst,
260 * the destination is written in a single u64 write - hence atomically w.r.t
261 * any packets inflight.
263 *((u64*)dst) = *(u64*)src;
270 dpo_is_adj (const dpo_id_t *dpo)
272 return ((dpo->dpoi_type == DPO_ADJACENCY) ||
273 (dpo->dpoi_type == DPO_ADJACENCY_INCOMPLETE) ||
274 (dpo->dpoi_type == DPO_ADJACENCY_MIDCHAIN) ||
275 (dpo->dpoi_type == DPO_ADJACENCY_GLEAN));
279 dpo_register (dpo_type_t type,
280 const dpo_vft_t *vft,
281 const char * const * const * nodes)
283 vec_validate(dpo_vfts, type);
284 dpo_vfts[type] = *vft;
286 vec_validate(dpo_nodes, type);
287 dpo_nodes[type] = nodes;
291 dpo_register_new_type (const dpo_vft_t *vft,
292 const char * const * const * nodes)
294 dpo_type_t type = dpo_dynamic++;
296 dpo_register(type, vft, nodes);
302 dpo_lock (dpo_id_t *dpo)
304 if (!dpo_id_is_valid(dpo))
307 dpo_vfts[dpo->dpoi_type].dv_lock(dpo);
311 dpo_unlock (dpo_id_t *dpo)
313 if (!dpo_id_is_valid(dpo))
316 dpo_vfts[dpo->dpoi_type].dv_unlock(dpo);
321 dpo_get_next_node (dpo_type_t child_type,
322 dpo_proto_t child_proto,
323 const dpo_id_t *parent_dpo)
325 dpo_proto_t parent_proto;
326 dpo_type_t parent_type;
328 parent_type = parent_dpo->dpoi_type;
329 parent_proto = parent_dpo->dpoi_proto;
331 vec_validate(dpo_edges, child_type);
332 vec_validate(dpo_edges[child_type], child_proto);
333 vec_validate(dpo_edges[child_type][child_proto], parent_type);
334 vec_validate_init_empty(
335 dpo_edges[child_type][child_proto][parent_type],
339 * if the edge index has not yet been created for this node to node transistion
341 if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
343 vlib_node_t *parent_node, *child_node;
347 vm = vlib_get_main();
349 vlib_worker_thread_barrier_sync(vm);
351 ASSERT(NULL != dpo_nodes[child_type]);
352 ASSERT(NULL != dpo_nodes[child_type][child_proto]);
353 ASSERT(NULL != dpo_nodes[parent_type]);
354 ASSERT(NULL != dpo_nodes[parent_type][parent_proto]);
359 * create a graph arc from each of the parent's registered node types,
360 * to each of the childs.
362 while (NULL != dpo_nodes[child_type][child_proto][cc])
365 vlib_get_node_by_name(vm,
366 (u8*) dpo_nodes[child_type][child_proto][cc]);
370 while (NULL != dpo_nodes[parent_type][parent_proto][pp])
373 vlib_get_node_by_name(vm,
374 (u8*) dpo_nodes[parent_type][parent_proto][pp]);
376 edge = vlib_node_add_next(vm,
380 if (~0 == dpo_edges[child_type][child_proto][parent_type][parent_proto])
382 dpo_edges[child_type][child_proto][parent_type][parent_proto] = edge;
386 ASSERT(dpo_edges[child_type][child_proto][parent_type][parent_proto] == edge);
393 vlib_worker_thread_barrier_release(vm);
396 return (dpo_edges[child_type][child_proto][parent_type][parent_proto]);
400 * @brief Stack one DPO object on another, and thus establish a child parent
401 * relationship. The VLIB graph arc used is taken from the parent and child types
405 dpo_stack_i (u32 edge,
407 const dpo_id_t *parent)
410 * in order to get an atomic update of the parent we create a temporary,
411 * from a copy of the child, and add the next_node. then we copy to the parent
413 dpo_id_t tmp = DPO_INVALID;
414 dpo_copy(&tmp, parent);
417 * get the edge index for the parent to child VLIB graph transisition
419 tmp.dpoi_next_node = edge;
422 * this update is atomic.
430 * @brief Stack one DPO object on another, and thus establish a child-parent
431 * relationship. The VLIB graph arc used is taken from the parent and child types
435 dpo_stack (dpo_type_t child_type,
436 dpo_proto_t child_proto,
438 const dpo_id_t *parent)
440 dpo_stack_i(dpo_get_next_node(child_type, child_proto, parent), dpo, parent);
444 * @brief Stack one DPO object on another, and thus establish a child parent
445 * relationship. A new VLIB graph arc is created from the child node passed
446 * to the nodes registered by the parent. The VLIB infra will ensure this arc
447 * is added only once.
450 dpo_stack_from_node (u32 child_node_index,
452 const dpo_id_t *parent)
454 dpo_proto_t parent_proto;
455 vlib_node_t *parent_node;
456 dpo_type_t parent_type;
460 parent_type = parent->dpoi_type;
461 parent_proto = parent->dpoi_proto;
463 vm = vlib_get_main();
465 ASSERT(NULL != dpo_nodes[parent_type]);
466 ASSERT(NULL != dpo_nodes[parent_type][parent_proto]);
469 vlib_get_node_by_name(vm, (u8*) dpo_nodes[parent_type][parent_proto][0]);
471 edge = vlib_node_get_next(vm,
477 vlib_worker_thread_barrier_sync(vm);
479 edge = vlib_node_add_next(vm,
483 vlib_worker_thread_barrier_release(vm);
486 dpo_stack_i(edge, dpo, parent);
489 static clib_error_t *
490 dpo_module_init (vlib_main_t * vm)
492 drop_dpo_module_init();
493 punt_dpo_module_init();
494 receive_dpo_module_init();
495 load_balance_module_init();
496 mpls_label_dpo_module_init();
497 classify_dpo_module_init();
498 lookup_dpo_module_init();
499 ip_null_dpo_module_init();
500 replicate_module_init();
501 interface_dpo_module_init();
502 mpls_disp_dpo_module_init();
507 VLIB_INIT_FUNCTION(dpo_module_init);
509 static clib_error_t *
510 dpo_memory_show (vlib_main_t * vm,
511 unformat_input_t * input,
512 vlib_cli_command_t * cmd)
516 vlib_cli_output (vm, "DPO memory");
517 vlib_cli_output (vm, "%=30s %=5s %=8s/%=9s totals",
518 "Name","Size", "in-use", "allocated");
520 vec_foreach(vft, dpo_vfts)
522 if (NULL != vft->dv_mem_show)
531 * The '<em>sh dpo memory </em>' command displays the memory usage for each
532 * data-plane object type.
535 * @cliexstart{show dpo memory}
537 * Name Size in-use /allocated totals
538 * load-balance 64 12 / 12 768/768
539 * Adjacency 256 1 / 1 256/256
540 * Receive 24 5 / 5 120/120
541 * Lookup 12 0 / 0 0/0
542 * Classify 12 0 / 0 0/0
543 * MPLS label 24 0 / 0 0/0
546 VLIB_CLI_COMMAND (show_fib_memory, static) = {
547 .path = "show dpo memory",
548 .function = dpo_memory_show,
549 .short_help = "show dpo memory",