FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
fib_entry_cover.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 
17 #include <vnet/fib/fib_entry_src.h>
18 #include <vnet/fib/fib_node_list.h>
20 
21 u32
23  fib_node_index_t covered)
24 {
26 
27  FIB_ENTRY_DBG(cover, "cover-track %d", covered);
28 
29  ASSERT(fib_entry_get_index(cover) != covered);
30 
32 
33  if (NULL == fed)
34  {
37  }
38 
39  return (fib_node_list_push_front(fed->fd_list,
41  covered));
42 }
43 
44 void
46  u32 tracked_index)
47 {
49 
50  FIB_ENTRY_DBG(cover, "cover-untrack @ %d", tracked_index);
51 
53 
54  if (NULL == fed)
55  return;
56 
57  fib_node_list_remove(fed->fd_list, tracked_index);
58 
59  if (0 == fib_node_list_get_size(fed->fd_list))
60  {
63  }
64 }
65 
66 /**
67  * Internal struct to hold user supplied parameters for the cover walk
68  */
72  void *ctx;
74 
75 static int
77  void *args)
78 {
80 
81  ctx->walk(ctx->cover, depend->fnp_index, ctx->ctx);
82 
83  /* continue */
84  return (1);
85 }
86 
87 void
90  void *args)
91 {
93 
95 
96  if (NULL == fed)
97  return;
98 
100  .cover = cover,
101  .walk = walk,
102  .ctx = args,
103  };
104 
107  &ctx);
108 }
109 
110 static int
112  fib_node_index_t covered,
113  void *args)
114 {
115  fib_node_index_t new_cover;
116 
117  /*
118  * The 3 entries involved here are:
119  * cover - the least specific. It will cover both the others
120  * new_cover - the enty just inserted below the cover
121  * covered - the entry that was tracking the cover.
122  *
123  * The checks below are to determine if new_cover is a cover for covered.
124  */
125  new_cover = pointer_to_uword(args);
126 
127  if (FIB_NODE_INDEX_INVALID == new_cover)
128  {
129  /*
130  * nothing has been inserted, which implies the cover was removed.
131  * 'cover' is thus the new cover.
132  */
133  fib_entry_cover_changed(covered);
134  }
135  else if (new_cover != covered)
136  {
137  const fib_prefix_t *pfx_covered, *pfx_new_cover;
138 
139  pfx_covered = fib_entry_get_prefix(covered);
140  pfx_new_cover = fib_entry_get_prefix(new_cover);
141 
142  if (fib_prefix_is_cover(pfx_new_cover, pfx_covered))
143  {
144  fib_entry_cover_changed(covered);
145  }
146  }
147  /* continue */
148  return (1);
149 }
150 
151 void
153  fib_node_index_t covered)
154 {
156 
157  cover = fib_entry_get(cover_index);
158 
159  fib_entry_cover_walk(cover,
161  uword_to_pointer(covered, void*));
162 }
163 
164 static int
166  fib_node_index_t covered,
167  void *args)
168 {
169  fib_entry_cover_updated(covered);
170 
171  /* continue */
172  return (1);
173 }
174 
175 void
177 {
178  fib_entry_cover_walk(fib_entry,
180  NULL);
181 }
static int fib_entry_cover_change_one(fib_entry_t *cover, fib_node_index_t covered, void *args)
static int fib_entry_cover_update_one(fib_entry_t *cover, fib_node_index_t covered, void *args)
#define FIB_ENTRY_DBG(_e, _fmt, _args...)
Definition: fib_entry_src.h:28
An entry in a FIB table.
Definition: fib_entry.h:305
void fib_entry_cover_untrack(fib_entry_t *cover, u32 tracked_index)
int(* fib_entry_covered_walk_t)(fib_entry_t *cover, fib_node_index_t covered, void *ctx)
callback function used when walking the covered entries
fib_entry_delegate_t * fib_entry_delegate_find(const fib_entry_t *fib_entry, fib_entry_delegate_type_t type)
const fib_prefix_t * fib_entry_get_prefix(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1691
void fib_node_list_walk(fib_node_list_t list, fib_node_list_walk_cb_t fn, void *args)
Walk the list of node.
u32 fib_entry_cover_track(fib_entry_t *cover, fib_node_index_t covered)
fib_node_index_t fnp_index
node&#39;s index
Definition: fib_node.h:197
void fib_node_list_remove(fib_node_list_t list, u32 sibling)
void fib_entry_delegate_remove(fib_entry_t *fib_entry, fib_entry_delegate_type_t type)
Aggregate type for a prefix.
Definition: fib_types.h:203
fib_node_index_t fib_entry_get_index(const fib_entry_t *fib_entry)
Definition: fib_entry.c:63
int fib_prefix_is_cover(const fib_prefix_t *p1, const fib_prefix_t *p2)
Compare two prefixes for covering relationship.
Definition: fib_types.c:212
unsigned int u32
Definition: types.h:88
A representation of one pointer to another node.
Definition: fib_node.h:189
struct fib_enty_cover_walk_ctx_t_ fib_enty_cover_walk_ctx_t
Internal struct to hold user supplied parameters for the cover walk.
fib_node_list_t fd_list
For the cover tracking.
u32 fib_node_list_push_front(fib_node_list_t list, int owner_id, fib_node_type_t type, fib_node_index_t index)
Insert an element at the from of the list.
void fib_entry_cover_change_notify(fib_node_index_t cover_index, fib_node_index_t covered)
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
fib_entry_t * fib_entry_get(fib_node_index_t index)
Definition: fib_entry.c:51
#define uword_to_pointer(u, type)
Definition: types.h:136
u32 fib_node_list_get_size(fib_node_list_t list)
#define ASSERT(truth)
fib_node_list_t fib_node_list_create(void)
Create a new node list.
fib_entry_covered_walk_t walk
void fib_node_list_destroy(fib_node_list_t *list)
static uword pointer_to_uword(const void *p)
Definition: types.h:131
void fib_entry_cover_changed(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1261
void fib_entry_cover_walk(fib_entry_t *cover, fib_entry_covered_walk_t walk, void *args)
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
void fib_entry_cover_updated(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1337
static int fib_entry_cover_walk_node_ptr(fib_node_ptr_t *depend, void *args)
Dependency list of covered entries.
void fib_entry_cover_update_notify(fib_entry_t *fib_entry)
A Delagate is a means to implmenet the Delagation design pattern; the extension of an objects functio...
fib_entry_delegate_t * fib_entry_delegate_find_or_add(fib_entry_t *fib_entry, fib_entry_delegate_type_t fdt)
Internal struct to hold user supplied parameters for the cover walk.