FD.io VPP  v19.04.4-rc0-5-ge88582fac
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 
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;
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_bp);
173  brpaths = NULL;
174 
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_tbl_id.bt_set,
188  .bti_sub_domain = mp->br_tbl_id.bt_sub_domain,
189  .bti_hdr_len = mp->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_n_paths - 1);
195 
196  vec_foreach_index(ii, brpaths)
197  {
198  brpath = &brpaths[ii];
199  rv = fib_path_api_parse(&mp->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 {
245  fib_route_path_encode_t *api_rpaths = NULL, *api_rpath;
248  vl_api_fib_path_t *fp;
249  u32 n_paths, m_size;
250 
252  m_size = sizeof(*mp) + (n_paths * sizeof(vl_api_fib_path_t));
253  mp = vl_msg_api_alloc(m_size);
254  if (!mp)
255  return;
256 
257  clib_memset(mp, 0, m_size);
258  mp->_vl_msg_id = ntohs(VL_API_BIER_ROUTE_DETAILS);
259  mp->context = ctx->context;
260 
261  mp->br_tbl_id.bt_set = bt->bt_id.bti_set;
264  mp->br_bp = htons(be->be_bp);
265  mp->br_n_paths = htonl(n_paths);
266 
268  NULL,
270  &api_rpaths);
271 
272  fp = mp->br_paths;
273  vec_foreach (api_rpath, api_rpaths)
274  {
275  fib_api_path_encode(api_rpath, fp);
276  fp++;
277  }
278 
279  vl_api_send_msg (ctx->reg, (u8 *) mp);
280 }
281 
282 static void
284 {
286 
288  if (!reg)
289  return;
290 
291  bier_table_id_t bti = {
292  .bti_set = mp->br_tbl_id.bt_set,
293  .bti_sub_domain = mp->br_tbl_id.bt_sub_domain,
294  .bti_hdr_len = mp->br_tbl_id.bt_hdr_len_id,
295  .bti_type = BIER_TABLE_MPLS_SPF,
296  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
297  };
299  .reg = reg,
300  .context = mp->context,
301  };
303 }
304 
305 static void
307 {
309  vnet_main_t *vnm;
310  index_t bii = ~0;
311  int rv = 0;
312 
313  vnm = vnet_get_main ();
314  vnm->api_errno = 0;
315 
316  /*
317  * The BSL support by VPP is limited to the size of the
318  * available space in the vlib_buffer_t
319  */
321  {
322  rv = VNET_API_ERROR_BIER_BSL_UNSUP;
323  }
324  else
325  {
326  bier_table_id_t bti = {
327  .bti_set = mp->bi_tbl_id.bt_set,
328  .bti_sub_domain = mp->bi_tbl_id.bt_sub_domain,
329  .bti_hdr_len = mp->bi_tbl_id.bt_hdr_len_id,
330  .bti_type = BIER_TABLE_MPLS_SPF,
331  .bti_ecmp = BIER_ECMP_TABLE_ID_MAIN,
332  };
333  bier_bit_string_t bs = {
334  .bbs_len = mp->bi_n_bytes,
335  .bbs_buckets = mp->bi_bytes,
336  };
337 
338  bii = bier_imp_add_or_lock(&bti, ntohs(mp->bi_src), &bs);
339  }
340 
341  REPLY_MACRO2 (VL_API_BIER_IMP_ADD_REPLY,
342  ({
343  rmp->bi_index = ntohl (bii);
344  }));
345 }
346 
347 static void
349 {
350  vl_api_bier_imp_del_reply_t *rmp;
351  vnet_main_t *vnm;
352  int rv = 0;
353 
354  vnm = vnet_get_main ();
355  vnm->api_errno = 0;
356 
357  bier_imp_unlock(ntohl(mp->bi_index));
358 
359  REPLY_MACRO(VL_API_BIER_IMP_DEL_REPLY);
360 }
361 
362 static void
364  u32 context,
365  const bier_imp_t *bi)
366 {
368  bier_hdr_t copy;
369  u8 n_bytes;
370 
371  copy = bi->bi_hdr;
372  bier_hdr_ntoh(&copy);
373 
375  bier_hdr_get_len_id(&copy));
376  mp = vl_msg_api_alloc(sizeof(*mp) + n_bytes);
377  if (!mp)
378  return;
379  clib_memset(mp, 0, sizeof(*mp)+n_bytes);
380  mp->_vl_msg_id = ntohs(VL_API_BIER_IMP_DETAILS);
381  mp->context = context;
382 
383  mp->bi_tbl_id.bt_set = bi->bi_tbl.bti_set;
386 
387  mp->bi_src = htons(bier_hdr_get_src_id(&copy));
388  mp->bi_n_bytes = n_bytes;
389  memcpy(mp->bi_bytes, bi->bi_bits, n_bytes);
390 
391  vl_api_send_msg (reg, (u8 *) mp);
392 }
393 
394 static void
396 {
398  bier_imp_t *bi;
399 
401  if (!reg)
402  return;
403 
405  ({
406  send_bier_imp_details(reg, mp->context, bi);
407  }));
408 }
409 
410 static void
412 {
413  vl_api_bier_disp_table_add_del_reply_t *rmp;
414  vnet_main_t *vnm;
415  u32 table_id;
416  int rv;
417 
418  vnm = vnet_get_main ();
419  vnm->api_errno = 0;
420  table_id = ntohl(mp->bdt_tbl_id);
421 
422  if (mp->bdt_is_add)
423  {
424  bier_disp_table_add_or_lock(table_id);
425  }
426  else
427  {
429  }
430 
431  rv = vnm->api_errno;
432 
433  REPLY_MACRO (VL_API_BIER_DISP_TABLE_ADD_DEL_REPLY);
434 }
435 
436 static void
438  u32 context,
439  const bier_disp_table_t *bdt)
440 {
442 
443  mp = vl_msg_api_alloc(sizeof(*mp));
444  if (!mp)
445  return;
446  clib_memset(mp, 0, sizeof(*mp));
447  mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_TABLE_DETAILS);
448  mp->context = context;
449 
450  mp->bdt_tbl_id = htonl(bdt->bdt_table_id);
451 
452  vl_api_send_msg (reg, (u8 *) mp);
453 }
454 
455 static void
457 {
459  bier_disp_table_t *bdt;
460 
462  if (!reg)
463  return;
464 
466  ({
467  send_bier_disp_table_details(reg, mp->context, bdt);
468  }));
469 }
470 
471 static void
473 {
474  vl_api_bier_disp_entry_add_del_reply_t *rmp;
475  fib_route_path_t *brps = NULL, *brp;
476  vnet_main_t *vnm;
477  bier_bp_t bp;
478  u32 table_id;
479  int rv = 0;
480  u32 ii;
481 
482  vnm = vnet_get_main ();
483  vnm->api_errno = 0;
484  table_id = ntohl(mp->bde_tbl_id);
485  bp = ntohs(mp->bde_bp);
486 
487  /*
488  * BP=0 is the default route
489  */
490  if (bp > 0xffff)
491  {
492  rv = -1;
493  goto done;
494  }
495 
496  vec_validate(brps, mp->bde_n_paths - 1);
497  vec_foreach_index(ii, brps)
498  {
499  brp = &brps[ii];
500  brp->frp_fib_index = ntohl(mp->bde_paths[ii].table_id);
501  brp->frp_sw_if_index = ntohl(mp->bde_paths[ii].sw_if_index);
502 
503  if (~0 != ntohl(mp->bde_paths[ii].rpf_id))
504  {
505  brp->frp_flags = FIB_ROUTE_PATH_RPF_ID;
506  brp->frp_rpf_id = ntohl(mp->bde_paths[ii].rpf_id);
507  }
508 
509  if (0 == mp->bde_paths[ii].afi)
510  {
511  clib_memcpy_fast (&brp->frp_addr.ip4,
512  mp->bde_paths[ii].next_hop,
513  sizeof (brp->frp_addr.ip4));
514  }
515  else
516  {
517  clib_memcpy_fast (&brp->frp_addr.ip6,
518  mp->bde_paths[ii].next_hop,
519  sizeof (brp->frp_addr.ip6));
520  }
521  if (ip46_address_is_zero(&brp->frp_addr))
522  {
523  index_t fti;
524 
525  switch (mp->bde_payload_proto)
526  {
532  case BIER_HDR_PROTO_CTRL:
533  case BIER_HDR_PROTO_OAM:
534  rv = VNET_API_ERROR_UNSUPPORTED;
535  goto done;
536  break;
537  case BIER_HDR_PROTO_IPV4:
538  case BIER_HDR_PROTO_IPV6:
539  {
540  fib_protocol_t fproto;
541 
542  fproto = (mp->bde_payload_proto == BIER_HDR_PROTO_IPV4 ?
545 
546  if (brp->frp_flags & FIB_ROUTE_PATH_RPF_ID)
547  {
548  fti = mfib_table_find (fproto,
549  ntohl (mp->bde_paths[ii].table_id));
550  }
551  else
552  {
553  fti = fib_table_find (fproto,
554  ntohl (mp->bde_paths[ii].table_id));
555  }
556 
557  if (INDEX_INVALID != fti)
558  {
559  brp->frp_fib_index = fti;
560  }
561  else
562  {
563  rv = VNET_API_ERROR_NO_SUCH_FIB;
564  goto done;
565  }
566  break;
567  }
568  }
569  }
570  }
571 
572  if (mp->bde_is_add)
573  {
574  bier_disp_table_entry_path_add(table_id, bp,
575  mp->bde_payload_proto,
576  brps);
577  }
578  else
579  {
581  mp->bde_payload_proto,
582  brps);
583  }
584 
585 done:
586  vec_free(brps);
587  rv = (rv == 0) ? vnm->api_errno : rv;
588 
589  REPLY_MACRO (VL_API_BIER_DISP_ENTRY_ADD_DEL_REPLY);
590 }
591 
593 {
597 
598 static void
600  const bier_disp_entry_t *bde,
601  u16 bp,
602  void *args)
603 {
604  fib_route_path_encode_t *api_rpaths = NULL, *api_rpath;
607  bier_hdr_proto_id_t pproto;
608  vl_api_fib_path_t *fp;
609  u32 n_paths, m_size;
610 
612  {
613  fib_node_index_t pl = bde->bde_pl[pproto];
614  if (INDEX_INVALID != pl)
615  {
616  n_paths = fib_path_list_get_n_paths(pl);
617  m_size = sizeof(*mp) + (n_paths * sizeof(vl_api_fib_path_t));
618  mp = vl_msg_api_alloc(m_size);
619  if (!mp)
620  return;
621 
622  clib_memset(mp, 0, m_size);
623  mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_ENTRY_DETAILS);
624  mp->context = ctx->context;
625 
626  mp->bde_tbl_id = htonl(bdt->bdt_table_id);
627  mp->bde_n_paths = htonl(n_paths);
628  mp->bde_payload_proto = pproto;
629  mp->bde_bp = htons(bp);
630 
632  NULL,
634  &api_rpaths);
635 
636  fp = mp->bde_paths;
637  vec_foreach (api_rpath, api_rpaths)
638  {
639  fib_api_path_encode(api_rpath, fp);
640  fp++;
641  }
642 
643  vl_api_send_msg (ctx->reg, (u8 *) mp);
644  }
645  }
646 }
647 
648 static void
650 {
652 
654  if (!reg)
655  return;
656 
658  .reg = reg,
659  .context = mp->context,
660  };
661  bier_disp_table_walk(ntohl(mp->bde_tbl_id),
663  &ctx);
664 }
665 
666 #define vl_msg_name_crc_list
667 #include <vnet/bier/bier.api.h>
668 #undef vl_msg_name_crc_list
669 
670 static void
672 {
673 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
674  foreach_vl_msg_name_crc_bier;
675 #undef _
676 }
677 
678 static clib_error_t *
680 {
681  api_main_t *am = &api_main;
682 
683 #define _(N,n) \
684  vl_msg_api_set_handlers(VL_API_##N, #n, \
685  vl_api_##n##_t_handler, \
686  vl_noop_handler, \
687  vl_api_##n##_t_endian, \
688  vl_api_##n##_t_print, \
689  sizeof(vl_api_##n##_t), 1);
691 #undef _
692 
693  /*
694  * Set up the (msg_name, crc, message-id) table
695  */
697 
698  return 0;
699 }
700 
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
static void vl_api_bier_imp_del_t_handler(vl_api_bier_imp_del_t *mp)
Definition: bier_api.c:348
#define vec_foreach_index(var, v)
Iterate over vector indices.
A representation of a fib path for fib_path_encode to convey the information to the caller...
Definition: fib_types.h:594
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:64
A representation of a path as described by a route producer.
Definition: fib_types.h:476
vl_api_fib_path_t br_paths[br_n_paths]
Definition: bier.api:89
static void vl_api_bier_table_dump_t_handler(vl_api_bier_table_dump_t *mp)
Definition: bier_api.c:139
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
static void vl_api_bier_table_add_del_t_handler(vl_api_bier_table_add_del_t *mp)
Definition: bier_api.c:68
Definition: bier_api.c:592
vl_api_bier_table_id_t bi_tbl_id
Definition: bier.api:122
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
#define REPLY_MACRO2(t, body)
#define NULL
Definition: clib.h:58
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:34
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
u32 bde_tbl_id
Definition: bier.api:210
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:671
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:133
u8 bi_bytes[bi_n_bytes]
Definition: bier.api:165
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)
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)
void * vl_msg_api_alloc(int nbytes)
vl_api_bier_table_id_t br_tbl_id
Definition: bier.api:87
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
u16 bde_bp
Definition: bier.api:209
A Variable length BitString.
Definition: bier_types.h:278
A local path with a RPF-ID => multicast traffic.
Definition: fib_types.h:359
VLIB_API_INIT_FUNCTION(bier_api_hookup)
bier_imposition : The BIER imposition object
Definition: bier_imp.h:34
u32 context
Definition: bier_api.c:595
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
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:679
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:162
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:1064
#define foreach_bier_api_msg
Definition: bier_api.c:54
Definition: bier.api:224
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:395
BIER Imposition Del.
Definition: bier.api:146
u16 bde_bp
Definition: bier.api:227
vnet_api_error_t api_errno
Definition: vnet.h:78
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:226
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)
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:118
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:363
BIER Table Add / del route.
Definition: bier.api:45
vl_api_fib_path_t bde_paths[bde_n_paths]
Definition: bier.api:214
vl_api_bier_table_id_t br_tbl_id
Definition: bier.api:103
vl_api_fib_path_t br_paths[br_n_paths]
Definition: bier.api:105
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:283
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:202
BIER Disposition Table Add / del route.
Definition: bier.api:173
static void vl_api_bier_disp_entry_dump_t_handler(vl_api_bier_disp_entry_dump_t *mp)
Definition: bier_api.c:649
An API client registration, only in vpp/vlib.
Definition: api_common.h:45
static void vl_api_bier_disp_table_dump_t_handler(vl_api_bier_disp_table_dump_t *mp)
Definition: bier_api.c:456
vlib_main_t * vm
Definition: buffer.c:312
static void vl_api_bier_imp_add_t_handler(vl_api_bier_imp_add_t *mp)
Definition: bier_api.c:306
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:341
u32 context
Definition: ipsec_gre.api:33
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:599
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:30
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:56
u8 bde_payload_proto
Definition: bier.api:230
void bier_table_walk(const bier_table_id_t *bti, bier_table_walk_fn_t fn, void *ctx)
Definition: bier_table.c:925
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:232
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:212
void bier_table_route_delete(const bier_table_id_t *btid, bier_bp_t bp)
Definition: bier_table.c:633
FIB path.
Definition: fib_types.api:47
#define FOR_EACH_BIER_HDR_PROTO(_proto)
Definition: bier_types.h:206
u32 bde_tbl_id
Definition: bier.api:221
void fib_api_path_encode(const fib_route_path_encode_t *api_rpath, vl_api_fib_path_t *out)
Definition: fib_api.c:218
u32 context
Definition: bier.api:220
vl_api_bier_table_id_t br_tbl_id
Definition: bier.api:96
#define BIER_BP_MAX
The maximum BP that can be assigned.
Definition: bier_types.h:301
vl_api_registration_t * reg
Definition: bier_api.c:594
BIER Disposition Entry Add / del.
Definition: bier.api:205
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:411
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:219
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:504
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:125
static void send_bier_disp_table_details(vl_api_registration_t *reg, u32 context, const bier_disp_table_t *bdt)
Definition: bier_api.c:437
A protocol Independent IP multicast FIB table.
vl_api_bier_table_id_t bt_tbl_id
Definition: bier.api:49
#define BIER_ECMP_TABLE_ID_MAIN
Definition of the ID of the BIER main table.
Definition: bier_types.h:389
u8 bde_is_add
Definition: bier.api:211
int fib_path_api_parse(const vl_api_fib_path_t *in, fib_route_path_t *out)
Definition: fib_api.c:43
static void vl_api_bier_disp_entry_add_del_t_handler(vl_api_bier_disp_entry_add_del_t *mp)
Definition: bier_api.c:472
u8 bde_n_paths
Definition: bier.api:213
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.
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 *ctx)
Definition: fib_path.c:2627
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:217
#define ip46_address_is_zero(ip46)
Definition: ip6_packet.h:93
api_main_t api_main
Definition: api_shared.c:35
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:522
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
BIER Route Add / del route.
Definition: bier.api:80
u32 bdt_table_id
Table ID (hash key) for this FIB.
u8 bde_n_paths
Definition: bier.api:231
u32 bde_tbl_id
Definition: bier.api:228
index_t bier_disp_table_add_or_lock(u32 table_id)