2 *------------------------------------------------------------------
3 * bier_api.c - vnet BIER api
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:
10 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
20 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
23 #include <vnet/api_errno.h>
24 #include <vnet/bier/bier_table.h>
25 #include <vnet/bier/bier_imp.h>
26 #include <vnet/bier/bier_disp_table.h>
27 #include <vnet/bier/bier_disp_entry.h>
28 #include <vnet/bier/bier_bit_string.h>
29 #include <vnet/bier/bier_hdr_inlines.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>
35 #include <vnet/vnet_msg_enum.h>
37 #define vl_typedefs /* define message structures */
38 #include <vnet/vnet_all_api_h.h>
41 #define vl_endianfun /* define message structures */
42 #include <vnet/vnet_all_api_h.h>
45 /* instantiate all the print functions we know about */
46 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
48 #include <vnet/vnet_all_api_h.h>
51 #include <vlibapi/api_helper_macros.h>
52 #include <vnet/fib/fib_api.h>
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)
68 vl_api_bier_table_add_del_t_handler (vl_api_bier_table_add_del_t * mp)
70 vl_api_bier_table_add_del_reply_t *rmp;
74 vnm = vnet_get_main ();
77 if (mp->bt_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
79 rv = VNET_API_ERROR_BIER_BSL_UNSUP;
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,
93 mpls_label_t label = ntohl(mp->bt_label);
96 * convert acceptable 'don't want a label' values from
97 * the API to the correct internal INVLID value
99 if ((0 == label) || (~0 == label))
101 label = MPLS_LABEL_INVALID;
103 bier_table_add_or_lock(&bti, label);
107 bier_table_unlock(&bti);
113 REPLY_MACRO (VL_API_BIER_TABLE_ADD_DEL_REPLY);
117 send_bier_table_details (vl_api_registration_t * reg,
119 const bier_table_t *bt)
121 vl_api_bier_table_details_t *mp;
123 mp = vl_msg_api_alloc(sizeof(*mp));
126 clib_memset(mp, 0, sizeof(*mp));
127 mp->_vl_msg_id = ntohs(VL_API_BIER_TABLE_DETAILS);
128 mp->context = context;
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;
135 vl_api_send_msg (reg, (u8 *) mp);
139 vl_api_bier_table_dump_t_handler (vl_api_bier_table_dump_t * mp)
141 vl_api_registration_t *reg;
144 reg = vl_api_client_index_to_registration (mp->client_index);
148 pool_foreach(bt, bier_table_pool,
151 * skip the ecmp tables.
153 if (bier_table_is_main(bt))
155 send_bier_table_details(reg, mp->context, bt);
161 vl_api_bier_route_add_del_t_handler (vl_api_bier_route_add_del_t * mp)
163 vl_api_bier_route_add_del_reply_t *rmp;
164 fib_route_path_t *brpaths, *brpath;
170 vnm = vnet_get_main ();
172 bp = ntohl(mp->br_route.br_bp);
175 if (mp->br_route.br_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
177 rv = VNET_API_ERROR_BIER_BSL_UNSUP;
180 if (0 == bp || bp > BIER_BP_MAX)
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,
194 vec_validate(brpaths, mp->br_route.br_n_paths - 1);
196 vec_foreach_index(ii, brpaths)
198 brpath = &brpaths[ii];
199 rv = fib_api_path_decode(&mp->br_route.br_paths[ii], brpath);
207 if (mp->br_is_replace)
209 if (0 == vec_len(brpaths))
211 bier_table_route_delete(&bti, bp);
215 bier_table_route_path_update(&bti, bp, brpaths);
218 else if (mp->br_is_add)
220 bier_table_route_path_add(&bti, bp, brpaths);
224 bier_table_route_path_remove(&bti, bp, brpaths);
229 rv = (rv == 0) ? vnm->api_errno : rv;
231 REPLY_MACRO (VL_API_BIER_ROUTE_ADD_DEL_REPLY);
234 typedef struct bier_route_details_walk_t_
236 vl_api_registration_t * reg;
238 } bier_route_details_walk_t;
241 send_bier_route_details (const bier_table_t *bt,
242 const bier_entry_t *be,
245 bier_route_details_walk_t *ctx = args;
246 vl_api_bier_route_details_t *mp;
247 fib_path_encode_ctx_t path_ctx = {
250 fib_route_path_t *rpath;
251 vl_api_fib_path_t *fp;
254 n_paths = fib_path_list_get_n_paths(be->be_path_list);
255 m_size = sizeof(*mp) + (n_paths * sizeof(vl_api_fib_path_t));
256 mp = vl_msg_api_alloc(m_size);
260 clib_memset(mp, 0, m_size);
261 mp->_vl_msg_id = ntohs(VL_API_BIER_ROUTE_DETAILS);
262 mp->context = ctx->context;
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);
270 fib_path_list_walk_w_ext(be->be_path_list,
275 fp = mp->br_route.br_paths;
276 vec_foreach (rpath, path_ctx.rpaths)
278 fib_api_path_encode(rpath, fp);
282 vec_free(path_ctx.rpaths);
283 vl_api_send_msg (ctx->reg, (u8 *) mp);
287 vl_api_bier_route_dump_t_handler (vl_api_bier_route_dump_t * mp)
289 vl_api_registration_t *reg;
291 reg = vl_api_client_index_to_registration (mp->client_index);
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,
302 bier_route_details_walk_t ctx = {
304 .context = mp->context,
306 bier_table_walk(&bti, send_bier_route_details, &ctx);
310 vl_api_bier_imp_add_t_handler (vl_api_bier_imp_add_t * mp)
312 vl_api_bier_imp_add_reply_t *rmp;
317 vnm = vnet_get_main ();
321 * The BSL support by VPP is limited to the size of the
322 * available space in the vlib_buffer_t
324 if (mp->bi_tbl_id.bt_hdr_len_id >= BIER_HDR_LEN_2048)
326 rv = VNET_API_ERROR_BIER_BSL_UNSUP;
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,
337 bier_bit_string_t bs = {
338 .bbs_len = mp->bi_n_bytes,
339 .bbs_buckets = mp->bi_bytes,
342 bii = bier_imp_add_or_lock(&bti, ntohs(mp->bi_src), &bs);
345 REPLY_MACRO2 (VL_API_BIER_IMP_ADD_REPLY,
347 rmp->bi_index = ntohl (bii);
352 vl_api_bier_imp_del_t_handler (vl_api_bier_imp_del_t * mp)
354 vl_api_bier_imp_del_reply_t *rmp;
358 vnm = vnet_get_main ();
361 bier_imp_unlock(ntohl(mp->bi_index));
363 REPLY_MACRO(VL_API_BIER_IMP_DEL_REPLY);
367 send_bier_imp_details (vl_api_registration_t * reg,
369 const bier_imp_t *bi)
371 vl_api_bier_imp_details_t *mp;
376 bier_hdr_ntoh(©);
378 n_bytes = bier_hdr_len_id_to_num_bytes(
379 bier_hdr_get_len_id(©));
380 mp = vl_msg_api_alloc(sizeof(*mp) + n_bytes);
383 clib_memset(mp, 0, sizeof(*mp)+n_bytes);
384 mp->_vl_msg_id = ntohs(VL_API_BIER_IMP_DETAILS);
385 mp->context = context;
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;
391 mp->bi_src = htons(bier_hdr_get_src_id(©));
392 mp->bi_n_bytes = n_bytes;
393 memcpy(mp->bi_bytes, bi->bi_bits, n_bytes);
395 vl_api_send_msg (reg, (u8 *) mp);
399 vl_api_bier_imp_dump_t_handler (vl_api_bier_imp_dump_t * mp)
401 vl_api_registration_t *reg;
404 reg = vl_api_client_index_to_registration (mp->client_index);
408 pool_foreach(bi, bier_imp_pool,
410 send_bier_imp_details(reg, mp->context, bi);
415 vl_api_bier_disp_table_add_del_t_handler (vl_api_bier_disp_table_add_del_t * mp)
417 vl_api_bier_disp_table_add_del_reply_t *rmp;
422 vnm = vnet_get_main ();
424 table_id = ntohl(mp->bdt_tbl_id);
428 bier_disp_table_add_or_lock(table_id);
432 bier_disp_table_unlock_w_table_id(table_id);
437 REPLY_MACRO (VL_API_BIER_DISP_TABLE_ADD_DEL_REPLY);
441 send_bier_disp_table_details (vl_api_registration_t * reg,
443 const bier_disp_table_t *bdt)
445 vl_api_bier_disp_table_details_t *mp;
447 mp = vl_msg_api_alloc(sizeof(*mp));
450 clib_memset(mp, 0, sizeof(*mp));
451 mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_TABLE_DETAILS);
452 mp->context = context;
454 mp->bdt_tbl_id = htonl(bdt->bdt_table_id);
456 vl_api_send_msg (reg, (u8 *) mp);
460 vl_api_bier_disp_table_dump_t_handler (vl_api_bier_disp_table_dump_t * mp)
462 vl_api_registration_t *reg;
463 bier_disp_table_t *bdt;
465 reg = vl_api_client_index_to_registration (mp->client_index);
469 pool_foreach(bdt, bier_disp_table_pool,
471 send_bier_disp_table_details(reg, mp->context, bdt);
476 vl_api_bier_disp_entry_add_del_t_handler (vl_api_bier_disp_entry_add_del_t * mp)
478 vl_api_bier_disp_entry_add_del_reply_t *rmp;
479 fib_route_path_t *brps = NULL, *brp;
486 vnm = vnet_get_main ();
488 table_id = ntohl(mp->bde_tbl_id);
489 bp = ntohs(mp->bde_bp);
492 * BP=0 is the default route
500 vec_validate(brps, mp->bde_n_paths - 1);
501 vec_foreach_index(ii, brps)
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);
507 if (~0 != ntohl(mp->bde_paths[ii].rpf_id))
509 brp->frp_flags = FIB_ROUTE_PATH_RPF_ID;
510 brp->frp_rpf_id = ntohl(mp->bde_paths[ii].rpf_id);
513 if (FIB_API_PATH_NH_PROTO_IP4 == mp->bde_paths[ii].proto)
515 clib_memcpy (&brp->frp_addr.ip4,
516 &mp->bde_paths[ii].nh.address.ip4,
517 sizeof (brp->frp_addr.ip4));
519 else if (FIB_API_PATH_NH_PROTO_IP6 == mp->bde_paths[ii].proto)
521 clib_memcpy (&brp->frp_addr.ip6,
522 &mp->bde_paths[ii].nh.address.ip6,
523 sizeof (brp->frp_addr.ip6));
525 if (ip46_address_is_zero(&brp->frp_addr))
529 switch (mp->bde_payload_proto)
531 case BIER_HDR_PROTO_INVALID:
532 case BIER_HDR_PROTO_MPLS_DOWN_STREAM:
533 case BIER_HDR_PROTO_MPLS_UP_STREAM:
534 case BIER_HDR_PROTO_ETHERNET:
535 case BIER_HDR_PROTO_VXLAN:
536 case BIER_HDR_PROTO_CTRL:
537 case BIER_HDR_PROTO_OAM:
538 rv = VNET_API_ERROR_UNSUPPORTED;
541 case BIER_HDR_PROTO_IPV4:
542 case BIER_HDR_PROTO_IPV6:
544 fib_protocol_t fproto;
546 fproto = (mp->bde_payload_proto == BIER_HDR_PROTO_IPV4 ?
550 if (brp->frp_flags & FIB_ROUTE_PATH_RPF_ID)
552 fti = mfib_table_find (fproto,
553 ntohl (mp->bde_paths[ii].table_id));
557 fti = fib_table_find (fproto,
558 ntohl (mp->bde_paths[ii].table_id));
561 if (INDEX_INVALID != fti)
563 brp->frp_fib_index = fti;
567 rv = VNET_API_ERROR_NO_SUCH_FIB;
578 bier_disp_table_entry_path_add(table_id, bp,
579 mp->bde_payload_proto,
584 bier_disp_table_entry_path_remove(table_id, bp,
585 mp->bde_payload_proto,
591 rv = (rv == 0) ? vnm->api_errno : rv;
593 REPLY_MACRO (VL_API_BIER_DISP_ENTRY_ADD_DEL_REPLY);
596 typedef struct bier_disp_entry_details_walk_t_
598 vl_api_registration_t * reg;
600 } bier_disp_entry_details_walk_t;
603 send_bier_disp_entry_details (const bier_disp_table_t *bdt,
604 const bier_disp_entry_t *bde,
608 bier_disp_entry_details_walk_t *ctx = args;
609 vl_api_bier_disp_entry_details_t *mp;
610 bier_hdr_proto_id_t pproto;
611 vl_api_fib_path_t *fp;
614 FOR_EACH_BIER_HDR_PROTO(pproto)
616 fib_node_index_t pl = bde->bde_pl[pproto];
618 if (INDEX_INVALID != pl)
620 fib_path_encode_ctx_t path_ctx = {
623 fib_route_path_t *rpath;
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);
631 clib_memset(mp, 0, m_size);
632 mp->_vl_msg_id = ntohs(VL_API_BIER_DISP_ENTRY_DETAILS);
633 mp->context = ctx->context;
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);
640 fib_path_list_walk_w_ext(pl,
646 vec_foreach (rpath, path_ctx.rpaths)
648 fib_api_path_encode(rpath, fp);
652 vl_api_send_msg (ctx->reg, (u8 *) mp);
653 vec_free(path_ctx.rpaths);
659 vl_api_bier_disp_entry_dump_t_handler (vl_api_bier_disp_entry_dump_t * mp)
661 vl_api_registration_t *reg;
663 reg = vl_api_client_index_to_registration (mp->client_index);
667 bier_disp_entry_details_walk_t ctx = {
669 .context = mp->context,
671 bier_disp_table_walk(ntohl(mp->bde_tbl_id),
672 send_bier_disp_entry_details,
676 #define vl_msg_name_crc_list
677 #include <vnet/bier/bier.api.h>
678 #undef vl_msg_name_crc_list
681 setup_message_id_table (api_main_t * am)
683 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
684 foreach_vl_msg_name_crc_bier;
688 static clib_error_t *
689 bier_api_hookup (vlib_main_t * vm)
691 api_main_t *am = vlibapi_get_main();
694 vl_msg_api_set_handlers(VL_API_##N, #n, \
695 vl_api_##n##_t_handler, \
697 vl_api_##n##_t_endian, \
698 vl_api_##n##_t_print, \
699 sizeof(vl_api_##n##_t), 1);
700 foreach_bier_api_msg;
704 * Set up the (msg_name, crc, message-id) table
706 setup_message_id_table (am);
711 VLIB_API_INIT_FUNCTION (bier_api_hookup);