FD.io VPP  v18.04-17-g3a0d853
Vector Packet Processing
bier_table.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 <vppinfra/vec.h>
17 
18 #include <vnet/bier/bier_table.h>
19 #include <vnet/bier/bier_entry.h>
20 #include <vnet/bier/bier_update.h>
22 #include <vnet/bier/bier_fmask.h>
24 
25 #include <vnet/fib/mpls_fib.h>
26 #include <vnet/mpls/mpls.h>
27 #include <vnet/fib/fib_path_list.h>
28 
29 /**
30  * Memory pool of all the allocated tables
31  */
33 
34 /**
35  * DB store of all BIER tables index by SD/set/hdr-len
36  */
38 
39 /**
40  * The magic number of BIER ECMP tables to create.
41  * The load-balance distribution algorithm will use a power of 2
42  * for the number of buckets, which constrains the choice.
43  */
44 #define BIER_N_ECMP_TABLES 16
45 
46 static inline index_t
48 {
49  return (bt - bier_table_pool);
50 }
51 
52 int
54 {
55  return (BIER_ECMP_TABLE_ID_MAIN == bt->bt_id.bti_ecmp);
56 }
57 
58 /*
59  * Construct the key to use to find a BIER table
60  * in the global hash map
61  */
62 static u32
64 {
65  /*
66  * the set and sub-domain Ids are 8 bit values.
67  * we have space for ECMP table ID and talbe type (SPF/TE)
68  * for later
69  */
70  u32 key = ((id->bti_sub_domain << 24) |
71  (id->bti_set << 16) |
72  (id->bti_ecmp << 8) |
73  (id->bti_hdr_len << 4) |
74  (id->bti_type));
75 
76  return (key);
77 }
78 
79 static void
81  const bier_table_id_t *id,
82  mpls_label_t ll)
83 {
84  u32 num_entries;
85 
87  bt->bt_id = *id;
88  bt->bt_ll = ll;
90 
91  /*
92  * create the lookup table of entries.
93  */
94  if (bier_table_is_main(bt))
95  {
97  num_entries,
100  }
101  else
102  {
104  num_entries,
107  }
108 }
109 
110 static void
112 {
114 
116  bt->bt_id.bti_sub_domain,
117  bt->bt_id.bti_hdr_len));
118 }
119 
120 static void
122 {
123  dpo_id_t dpo = DPO_INVALID;
124 
126 
128 
130  bt->bt_id.bti_sub_domain,
131  bt->bt_id.bti_hdr_len),
132  &dpo);
133 
134  dpo_reset(&dpo);
135 }
136 
137 static void
139 {
140  if (FIB_NODE_INDEX_INVALID != bt->bt_lfei)
141  {
147  }
149 }
150 
151 static void
153 {
154  if (bier_table_is_main(bt))
155  {
156  index_t *bei;
157 
158  if (MPLS_LABEL_INVALID != bt->bt_ll)
159  {
160  bier_table_rm_lfib(bt);
161  }
162  else
163  {
164  bier_table_rm_bift(bt);
165  }
166 
169  /*
170  * unresolve/remove all entries from the table
171  */
172  vec_foreach (bei, bt->bt_entries)
173  {
174  if (INDEX_INVALID != *bei)
175  {
176  bier_entry_delete(*bei);
177  }
178  }
179  vec_free (bt->bt_entries);
180  }
181  else
182  {
183  index_t *bfmi;
184 
185  /*
186  * unlock any fmasks
187  */
188  vec_foreach (bfmi, bt->bt_fmasks)
189  {
190  bier_fmask_unlock(*bfmi);
191  }
192  vec_free(bt->bt_fmasks);
193  }
194 
196  bier_table_mk_key(&bt->bt_id));
197  pool_put(bier_table_pool, bt);
198 }
199 
200 static void
202 {
203  bt->bt_locks++;
204 }
205 
206 static void
208 {
209  bt->bt_locks--;
210 
211  if (0 == bt->bt_locks)
212  {
213  bier_table_destroy(bt);
214  }
215 }
216 
217 void
219 {
220  uword *p;
221  u32 key;
222 
223  key = bier_table_mk_key(bti);
224 
225  p = hash_get (bier_tables_by_key, key);
226 
227  if (NULL != p) {
229  }
230 }
231 
232 static void
234 {
235  /*
236  * Add a new MPLS lfib entry
237  */
238  if (MPLS_LABEL_INVALID != bt->bt_ll) {
239  fib_prefix_t pfx = {
241  .fp_len = 21,
242  .fp_label = bt->bt_ll,
243  .fp_eos = MPLS_EOS,
244  .fp_payload_proto = DPO_PROTO_BIER,
245  };
246  u32 mpls_fib_index;
247  dpo_id_t dpo = DPO_INVALID;
248 
252 
253  /*
254  * stack the entry on the forwarding chain prodcued by the
255  * path-list via the ECMP tables.
256  */
260  &dpo);
261 
262  mpls_fib_index = fib_table_find(FIB_PROTOCOL_MPLS,
264  bt->bt_lfei = fib_table_entry_special_dpo_add(mpls_fib_index,
265  &pfx,
268  &dpo);
269  dpo_reset(&dpo);
270  }
271 }
272 
273 static bier_table_t *
275 {
276  uword *p;
277  u32 key;
278 
279  key = bier_table_mk_key(bti);
280 
281  p = hash_get(bier_tables_by_key, key);
282 
283  if (NULL != p)
284  {
285  return (bier_table_get(p[0]));
286  }
287 
288  return (NULL);
289 }
290 
291 static bier_table_t *
293 {
294  fib_route_path_t *rpaths;
295  fib_node_index_t pli;
296  bier_table_t *bt;
297  int ii;
298 
299  rpaths = NULL;
300  bt = bier_table_get(bti);
301 
302  vec_validate(rpaths, BIER_N_ECMP_TABLES-1);
303 
304  vec_foreach_index(ii, rpaths)
305  {
306  rpaths[ii].frp_bier_tbl = bt->bt_id;
307  rpaths[ii].frp_bier_tbl.bti_ecmp = ii;
309  }
310 
311  /*
312  * no oppotunity to share, this the resolving ECMP tables are unique
313  * to this table.
314  * no need to be a child of the path list, we can do nothing with any
315  * notifications it would generate [not that it will].
316  */
318  fib_path_list_lock(pli);
319 
320  /*
321  * constructing the path-list will have created many more BIER tables,
322  * so this main table will no doubt have re-alloc.
323  */
324  bt = bier_table_get(bti);
325  bt->bt_pl = pli;
326 
327  vec_free(rpaths);
328 
329  return (bt);
330 }
331 
332 index_t
334  mpls_label_t local_label)
335 {
336  bier_table_t *bt;
337  index_t bti;
338 
339  bt = bier_table_find(btid);
340 
341  if (NULL != bt) {
342  /*
343  * modify an existing table.
344  * change the lfib entry to the new local label
345  */
346  if (bier_table_is_main(bt))
347  {
348  /*
349  * remove the mpls-fib or bift entry
350  */
351  if (MPLS_LABEL_INVALID != bt->bt_ll)
352  {
353  bier_table_rm_lfib(bt);
354  }
355  else
356  {
357  bier_table_rm_bift(bt);
358  }
359 
360  /*
361  * reset
362  */
364 
365  /*
366  * add whichever mpls-fib or bift we need
367  */
368  if (local_label != MPLS_LABEL_INVALID)
369  {
370  bt->bt_ll = local_label;
371  bier_table_mk_lfib(bt);
372  }
373  else
374  {
375  bier_table_mk_bift(bt);
376  }
377  }
378  bti = bier_table_get_index(bt);
379  }
380  else
381  {
382  /*
383  * add a new table
384  */
385  u32 key;
386 
387  key = bier_table_mk_key(btid);
388 
389  pool_get_aligned(bier_table_pool, bt, CLIB_CACHE_LINE_BYTES);
390  bier_table_init(bt, btid, local_label);
391 
393  bti = bier_table_get_index(bt);
394 
395  if (bier_table_is_main(bt))
396  {
397  bt = bier_table_mk_ecmp(bti);
398 
399  /*
400  * add whichever mpls-fib or bift we need
401  */
402  if (local_label != MPLS_LABEL_INVALID)
403  {
404  bt->bt_ll = local_label;
405  bier_table_mk_lfib(bt);
406  }
407  else
408  {
409  bier_table_mk_bift(bt);
410  }
411  }
412  }
413 
414  bier_table_lock_i(bt);
415 
416  return (bti);
417 }
418 
419 index_t
421 {
423 }
424 
425 void
427 {
429 }
430 
431 static void
433 {
434 }
435 
436 static void
438 {
439 }
440 
441 static void
443 {
444  fib_show_memory_usage("BIER-table",
445  pool_elts(bier_table_pool),
446  pool_len(bier_table_pool),
447  sizeof(bier_table_t));
448 }
449 static u8 *
450 format_bier_table_dpo (u8 *s, va_list *ap)
451 {
452  index_t bti = va_arg(*ap, index_t);
453  bier_table_t *bt;
454 
455  bt = bier_table_get(bti);
456 
457  return (format(s, "[%U]", format_bier_table_id, &bt->bt_id));
458 }
459 
460 const static dpo_vft_t bier_table_dpo_vft = {
462  .dv_unlock = bier_table_dpo_unlock,
463  .dv_format = format_bier_table_dpo,
464  .dv_mem_show = bier_table_dpo_mem_show,
465 };
466 
467 const static char *const bier_table_mpls_nodes[] =
468 {
469  "bier-input",
470  NULL
471 };
472 const static char * const * const bier_table_nodes[DPO_PROTO_NUM] =
473 {
475 };
476 
477 static clib_error_t *
479 {
480  dpo_register(DPO_BIER_TABLE, &bier_table_dpo_vft, bier_table_nodes);
481 
482  return (NULL);
483 }
484 
486 
487 const bier_table_id_t *
489 {
490  bier_table_t *bt;
491 
492  bt = bier_table_get(bti);
493 
494  return (&bt->bt_id);
495 }
496 
497 static void
499  bier_bp_t bp,
500  index_t bei)
501 {
502  bt->bt_entries[BIER_BP_TO_INDEX(bp)] = bei;
503 }
504 
505 static void
507  bier_bp_t bp)
508 {
510 }
511 
512 void
514  bier_bp_t bp,
515  fib_route_path_t *brps)
516 {
517  index_t bfmi, bti, bei, *bfmip, *bfmis = NULL;
518  fib_route_path_t *brp;
519  bier_table_t *bt;
520 
521  bt = bier_table_find(btid);
522 
523  if (NULL == bt) {
524  return;
525  }
526 
527  bti = bier_table_get_index(bt);
528  bei = bier_table_lookup(bt, bp);
529 
530  /*
531  * set the FIB index in the path to the BIER table index
532  */
533  vec_foreach(brp, brps)
534  {
535  /*
536  * First use the path to find or construct an FMask object
537  * via the next-hop
538  */
539  bfmi = bier_fmask_db_find_or_create_and_lock(bti, brp);
540  vec_add1(bfmis, bfmi);
541 
542  /*
543  * then modify the path to resolve via this fmask object
544  * and use it to resolve the BIER entry.
545  */
547  brp->frp_bier_fmask = bfmi;
548  }
549 
550  if (INDEX_INVALID == bei)
551  {
552  bei = bier_entry_create(bti, bp);
553  bier_table_insert(bt, bp, bei);
554  }
555  bier_entry_path_add(bei, brps);
556 
557  vec_foreach(bfmip, bfmis)
558  {
559  bier_fmask_unlock(*bfmip);
560  }
561  vec_free(bfmis);
562 }
563 
564 void
566  bier_bp_t bp,
567  fib_route_path_t *brps)
568 {
569  fib_route_path_t *brp = NULL;
570  index_t bfmi, bti, bei;
571  bier_table_t *bt;
572  u32 ii;
573 
574  bt = bier_table_find(btid);
575 
576  if (NULL == bt) {
577  return;
578  }
579 
580  bti = bier_table_get_index(bt);
581  bei = bier_table_lookup(bt, bp);
582 
583  if (INDEX_INVALID == bei)
584  {
585  /* no such entry */
586  return;
587  }
588 
589  /*
590  * set the FIB index in the path to the BIER table index
591  */
592  vec_foreach_index(ii, brps)
593  {
594  brp = &brps[ii];
595  bfmi = bier_fmask_db_find(bti, brp);
596 
597  if (INDEX_INVALID == bfmi)
598  {
599  /*
600  * no matching fmask, not a path we can remove
601  */
602  vec_del1(brps, ii);
603  continue;
604  }
605 
606  /*
607  * then modify the path to resolve via this fmask object
608  * and use it to resolve the BIER entry.
609  */
611  brp->frp_bier_fmask = bfmi;
612  }
613 
614  if (0 == vec_len(brps))
615  {
616  return;
617  }
618 
619  if (0 == bier_entry_path_remove(bei, brps))
620  {
621  /* 0 remaining paths */
622  bier_table_remove(bt, bp);
623  bier_entry_delete(bei);
624  }
625 }
626 
627 void
629  dpo_id_t *dpo)
630 {
631  bier_table_t *bt;
632 
633  bt = bier_table_get(bti);
634 
636  {
637  /*
638  * return the load-balance for the ECMP tables
639  */
643  dpo);
644  }
645  else
646  {
648  }
649 }
650 
652 {
654  void *ctx;
656 
659  fib_node_index_t path_index,
660  void *arg)
661 {
663 
664  ctx->fn(fib_path_get_resolving_index(path_index), ctx->ctx);
665  /* continue */
667 }
668 
669 void
672  void *ctx)
673 {
675  .fn = fn,
676  .ctx = ctx,
677  };
678  bier_table_t *bt;
679 
680  bt = bier_table_get(bti);
681 
684  &ewc);
685 }
686 
687 void
689  bier_bp_t bp,
690  index_t bfmi)
691 {
692  bier_table_t *bt;
693 
694  bt = bier_table_get(bti);
695 
696  /*
697  * we hold a lock for fmasks in the table
698  */
699  bier_fmask_lock(bfmi);
701 
702  bt->bt_fmasks[BIER_BP_TO_INDEX(bp)] = bfmi;
703 }
704 
705 u8 *
706 format_bier_table_entry (u8 *s, va_list *ap)
707 {
708  index_t bti = va_arg(*ap, index_t);
709  bier_bp_t bp = va_arg(*ap, bier_bp_t);
710  bier_table_t *bt;
711  bt = bier_table_get(bti);
712 
713  if (bier_table_is_main(bt))
714  {
715  index_t bei;
716 
717  bei = bier_table_lookup(bier_table_get(bti), bp);
718 
719  if (INDEX_INVALID != bei)
720  {
721  s = format(s, "%U", format_bier_entry, bei,
723  }
724  }
725  else
726  {
727  index_t bfmi;
728 
729  bfmi = bier_table_fwd_lookup(bier_table_get(bti), bp);
730 
731  if (INDEX_INVALID != bfmi)
732  {
733  s = format(s, "%U", format_bier_fmask, bfmi,
735  }
736  }
737  return (s);
738 }
739 
740 u8 *
741 format_bier_table (u8 *s, va_list *ap)
742 {
743  index_t bti = va_arg(*ap, index_t);
745  bier_table_t *bt;
746 
747  if (pool_is_free_index(bier_table_pool, bti))
748  {
749  return (format(s, "No BIER table %d", bti));
750  }
751 
752  bt = bier_table_get(bti);
753 
754  s = format(s, "[@%d] bier-table:[%U local-label:%U",
755  bti,
758 
759  if (flags & BIER_SHOW_DETAIL)
760  {
761  s = format(s, " locks:%d", bt->bt_locks);
762  }
763  s = format(s, "]");
764 
765  if (flags & BIER_SHOW_DETAIL)
766  {
767  if (bier_table_is_main(bt))
768  {
769  index_t *bei;
770 
771  vec_foreach (bei, bt->bt_entries)
772  {
773  if (INDEX_INVALID != *bei)
774  {
775  s = format(s, "\n%U", format_bier_entry, *bei, 2);
776  }
777  }
778  }
779  else
780  {
781  u32 ii;
782 
783  vec_foreach_index (ii, bt->bt_fmasks)
784  {
785  if (INDEX_INVALID != bt->bt_fmasks[ii])
786  {
787  s = format(s, "\n bp:%d\n %U", ii,
788  format_bier_fmask, bt->bt_fmasks[ii], 2);
789  }
790  }
791  }
792  }
793 
794  return (s);
795 }
796 
797 void
800 {
801  if (!pool_elts(bier_table_pool))
802  {
803  vlib_cli_output (vm, "No BIER tables");
804  }
805  else
806  {
807  int ii;
808 
809  pool_foreach_index(ii, bier_table_pool,
810  ({
811  vlib_cli_output (vm, "%U", format_bier_table, ii, flags);
812  }));
813  }
814 }
815 
816 void
818  void *ctx)
819 {
820  ASSERT(0);
821 }
822 
823 
824 void
827  void *ctx)
828 {
829  bier_table_t *bt;
830  bier_entry_t *be;
831  index_t *bei;
832 
833  bt = bier_table_find(bti);
834 
835  if (NULL == bt)
836  {
837  return;
838  }
839 
840  vec_foreach (bei, bt->bt_entries)
841  {
842  if (INDEX_INVALID != *bei)
843  {
844  be = bier_entry_get(*bei);
845 
846  fn(bt, be, ctx);
847  }
848  }
849 }
static bier_table_t * bier_table_mk_ecmp(index_t bti)
Definition: bier_table.c:292
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:434
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:197
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
#define vec_foreach_index(var, v)
Iterate over vector indices.
#define hash_set(h, key, value)
Definition: hash.h:254
u8 * format_bier_fmask(u8 *s, va_list *ap)
Definition: bier_fmask.c:328
static void bier_table_mk_bift(bier_table_t *bt)
Definition: bier_table.c:121
A virtual function table regisitered for a DPO type.
Definition: dpo.h:399
#define hash_unset(h, key)
Definition: hash.h:260
void bier_fmask_lock(index_t bfmi)
Definition: bier_fmask.c:252
u32 bier_fmask_db_find_or_create_and_lock(index_t bti, const fib_route_path_t *rpath)
index_t fib_path_get_resolving_index(fib_node_index_t path_index)
Definition: fib_path.c:2079
A representation of a path as described by a route producer.
Definition: fib_types.h:455
#define BIER_N_ECMP_TABLES
The magic number of BIER ECMP tables to create.
Definition: bier_table.c:44
u8 * format_bier_table(u8 *s, va_list *ap)
Definition: bier_table.c:741
u16 bt_locks
Number of locks on the table.
Definition: bier_table.h:64
u8 * format_bier_table_id(u8 *s, va_list *ap)
Format a BIER table ID.
Definition: bier_types.c:193
index_t * bt_fmasks
f-masks in the ECMP table This is a vector sized to the appropriate number of entries given the table...
Definition: bier_table.h:86
enum bier_show_flags_t_ bier_show_flags_t
Flags to control show output.
static const char *const *const bier_table_nodes[DPO_PROTO_NUM]
Definition: bier_table.c:472
static index_t bier_table_get_index(const bier_table_t *bt)
Definition: bier_table.c:47
void bier_entry_delete(index_t bei)
Definition: bier_entry.c:77
#define NULL
Definition: clib.h:55
void bier_table_ecmp_unlock(index_t bti)
Definition: bier_table.c:426
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
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
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:520
index_t bier_entry_create(index_t bti, bier_bp_t bp)
Definition: bier_entry.c:62
void(* bier_table_ecmp_walk_fn_t)(index_t btei, void *ctx)
Types and functions to walk the ECMP tables of a main table.
Definition: bier_table.h:123
A path that resolves via a BIER [ECMP] Table.
Definition: fib_types.h:354
void fib_path_list_walk(fib_node_index_t path_list_index, fib_path_list_walk_fn_t func, void *ctx)
static const char *const bier_table_mpls_nodes[]
Definition: bier_table.c:467
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static void bier_table_insert(bier_table_t *bt, bier_bp_t bp, index_t bei)
Definition: bier_table.c:498
static bier_entry_t * bier_entry_get(index_t bei)
Definition: bier_entry.h:90
static bier_table_t * bier_table_get(index_t bti)
Definition: bier_table.h:154
bier_table_id_t frp_bier_tbl
A path that resolves via a BIER Table.
Definition: fib_types.h:516
The ID of a table.
Definition: bier_types.h:394
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
void bier_bift_table_entry_add(bier_bift_id_t id, const dpo_id_t *dpo)
static void bier_table_unlock_i(bier_table_t *bt)
Definition: bier_table.c:207
static uword * bier_tables_by_key
DB store of all BIER tables index by SD/set/hdr-len.
Definition: bier_table.c:37
static bier_table_t * bier_table_find(const bier_table_id_t *bti)
Definition: bier_table.c:274
void(* bier_tables_walk_fn_t)(const bier_table_t *bt, void *ctx)
Types and functions to walk all the BIER Tables.
Definition: bier_table.h:133
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 VLIB_INIT_FUNCTION(x)
Definition: init.h:111
bier_table_ecmp_id_t bti_ecmp
The SUB/ECMP-ID Constructed by FIB to achieve ECMP between BFR-NBRs.
Definition: bier_types.h:414
void bier_table_contribute_forwarding(index_t bti, dpo_id_t *dpo)
Definition: bier_table.c:628
int bier_table_is_main(const bier_table_t *bt)
Definition: bier_table.c:53
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
Aggregrate type for a prefix.
Definition: fib_types.h:188
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 void bier_table_dpo_unlock(dpo_id_t *dpo)
Definition: bier_table.c:437
static void bier_table_destroy(bier_table_t *bt)
Definition: bier_table.c:152
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1037
mpls_label_t bt_ll
Save the MPLS local label associated with the table.
Definition: bier_table.h:48
u32 bier_bp_t
A bit positon as assigned to egress PEs.
Definition: bier_types.h:294
index_t frp_bier_fmask
Resolving via a BIER Fmask.
Definition: fib_types.h:532
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
#define hash_get(h, key)
Definition: hash.h:248
static fib_path_list_walk_rc_t bier_table_ecmp_walk_path_list(fib_node_index_t pl_index, fib_node_index_t path_index, void *arg)
Definition: bier_table.c:658
Definition: fib_entry.h:274
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:419
From the BIER subsystem.
Definition: fib_entry.h:66
index_t bier_table_add_or_lock(const bier_table_id_t *btid, mpls_label_t local_label)
Definition: bier_table.c:333
static void bier_table_remove(bier_table_t *bt, bier_bp_t bp)
Definition: bier_table.c:506
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:273
static const index_t bier_table_fwd_lookup(const bier_table_t *bt, bier_bp_t bp)
Definition: bier_table.h:167
#define vec_del1(v, i)
Delete the element at index I.
Definition: vec.h:803
void fib_path_list_lock(fib_node_index_t path_list_index)
void bier_table_route_add(const bier_table_id_t *btid, bier_bp_t bp, fib_route_path_t *brps)
Definition: bier_table.c:513
bier_table_ecmp_walk_fn_t fn
Definition: bier_table.c:653
void fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
Definition: fib_table.c:1209
u8 * format_bier_table_entry(u8 *s, va_list *ap)
Definition: bier_table.c:706
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:188
int bier_entry_path_remove(index_t bei, const fib_route_path_t *rpaths)
Definition: bier_entry.c:234
#define MPLS_FIB_DEFAULT_TABLE_ID
Definition: mpls_fib.h:28
static u32 bier_table_mk_key(const bier_table_id_t *id)
Definition: bier_table.c:63
vlib_main_t * vm
Definition: buffer.c:294
void fib_table_entry_delete_index(fib_node_index_t fib_entry_index, fib_source_t source)
Delete a FIB entry.
Definition: fib_table.c:869
#define MPLS_LABEL_INVALID
Definition: mpls_types.h:48
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
static const index_t bier_table_lookup(const bier_table_t *bt, bier_bp_t bp)
Definition: bier_table.h:160
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:270
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
void fib_path_list_unlock(fib_node_index_t path_list_index)
void bier_table_walk(const bier_table_id_t *bti, bier_table_walk_fn_t fn, void *ctx)
Definition: bier_table.c:825
bier_table_t * bier_table_pool
Memory pool of all the allocated tables.
Definition: bier_table.c:32
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a &#39;special&#39; entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:299
fib_node_index_t bt_lfei
The index of the lfib entry created for this table.
Definition: bier_table.h:59
The BIER entry.
Definition: bier_entry.h:46
#define ASSERT(truth)
void bier_table_unlock(const bier_table_id_t *bti)
Definition: bier_table.c:218
static void bier_table_init(bier_table_t *bt, const bier_table_id_t *id, mpls_label_t ll)
Definition: bier_table.c:80
unsigned int u32
Definition: types.h:88
index_t * bt_entries
Entries in the table This is a vector sized to the appropriate number of entries given the table&#39;s su...
Definition: bier_table.h:71
static void bier_table_mk_lfib(bier_table_t *bt)
Definition: bier_table.c:233
const bier_table_id_t * bier_table_get_id(index_t bti)
Definition: bier_table.c:488
static void bier_table_lock_i(bier_table_t *bt)
Definition: bier_table.c:201
index_t bier_table_ecmp_create_and_lock(const bier_table_id_t *btid)
Definition: bier_table.c:420
static void bier_table_dpo_lock(dpo_id_t *dpo)
Definition: bier_table.c:432
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, fib_source_t src)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1096
fib_route_path_flags_t frp_flags
flags on the path
Definition: fib_types.h:547
u8 * format_bier_entry(u8 *s, va_list *ap)
Definition: bier_entry.c:306
fib_node_index_t bt_pl
The path-list used for the ECMP-tables.
Definition: bier_table.h:53
A path that resolves via a BIER F-Mask.
Definition: fib_types.h:350
format_function_t format_mpls_unicast_label
Definition: mpls.h:69
u64 uword
Definition: types.h:112
void(* bier_table_walk_fn_t)(const bier_table_t *bt, const bier_entry_t *be, void *ctx)
Types and functions to walk all the entries in one BIER Table.
Definition: bier_table.h:141
bier_table_id_t bt_id
The identity/key or the table.
Definition: bier_table.h:76
#define DPO_PROTO_NUM
Definition: dpo.h:70
enum fib_path_list_walk_rc_t_ fib_path_list_walk_rc_t
return code to control pat-hlist walk
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
A BIER Table is the bit-indexed forwarding table.
Definition: bier_table.h:38
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
void bier_table_show_all(vlib_main_t *vm, bier_show_flags_t flags)
Definition: bier_table.c:798
void bier_table_route_remove(const bier_table_id_t *btid, bier_bp_t bp, fib_route_path_t *brps)
Definition: bier_table.c:565
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:195
static clib_error_t * bier_table_module_init(vlib_main_t *vm)
Definition: bier_table.c:478
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_ECMP_TABLE_ID_MAIN
Definition of the ID of the BIER main table.
Definition: bier_types.h:389
static void bier_table_rm_bift(bier_table_t *bt)
Definition: bier_table.c:111
#define BIER_BP_TO_INDEX(bp)
Definition: bier_types.h:296
void bier_fmask_unlock(index_t bfmi)
Definition: bier_fmask.c:237
void bier_entry_path_add(index_t bei, const fib_route_path_t *rpaths)
Definition: bier_entry.c:164
void bier_bift_table_entry_remove(bier_bift_id_t id)
#define vec_validate_init_empty_aligned(V, I, INIT, A)
Make sure vector is long enough for given index and initialize empty space (no header, alignment alignment)
Definition: vec.h:496
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:231
#define vec_foreach(var, vec)
Vector iterator.
struct bier_table_ecmp_walk_ctx_t_ bier_table_ecmp_walk_ctx_t
void bier_table_ecmp_walk(index_t bti, bier_table_ecmp_walk_fn_t fn, void *ctx)
Definition: bier_table.c:670
void bier_table_ecmp_set_fmask(index_t bti, bier_bp_t bp, index_t bfmi)
Definition: bier_table.c:688
static u8 * format_bier_table_dpo(u8 *s, va_list *ap)
Definition: bier_table.c:450
#define pool_foreach_index(i, v, body)
Iterate pool by index.
Definition: pool.h:482
u32 flags
Definition: vhost-user.h:77
void bier_tables_walk(bier_tables_walk_fn_t fn, void *ctx)
Definition: bier_table.c:817
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
u32 bier_fmask_db_find(index_t bti, const fib_route_path_t *rpath)
Definition: bier_fmask_db.c:88
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
static void bier_table_rm_lfib(bier_table_t *bt)
Definition: bier_table.c:138
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
static void bier_table_dpo_mem_show(void)
Definition: bier_table.c:442
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128