FD.io VPP  v18.07-34-g55fbdb9
Vector Packet Processing
abf_policy.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 <plugins/abf/abf_policy.h>
17 
18 #include <vlib/vlib.h>
19 #include <vnet/plugin/plugin.h>
20 #include <vnet/fib/fib_path_list.h>
21 #include <vnet/fib/fib_walk.h>
22 
23 /**
24  * FIB node type the attachment is registered
25  */
27 
28 /**
29  * Pool of ABF objects
30  */
32 
33 /**
34  * DB of ABF policy objects
35  * - policy ID to index conversion.
36  */
38 
39 
42 {
43  return (pool_elt_at_index (abf_policy_pool, index));
44 }
45 
46 static u32
48 {
49  return (abf - abf_policy_pool);
50 }
51 
52 static abf_policy_t *
54 {
55  u32 api;
56 
57  api = abf_policy_find (policy_id);
58 
59  if (INDEX_INVALID != api)
60  return (abf_policy_get (api));
61 
62  return (NULL);
63 }
64 
65 u32
66 abf_policy_find (u32 policy_id)
67 {
68  uword *p;
69 
70  p = hash_get (abf_policy_db, policy_id);
71 
72  if (NULL != p)
73  return (p[0]);
74 
75  return (INDEX_INVALID);
76 }
77 
78 
79 void
81  u32 acl_index, const fib_route_path_t * rpaths)
82 {
83  abf_policy_t *ap;
84  u32 api;
85 
86  api = abf_policy_find (policy_id);
87 
88  if (INDEX_INVALID == api)
89  {
90  /*
91  * create a new policy
92  */
93  pool_get (abf_policy_pool, ap);
94 
95  api = ap - abf_policy_pool;
97  ap->ap_acl = acl_index;
98  ap->ap_id = policy_id;
100  FIB_PATH_LIST_FLAG_NO_URPF), rpaths);
101 
102  /*
103  * become a child of the path list so we get poked when
104  * the forwarding changes.
105  */
108  api);
109 
110  /*
111  * add this new policy to the DB
112  */
113  hash_set (abf_policy_db, policy_id, api);
114 
115  /*
116  * take a lock on behalf of the CLI/API creation
117  */
118  fib_node_lock (&ap->ap_node);
119  }
120  else
121  {
122  /*
123  * update an existing policy.
124  * - add the path to the path-list and swap our ancestory
125  * - backwalk to poke all attachments to update
126  */
127  fib_node_index_t old_pl;
128 
129  ap = abf_policy_get (api);
130  old_pl = ap->ap_pl;
131 
132  if (FIB_NODE_INDEX_INVALID != old_pl)
133  {
136  |
138  rpaths);
140  }
141  else
142  {
145  rpaths);
146  }
147 
150  api);
151 
153  .fnbw_reason = FIB_NODE_BW_REASON_FLAG_EVALUATE,
154  };
155 
157  }
158 }
159 
160 static void
162 {
163  /*
164  * this ABF should not be a sibling on the path list, since
165  * that was removed when the API config went
166  */
167  ASSERT (ap->ap_sibling == ~0);
169 
171  pool_put (abf_policy_pool, ap);
172 }
173 
174 int
175 abf_policy_delete (u32 policy_id, const fib_route_path_t * rpaths)
176 {
177  abf_policy_t *ap;
178  u32 api;
179 
180  api = abf_policy_find (policy_id);
181 
182  if (INDEX_INVALID == api)
183  {
184  /*
185  * no such policy
186  */
187  return (-1);
188  }
189  else
190  {
191  /*
192  * update an existing policy.
193  * - add the path to the path-list and swap our ancestory
194  * - backwalk to poke all attachments to update
195  */
196  fib_node_index_t old_pl;
197 
198  ap = abf_policy_get (api);
199  old_pl = ap->ap_pl;
200 
201  ap->ap_pl =
205  rpaths);
206 
208  ap->ap_sibling = ~0;
209 
210  if (FIB_NODE_INDEX_INVALID == ap->ap_pl)
211  {
212  /*
213  * no more paths on this policy. It's toast
214  * remove the CLI/API's lock
215  */
216  fib_node_unlock (&ap->ap_node);
217  }
218  else
219  {
222  api);
223 
225  .fnbw_reason = FIB_NODE_BW_REASON_FLAG_EVALUATE,
226  };
227 
229  }
230  }
231 
232  return (0);
233 }
234 
235 static clib_error_t *
237  unformat_input_t * main_input, vlib_cli_command_t * cmd)
238 {
239  unformat_input_t _line_input, *line_input = &_line_input;
240  u32 acl_index, policy_id;
241  fib_route_path_t *rpaths = NULL, rpath;
242  u32 is_del;
243 
244  is_del = 0;
245  acl_index = INDEX_INVALID;
246  policy_id = INDEX_INVALID;
247 
248  /* Get a line of input. */
249  if (!unformat_user (main_input, unformat_line_input, line_input))
250  return 0;
251 
252  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
253  {
254  if (unformat (line_input, "acl %d", &acl_index))
255  ;
256  else if (unformat (line_input, "id %d", &policy_id))
257  ;
258  else if (unformat (line_input, "del"))
259  is_del = 1;
260  else if (unformat (line_input, "add"))
261  is_del = 0;
262  else if (unformat (line_input, "via %U",
263  unformat_fib_route_path, &rpath))
264  vec_add1 (rpaths, rpath);
265  else
266  return (clib_error_return (0, "unknown input '%U'",
267  format_unformat_error, line_input));
268  }
269 
270  if (INDEX_INVALID == policy_id)
271  {
272  vlib_cli_output (vm, "Specify a Policy ID");
273  return 0;
274  }
275 
276  if (!is_del)
277  {
278  if (INDEX_INVALID == acl_index)
279  {
280  vlib_cli_output (vm, "ACL index must be set");
281  return 0;
282  }
283 
284  abf_policy_update (policy_id, acl_index, rpaths);
285  }
286  else
287  {
288  abf_policy_delete (policy_id, rpaths);
289  }
290 
291  unformat_free (line_input);
292  return (NULL);
293 }
294 
295 /* *INDENT-OFF* */
296 /**
297  * Create an ABF policy.
298  */
299 VLIB_CLI_COMMAND (abf_policy_cmd_node, static) = {
300  .path = "abf policy",
301  .function = abf_policy_cmd,
302  .short_help = "abf policy [add|del] id <index> acl <index> via ...",
303  .is_mp_safe = 1,
304 };
305 /* *INDENT-ON* */
306 
307 static u8 *
308 format_abf (u8 * s, va_list * args)
309 {
310  abf_policy_t *ap = va_arg (*args, abf_policy_t *);
311 
312  s = format (s, "abf:[%d]: policy:%d acl:%d",
313  ap - abf_policy_pool, ap->ap_id, ap->ap_acl);
314  s = format (s, "\n ");
315  if (FIB_NODE_INDEX_INVALID == ap->ap_pl)
316  {
317  s = format (s, "no forwarding");
318  }
319  else
320  {
321  s = fib_path_list_format (ap->ap_pl, s);
322  }
323 
324  return (s);
325 }
326 
327 void
329 {
330  u32 api;
331 
332  /* *INDENT-OFF* */
333  pool_foreach_index(api, abf_policy_pool,
334  ({
335  if (!cb(api, ctx))
336  break;
337  }));
338  /* *INDENT-ON* */
339 }
340 
341 static clib_error_t *
343  unformat_input_t * input, vlib_cli_command_t * cmd)
344 {
345  u32 policy_id;
346  abf_policy_t *ap;
347 
348  policy_id = INDEX_INVALID;
349 
351  {
352  if (unformat (input, "%d", &policy_id))
353  ;
354  else
355  return (clib_error_return (0, "unknown input '%U'",
356  format_unformat_error, input));
357  }
358 
359  if (INDEX_INVALID == policy_id)
360  {
361  /* *INDENT-OFF* */
362  pool_foreach(ap, abf_policy_pool,
363  ({
364  vlib_cli_output(vm, "%U", format_abf, ap);
365  }));
366  /* *INDENT-ON* */
367  }
368  else
369  {
370  ap = abf_policy_find_i (policy_id);
371 
372  if (NULL != ap)
373  vlib_cli_output (vm, "%U", format_abf, ap);
374  else
375  vlib_cli_output (vm, "Invalid policy ID:%d", policy_id);
376  }
377 
378  return (NULL);
379 }
380 
381 /* *INDENT-OFF* */
382 VLIB_CLI_COMMAND (abf_policy_show_policy_cmd_node, static) = {
383  .path = "show abf policy",
384  .function = abf_show_policy_cmd,
385  .short_help = "show abf policy <value>",
386  .is_mp_safe = 1,
387 };
388 /* *INDENT-ON* */
389 
390 static fib_node_t *
392 {
393  abf_policy_t *ap = abf_policy_get (index);
394  return (&(ap->ap_node));
395 }
396 
397 static abf_policy_t *
399 {
400  return ((abf_policy_t *) (((char *) node) -
401  STRUCT_OFFSET_OF (abf_policy_t, ap_node)));
402 }
403 
404 static void
406 {
408 }
409 
410 /*
411  * A back walk has reached this ABF policy
412  */
416 {
417  /*
418  * re-stack the fmask on the n-eos of the via
419  */
421 
422  /*
423  * propagate further up the graph.
424  * we can do this synchronously since the fan out is small.
425  */
427 
429 }
430 
431 /*
432  * The BIER fmask's graph node virtual function table
433  */
434 static const fib_node_vft_t abf_policy_vft = {
436  .fnv_last_lock = abf_policy_last_lock_gone,
437  .fnv_back_walk = abf_policy_back_walk_notify,
438 };
439 
440 static clib_error_t *
442 {
444 
445  return (NULL);
446 }
447 
449 
450 /*
451  * fd.io coding-style-patch-verification: ON
452  *
453  * Local Variables:
454  * eval: (c-set-style "gnu")
455  * End:
456  */
static abf_policy_t * abf_policy_get_from_node(fib_node_t *node)
Definition: abf_policy.c:398
static abf_policy_t * abf_policy_find_i(u32 policy_id)
Definition: abf_policy.c:53
static u32 abf_policy_get_index(const abf_policy_t *abf)
Definition: abf_policy.c:47
#define hash_set(h, key, value)
Definition: hash.h:255
fib_node_index_t fib_path_list_copy_and_path_remove(fib_node_index_t orig_path_list_index, fib_path_list_flags_t flags, const fib_route_path_t *rpath)
static uword * abf_policy_db
DB of ABF policy objects.
Definition: abf_policy.c:37
void fib_path_list_child_remove(fib_node_index_t path_list_index, u32 si)
#define hash_unset(h, key)
Definition: hash.h:261
static fib_node_back_walk_rc_t abf_policy_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Definition: abf_policy.c:414
A representation of a path as described by a route producer.
Definition: fib_types.h:455
u32 ap_id
The policy ID - as configured by the client.
Definition: abf_policy.h:58
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
uword unformat_fib_route_path(unformat_input_t *input, va_list *args)
Unformat a fib_route_path_t from CLI input.
Definition: fib_types.c:384
abf_policy_t * abf_policy_get(u32 index)
Get an ABF object from its VPP index.
Definition: abf_policy.c:41
#define NULL
Definition: clib.h:55
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
import vnet fib fib_types api
Definition: bier.api:22
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:62
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static fib_node_t * abf_policy_get_node(fib_node_index_t index)
Definition: abf_policy.c:391
fib_node_type_t abf_policy_fib_node_type
FIB node type the attachment is registered.
Definition: abf_policy.c:26
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
u32 fib_path_list_child_add(fib_node_index_t path_list_index, fib_node_type_t child_type, fib_node_index_t child_index)
unsigned char u8
Definition: types.h:56
fib_node_type_t fib_node_register_new_type(const fib_node_vft_t *vft)
Create a new FIB node type and Register the function table for it.
Definition: fib_node.c:80
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:443
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
static clib_error_t * abf_policy_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
Definition: abf_policy.c:236
void fib_walk_sync(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_back_walk_ctx_t *ctx)
Back walk all the children of a FIB node.
Definition: fib_walk.c:727
u32 ap_sibling
Sibling index on the path-list.
Definition: abf_policy.h:53
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned int u32
Definition: types.h:88
static u8 * format_abf(u8 *s, va_list *args)
Definition: abf_policy.c:308
unformat_function_t unformat_line_input
Definition: format.h:282
u32 abf_policy_find(u32 policy_id)
Find a ABF object from the client&#39;s policy ID.
Definition: abf_policy.c:66
fib_node_index_t fib_path_list_copy_and_path_add(fib_node_index_t orig_path_list_index, fib_path_list_flags_t flags, const fib_route_path_t *rpaths)
static void abf_policy_destroy(abf_policy_t *ap)
Definition: abf_policy.c:161
void abf_policy_update(u32 policy_id, u32 acl_index, const fib_route_path_t *rpaths)
Create or update an ABF Policy.
Definition: abf_policy.c:80
#define hash_get(h, key)
Definition: hash.h:249
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags, const fib_route_path_t *rpaths)
void fib_node_lock(fib_node_t *node)
Definition: fib_node.c:203
int(* abf_policy_walk_cb_t)(index_t index, void *ctx)
Callback function invoked during a walk of all policies.
Definition: abf_policy.h:102
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
void abf_policy_walk(abf_policy_walk_cb_t cb, void *ctx)
Walk/visit each of the ABF policies.
Definition: abf_policy.c:328
An node in the FIB graph.
Definition: fib_node.h:287
void fib_node_unlock(fib_node_t *node)
Definition: fib_node.c:209
static void abf_policy_last_lock_gone(fib_node_t *node)
Definition: abf_policy.c:405
fib_node_index_t ap_pl
The path-list describing how to forward in case of a match.
Definition: abf_policy.h:48
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
vlib_main_t * vm
Definition: buffer.c:294
fib_node_get_t fnv_get
Definition: fib_node.h:275
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
Context passed between object during a back walk.
Definition: fib_node.h:200
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define ASSERT(truth)
An ACL based Forwading &#39;policy&#39;.
Definition: abf_policy.h:33
long ctx[MAX_CONNS]
Definition: main.c:126
u32 ap_acl
ACL index to match.
Definition: abf_policy.h:43
static clib_error_t * abf_policy_init(vlib_main_t *vm)
Definition: abf_policy.c:441
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
u8 * fib_path_list_format(fib_node_index_t path_list_index, u8 *s)
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:162
A FIB graph nodes virtual function table.
Definition: fib_node.h:274
enum fib_node_type_t_ fib_node_type_t
The types of nodes in a FIB graph.
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
int abf_policy_delete(u32 policy_id, const fib_route_path_t *rpaths)
Delete paths from an ABF Policy.
Definition: abf_policy.c:175
fib_node_t ap_node
Linkage into the FIB graph.
Definition: abf_policy.h:38
static clib_error_t * abf_show_policy_cmd(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: abf_policy.c:342
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:488
static abf_policy_t * abf_policy_pool
Pool of ABF objects.
Definition: abf_policy.c:31
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170