FD.io VPP  v18.01.2-1-g9b554f3
Vector Packet Processing
bier_fmask.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/fib/fib_entry.h>
17 #include <vnet/fib/fib_table.h>
18 #include <vnet/fib/fib_walk.h>
19 #include <vnet/fib/fib_path_list.h>
20 
21 #include <vnet/bier/bier_table.h>
22 #include <vnet/bier/bier_fmask.h>
25 
26 #include <vnet/mpls/mpls.h>
27 #include <vnet/dpo/drop_dpo.h>
28 #include <vnet/dpo/load_balance.h>
29 
30 /*
31  * attributes names for formatting
32  */
33 static const char *const bier_fmask_attr_names[] = BIER_FMASK_ATTR_NAMES;
34 
35 /*
36  * pool of BIER fmask objects
37  */
39 
40 static inline index_t
42 {
43  return (bfm - bier_fmask_pool);
44 }
45 
46 static void
48  bier_hdr_len_id_t hlid)
49 {
50  bits->bfmb_refs = clib_mem_alloc(sizeof(bits->bfmb_refs[0]) *
52  memset(bits->bfmb_refs,
53  0,
54  (sizeof(bits->bfmb_refs[0]) *
56 
59 
60  /*
61  * The buckets are accessed in the switch path
62  */
65  sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
69  0,
70  sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
72 }
73 
74 static void
76 {
77  dpo_id_t via_dpo = DPO_INVALID;
79 
81  {
83  }
84  else
85  {
87  }
88 
91  &via_dpo);
92 
93  /*
94  * If the via PL entry provides no forwarding (i.e. a drop)
95  * then neither does this fmask. That way children consider this fmask
96  * unresolved and other ECMP options are used instead.
97  */
98  if (dpo_is_drop(&via_dpo))
99  {
101  }
102  else
103  {
105  }
106 
109  &bfm->bfm_dpo,
110  &via_dpo);
111  dpo_reset(&via_dpo);
112 }
113 
114 void
116  dpo_id_t *dpo)
117 {
118  bier_fmask_t *bfm;
119 
120  bfm = bier_fmask_get(bfmi);
121 
123  {
124  dpo_set(dpo,
127  bfmi);
128  }
129  else
130  {
132  }
133 }
134 
135 u32
137  fib_node_type_t child_type,
138  fib_node_index_t child_index)
139 {
141  bfmi,
142  child_type,
143  child_index));
144 };
145 
146 void
148  u32 sibling_index)
149 {
150  if (INDEX_INVALID == bfmi)
151  {
152  return;
153  }
154 
156  bfmi,
157  sibling_index);
158 }
159 
160 static void
162  const bier_fmask_id_t *fmid,
163  const fib_route_path_t *rpaths)
164 {
165  const bier_table_id_t *btid;
166  mpls_label_t olabel;
167 
168  *bfm->bfm_id = *fmid;
169  dpo_reset(&bfm->bfm_dpo);
170  btid = bier_table_get_id(bfm->bfm_id->bfmi_bti);
172 
173  if (ip46_address_is_zero(&(bfm->bfm_id->bfmi_nh)))
174  {
176  }
177 
178  if (!(bfm->bfm_flags & BIER_FMASK_FLAG_DISP))
179  {
180  /*
181  * leave this label in host byte order so we can OR in the TTL
182  */
183  if (NULL != rpaths->frp_label_stack)
184  {
185  olabel = rpaths->frp_label_stack[0];
186  vnet_mpls_uc_set_label(&bfm->bfm_label, olabel);
188  vnet_mpls_uc_set_s(&bfm->bfm_label, 1);
191  }
192  else
193  {
194  bier_bift_id_t id;
195 
196  /*
197  * not an MPLS label
198  */
200 
201  /*
202  * use a label as encoded for BIFT value
203  */
204  id = bier_bift_id_encode(btid->bti_set,
205  btid->bti_sub_domain,
206  btid->bti_hdr_len);
208  vnet_mpls_uc_set_s(&bfm->bfm_label, 1);
210  }
211  }
212 
215  rpaths);
218  bier_fmask_get_index(bfm));
219 
220  bier_fmask_stack(bfm);
221 }
222 
223 static void
225 {
228 
231  bfm->bfm_sibling);
232  dpo_reset(&bfm->bfm_dpo);
233  clib_mem_free(bfm->bfm_id);
234  pool_put(bier_fmask_pool, bfm);
235 }
236 
237 void
239 {
240  bier_fmask_t *bfm;
241 
242  if (INDEX_INVALID == bfmi)
243  {
244  return;
245  }
246 
247  bfm = bier_fmask_get(bfmi);
248 
249  fib_node_unlock(&bfm->bfm_node);
250 }
251 
252 void
254 {
255  bier_fmask_t *bfm;
256 
257  if (INDEX_INVALID == bfmi)
258  {
259  return;
260  }
261 
262  bfm = bier_fmask_get(bfmi);
263 
264  fib_node_lock(&bfm->bfm_node);
265 }
266 
267 index_t
269  const fib_route_path_t *rpaths)
270 {
271  bier_fmask_t *bfm;
272 
273  pool_get_aligned(bier_fmask_pool, bfm, CLIB_CACHE_LINE_BYTES);
274 
275  memset(bfm, 0, sizeof(*bfm));
276 
277  bfm->bfm_id = clib_mem_alloc(sizeof(*bfm->bfm_id));
278 
279  ASSERT(1 == vec_len(rpaths));
281  bier_fmask_init(bfm, fmid, rpaths);
282 
284 
285  return (bier_fmask_get_index(bfm));
286 }
287 
288 void
290  bier_bp_t bp)
291 {
292  bier_fmask_t *bfm;
293 
294  bfm = bier_fmask_get(bfmi);
295 
296  if (0 == bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)])
297  {
298  /*
299  * 0 -> 1 transistion - set the bit in the string
300  */
302  }
303 
304  ++bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)];
305  ++bfm->bfm_bits.bfmb_count;
306 }
307 
308 void
310  bier_bp_t bp)
311 {
312  bier_fmask_t *bfm;
313 
314  bfm = bier_fmask_get(bfmi);
315 
316  --bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)];
317  --bfm->bfm_bits.bfmb_count;
318 
319  if (0 == bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)])
320  {
321  /*
322  * 1 -> 0 transistion - clear the bit in the string
323  */
325  }
326 }
327 
328 u8*
329 format_bier_fmask (u8 *s, va_list *ap)
330 {
331  index_t bfmi = va_arg(*ap, index_t);
332  u32 indent = va_arg(*ap, u32);
334  bier_fmask_t *bfm;
335 
336  if (pool_is_free_index(bier_fmask_pool, bfmi))
337  {
338  return (format(s, "No BIER f-mask %d", bfmi));
339  }
340 
341  bfm = bier_fmask_get(bfmi);
342 
343  s = format(s, "fmask: nh:%U bs:%U locks:%d ",
346  bfm->bfm_node.fn_locks);
347  s = format(s, "flags:");
349  if ((1<<attr) & bfm->bfm_flags) {
350  s = format (s, "%s,", bier_fmask_attr_names[attr]);
351  }
352  }
353  s = format(s, "\n");
354  s = fib_path_list_format(bfm->bfm_pl, s);
355 
356  if (bfm->bfm_flags & BIER_FMASK_FLAG_MPLS)
357  {
358  s = format(s, " output-label:%U",
361  }
362  else
363  {
364  s = format(s, " output-bfit:[%U]",
367  }
368  s = format(s, "\n %U%U",
369  format_white_space, indent,
370  format_dpo_id, &bfm->bfm_dpo, indent+2);
371 
372  return (s);
373 }
374 
375 
376 static fib_node_t *
378 {
379  bier_fmask_t *bfm = bier_fmask_get(index);
380  return (&(bfm->bfm_node));
381 }
382 
383 static bier_fmask_t*
385 {
386  return ((bier_fmask_t*)(((char*)node) -
388  bfm_node)));
389 }
390 
391 /*
392  * bier_fmask_last_lock_gone
393  */
394 static void
396 {
398 }
399 
400 /*
401  * bier_fmask_back_walk_notify
402  *
403  * A back walk has reached this BIER fmask
404  */
408 {
409  /*
410  * re-stack the fmask on the n-eos of the via
411  */
413 
414  bier_fmask_stack(bfm);
415 
416  /*
417  * propagate further up the graph.
418  * we can do this synchronously since the fan out is small.
419  */
421 
423 }
424 
425 /*
426  * The BIER fmask's graph node virtual function table
427  */
428 static const fib_node_vft_t bier_fmask_vft = {
430  .fnv_last_lock = bier_fmask_last_lock_gone,
431  .fnv_back_walk = bier_fmask_back_walk_notify,
432 };
433 
434 static void
436 {
437 }
438 
439 static void
441 {
442 }
443 
444 static void
446 {
447  fib_show_memory_usage("BIER-fmask",
448  pool_elts(bier_fmask_pool),
449  pool_len(bier_fmask_pool),
450  sizeof(bier_fmask_t));
451 }
452 
453 const static dpo_vft_t bier_fmask_dpo_vft = {
455  .dv_unlock = bier_fmask_dpo_unlock,
456  .dv_mem_show = bier_fmask_dpo_mem_show,
457  .dv_format = format_bier_fmask,
458 };
459 
460 const static char *const bier_fmask_mpls_nodes[] =
461 {
462  "bier-output",
463  NULL
464 };
465 const static char * const * const bier_fmask_nodes[DPO_PROTO_NUM] =
466 {
469 };
470 
471 clib_error_t *
473 {
475  dpo_register(DPO_BIER_FMASK, &bier_fmask_dpo_vft, bier_fmask_nodes);
476 
477  return (NULL);
478 }
479 
481 
482 static clib_error_t *
484  unformat_input_t * input,
485  vlib_cli_command_t * cmd)
486 {
487  bier_fmask_t *bfm;
488  index_t bfmi;
489 
490  bfmi = INDEX_INVALID;
491 
492  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
493  if (unformat (input, "%d", &bfmi))
494  {
495  ;
496  } else
497  {
498  break;
499  }
500  }
501 
502  if (INDEX_INVALID == bfmi)
503  {
504  pool_foreach(bfm, bier_fmask_pool,
505  ({
506  vlib_cli_output (vm, "[@%d] %U",
509  }));
510  }
511  else
512  {
513  vlib_cli_output (vm, "%U", format_bier_fmask, bfmi, 0);
514  }
515 
516  return (NULL);
517 }
518 
519 VLIB_CLI_COMMAND (show_bier_fmask, static) = {
520  .path = "show bier fmask",
521  .short_help = "show bier fmask",
522  .function = bier_fmask_show,
523 };
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:382
Contribute an object that is to be used to forward BIER packets.
Definition: fib_types.h:101
static void bier_fmask_bits_init(bier_fmask_bits_t *bits, bier_hdr_len_id_t hlid)
Definition: bier_fmask.c:47
clib_error_t * bier_fmask_module_init(vlib_main_t *vm)
Definition: bier_fmask.c:472
u8 * format_bier_bit_string(u8 *string, va_list *args)
u32 bfmb_count
The total number of references to bits set on this mask in effect a count of the number of children...
Definition: bier_fmask.h:57
u8 * format_bier_fmask(u8 *s, va_list *ap)
Definition: bier_fmask.c:329
void bier_bit_string_set_bit(bier_bit_string_t *bit_string, bier_bp_t bp)
A virtual function table regisitered for a DPO type.
Definition: dpo.h:377
void fib_path_list_child_remove(fib_node_index_t path_list_index, u32 si)
void bier_fmask_lock(index_t bfmi)
Definition: bier_fmask.c:253
static void bier_fmask_init(bier_fmask_t *bfm, const bier_fmask_id_t *fmid, const fib_route_path_t *rpaths)
Definition: bier_fmask.c:161
A representation of a path as described by a route producer.
Definition: fib_types.h:377
bier_fmask_t * bier_fmask_pool
Definition: bier_fmask.c:38
void bier_fmask_contribute_forwarding(index_t bfmi, dpo_id_t *dpo)
Definition: bier_fmask.c:115
void fib_node_init(fib_node_t *node, fib_node_type_t type)
Definition: fib_node.c:185
static const char *const *const bier_fmask_nodes[DPO_PROTO_NUM]
Definition: bier_fmask.c:465
bier_fmask_id_t * bfm_id
The key to this fmask - used for store/lookup in the DB.
Definition: bier_fmask.h:119
#define NULL
Definition: clib.h:55
static bier_fmask_t * bier_fmask_get(u32 index)
Definition: bier_fmask.h:168
static void bier_fmask_dpo_lock(dpo_id_t *dpo)
Definition: bier_fmask.c:435
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
Definition: dpo.c:258
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
u8 * format_bier_bift_id(u8 *s, va_list *ap)
Definition: bier_types.c:222
bier_fmask : The BIER fmask
Definition: bier_fmask.h:45
format_function_t format_ip46_address
Definition: format.h:61
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:62
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
bier_fmask_bits_t bfm_bits
The bits, and their ref counts, that are set on this mask This mask changes as BIER entries link to a...
Definition: bier_fmask.h:114
The ID of a table.
Definition: bier_types.h:446
fib_node_index_t bfm_pl
The path-list.
Definition: bier_fmask.h:129
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)
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
u32 fib_node_child_add(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_type_t type, fib_node_index_t index)
Definition: fib_node.c:98
u16 bbs_len
The length of the string in BYTES.
Definition: bier_types.h:327
void fib_node_register_type(fib_node_type_t type, const fib_node_vft_t *vft)
fib_node_register_type
Definition: fib_node.c:60
static const char *const bier_fmask_mpls_nodes[]
Definition: bier_fmask.c:460
void bier_fmask_unlink(index_t bfmi, bier_bp_t bp)
Definition: bier_fmask.c:309
const dpo_id_t * drop_dpo_get(dpo_proto_t proto)
Definition: drop_dpo.c:25
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:306
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:438
mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:432
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
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
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
bier_table_set_id_t bti_set
The SET-ID The control plane divdies the bit-position space into sets in the case the max bit-positio...
Definition: bier_types.h:453
void bier_fmask_child_remove(fib_node_index_t bfmi, u32 sibling_index)
Definition: bier_fmask.c:147
bier_bift_id_t bier_bift_id_encode(bier_table_set_id_t set, bier_table_sub_domain_id_t sd, bier_hdr_len_id_t bsl)
Encode a BIFT-ID as per draft-wijnandsxu-bier-non-mpls-bift-encoding-00.txt.
Definition: bier_types.c:164
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:220
static index_t bier_fmask_get_index(const bier_fmask_t *bfm)
Definition: bier_fmask.c:41
static void vnet_mpls_uc_set_label(mpls_label_t *label_exp_s_ttl, u32 value)
Definition: packet.h:97
u32 bier_bp_t
A bit positon as assigned to egress PEs.
Definition: bier_types.h:346
static void vnet_mpls_uc_set_exp(mpls_label_t *label_exp_s_ttl, u32 exp)
Definition: packet.h:104
void bier_fmask_link(index_t bfmi, bier_bp_t bp)
Definition: bier_fmask.c:289
u32 bier_hdr_len_id_to_num_bits(bier_hdr_len_id_t id)
Definition: bier_types.c:78
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:166
index_t bier_fmask_create_and_lock(const bier_fmask_id_t *fmid, const fib_route_path_t *rpaths)
Definition: bier_fmask.c:268
fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags, const fib_route_path_t *rpaths)
bier_hdr_len_id_t bti_hdr_len
The size of the bit string processed by this table.
Definition: bier_types.h:471
static fib_node_back_walk_rc_t bier_fmask_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Definition: bier_fmask.c:406
void fib_node_lock(fib_node_t *node)
Definition: fib_node.c:203
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
void bier_bit_string_clear_bit(bier_bit_string_t *bit_string, bier_bp_t bp)
static u32 vnet_mpls_uc_get_label(mpls_label_t label_exp_s_ttl)
Definition: packet.h:77
#define BIER_FMASK_ATTR_NAMES
Definition: bier_fmask.h:72
An node in the FIB graph.
Definition: fib_node.h:286
void fib_node_unlock(fib_node_t *node)
Definition: fib_node.c:209
void bier_fmask_db_remove(const bier_fmask_id_t *fmid)
An outgoing BIER mask.
Definition: bier_fmask.h:99
mpls_label_t bfm_label
The MPLS label to paint on the header during forwarding.
Definition: bier_fmask.h:124
static bier_fmask_t * bier_fmask_get_from_node(fib_node_t *node)
Definition: bier_fmask.c:384
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:188
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
vlib_main_t * vm
Definition: buffer.c:283
static void bier_fmask_stack(bier_fmask_t *bfm)
Definition: bier_fmask.c:75
fib_node_get_t fnv_get
Definition: fib_node.h:274
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
u32 bier_hdr_len_id_to_num_buckets(bier_hdr_len_id_t id)
Conversion functions for the enumerated bit-string length values, to bit and bytes.
Definition: bier_types.c:60
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:268
enum bier_hdr_len_id_t_ bier_hdr_len_id_t
bier_hdr_len_id_t enumerator
bier_fmask_flags_t bfm_flags
operational/state flags on the fmask
Definition: bier_fmask.h:108
fib_node_t bfm_node
The BIER fmask is a child of a FIB entry in the FIB graph.
Definition: bier_fmask.h:103
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:182
static void bier_fmask_dpo_mem_show(void)
Definition: bier_fmask.c:445
Context passed between object during a back walk.
Definition: fib_node.h:199
u32 bier_bift_id_t
The BIER universal &#39;label&#39;.
Definition: bier_types.h:510
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
A key/ID for a BIER forwarding Mas (FMask).
Definition: bier_fmask_db.h:45
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
const bier_table_id_t * bier_table_get_id(index_t bti)
Definition: bier_table.c:488
long ctx[MAX_CONNS]
Definition: main.c:122
static void clib_mem_free(void *p)
Definition: mem.h:179
enum fib_forward_chain_type_t_ fib_forward_chain_type_t
FIB output chain type.
#define FOR_EACH_BIER_FMASK_ATTR(_item)
Definition: bier_fmask.h:78
bier_bit_mask_bucket_t * bbs_buckets
The buckets in the string.
Definition: bier_types.h:332
void fib_node_child_remove(fib_node_type_t parent_type, fib_node_index_t parent_index, fib_node_index_t sibling_index)
Definition: fib_node.c:123
static clib_error_t * bier_fmask_show(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: bier_fmask.c:483
static void * clib_mem_alloc(uword size)
Definition: mem.h:112
static void vnet_mpls_uc_set_s(mpls_label_t *label_exp_s_ttl, u32 eos)
Definition: packet.h:111
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:146
index_t bfmi_bti
The BIER table this fmask is in.
Definition: bier_fmask_db.h:54
format_function_t format_mpls_unicast_label
Definition: mpls.h:69
#define DPO_PROTO_NUM
Definition: dpo.h:70
static fib_node_t * bier_fmask_get_node(fib_node_index_t index)
Definition: bier_fmask.c:377
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
u32 fn_locks
Number of dependents on this node.
Definition: fib_node.h:312
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
bier_table_sub_domain_id_t bti_sub_domain
The Sub-Domain-ID The control plane has the configuration option to specify multiple domains or topol...
Definition: bier_types.h:460
u8 * fib_path_list_format(fib_node_index_t path_list_index, u8 *s)
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:193
void fib_path_list_contribute_forwarding(fib_node_index_t path_list_index, fib_forward_chain_type_t fct, fib_path_list_fwd_flags_t flags, dpo_id_t *dpo)
#define BIER_BP_TO_INDEX(bp)
Definition: bier_types.h:348
bier_bit_string_t bfmb_input_reset_string
each bit in the mask needs to be reference counted and set/cleared on the 0->1 and 1->0 transitions...
Definition: bier_fmask.h:50
static void bier_fmask_last_lock_gone(fib_node_t *node)
Definition: bier_fmask.c:395
A FIB graph nodes virtual function table.
Definition: fib_node.h:273
static void vnet_mpls_uc_set_ttl(mpls_label_t *label_exp_s_ttl, u32 ttl)
Definition: packet.h:118
void bier_fmask_unlock(index_t bfmi)
Definition: bier_fmask.c:238
static void * clib_mem_alloc_aligned(uword size, uword align)
Definition: mem.h:120
static void bier_fmask_dpo_unlock(dpo_id_t *dpo)
Definition: bier_fmask.c:440
enum fib_node_type_t_ fib_node_type_t
The types of nodes in a FIB graph.
static void bier_fmask_destroy(bier_fmask_t *bfm)
Definition: bier_fmask.c:224
static const char *const bier_fmask_attr_names[]
Definition: bier_fmask.c:33
dpo_id_t bfm_dpo
The index into the adj table for the adj that this fmask resolves via.
Definition: bier_fmask.h:140
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:228
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:97
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:81
u32 bier_fmask_child_add(fib_node_index_t bfmi, fib_node_type_t child_type, fib_node_index_t child_index)
Definition: bier_fmask.c:136
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
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:169
enum bier_fmask_attributes_t_ bier_fmask_attributes_t
Flags on fmask.
void dpo_stack(dpo_type_t child_type, dpo_proto_t child_proto, dpo_id_t *dpo, const dpo_id_t *parent)
Stack one DPO object on another, and thus establish a child-parent relationship.
Definition: dpo.c:470
ip46_address_t bfmi_nh
next-hop of the peer
Definition: bier_fmask_db.h:60
u32 bfm_sibling
the index of this fmask in the parent&#39;s child list.
Definition: bier_fmask.h:134
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128