FD.io VPP  v18.07-rc0-415-g6c78436
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 /**
41  * Stats for each BIER fmask object
42  */
44 
45 static inline index_t
47 {
48  return (bfm - bier_fmask_pool);
49 }
50 
51 static void
53  bier_hdr_len_id_t hlid)
54 {
55  bits->bfmb_refs = clib_mem_alloc(sizeof(bits->bfmb_refs[0]) *
57  memset(bits->bfmb_refs,
58  0,
59  (sizeof(bits->bfmb_refs[0]) *
61 
64 
65  /*
66  * The buckets are accessed in the switch path
67  */
70  sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
74  0,
75  sizeof(bits->bfmb_input_reset_string.bbs_buckets[0]) *
77 }
78 
79 static void
81 {
82  dpo_id_t via_dpo = DPO_INVALID;
84 
86  {
88  }
89  else
90  {
92  }
93 
96  &via_dpo);
97 
98  /*
99  * If the via PL entry provides no forwarding (i.e. a drop)
100  * then neither does this fmask. That way children consider this fmask
101  * unresolved and other ECMP options are used instead.
102  */
103  if (dpo_is_drop(&via_dpo))
104  {
106  }
107  else
108  {
110  }
111 
114  &bfm->bfm_dpo,
115  &via_dpo);
116  dpo_reset(&via_dpo);
117 }
118 
119 void
121  dpo_id_t *dpo)
122 {
123  bier_fmask_t *bfm;
124 
125  bfm = bier_fmask_get(bfmi);
126 
128  {
129  dpo_set(dpo,
132  bfmi);
133  }
134  else
135  {
137  }
138 }
139 
140 u32
142  fib_node_type_t child_type,
143  fib_node_index_t child_index)
144 {
146  bfmi,
147  child_type,
148  child_index));
149 };
150 
151 void
153  u32 sibling_index)
154 {
155  if (INDEX_INVALID == bfmi)
156  {
157  return;
158  }
159 
161  bfmi,
162  sibling_index);
163 }
164 
165 static void
167  const bier_fmask_id_t *fmid,
168  const fib_route_path_t *rpaths)
169 {
170  const bier_table_id_t *btid;
171  mpls_label_t olabel;
172 
173  ASSERT(1 == vec_len(rpaths));
174  memset(bfm, 0, sizeof(*bfm));
175 
176  bfm->bfm_id = clib_mem_alloc(sizeof(*bfm->bfm_id));
177 
179  *bfm->bfm_id = *fmid;
180  dpo_reset(&bfm->bfm_dpo);
181  btid = bier_table_get_id(bfm->bfm_id->bfmi_bti);
183 
184  if (ip46_address_is_zero(&(bfm->bfm_id->bfmi_nh)))
185  {
187  }
188 
189  if (!(bfm->bfm_flags & BIER_FMASK_FLAG_DISP))
190  {
191  if (NULL != rpaths->frp_label_stack)
192  {
193  olabel = rpaths->frp_label_stack[0].fml_value;
194  vnet_mpls_uc_set_label(&bfm->bfm_label, olabel);
196  vnet_mpls_uc_set_s(&bfm->bfm_label, 1);
197  vnet_mpls_uc_set_ttl(&bfm->bfm_label, 64);
199  }
200  else
201  {
202  bier_bift_id_t id;
203 
204  /*
205  * not an MPLS label
206  */
208 
209  /*
210  * use a label as encoded for BIFT value
211  */
212  id = bier_bift_id_encode(btid->bti_set,
213  btid->bti_sub_domain,
214  btid->bti_hdr_len);
216  vnet_mpls_uc_set_s(&bfm->bfm_label, 1);
218  vnet_mpls_uc_set_ttl(&bfm->bfm_label, 64);
219  }
220  bfm->bfm_label = clib_host_to_net_u32(bfm->bfm_label);
221  }
222 
225  rpaths);
228  bier_fmask_get_index(bfm));
229 
230  bier_fmask_stack(bfm);
231 }
232 
233 static void
235 {
238 
241  bfm->bfm_sibling);
242  dpo_reset(&bfm->bfm_dpo);
243  clib_mem_free(bfm->bfm_id);
244  pool_put(bier_fmask_pool, bfm);
245 }
246 
247 void
249 {
250  bier_fmask_t *bfm;
251 
252  if (INDEX_INVALID == bfmi)
253  {
254  return;
255  }
256 
257  bfm = bier_fmask_get(bfmi);
258 
259  fib_node_unlock(&bfm->bfm_node);
260 }
261 
262 void
264 {
265  bier_fmask_t *bfm;
266 
267  if (INDEX_INVALID == bfmi)
268  {
269  return;
270  }
271 
272  bfm = bier_fmask_get(bfmi);
273 
274  fib_node_lock(&bfm->bfm_node);
275 }
276 
277 index_t
279  const fib_route_path_t *rpaths)
280 {
281  bier_fmask_t *bfm;
282  index_t bfmi;
283 
284  pool_get_aligned(bier_fmask_pool, bfm, CLIB_CACHE_LINE_BYTES);
285  bfmi = bier_fmask_get_index(bfm);
286 
287  vlib_validate_combined_counter (&(bier_fmask_counters), bfmi);
288  vlib_zero_combined_counter (&(bier_fmask_counters), bfmi);
289 
290  bier_fmask_init(bfm, fmid, rpaths);
291 
292  bier_fmask_lock(bfmi);
293 
294  return (bfmi);
295 }
296 
297 void
299  bier_bp_t bp)
300 {
301  bier_fmask_t *bfm;
302 
303  bfm = bier_fmask_get(bfmi);
304 
305  if (0 == bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)])
306  {
307  /*
308  * 0 -> 1 transistion - set the bit in the string
309  */
311  }
312 
313  ++bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)];
314  ++bfm->bfm_bits.bfmb_count;
315 }
316 
317 void
319  bier_bp_t bp)
320 {
321  bier_fmask_t *bfm;
322 
323  bfm = bier_fmask_get(bfmi);
324 
325  --bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)];
326  --bfm->bfm_bits.bfmb_count;
327 
328  if (0 == bfm->bfm_bits.bfmb_refs[BIER_BP_TO_INDEX(bp)])
329  {
330  /*
331  * 1 -> 0 transistion - clear the bit in the string
332  */
334  }
335 }
336 
337 u8*
338 format_bier_fmask (u8 *s, va_list *ap)
339 {
340  index_t bfmi = va_arg(*ap, index_t);
341  u32 indent = va_arg(*ap, u32);
343  bier_fmask_t *bfm;
344  vlib_counter_t to;
345 
346  if (pool_is_free_index(bier_fmask_pool, bfmi))
347  {
348  return (format(s, "No BIER f-mask %d", bfmi));
349  }
350 
351  bfm = bier_fmask_get(bfmi);
352 
353  s = format(s, "fmask: nh:%U bs:%U locks:%d ",
356  bfm->bfm_node.fn_locks);
357  s = format(s, "flags:");
359  if ((1<<attr) & bfm->bfm_flags) {
360  s = format (s, "%s,", bier_fmask_attr_names[attr]);
361  }
362  }
363  vlib_get_combined_counter (&(bier_fmask_counters), bfmi, &to);
364  s = format (s, " to:[%Ld:%Ld]]", to.packets, to.bytes);
365  s = format(s, "\n");
366  s = fib_path_list_format(bfm->bfm_pl, s);
367 
368  if (bfm->bfm_flags & BIER_FMASK_FLAG_MPLS)
369  {
370  s = format(s, " output-label:%U",
372  vnet_mpls_uc_get_label(clib_net_to_host_u32(bfm->bfm_label)));
373  }
374  else
375  {
376  s = format(s, " output-bfit:[%U]",
378  vnet_mpls_uc_get_label(clib_net_to_host_u32(bfm->bfm_label)));
379  }
380  s = format(s, "\n %U%U",
381  format_white_space, indent,
382  format_dpo_id, &bfm->bfm_dpo, indent+2);
383 
384  return (s);
385 }
386 
387 void
388 bier_fmask_get_stats (index_t bfmi, u64 * packets, u64 * bytes)
389 {
390  vlib_counter_t to;
391 
392  vlib_get_combined_counter (&(bier_fmask_counters), bfmi, &to);
393 
394  *packets = to.packets;
395  *bytes = to.bytes;
396 }
397 
398 void
400  bier_table_id_t *btid,
402 {
403  bier_fmask_t *bfm;
404 
405  bfm = bier_fmask_get(bfmi);
406  *btid = *bier_table_get_id(bfm->bfm_id->bfmi_bti);
407 
408  memset(rpath, 0, sizeof(*rpath));
409 
410  rpath->rpath.frp_sw_if_index = ~0;
411 
412  switch (bfm->bfm_id->bfmi_nh_type)
413  {
414  case BIER_NH_UDP:
416  rpath->rpath.frp_udp_encap_id = bfm->bfm_id->bfmi_id;
417  break;
418  case BIER_NH_IP:
419  memcpy(&rpath->rpath.frp_addr, &bfm->bfm_id->bfmi_nh,
420  sizeof(rpath->rpath.frp_addr));
421  break;
422  }
423 }
424 
425 static fib_node_t *
427 {
428  bier_fmask_t *bfm = bier_fmask_get(index);
429  return (&(bfm->bfm_node));
430 }
431 
432 static bier_fmask_t*
434 {
435  return ((bier_fmask_t*)(((char*)node) -
437  bfm_node)));
438 }
439 
440 /*
441  * bier_fmask_last_lock_gone
442  */
443 static void
445 {
447 }
448 
449 /*
450  * bier_fmask_back_walk_notify
451  *
452  * A back walk has reached this BIER fmask
453  */
457 {
458  /*
459  * re-stack the fmask on the n-eos of the via
460  */
462 
463  bier_fmask_stack(bfm);
464 
465  /*
466  * propagate further up the graph.
467  * we can do this synchronously since the fan out is small.
468  */
470 
472 }
473 
474 /*
475  * The BIER fmask's graph node virtual function table
476  */
477 static const fib_node_vft_t bier_fmask_vft = {
479  .fnv_last_lock = bier_fmask_last_lock_gone,
480  .fnv_back_walk = bier_fmask_back_walk_notify,
481 };
482 
483 static void
485 {
486 }
487 
488 static void
490 {
491 }
492 
493 static void
495 {
496  fib_show_memory_usage("BIER-fmask",
497  pool_elts(bier_fmask_pool),
498  pool_len(bier_fmask_pool),
499  sizeof(bier_fmask_t));
500 }
501 
502 const static dpo_vft_t bier_fmask_dpo_vft = {
504  .dv_unlock = bier_fmask_dpo_unlock,
505  .dv_mem_show = bier_fmask_dpo_mem_show,
506  .dv_format = format_bier_fmask,
507 };
508 
509 const static char *const bier_fmask_mpls_nodes[] =
510 {
511  "bier-output",
512  NULL
513 };
514 const static char * const * const bier_fmask_nodes[DPO_PROTO_NUM] =
515 {
518 };
519 
520 clib_error_t *
522 {
524  dpo_register(DPO_BIER_FMASK, &bier_fmask_dpo_vft, bier_fmask_nodes);
525 
526  return (NULL);
527 }
528 
530 
531 static clib_error_t *
533  unformat_input_t * input,
534  vlib_cli_command_t * cmd)
535 {
536  bier_fmask_t *bfm;
537  index_t bfmi;
538 
539  bfmi = INDEX_INVALID;
540 
541  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
542  if (unformat (input, "%d", &bfmi))
543  {
544  ;
545  } else
546  {
547  break;
548  }
549  }
550 
551  if (INDEX_INVALID == bfmi)
552  {
553  pool_foreach(bfm, bier_fmask_pool,
554  ({
555  vlib_cli_output (vm, "[@%d] %U",
558  }));
559  }
560  else
561  {
562  vlib_cli_output (vm, "%U", format_bier_fmask, bfmi, 0);
563  }
564 
565  return (NULL);
566 }
567 
568 VLIB_CLI_COMMAND (show_bier_fmask, static) = {
569  .path = "show bier fmask",
570  .short_help = "show bier fmask",
571  .function = bier_fmask_show,
572 };
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:404
Contribute an object that is to be used to forward BIER packets.
Definition: fib_types.h:112
static void bier_fmask_bits_init(bier_fmask_bits_t *bits, bier_hdr_len_id_t hlid)
Definition: bier_fmask.c:52
ip46_address_t frp_addr
The next-hop address.
Definition: fib_types.h:471
clib_error_t * bier_fmask_module_init(vlib_main_t *vm)
Definition: bier_fmask.c:521
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:338
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:399
A representation of a fib path for fib_path_encode to convey the information to the caller...
Definition: fib_types.h:564
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:106
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:263
u32 bfmi_id
ID of the next-hop object, e.g.
Definition: bier_fmask_db.h:70
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:166
A representation of a path as described by a route producer.
Definition: fib_types.h:455
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:120
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:514
unsigned long u64
Definition: types.h:89
bier_fmask_id_t * bfm_id
The key to this fmask - used for store/lookup in the DB.
Definition: bier_fmask.h:124
#define NULL
Definition: clib.h:55
static bier_fmask_t * bier_fmask_get(u32 index)
Definition: bier_fmask.h:177
static void bier_fmask_dpo_lock(dpo_id_t *dpo)
Definition: bier_fmask.c:484
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:261
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 header in non-MPLS networks.
Definition: bier_fmask_db.h:53
Combined counter to hold both packets and byte differences.
Definition: counter.h:140
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:119
The ID of a table.
Definition: bier_types.h:394
fib_node_index_t bfm_pl
The path-list.
Definition: bier_fmask.h:134
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
#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:282
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:509
void bier_fmask_unlink(index_t bfmi, bier_bp_t bp)
Definition: bier_fmask.c:318
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:321
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:440
u32 frp_sw_if_index
The interface.
Definition: fib_types.h:490
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:156
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:401
void bier_fmask_child_remove(fib_node_index_t bfmi, u32 sibling_index)
Definition: bier_fmask.c:152
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:46
A path via a UDP encap object.
Definition: fib_types.h:346
unsigned int u32
Definition: types.h:88
static void vnet_mpls_uc_set_label(mpls_label_t *label_exp_s_ttl, u32 value)
Definition: packet.h:123
u32 bier_bp_t
A bit positon as assigned to egress PEs.
Definition: bier_types.h:294
static void vnet_mpls_uc_set_exp(mpls_label_t *label_exp_s_ttl, u32 exp)
Definition: packet.h:130
void bier_fmask_link(index_t bfmi, bier_bp_t bp)
Definition: bier_fmask.c:298
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:168
index_t bier_fmask_create_and_lock(const bier_fmask_id_t *fmid, const fib_route_path_t *rpaths)
Definition: bier_fmask.c:278
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:278
fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags, const fib_route_path_t *rpaths)
counter_t packets
packet counter
Definition: counter.h:142
bier_hdr_len_id_t bti_hdr_len
The size of the bit string processed by this table.
Definition: bier_types.h:419
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:455
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:273
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:103
fib_mpls_label_t * frp_label_stack
The outgoing MPLS label Stack.
Definition: fib_types.h:510
#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:129
static bier_fmask_t * bier_fmask_get_from_node(fib_node_t *node)
Definition: bier_fmask.c:433
#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
static void vlib_get_combined_counter(const vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thr...
Definition: counter.h:252
vlib_main_t * vm
Definition: buffer.c:294
static void bier_fmask_stack(bier_fmask_t *bfm)
Definition: bier_fmask.c:80
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:30
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:270
enum bier_hdr_len_id_t_ bier_hdr_len_id_t
bier_hdr_len_id_t enumerator
mpls_label_t fml_value
The label value.
Definition: fib_types.h:415
bier_fmask_flags_t bfm_flags
operational/state flags on the fmask
Definition: bier_fmask.h:113
fib_node_t bfm_node
The BIER fmask is a child of a FIB entry in the FIB graph.
Definition: bier_fmask.h:108
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:185
static void bier_fmask_dpo_mem_show(void)
Definition: bier_fmask.c:494
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:458
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
A key/ID for a BIER forwarding Mas (FMask).
Definition: bier_fmask_db.h:60
#define ASSERT(truth)
const bier_table_id_t * bier_table_get_id(index_t bti)
Definition: bier_table.c:488
long ctx[MAX_CONNS]
Definition: main.c:126
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.
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:547
#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:287
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:532
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:137
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:147
index_t bfmi_bti
The BIER table this fmask is in.
Definition: bier_fmask_db.h:75
format_function_t format_mpls_unicast_label
Definition: mpls.h:69
counter_t bytes
byte counter
Definition: counter.h:143
#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:426
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 fn_locks
Number of dependents on this node.
Definition: fib_node.h:306
void bier_fmask_get_stats(index_t bfmi, u64 *packets, u64 *bytes)
Definition: bier_fmask.c:388
#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:408
u8 * fib_path_list_format(fib_node_index_t path_list_index, u8 *s)
bier_nh_type_t bfmi_nh_type
Union discriminatrr.
Definition: bier_fmask_db.h:85
vlib_combined_counter_main_t bier_fmask_counters
Stats for each BIER fmask object.
Definition: bier_fmask.c:43
BIER Header in MPLS networks.
Definition: bier_fmask_db.h:48
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
A collection of combined counters.
Definition: counter.h:181
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:296
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:444
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:144
void bier_fmask_unlock(index_t bfmi)
Definition: bier_fmask.c:248
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:489
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:234
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:145
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:231
fib_route_path_t rpath
Definition: fib_types.h:565
Contribute an object that is to be used to forward non-end-of-stack MPLS packets. ...
Definition: fib_types.h:108
void bier_fmask_encode(index_t bfmi, bier_table_id_t *btid, fib_route_path_encode_t *rpath)
Definition: bier_fmask.c:399
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:62
u32 frp_udp_encap_id
UDP encap ID.
Definition: fib_types.h:527
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:86
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:141
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: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:515
ip46_address_t bfmi_nh
next-hop of the peer
Definition: bier_fmask_db.h:65
u32 bfm_sibling
the index of this fmask in the parent&#39;s child list.
Definition: bier_fmask.h:139
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128