FD.io VPP  v21.01.1
Vector Packet Processing
bier_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * bier_api.c - vnet BIER api
4  *
5  * Copyright (c) 2016 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
22 
23 #include <vnet/api_errno.h>
24 #include <vnet/bier/bier_table.h>
25 #include <vnet/bier/bier_imp.h>
30 #include <vnet/fib/fib_path_list.h>
31 #include <vnet/fib/fib_api.h>
32 #include <vnet/fib/fib_table.h>
33 #include <vnet/mfib/mfib_table.h>
34 
35 #include <vnet/vnet_msg_enum.h>
36 
37 #define vl_typedefs /* define message structures */
38 #include <vnet/vnet_all_api_h.h>
39 #undef vl_typedefs
40 
41 #define vl_endianfun /* define message structures */
42 #include <vnet/vnet_all_api_h.h>
43 #undef vl_endianfun
44 
45 /* instantiate all the print functions we know about */
46 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
47 #define vl_printfun
48 #include <vnet/vnet_all_api_h.h>
49 #undef vl_printfun
50 
52 #include <vnet/fib/fib_api.h>
53 
54 #define foreach_bier_api_msg \
55  _(BIER_TABLE_ADD_DEL, bier_table_add_del) \
56  _(BIER_TABLE_DUMP, bier_table_dump) \
57  _(BIER_ROUTE_ADD_DEL, bier_route_add_del) \
58  _(BIER_ROUTE_DUMP, bier_route_dump) \
59  _(BIER_IMP_ADD, bier_imp_add) \
60  _(BIER_IMP_DEL, bier_imp_del) \
61  _(BIER_IMP_DUMP, bier_imp_dump) \
62  _(BIER_DISP_TABLE_ADD_DEL, bier_disp_table_add_del) \
63  _(BIER_DISP_TABLE_DUMP, bier_disp_table_dump) \
64  _(BIER_DISP_ENTRY_ADD_DEL, bier_disp_entry_add_del) \
65  _(BIER_DISP_ENTRY_DUMP, bier_disp_entry_dump)
66 
67 static void
69 {
70  vl_api_bier_table_add_del_reply_t *rmp;
71  vnet_main_t *vnm;
72  int rv;
73 
74  vnm = vnet_get_main ();
75  vnm->api_errno = 0;
76 
77  if (mp->bt_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
78  {
79  rv = VNET_API_ERROR_BIER_BSL_UNSUP;
80  }
81  else
82  {
83  bier_table_id_t bti = {
84  .bti_set = mp->bt_tbl_id.bt_set,
85  .bti_sub_domain = mp->bt_tbl_id.bt_sub_domain,
86  .bti_hdr_len = mp->bt_tbl_id.bt_hdr_len_id,
87  .bti_type = BIER_TABLE_MPLS_SPF,
88  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
89  };
90 
91  if (mp->bt_is_add)
92  {
93  mpls_label_t label = ntohl(mp->bt_label);
94 
95  /*
96  * convert acceptable 'don't want a label' values from
97  * the API to the correct internal INVLID value
98  */
99  if ((0 == label) || (~0 == label))
100  {
101  label = MPLS_LABEL_INVALID;
102  }
103  bier_table_add_or_lock(&bti, label);
104  }
105  else
106  {
107  bier_table_unlock(&bti);
108  }
109 
110  rv = vnm->api_errno;
111  }
112 
113  REPLY_MACRO (VL_API_BIER_TABLE_ADD_DEL_REPLY);
114 }
115 
116 static void
118  u32 context,
119  const bier_table_t *bt)
120 {
122 
123  mp = vl_msg_api_alloc(sizeof(*mp));
124  if (!mp)
125  return;
126  clib_memset(mp, 0, sizeof(*mp));
127  mp->_vl_msg_id = ntohs(VL_API_BIER_TABLE_DETAILS);
128  mp->context = context;
129 
130  mp->bt_label = bt->bt_ll;
131  mp->bt_tbl_id.bt_set = bt->bt_id.bti_set;
132  mp->bt_tbl_id.bt_sub_domain = bt->bt_id.bti_sub_domain;
133  mp->bt_tbl_id.bt_hdr_len_id = bt->bt_id.bti_hdr_len;
134 
135  vl_api_send_msg (reg, (u8 *) mp);
136 }
137 
138 static void
140 {
142  bier_table_t *bt;
143 
145  if (!reg)
146  return;
147 
149  {
150  /*
151  * skip the ecmp tables.
152  */
153  if (bier_table_is_main(bt))
154  {
155  send_bier_table_details(reg, mp->context, bt);
156  }
157  }
158 }
159 
160 static void
162 {
163  vl_api_bier_route_add_del_reply_t *rmp;
164  fib_route_path_t *brpaths, *brpath;
165  vnet_main_t *vnm;
166  bier_bp_t bp;
167  int rv = 0;
168  u8 ii;
169 
170  vnm = vnet_get_main ();
171  vnm->api_errno = 0;
172  bp = ntohl(mp->br_route.br_bp);
173  brpaths = NULL;
174 
175  if (mp->br_route.br_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
176  {
177  rv = VNET_API_ERROR_BIER_BSL_UNSUP;
178  goto done;
179  }
180  if (0 == bp || bp > BIER_BP_MAX)
181  {
182  rv = -1;
183  goto done;
184  }
185 
186  bier_table_id_t bti = {
187  .bti_set = mp->br_route.br_tbl_id.bt_set,
188  .bti_sub_domain = mp->br_route.br_tbl_id.bt_sub_domain,
189  .bti_hdr_len = mp->br_route.br_tbl_id.bt_hdr_len_id,
190  .bti_type = BIER_TABLE_MPLS_SPF,
191  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
192  };
193 
194  vec_validate(brpaths, mp->br_route.br_n_paths - 1);
195 
196  vec_foreach_index(ii, brpaths)
197  {
198  brpath = &brpaths[ii];
199  rv = fib_api_path_decode(&mp->br_route.br_paths[ii], brpath);
200 
201  if (0 != rv)
202  {
203  goto done;
204  }
205  }
206 
207  if (mp->br_is_replace)
208  {
209  if (0 == vec_len(brpaths))
210  {
211  bier_table_route_delete(&bti, bp);
212  }
213  else
214  {
215  bier_table_route_path_update(&bti, bp, brpaths);
216  }
217  }
218  else if (mp->br_is_add)
219  {
220  bier_table_route_path_add(&bti, bp, brpaths);
221  }
222  else
223  {
224  bier_table_route_path_remove(&bti, bp, brpaths);
225  }
226  vec_free(brpaths);
227 
228 done:
229  rv = (rv == 0) ? vnm->api_errno : rv;
230 
231  REPLY_MACRO (VL_API_BIER_ROUTE_ADD_DEL_REPLY);
232 }
233 
235 {
239 
240 static void
242  const bier_entry_t *be,
243  void *args)
244 {
247  fib_path_encode_ctx_t path_ctx = {
248  .rpaths = NULL,
249  };
250  fib_route_path_t *rpath;
251  vl_api_fib_path_t *fp;
252  u32 n_paths, m_size;
253 
255  m_size = sizeof(*mp) + (n_paths * sizeof(vl_api_fib_path_t));
256  mp = vl_msg_api_alloc(m_size);
257  if (!mp)
258  return;
259 
260  clib_memset(mp, 0, m_size);
261  mp->_vl_msg_id = ntohs(VL_API_BIER_ROUTE_DETAILS);
262  mp->context = ctx->context;
263 
264  mp->br_route.br_tbl_id.bt_set = bt->bt_id.bti_set;
265  mp->br_route.br_tbl_id.bt_sub_domain = bt->bt_id.bti_sub_domain;
266  mp->br_route.br_tbl_id.bt_hdr_len_id = bt->bt_id.bti_hdr_len;
267  mp->br_route.br_bp = htonl(be->be_bp);
268  mp->br_route.br_n_paths = htonl(n_paths);
269 
271  NULL,
273  &path_ctx);
274 
275  fp = mp->br_route.br_paths;
276  vec_foreach (rpath, path_ctx.rpaths)
277  {
278  fib_api_path_encode(rpath, fp);
279  fp++;
280  }
281 
282  vec_free(path_ctx.rpaths);
283  vl_api_send_msg (ctx->reg, (u8 *) mp);
284 }
285 
286 static void
288 {
290 
292  if (!reg)
293  return;
294 
295  bier_table_id_t bti = {
296  .bti_set = mp->br_tbl_id.bt_set,
297  .bti_sub_domain = mp->br_tbl_id.bt_sub_domain,
298  .bti_hdr_len = mp->br_tbl_id.bt_hdr_len_id,
299  .bti_type = BIER_TABLE_MPLS_SPF,
300  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
301  };
303  .reg = reg,
304  .context = mp->context,
305  };
307 }
308 
309 static void
311 {
313  vnet_main_t *vnm;
314  index_t bii = ~0;
315  int rv = 0;
316 
317  vnm = vnet_get_main ();
318  vnm->api_errno = 0;
319 
320  /*
321  * The BSL support by VPP is limited to the size of the
322  * available space in the vlib_buffer_t
323  */
324  if (mp->bi_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
325  {
326  rv = VNET_API_ERROR_BIER_BSL_UNSUP;
327  }
328  else
329  {
330  bier_table_id_t bti = {
331  .bti_set = mp->bi_tbl_id.bt_set,
332  .bti_sub_domain = mp->bi_tbl_id.bt_sub_domain,
333  .bti_hdr_len = mp->bi_tbl_id.bt_hdr_len_id,
334  .bti_type = BIER_TABLE_MPLS_SPF,
335  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
336  };
337  bier_bit_string_t bs = {
338  .bbs_len = mp->bi_n_bytes,
339  .bbs_buckets = mp->bi_bytes,
340  };
341 
342  bii = bier_imp_add_or_lock(&bti, ntohs(mp->bi_src), &bs);
343  }
344 
345  REPLY_MACRO2 (VL_API_BIER_IMP_ADD_REPLY,
346  ({
347  rmp->bi_index = ntohl (bii);
348  }));
349 }
350 
351 static void
353 {
354  vl_api_bier_imp_del_reply_t *rmp;
355  vnet_main_t *vnm;
356  int rv = 0;
357 
358  vnm = vnet_get_main ();
359  vnm->api_errno = 0;
360 
361  bier_imp_unlock(ntohl(mp->bi_index));
362 
363  REPLY_MACRO(VL_API_BIER_IMP_DEL_REPLY);
364 }
365 
366 static void
368  u32 context,
369  const bier_imp_t *bi)
370 {
372  bier_hdr_t copy;
373  u8 n_bytes;
374 
375  copy = bi->bi_hdr;
376  bier_hdr_ntoh(&copy);
377 
379  bier_hdr_get_len_id(&copy));
380  mp = vl_msg_api_alloc(sizeof(*mp) + n_bytes);
381  if (!mp)
382  return;
383  clib_memset(mp, 0, sizeof(*mp)+n_bytes);
384  mp->_vl_msg_id = ntohs(VL_API_BIER_IMP_DETAILS);
385  mp->context = context;
386 
387  mp->bi_tbl_id.bt_set = bi->bi_tbl.bti_set;
388  mp->bi_tbl_id.bt_sub_domain = bi->bi_tbl.bti_sub_domain;
389  mp->bi_tbl_id.bt_hdr_len_id = bi->bi_tbl.bti_hdr_len;
390 
391  mp->bi_src = htons(bier_hdr_get_src_id(&copy));
392  mp->bi_n_bytes = n_bytes;
393  memcpy(mp->bi_bytes, bi->bi_bits, n_bytes);
394 
395  vl_api_send_msg (reg, (u8 *) mp);
396 }
397 
398 static void
400 {
402  bier_imp_t *bi;
403 
405  if (!reg)
406  return;
407 
409  {
410  send_bier_imp_details(reg, mp->context, bi);
411  }
412 }
413 
414 static void
416 {
417  vl_api_bier_disp_table_add_del_reply_t *rmp;
418  vnet_main_t *vnm;
419  u32 table_id;
420  int rv;
421 
422  vnm = vnet_get_main ();
423  vnm->api_errno = 0;
424  table_id = ntohl(mp->bdt_tbl_id);
425 
426  if (mp->bdt_is_add)
427  {
428  bier_disp_table_add_or_lock(table_id);
429  }
430  else
431  {
433  }
434 
435  rv = vnm->api_errno;
436 
437  REPLY_MACRO (VL_API_BIER_DISP_TABLE_ADD_DEL_REPLY);
438 }
439 
440 static void
442  u32 context,
443  const bier_disp_table_t *bdt)
444 {
446 
447  mp = vl_msg_api_alloc(sizeof(*mp));
448  if (!mp)
449  return;
450  clib_memset(mp, 0, sizeof(*mp));
451  mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_TABLE_DETAILS);
452  mp->context = context;
453 
454  mp->bdt_tbl_id = htonl(bdt->bdt_table_id);
455 
456  vl_api_send_msg (reg, (u8 *) mp);
457 }
458 
459 static void
461 {
463  bier_disp_table_t *bdt;
464 
466  if (!reg)
467  return;
468 
470  {
471  send_bier_disp_table_details(reg, mp->context, bdt);
472  }
473 }
474 
475 static void
477 {
478  vl_api_bier_disp_entry_add_del_reply_t *rmp;
479  fib_route_path_t *brps = NULL, *brp;
480  vnet_main_t *vnm;
481  bier_bp_t bp;
482  u32 table_id;
483  int rv = 0;
484  u32 ii;
485 
486  vnm = vnet_get_main ();
487  vnm->api_errno = 0;
488  table_id = ntohl(mp->bde_tbl_id);
489  bp = ntohs(mp->bde_bp);
490 
491  /*
492  * BP=0 is the default route
493  */
494  if (bp > 0xffff)
495  {
496  rv = -1;
497  goto done;
498  }
499 
500  vec_validate(brps, mp->bde_n_paths - 1);
501  vec_foreach_index(ii, brps)
502  {
503  brp = &brps[ii];
504  brp->frp_fib_index = ntohl(mp->bde_paths[ii].table_id);
505  brp->frp_sw_if_index = ntohl(mp->bde_paths[ii].sw_if_index);
506 
507  if (~0 != ntohl(mp->bde_paths[ii].rpf_id))
508  {
509  brp->frp_flags = FIB_ROUTE_PATH_RPF_ID;
510  brp->frp_rpf_id = ntohl(mp->bde_paths[ii].rpf_id);
511  }
512 
513  if (FIB_API_PATH_NH_PROTO_IP4 == mp->bde_paths[ii].proto)
514  {
515  clib_memcpy (&brp->frp_addr.ip4,
516  &mp->bde_paths[ii].nh.address.ip4,
517  sizeof (brp->frp_addr.ip4));
518  }
519  else if (FIB_API_PATH_NH_PROTO_IP6 == mp->bde_paths[ii].proto)
520  {
521  clib_memcpy (&brp->frp_addr.ip6,
522  &mp->bde_paths[ii].nh.address.ip6,
523  sizeof (brp->frp_addr.ip6));
524  }
525  if (ip46_address_is_zero(&brp->frp_addr))
526  {
527  index_t fti;
528 
529  switch (mp->bde_payload_proto)
530  {
536  case BIER_HDR_PROTO_CTRL:
537  case BIER_HDR_PROTO_OAM:
538  rv = VNET_API_ERROR_UNSUPPORTED;
539  goto done;
540  break;
541  case BIER_HDR_PROTO_IPV4:
542  case BIER_HDR_PROTO_IPV6:
543  {
544  fib_protocol_t fproto;
545 
546  fproto = (mp->bde_payload_proto == BIER_HDR_PROTO_IPV4 ?
549 
550  if (brp->frp_flags & FIB_ROUTE_PATH_RPF_ID)
551  {
552  fti = mfib_table_find (fproto,
553  ntohl (mp->bde_paths[ii].table_id));
554  }
555  else
556  {
557  fti = fib_table_find (fproto,
558  ntohl (mp->bde_paths[ii].table_id));
559  }
560 
561  if (INDEX_INVALID != fti)
562  {
563  brp->frp_fib_index = fti;
564  }
565  else
566  {
567  rv = VNET_API_ERROR_NO_SUCH_FIB;
568  goto done;
569  }
570  break;
571  }
572  }
573  }
574  }
575 
576  if (mp->bde_is_add)
577  {
578  bier_disp_table_entry_path_add(table_id, bp,
579  mp->bde_payload_proto,
580  brps);
581  }
582  else
583  {
585  mp->bde_payload_proto,
586  brps);
587  }
588 
589 done:
590  vec_free(brps);
591  rv = (rv == 0) ? vnm->api_errno : rv;
592 
593  REPLY_MACRO (VL_API_BIER_DISP_ENTRY_ADD_DEL_REPLY);
594 }
595 
597 {
601 
602 static void
604  const bier_disp_entry_t *bde,
605  u16 bp,
606  void *args)
607 {
610  bier_hdr_proto_id_t pproto;
611  vl_api_fib_path_t *fp;
612  u32 n_paths, m_size;
613 
615  {
616  fib_node_index_t pl = bde->bde_pl[pproto];
617 
618  if (INDEX_INVALID != pl)
619  {
620  fib_path_encode_ctx_t path_ctx = {
621  .rpaths = NULL,
622  };
623  fib_route_path_t *rpath;
624 
625  n_paths = fib_path_list_get_n_paths(pl);
626  m_size = sizeof(*mp) + (n_paths * sizeof(vl_api_fib_path_t));
627  mp = vl_msg_api_alloc(m_size);
628  if (!mp)
629  return;
630 
631  clib_memset(mp, 0, m_size);
632  mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_ENTRY_DETAILS);
633  mp->context = ctx->context;
634 
635  mp->bde_tbl_id = htonl(bdt->bdt_table_id);
636  mp->bde_n_paths = htonl(n_paths);
637  mp->bde_payload_proto = pproto;
638  mp->bde_bp = htons(bp);
639 
641  NULL,
643  &path_ctx);
644 
645  fp = mp->bde_paths;
646  vec_foreach (rpath, path_ctx.rpaths)
647  {
648  fib_api_path_encode(rpath, fp);
649  fp++;
650  }
651 
652  vl_api_send_msg (ctx->reg, (u8 *) mp);
653  vec_free(path_ctx.rpaths);
654  }
655  }
656 }
657 
658 static void
660 {
662 
664  if (!reg)
665  return;
666 
668  .reg = reg,
669  .context = mp->context,
670  };
671  bier_disp_table_walk(ntohl(mp->bde_tbl_id),
673  &ctx);
674 }
675 
676 #define vl_msg_name_crc_list
677 #include <vnet/bier/bier.api.h>
678 #undef vl_msg_name_crc_list
679 
680 static void
682 {
683 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
684  foreach_vl_msg_name_crc_bier;
685 #undef _
686 }
687 
688 static clib_error_t *
690 {
692 
693 #define _(N,n) \
694  vl_msg_api_set_handlers(VL_API_##N, #n, \
695  vl_api_##n##_t_handler, \
696  vl_noop_handler, \
697  vl_api_##n##_t_endian, \
698  vl_api_##n##_t_print, \
699  sizeof(vl_api_##n##_t), 1);
701 #undef _
702 
703  /*
704  * Set up the (msg_name, crc, message-id) table
705  */
707 
708  return 0;
709 }
710 
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
static void vl_api_bier_imp_del_t_handler(vl_api_bier_imp_del_t *mp)
Definition: bier_api.c:352
#define vec_foreach_index(var, v)
Iterate over vector indices.
vl_api_bier_route_t br_route
Definition: bier.api:108
static bier_hdr_len_id_t bier_hdr_get_len_id(const bier_hdr_t *bier_hdr)
fib_node_index_t bde_pl[BIER_HDR_N_PROTO]
The path-lists used by per-payload protocol parents.
struct bier_route_details_walk_t_ bier_route_details_walk_t
vl_api_bier_table_id_t bt_tbl_id
Definition: bier.api:65
A representation of a path as described by a route producer.
Definition: fib_types.h:500
#define ntohs(x)
Definition: af_xdp.bpf.c:29
static void vl_api_bier_table_dump_t_handler(vl_api_bier_table_dump_t *mp)
Definition: bier_api.c:139
bool bde_is_add
Definition: bier.api:214
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static void vl_api_bier_table_add_del_t_handler(vl_api_bier_table_add_del_t *mp)
Definition: bier_api.c:68
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:527
Definition: bier_api.c:596
vl_api_bier_table_id_t bi_tbl_id
Definition: bier.api:125
void fib_api_path_encode(const fib_route_path_t *rpath, vl_api_fib_path_t *out)
Encode and decode functions from the API types to internal types.
Definition: fib_api.c:359
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
bier_disp_table_t * bier_disp_table_pool
memory pool for disposition tables
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
u32 bde_tbl_id
Definition: bier.api:213
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
static void setup_message_id_table(api_main_t *am)
Definition: bier_api.c:681
static void vl_api_bier_route_add_del_t_handler(vl_api_bier_route_add_del_t *mp)
Definition: bier_api.c:161
fib_node_index_t be_path_list
the FIB path-list this entry resolves through.
Definition: bier_entry.h:67
Reply for BIER route add / del request.
Definition: bier.api:136
u8 bi_bytes[bi_n_bytes]
Definition: bier.api:168
void bier_disp_table_entry_path_remove(u32 table_id, bier_bp_t src, bier_hdr_proto_id_t payload_proto, const fib_route_path_t *rpath)
vlib_main_t * vm
Definition: in2out_ed.c:1580
u32 bier_hdr_len_id_to_num_bytes(bier_hdr_len_id_t id)
Definition: bier_types.c:66
static void send_bier_route_details(const bier_table_t *bt, const bier_entry_t *be, void *args)
Definition: bier_api.c:241
The ID of a table.
Definition: bier_types.h:394
void bier_disp_table_entry_path_add(u32 table_id, bier_bp_t src, bier_hdr_proto_id_t payload_proto, const fib_route_path_t *rpaths)
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:26
void * vl_msg_api_alloc(int nbytes)
bier_bp_t be_bp
the bit position this entry represents.
Definition: bier_entry.h:61
bier_disposition : The BIER disposition object
unsigned char u8
Definition: types.h:56
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u16 bbs_len
The length of the string in BYTES.
Definition: bier_types.h:282
#define clib_memcpy(d, s, n)
Definition: string.h:180
u16 bde_bp
Definition: bier.api:212
A Variable length BitString.
Definition: bier_types.h:278
A local path with a RPF-ID => multicast traffic.
Definition: fib_types.h:365
VLIB_API_INIT_FUNCTION(bier_api_hookup)
bier_imposition : The BIER imposition object
Definition: bier_imp.h:34
u32 context
Definition: bier_api.c:599
int bier_table_is_main(const bier_table_t *bt)
Definition: bier_table.c:53
bier_hdr_t bi_hdr
The Header to impose.
Definition: bier_imp.h:50
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
static clib_error_t * bier_api_hookup(vlib_main_t *vm)
Definition: bier_api.c:689
void bier_table_route_path_remove(const bier_table_id_t *btid, bier_bp_t bp, fib_route_path_t *brps)
Definition: bier_table.c:658
vl_api_bier_table_id_t bi_tbl_id
Definition: bier.api:165
unsigned int u32
Definition: types.h:88
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:1106
#define foreach_bier_api_msg
Definition: bier_api.c:54
Definition: bier.api:227
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
static void vl_api_bier_imp_dump_t_handler(vl_api_bier_imp_dump_t *mp)
Definition: bier_api.c:399
BIER Imposition Del.
Definition: bier.api:149
u16 bde_bp
Definition: bier.api:230
vnet_api_error_t api_errno
Definition: vnet.h:90
Bit-string lengths greater than 1024 are not supported due to the limited about pf space available in...
Definition: bier_types.h:64
u32 context
Definition: bier.api:229
bier_hdr_len_id_t bti_hdr_len
The size of the bit string processed by this table.
Definition: bier_types.h:419
struct bier_disp_entry_details_walk_t_ bier_disp_entry_details_walk_t
static bier_hdr_src_id_t bier_hdr_get_src_id(const bier_hdr_t *bier_hdr)
static u8 ip46_address_is_zero(const ip46_address_t *ip46)
Definition: ip46_address.h:87
long ctx[MAX_CONNS]
Definition: main.c:144
unsigned short u16
Definition: types.h:57
index_t bier_table_add_or_lock(const bier_table_id_t *btid, mpls_label_t local_label)
Definition: bier_table.c:397
BIER Imposition Add.
Definition: bier.api:121
vl_api_registration_t * reg
Definition: bier_api.c:236
#define REPLY_MACRO(t)
static void send_bier_imp_details(vl_api_registration_t *reg, u32 context, const bier_imp_t *bi)
Definition: bier_api.c:367
BIER Table Add / del route.
Definition: bier.api:46
vl_api_fib_path_t bde_paths[bde_n_paths]
Definition: bier.api:217
u32 label
Definition: fib_types.api:25
index_t bier_imp_add_or_lock(const bier_table_id_t *bti, bier_bp_t sender, const bier_bit_string_t *bs)
Definition: bier_imp.c:60
static void vl_api_bier_route_dump_t_handler(vl_api_bier_route_dump_t *mp)
Definition: bier_api.c:287
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:227
BIER Disposition Table Add / del route.
Definition: bier.api:176
static void vl_api_bier_disp_entry_dump_t_handler(vl_api_bier_disp_entry_dump_t *mp)
Definition: bier_api.c:659
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
static void vl_api_bier_disp_table_dump_t_handler(vl_api_bier_disp_table_dump_t *mp)
Definition: bier_api.c:460
static void vl_api_bier_imp_add_t_handler(vl_api_bier_imp_add_t *mp)
Definition: bier_api.c:310
bier_imp_t * bier_imp_pool
bier_imposition : The BIER imposition object
Definition: bier_imp.c:33
#define MPLS_LABEL_INVALID
Definition: mpls_types.h:48
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
vl_api_bier_route_t br_route
Definition: bier.api:95
u8 n_paths
Definition: ip.api:145
static void send_bier_disp_entry_details(const bier_disp_table_t *bdt, const bier_disp_entry_t *bde, u16 bp, void *args)
Definition: bier_api.c:603
u32 fib_path_list_get_n_paths(fib_node_index_t path_list_index)
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
enum bier_hdr_proto_id_t_ bier_hdr_proto_id_t
BIER header protocol payload types.
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
u8 bde_payload_proto
Definition: bier.api:233
void bier_table_walk(const bier_table_id_t *bti, bier_table_walk_fn_t fn, void *ctx)
Definition: bier_table.c:928
bier_table_t * bier_table_pool
Memory pool of all the allocated tables.
Definition: bier_table.c:32
The BIER entry.
Definition: bier_entry.h:46
void bier_table_unlock(const bier_table_id_t *bti)
Definition: bier_table.c:218
vl_api_fib_path_t bde_paths[bde_n_paths]
Definition: bier.api:235
static void send_bier_table_details(vl_api_registration_t *reg, u32 context, const bier_table_t *bt)
Definition: bier_api.c:117
u8 bde_payload_proto
Definition: bier.api:215
void bier_table_route_delete(const bier_table_id_t *btid, bier_bp_t bp)
Definition: bier_table.c:633
#define FOR_EACH_BIER_HDR_PROTO(_proto)
Definition: bier_types.h:206
int fib_api_path_decode(vl_api_fib_path_t *in, fib_route_path_t *out)
Definition: fib_api.c:151
Path encode context to use when walking a path-list to encode paths.
Definition: fib_path.h:219
u32 bde_tbl_id
Definition: bier.api:224
u32 context
Definition: bier.api:223
vl_api_bier_table_id_t br_tbl_id
Definition: bier.api:102
#define BIER_BP_MAX
The maximum BP that can be assigned.
Definition: bier_types.h:301
fib_route_path_t * rpaths
Definition: fib_path.h:221
vl_api_registration_t * reg
Definition: bier_api.c:598
BIER Disposition Entry Add / del.
Definition: bier.api:208
bier_table_id_t bt_id
The identity/key or the table.
Definition: bier_table.h:76
u8 bi_bits[BIER_HDR_BUCKETS_1024]
The bit string.
Definition: bier_imp.h:58
static void vl_api_bier_disp_table_add_del_t_handler(vl_api_bier_disp_table_add_del_t *mp)
Definition: bier_api.c:415
A BIER header of variable length The encoding follows: https://tools.ietf.org/html/draft-ietf-bier-mp...
Definition: bier_types.h:321
void bier_disp_table_unlock_w_table_id(u32 table_id)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 client_index
Definition: bier.api:222
void bier_table_route_path_add(const bier_table_id_t *btid, bier_bp_t bp, fib_route_path_t *brps)
Definition: bier_table.c:625
#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
u32 mfib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: mfib_table.c:555
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 bi_bytes[bi_n_bytes]
Definition: bier.api:128
static void send_bier_disp_table_details(vl_api_registration_t *reg, u32 context, const bier_disp_table_t *bdt)
Definition: bier_api.c:441
A protocol Independent IP multicast FIB table.
u32 table_id
Definition: wireguard.api:102
vl_api_bier_table_id_t bt_tbl_id
Definition: bier.api:50
#define BIER_ECMP_TABLE_ID_MAIN
Definition of the ID of the BIER main table.
Definition: bier_types.h:389
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:389
static void vl_api_bier_disp_entry_add_del_t_handler(vl_api_bier_disp_entry_add_del_t *mp)
Definition: bier_api.c:476
u8 bde_n_paths
Definition: bier.api:216
bier_table_id_t bi_tbl
The BIER table into which to forward the post imposed packet.
Definition: bier_imp.h:63
#define vec_foreach(var, vec)
Vector iterator.
void bier_disp_table_walk(u32 table_id, bier_disp_table_walk_fn_t fn, void *ctx)
void fib_path_list_walk_w_ext(fib_node_index_t path_list_index, const fib_path_ext_list_t *ext_list, fib_path_list_walk_w_ext_fn_t func, void *ctx)
Definition: bier.api:220
void bier_imp_unlock(index_t bii)
Definition: bier_imp.c:110
u32 frp_fib_index
The FIB index to lookup the nexthop Only valid for recursive paths.
Definition: fib_types.h:556
static void bier_hdr_ntoh(bier_hdr_t *bier_hdr)
void bier_table_route_path_update(const bier_table_id_t *btid, bier_bp_t bp, fib_route_path_t *brps)
Definition: bier_table.c:618
BIER over MPLS with SPF.
Definition: bier_types.h:37
fib_path_list_walk_rc_t fib_path_encode(fib_node_index_t path_list_index, fib_node_index_t path_index, const fib_path_ext_t *path_ext, void *args)
Definition: fib_path.c:2693
u32 bdt_table_id
Table ID (hash key) for this FIB.
u8 bde_n_paths
Definition: bier.api:234
u32 bde_tbl_id
Definition: bier.api:231
index_t bier_disp_table_add_or_lock(u32 table_id)