FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
fib_path_ext.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 #include <vnet/mpls/mpls.h>
18 #include <vnet/dpo/load_balance.h>
19 #include <vnet/dpo/drop_dpo.h>
20 
21 #include <vnet/fib/fib_path_ext.h>
22 #include <vnet/fib/fib_entry_src.h>
23 #include <vnet/fib/fib_path.h>
24 #include <vnet/fib/fib_path_list.h>
25 #include <vnet/fib/fib_internal.h>
26 
27 u8 *
28 format_fib_path_ext (u8 * s, va_list * args)
29 {
30  fib_path_ext_t *path_ext;
31  u32 ii;
32 
33  path_ext = va_arg (*args, fib_path_ext_t *);
34 
35  s = format(s, "path:%d labels:",
36  path_ext->fpe_path_index);
37  for (ii = 0; ii < vec_len(path_ext->fpe_path.frp_label_stack); ii++)
38  {
39  s = format(s, "%U ",
41  path_ext->fpe_path.frp_label_stack[ii]);
42  }
43  return (s);
44 }
45 
46 int
48  const fib_route_path_t *rpath)
49 {
50  return (fib_route_path_cmp(&path_ext->fpe_path, rpath));
51 }
52 
53 static int
55  fib_node_index_t path_index,
56  void *ctx)
57 {
58  fib_path_ext_t *path_ext = ctx;
59 
60  if (!fib_path_cmp_w_route_path(path_index,
61  &path_ext->fpe_path))
62  {
63  path_ext->fpe_path_index = path_index;
64  return (0);
65  }
66  // keep going
67  return (1);
68 }
69 
70 void
72  fib_node_index_t path_list_index)
73 {
74  /*
75  * Find the path on the path list that this is an extension for
76  */
78  fib_path_list_walk(path_list_index,
80  path_ext);
81 }
82 
83 void
85  fib_node_index_t path_list_index,
86  const fib_route_path_t *rpath)
87 {
88  path_ext->fpe_path = *rpath;
90 
91  fib_path_ext_resolve(path_ext, path_list_index);
92 }
93 
94 /**
95  * @brief Return true if the label stack is implicit null
96  */
97 static int
99 {
100  return ((1 == vec_len(path_ext->fpe_label_stack)) &&
101  (MPLS_IETF_IMPLICIT_NULL_LABEL == path_ext->fpe_label_stack[0]));
102 }
103 
106  const fib_entry_t *entry,
107  fib_forward_chain_type_t child_fct,
108  load_balance_path_t *nhs)
109 {
110  fib_forward_chain_type_t parent_fct;
112 
113  if (!fib_path_is_resolved(path_ext->fpe_path_index))
114  return (nhs);
115 
116  /*
117  * Since we are stacking this path-extension, it must have a valid out
118  * label. From the chain type request by the child, determine what
119  * chain type we will request from the parent.
120  */
121  switch (child_fct)
122  {
124  {
125  /*
126  * The EOS chain is a tricky since, when the path has an imp NULL one cannot know
127  * the adjacency to link to without knowing what the packets payload protocol
128  * will be once the label is popped.
129  */
130  if (fib_path_ext_is_imp_null(path_ext))
131  {
132  parent_fct = fib_entry_chain_type_fixup(entry, child_fct);
133  }
134  else
135  {
136  /*
137  * we have a label to stack. packets will thus be labelled when
138  * they encounter the child, ergo, non-eos.
139  */
141  }
142  break;
143  }
146  if (fib_path_ext_is_imp_null(path_ext))
147  {
148  /*
149  * implicit-null label for the eos or IP chain, need to pick up
150  * the IP adj
151  */
152  parent_fct = child_fct;
153  }
154  else
155  {
156  /*
157  * we have a label to stack. packets will thus be labelled when
158  * they encounter the child, ergo, non-eos.
159  */
161  }
162  break;
164  parent_fct = child_fct;
165  break;
166  default:
167  return (nhs);
168  break;
169  }
170 
171  dpo_id_t via_dpo = DPO_INVALID;
172 
173  /*
174  * The next object in the graph after the imposition of the label
175  * will be the DPO contributed by the path through which the packets
176  * are to be sent. We stack the MPLS Label DPO on this path DPO
177  */
179  parent_fct,
180  &via_dpo);
181 
182  if (dpo_is_drop(&via_dpo) ||
183  load_balance_is_drop(&via_dpo))
184  {
185  /*
186  * don't stack a path extension on a drop. doing so will create
187  * a LB bucket entry on drop, and we will lose a percentage of traffic.
188  */
189  }
190  else
191  {
192  vec_add2(nhs, nh, 1);
194  nh->path_index = path_ext->fpe_path_index;
195  dpo_copy(&nh->path_dpo, &via_dpo);
196 
197  /*
198  * The label is stackable for this chain type
199  * construct the mpls header that will be imposed in the data-path
200  */
201  if (!fib_path_ext_is_imp_null(path_ext))
202  {
203  /*
204  * we use the parent protocol for the label so that
205  * we pickup the correct MPLS imposition nodes to do
206  * ip[46] processing.
207  */
208  dpo_proto_t chain_proto;
209  mpls_eos_bit_t eos;
210  index_t mldi;
211 
212  eos = (child_fct == FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS ?
213  MPLS_NON_EOS :
214  MPLS_EOS);
215  chain_proto = fib_forw_chain_type_to_dpo_proto(child_fct);
216 
217  mldi = mpls_label_dpo_create(path_ext->fpe_label_stack,
218  eos, 255, 0,
219  chain_proto,
220  &nh->path_dpo);
221 
222  dpo_set(&nh->path_dpo,
224  chain_proto,
225  mldi);
226  }
227  }
228  dpo_reset(&via_dpo);
229 
230  return (nhs);
231 }
int fib_path_is_resolved(fib_node_index_t path_index)
Definition: fib_path.c:1877
Contribute an object that is to be used to forward IP6 packets.
Definition: fib_types.h:85
An entry in a FIB table.
Definition: fib_entry.h:361
fib_node_index_t path_index
The index of the FIB path.
Definition: load_balance.h:70
void fib_path_contribute_forwarding(fib_node_index_t path_index, fib_forward_chain_type_t fct, dpo_id_t *dpo)
Definition: fib_path.c:1724
void fib_path_ext_resolve(fib_path_ext_t *path_ext, fib_node_index_t path_list_index)
Definition: fib_path_ext.c:71
A representation of a path as described by a route producer.
Definition: fib_types.h:285
int fib_path_ext_cmp(fib_path_ext_t *path_ext, const fib_route_path_t *rpath)
Definition: fib_path_ext.c:47
dpo_id_t path_dpo
ID of the Data-path object.
Definition: load_balance.h:65
int fib_route_path_cmp(const fib_route_path_t *rpath1, const fib_route_path_t *rpath2)
Definition: fib_types.c:187
dpo_proto_t fib_forw_chain_type_to_dpo_proto(fib_forward_chain_type_t fct)
Convert from a chain type to the DPO proto it will install.
Definition: fib_types.c:311
#define MPLS_IETF_IMPLICIT_NULL_LABEL
Definition: mpls_types.h:16
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 vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:521
void fib_path_list_walk(fib_node_index_t path_list_index, fib_path_list_walk_fn_t func, void *ctx)
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:81
static int fib_path_ext_match(fib_node_index_t pl_index, fib_node_index_t path_index, void *ctx)
Definition: fib_path_ext.c:54
void fib_path_ext_init(fib_path_ext_t *path_ext, fib_node_index_t path_list_index, const fib_route_path_t *rpath)
Definition: fib_path_ext.c:84
index_t mpls_label_dpo_create(mpls_label_t *label_stack, mpls_eos_bit_t eos, u8 ttl, u8 exp, dpo_proto_t payload_proto, const dpo_id_t *dpo)
Create an MPLS label object.
mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:328
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
int load_balance_is_drop(const dpo_id_t *dpo)
Definition: load_balance.c:225
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
Contribute an object that is to be used to forward end-of-stack MPLS packets.
Definition: fib_types.h:97
u8 * format_fib_path_ext(u8 *s, va_list *args)
Definition: fib_path_ext.c:28
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
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
unsigned int u32
Definition: types.h:88
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
int fib_path_get_weight(fib_node_index_t path_index)
Definition: fib_path.c:1656
load_balance_path_t * fib_path_ext_stack(fib_path_ext_t *path_ext, const fib_entry_t *entry, fib_forward_chain_type_t child_fct, load_balance_path_t *nhs)
Definition: fib_path_ext.c:105
format_function_t format_mpls_unicast_label
Definition: mpls.h:94
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
u32 path_weight
weight for the path.
Definition: load_balance.h:75
fib_node_index_t fpe_path_index
The index of the path.
Definition: fib_path_ext.h:46
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:165
One path from an [EU]CMP set that the client wants to add to a load-balance object.
Definition: load_balance.h:61
static int fib_path_ext_is_imp_null(fib_path_ext_t *path_ext)
Return true if the label stack is implicit null.
Definition: fib_path_ext.c:98
fib_forward_chain_type_t fib_entry_chain_type_fixup(const fib_entry_t *entry, fib_forward_chain_type_t fct)
Turn the chain type requested by the client into the one they really wanted.
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
int dpo_is_drop(const dpo_id_t *dpo)
The Drop DPO will drop all packets, no questions asked.
Definition: drop_dpo.c:33
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:191
A path extension is a per-entry addition to the forwarding information when packets are sent for that...
Definition: fib_path_ext.h:32
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:90
int fib_path_cmp_w_route_path(fib_node_index_t path_index, const fib_route_path_t *rpath)
Definition: fib_path.c:1289
fib_route_path_t fpe_path
A description of the path that is being extended.
Definition: fib_path_ext.h:39
enum mpls_eos_bit_t_ mpls_eos_bit_t