FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
fib_entry_src_rr.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 <vlib/vlib.h>
17 #include <vnet/ip/format.h>
18 #include <vnet/ip/lookup.h>
19 #include <vnet/adj/adj.h>
20 #include <vnet/dpo/drop_dpo.h>
21 
22 #include "fib_entry_src.h"
23 #include "fib_entry_cover.h"
24 #include "fib_entry.h"
25 #include "fib_table.h"
26 
27 /*
28  * fib_entry_src_rr_resolve_via_connected
29  *
30  * Resolve via a connected cover.
31  */
32 static void
34  const fib_entry_t *fib_entry,
35  const fib_entry_t *cover)
36 {
37  const fib_route_path_t path = {
38  .frp_proto = fib_entry->fe_prefix.fp_proto,
39  .frp_addr = fib_entry->fe_prefix.fp_addr,
40  .frp_sw_if_index = fib_entry_get_resolving_interface(
41  fib_entry_get_index(cover)),
42  .frp_fib_index = ~0,
43  .frp_weight = 1,
44  };
45  fib_route_path_t *paths = NULL;
46  vec_add1(paths, path);
47 
48  /*
49  * since the cover is connected, the address this entry corresponds
50  * to is a peer (ARP-able for) on the interface to which the cover is
51  * connected. The fact we resolve via the cover, just means this RR
52  * source is the first SRC to use said peer. The ARP source will be along
53  * shortly to over-rule this RR source.
54  */
57 
58  vec_free(paths);
59 }
60 
61 
62 /**
63  * Source initialisation Function
64  */
65 static void
67 {
68  src->rr.fesr_cover = FIB_NODE_INDEX_INVALID;
69  src->rr.fesr_sibling = FIB_NODE_INDEX_INVALID;
70 }
71 
72 /*
73  * Source activation. Called when the source is the new best source on the entry
74  */
75 static int
77  const fib_entry_t *fib_entry)
78 {
79  fib_entry_t *cover;
80 
81  /*
82  * find the covering prefix. become a dependent thereof.
83  * for IP there should always be a cover, though it may be the default route.
84  * For MPLS there is never a cover.
85  */
86  if (FIB_PROTOCOL_MPLS == fib_entry->fe_prefix.fp_proto)
87  {
90  NULL);
92  return (!0);
93  }
94 
95  src->rr.fesr_cover = fib_table_get_less_specific(fib_entry->fe_fib_index,
96  &fib_entry->fe_prefix);
97 
98  ASSERT(FIB_NODE_INDEX_INVALID != src->rr.fesr_cover);
99 
100  cover = fib_entry_get(src->rr.fesr_cover);
101 
102  src->rr.fesr_sibling =
103  fib_entry_cover_track(cover, fib_entry_get_index(fib_entry));
104 
105  /*
106  * if the ocver is attached then install an attached-host path
107  * (like an adj-fib). Otherwise inherit the forwarding from the cover
108  */
110  {
111  fib_entry_src_rr_resolve_via_connected(src, fib_entry, cover);
112  }
113  else
114  {
115  /*
116  * use the path-list of the cover, unless it would form a loop.
117  * that is unless the cover is via this entry.
118  * If a loop were to form it would be a 1 level loop (i.e. X via X),
119  * and there would be 2 locks on the path-list; one since its used
120  * by the cover, and 1 from here. The first lock will go when the
121  * cover is removed, the second, and last, when the covered walk
122  * occurs during the cover's removel - this is not a place where
123  * we can handle last lock gone.
124  * In short, don't let the loop form. The usual rules of 'we must
125  * let it form so we know when it breaks' don't apply here, since
126  * the loop will break when the cover changes, and this function
127  * will be called again when that happens.
128  */
129  fib_node_index_t *entries = NULL;
130  fib_protocol_t proto;
131 
132  proto = fib_entry->fe_prefix.fp_proto;
133  vec_add1(entries, fib_entry_get_index(fib_entry));
134 
136  &entries))
137  {
139  proto,
142  }
143  else
144  {
145  src->fes_pl = cover->fe_parent;
146  }
147  vec_free(entries);
148 
149  }
151 
152  /*
153  * return go for install
154  */
155  return (!0);
156 }
157 
158 /**
159  * Source Deactivate.
160  * Called when the source is no longer best source on the entry
161  */
162 static void
164  const fib_entry_t *fib_entry)
165 {
166  fib_entry_t *cover;
167 
168  /*
169  * remove the depednecy on the covering entry
170  */
171  if (FIB_NODE_INDEX_INVALID != src->rr.fesr_cover)
172  {
173  cover = fib_entry_get(src->rr.fesr_cover);
174  fib_entry_cover_untrack(cover, src->rr.fesr_sibling);
175  src->rr.fesr_cover = FIB_NODE_INDEX_INVALID;
176  }
177 
181 }
182 
185  const fib_entry_t *fib_entry)
186 {
188  .install = !0,
189  .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
190  };
191 
192  if (FIB_NODE_INDEX_INVALID == src->rr.fesr_cover)
193  {
194  /*
195  * the source may be added, but it is not active
196  * if it is not tracking the cover.
197  */
198  return (res);
199  }
200 
201  /*
202  * this function is called when this entry's cover has a more specific
203  * entry inserted benaeth it. That does not necessarily mean that this
204  * entry is covered by the new prefix. check that
205  */
206  if (src->rr.fesr_cover != fib_table_get_less_specific(fib_entry->fe_fib_index,
207  &fib_entry->fe_prefix))
208  {
209  fib_entry_src_rr_deactivate(src, fib_entry);
210  fib_entry_src_rr_activate(src, fib_entry);
211 
212  /*
213  * dependent children need to re-resolve to the new forwarding info
214  */
216  }
217  return (res);
218 }
219 
220 /*
221  * fib_entry_src_rr_cover_update
222  *
223  * This entry's cover has updated its forwarding info. This entry
224  * will need to re-inheret.
225  */
228  const fib_entry_t *fib_entry)
229 {
231  .install = !0,
232  .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE,
233  };
234  fib_node_index_t old_path_list;
235  fib_entry_t *cover;
236 
237  if (FIB_NODE_INDEX_INVALID == src->rr.fesr_cover)
238  {
239  /*
240  * the source may be added, but it is not active
241  * if it is not tracking the cover.
242  */
243  return (res);
244  }
245 
246  cover = fib_entry_get(src->rr.fesr_cover);
247  old_path_list = src->fes_pl;
248 
249  /*
250  * if the ocver is attached then install an attached-host path
251  * (like an adj-fib). Otherwise inherit the forwarding from the cover
252  */
254  {
255  fib_entry_src_rr_resolve_via_connected(src, fib_entry, cover);
256  }
257  else
258  {
259  src->fes_pl = cover->fe_parent;
260  }
262  fib_path_list_unlock(old_path_list);
263 
264  /*
265  * dependent children need to re-resolve to the new forwarding info
266  */
268 
269  return (res);
270 }
271 
272 static u8*
274  u8* s)
275 {
276  return (format(s, "cover:%d", src->rr.fesr_cover));
277 }
278 
279 const static fib_entry_src_vft_t rr_src_vft = {
281  .fesv_activate = fib_entry_src_rr_activate,
282  .fesv_deactivate = fib_entry_src_rr_deactivate,
283  .fesv_cover_change = fib_entry_src_rr_cover_change,
284  .fesv_cover_update = fib_entry_src_rr_cover_update,
285  .fesv_format = fib_entry_src_rr_format,
286 };
287 
288 void
290 {
291  fib_entry_src_register(FIB_SOURCE_RR, &rr_src_vft);
293 }
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:154
fib_entry_src_init_t fesv_init
fib_protocol_t frp_proto
The protocol of the address below.
Definition: fib_types.h:290
Recursive resolution source.
Definition: fib_entry.h:105
An entry in a FIB table.
Definition: fib_entry.h:361
fib_node_bw_reason_flag_t bw_reason
Definition: fib_entry_src.h:89
fib_entry_flag_t fib_entry_get_flags_i(const fib_entry_t *fib_entry)
A representation of a path as described by a route producer.
Definition: fib_types.h:285
void fib_entry_cover_untrack(fib_entry_t *cover, u32 tracked_index)
void fib_entry_src_rr_register(void)
Virtual function table each FIB entry source will register.
Definitions for all things IP (v4|v6) unicast and multicast lookup related.
#define NULL
Definition: clib.h:55
Information related to the source of a FIB entry.
Definition: fib_entry.h:270
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
Result from a cover update/change.
Definition: fib_entry_src.h:87
u32 fe_fib_index
The index of the FIB table this entry is in.
Definition: fib_entry.h:374
uRPF bypass/exemption.
Definition: fib_entry.h:110
Definition: fib_entry.h:218
fib_node_index_t fe_parent
the path-list for which this entry is a child.
Definition: fib_entry.h:398
static void fib_entry_src_rr_init(fib_entry_src_t *src)
Source initialisation Function.
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
struct fib_entry_src_t_::@125::@127 rr
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
u32 fib_entry_cover_track(fib_entry_t *cover, fib_node_index_t covered)
fib_node_index_t fib_entry_get_index(const fib_entry_t *fib_entry)
Definition: fib_entry.c:56
u16 install
Definition: fib_entry_src.h:88
Definition: fib_entry.h:216
static fib_entry_src_cover_res_t fib_entry_src_rr_cover_change(fib_entry_src_t *src, const fib_entry_t *fib_entry)
fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags, const fib_route_path_t *rpaths)
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:168
void fib_path_list_lock(fib_node_index_t path_list_index)
static void fib_entry_src_rr_resolve_via_connected(fib_entry_src_t *src, const fib_entry_t *fib_entry, const fib_entry_t *cover)
static fib_entry_src_cover_res_t fib_entry_src_rr_cover_update(fib_entry_src_t *src, const fib_entry_t *fib_entry)
u32 fib_entry_get_resolving_interface(fib_node_index_t entry_index)
Definition: fib_entry.c:1301
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
void fib_path_list_unlock(fib_node_index_t path_list_index)
fib_entry_t * fib_entry_get(fib_node_index_t index)
Definition: fib_entry.c:44
int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index, fib_node_index_t **entry_indicies)
fib_entry_flag_t fes_entry_flags
Flags the source contributes to the entry.
Definition: fib_entry.h:299
#define ASSERT(truth)
void fib_entry_src_register(fib_source_t source, const fib_entry_src_vft_t *vft)
Definition: fib_entry_src.c:38
dpo_proto_t fib_proto_to_dpo(fib_protocol_t fib_proto)
Definition: fib_types.c:220
fib_node_index_t fes_pl
The path-list created by the source.
Definition: fib_entry.h:279
static int fib_entry_src_rr_activate(fib_entry_src_t *src, const fib_entry_t *fib_entry)
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
unsigned char u8
Definition: types.h:56
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static void fib_entry_src_rr_deactivate(fib_entry_src_t *src, const fib_entry_t *fib_entry)
Source Deactivate.
static u8 * fib_entry_src_rr_format(fib_entry_src_t *src, u8 *s)
fib_node_index_t fib_path_list_create_special(fib_protocol_t nh_proto, fib_path_list_flags_t flags, const dpo_id_t *dpo)
const fib_prefix_t fe_prefix
The prefix of the route.
Definition: fib_entry.h:370
fib_node_index_t fib_table_get_less_specific(u32 fib_index, const fib_prefix_t *prefix)
Get the less specific (covering) prefix.
Definition: fib_table.c:131
fib_entry_flag_t fib_entry_get_flags(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:278