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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vnet/fib/fib_test.h>
17 #include <vnet/fib/ip6_fib.h>
18 #include <vnet/fib/ip4_fib.h>
19 #include <vnet/fib/mpls_fib.h>
20 #include <vnet/adj/adj.h>
21 #include <vnet/dpo/load_balance.h>
22 #include <vnet/dpo/load_balance_map.h>
23 #include <vnet/dpo/mpls_label_dpo.h>
24 #include <vnet/dpo/lookup_dpo.h>
25 #include <vnet/dpo/drop_dpo.h>
26 #include <vnet/dpo/receive_dpo.h>
27 #include <vnet/dpo/ip_null_dpo.h>
28 #include <vnet/bfd/bfd_main.h>
29 #include <vnet/dpo/interface_rx_dpo.h>
30 #include <vnet/dpo/replicate_dpo.h>
31 #include <vnet/dpo/l2_bridge_dpo.h>
32 #include <vnet/dpo/mpls_disposition.h>
34 #include <vnet/mpls/mpls.h>
36 #include <vnet/fib/fib_test.h>
37 #include <vnet/fib/fib_path_list.h>
38 #include <vnet/fib/fib_entry_src.h>
39 #include <vnet/fib/fib_walk.h>
40 #include <vnet/fib/fib_node_list.h>
41 #include <vnet/fib/fib_urpf_list.h>
44 * Add debugs for passing tests
46 static int fib_test_do_debug;
48 #define FIB_TEST_I(_cond, _comment, _args...) \
50 int _evald = (_cond); \
52 fformat(stderr, "FAIL:%d: " _comment "\n", \
55 if (fib_test_do_debug) \
56 fformat(stderr, "PASS:%d: " _comment "\n", \
61 #define FIB_TEST(_cond, _comment, _args...) \
63 if (!FIB_TEST_I(_cond, _comment, ##_args)) { \
65 ASSERT(!("FAIL: " _comment)); \
70 * A 'i'm not fussed is this is not efficient' store of test data
72 typedef struct test_main_t_ {
76 u32 hw_if_indicies[4];
80 vnet_hw_interface_t * hw[4];
83 static test_main_t test_main;
85 /* fake ethernet device class, distinct from "fake-ethX" */
86 static u8 * format_test_interface_name (u8 * s, va_list * args)
88 u32 dev_instance = va_arg (*args, u32);
89 return format (s, "test-eth%d", dev_instance);
92 static uword dummy_interface_tx (vlib_main_t * vm,
93 vlib_node_runtime_t * node,
96 clib_warning ("you shouldn't be here, leaking buffers...");
97 return frame->n_vectors;
100 static clib_error_t *
101 test_interface_admin_up_down (vnet_main_t * vnm,
105 u32 hw_flags = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
106 VNET_HW_INTERFACE_FLAG_LINK_UP : 0;
107 vnet_hw_interface_set_flags (vnm, hw_if_index, hw_flags);
111 VNET_DEVICE_CLASS (test_interface_device_class,static) = {
112 .name = "Test interface",
113 .format_device_name = format_test_interface_name,
114 .tx_function = dummy_interface_tx,
115 .admin_up_down_function = test_interface_admin_up_down,
118 static u8 *hw_address;
121 fib_test_mk_intf (u32 ninterfaces)
123 clib_error_t * error = NULL;
124 test_main_t *tm = &test_main;
128 ASSERT(ninterfaces <= ARRAY_LEN(tm->hw_if_indicies));
133 vec_add1(hw_address, byte);
136 for (i = 0; i < ninterfaces; i++)
140 error = ethernet_register_interface(vnet_get_main(),
141 test_interface_device_class.index,
144 &tm->hw_if_indicies[i],
145 /* flag change */ 0);
147 FIB_TEST((NULL == error), "ADD interface %d", i);
149 error = vnet_hw_interface_set_flags(vnet_get_main(),
150 tm->hw_if_indicies[i],
151 VNET_HW_INTERFACE_FLAG_LINK_UP);
152 tm->hw[i] = vnet_get_hw_interface(vnet_get_main(),
153 tm->hw_if_indicies[i]);
154 vec_validate (ip4_main.fib_index_by_sw_if_index,
155 tm->hw[i]->sw_if_index);
156 vec_validate (ip6_main.fib_index_by_sw_if_index,
157 tm->hw[i]->sw_if_index);
158 ip4_main.fib_index_by_sw_if_index[tm->hw[i]->sw_if_index] = 0;
159 ip6_main.fib_index_by_sw_if_index[tm->hw[i]->sw_if_index] = 0;
161 error = vnet_sw_interface_set_flags(vnet_get_main(),
162 tm->hw[i]->sw_if_index,
163 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
164 FIB_TEST((NULL == error), "UP interface %d", i);
167 * re-eval after the inevitable realloc
169 for (i = 0; i < ninterfaces; i++)
171 tm->hw[i] = vnet_get_hw_interface(vnet_get_main(),
172 tm->hw_if_indicies[i]);
178 #define FIB_TEST_REC_FORW(_rec_prefix, _via_prefix, _bucket) \
180 const dpo_id_t *_rec_dpo = fib_entry_contribute_ip_forwarding( \
181 fib_table_lookup_exact_match(fib_index, (_rec_prefix))); \
182 const dpo_id_t *_via_dpo = fib_entry_contribute_ip_forwarding( \
183 fib_table_lookup(fib_index, (_via_prefix))); \
184 FIB_TEST(!dpo_cmp(_via_dpo, \
185 load_balance_get_bucket(_rec_dpo->dpoi_index, \
187 "%U is recursive via %U", \
188 format_fib_prefix, (_rec_prefix), \
189 format_fib_prefix, _via_prefix); \
192 #define FIB_TEST_LB_BUCKET_VIA_ADJ(_prefix, _bucket, _ai) \
194 const dpo_id_t *_dpo = fib_entry_contribute_ip_forwarding( \
195 fib_table_lookup_exact_match(fib_index, (_prefix))); \
196 const dpo_id_t *_dpo1 = \
197 load_balance_get_bucket(_dpo->dpoi_index, _bucket); \
198 FIB_TEST(DPO_ADJACENCY == _dpo1->dpoi_type, "type is %U", \
199 format_dpo_type, _dpo1->dpoi_type); \
200 FIB_TEST((_ai == _dpo1->dpoi_index), \
201 "%U bucket %d resolves via %U", \
202 format_fib_prefix, (_prefix), \
204 format_dpo_id, _dpo1, 0); \
207 #define FIB_TEST_RPF(_cond, _comment, _args...) \
209 if (!FIB_TEST_I(_cond, _comment, ##_args)) { \
215 fib_test_urpf_is_equal (fib_node_index_t fei,
216 fib_forward_chain_type_t fct,
219 dpo_id_t dpo = DPO_INVALID;
220 fib_urpf_list_t *urpf;
227 fib_entry_contribute_forwarding(fei, fct, &dpo);
228 ui = load_balance_get_urpf(dpo.dpoi_index);
230 urpf = fib_urpf_list_get(ui);
232 FIB_TEST_RPF(num == vec_len(urpf->furpf_itfs),
233 "RPF:%U len %d == %d",
234 format_fib_urpf_list, ui,
235 num, vec_len(urpf->furpf_itfs));
236 FIB_TEST_RPF(num == fib_urpf_check_size(ui),
237 "RPF:%U check-size %d == %d",
238 format_fib_urpf_list, ui,
239 num, vec_len(urpf->furpf_itfs));
241 for (ii = 0; ii < num; ii++)
243 adj_index_t ai = va_arg(ap, adj_index_t);
245 FIB_TEST_RPF(ai == urpf->furpf_itfs[ii],
246 "RPF:%d item:%d - %d == %d",
247 ui, ii, ai, urpf->furpf_itfs[ii]);
248 FIB_TEST_RPF(fib_urpf_check(ui, ai),
261 fib_test_build_rewrite (u8 *eth_addr)
265 vec_validate(rewrite, 13);
267 memcpy(rewrite, eth_addr, 6);
268 memcpy(rewrite+6, eth_addr, 6);
273 #define FIB_TEST_LB(_cond, _comment, _args...) \
275 if (!FIB_TEST_I(_cond, _comment, ##_args)) { \
281 fib_test_validate_rep_v (const replicate_t *rep,
285 const fib_test_rep_bucket_t *exp;
289 FIB_TEST_LB((n_buckets == rep->rep_n_buckets),
290 "n_buckets = %d", rep->rep_n_buckets);
292 for (bucket = 0; bucket < n_buckets; bucket++)
294 exp = va_arg(*ap, fib_test_rep_bucket_t*);
296 dpo = replicate_get_bucket_i(rep, bucket);
300 case FT_REP_LABEL_O_ADJ:
302 const mpls_label_dpo_t *mld;
304 FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type),
305 "bucket %d stacks on %U",
307 format_dpo_type, dpo->dpoi_type);
309 mld = mpls_label_dpo_get(dpo->dpoi_index);
310 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
312 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
313 exp->label_o_adj.label),
314 "bucket %d stacks on label %d",
316 exp->label_o_adj.label);
318 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
319 exp->label_o_adj.eos),
320 "bucket %d stacks on label %d %U",
322 exp->label_o_adj.label,
323 format_mpls_eos_bit, exp->label_o_adj.eos);
325 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
326 "bucket %d label stacks on %U",
328 format_dpo_type, mld->mld_dpo.dpoi_type);
330 FIB_TEST_LB((exp->label_o_adj.adj == mld->mld_dpo.dpoi_index),
331 "bucket %d label stacks on adj %d",
333 exp->label_o_adj.adj);
337 FIB_TEST_LB((DPO_INTERFACE_RX == dpo->dpoi_type),
338 "bucket %d stacks on %U",
340 format_dpo_type, dpo->dpoi_type);
342 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
343 "bucket %d stacks on adj %d",
347 case FT_REP_DISP_MFIB_LOOKUP:
357 fib_test_validate_lb_v (const load_balance_t *lb,
364 FIB_TEST_LB((n_buckets == lb->lb_n_buckets), "n_buckets = %d", lb->lb_n_buckets);
366 for (bucket = 0; bucket < n_buckets; bucket++)
368 const fib_test_lb_bucket_t *exp;
370 exp = va_arg(*ap, fib_test_lb_bucket_t*);
371 dpo = load_balance_get_bucket_i(lb, bucket);
375 case FT_LB_LABEL_STACK_O_ADJ:
377 const mpls_label_dpo_t *mld;
381 FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type),
382 "bucket %d stacks on %U",
384 format_dpo_type, dpo->dpoi_type);
386 mld = mpls_label_dpo_get(dpo->dpoi_index);
388 FIB_TEST_LB(exp->label_stack_o_adj.label_stack_size == mld->mld_n_labels,
392 for (ii = 0; ii < mld->mld_n_labels; ii++)
394 hdr = clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
395 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
396 exp->label_stack_o_adj.label_stack[ii]),
397 "bucket %d stacks on label %d",
399 exp->label_stack_o_adj.label_stack[ii]);
401 if (ii == mld->mld_n_labels-1)
403 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
404 exp->label_o_adj.eos),
405 "bucket %d stacks on label %d %U!=%U",
407 exp->label_stack_o_adj.label_stack[ii],
408 format_mpls_eos_bit, exp->label_o_adj.eos,
409 format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
413 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) == MPLS_NON_EOS),
414 "bucket %d stacks on label %d %U",
416 exp->label_stack_o_adj.label_stack[ii],
417 format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
421 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
422 "bucket %d label stacks on %U",
424 format_dpo_type, mld->mld_dpo.dpoi_type);
426 FIB_TEST_LB((exp->label_stack_o_adj.adj == mld->mld_dpo.dpoi_index),
427 "bucket %d label stacks on adj %d",
429 exp->label_stack_o_adj.adj);
432 case FT_LB_LABEL_O_ADJ:
434 const mpls_label_dpo_t *mld;
436 FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type),
437 "bucket %d stacks on %U",
439 format_dpo_type, dpo->dpoi_type);
441 mld = mpls_label_dpo_get(dpo->dpoi_index);
442 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
444 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
445 exp->label_o_adj.label),
446 "bucket %d stacks on label %d",
448 exp->label_o_adj.label);
450 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
451 exp->label_o_adj.eos),
452 "bucket %d stacks on label %d %U",
454 exp->label_o_adj.label,
455 format_mpls_eos_bit, exp->label_o_adj.eos);
457 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
458 "bucket %d label stacks on %U",
460 format_dpo_type, mld->mld_dpo.dpoi_type);
462 FIB_TEST_LB((exp->label_o_adj.adj == mld->mld_dpo.dpoi_index),
463 "bucket %d label stacks on adj %d",
465 exp->label_o_adj.adj);
468 case FT_LB_LABEL_O_LB:
470 const mpls_label_dpo_t *mld;
473 FIB_TEST_LB((DPO_MPLS_LABEL == dpo->dpoi_type),
474 "bucket %d stacks on %U",
476 format_dpo_type, dpo->dpoi_type);
478 mld = mpls_label_dpo_get(dpo->dpoi_index);
479 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
481 FIB_TEST_LB(1 == mld->mld_n_labels, "label stack size",
483 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
484 exp->label_o_lb.label),
485 "bucket %d stacks on label %d",
487 exp->label_o_lb.label);
489 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
490 exp->label_o_lb.eos),
491 "bucket %d stacks on label %d %U",
493 exp->label_o_lb.label,
494 format_mpls_eos_bit, exp->label_o_lb.eos);
496 FIB_TEST_LB((DPO_LOAD_BALANCE == mld->mld_dpo.dpoi_type),
497 "bucket %d label stacks on %U",
499 format_dpo_type, mld->mld_dpo.dpoi_type);
501 FIB_TEST_LB((exp->label_o_lb.lb == mld->mld_dpo.dpoi_index),
502 "bucket %d label stacks on LB %d",
508 FIB_TEST_I(((DPO_ADJACENCY == dpo->dpoi_type) ||
509 (DPO_ADJACENCY_INCOMPLETE == dpo->dpoi_type)),
510 "bucket %d stacks on %U",
512 format_dpo_type, dpo->dpoi_type);
513 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
514 "bucket %d stacks on adj %d",
518 case FT_LB_MPLS_DISP_O_ADJ:
520 const mpls_disp_dpo_t *mdd;
522 FIB_TEST_I((DPO_MPLS_DISPOSITION == dpo->dpoi_type),
523 "bucket %d stacks on %U",
525 format_dpo_type, dpo->dpoi_type);
527 mdd = mpls_disp_dpo_get(dpo->dpoi_index);
531 FIB_TEST_I(((DPO_ADJACENCY == dpo->dpoi_type) ||
532 (DPO_ADJACENCY_INCOMPLETE == dpo->dpoi_type)),
533 "bucket %d stacks on %U",
535 format_dpo_type, dpo->dpoi_type);
536 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
537 "bucket %d stacks on adj %d",
543 FIB_TEST_I((DPO_INTERFACE_RX == dpo->dpoi_type),
544 "bucket %d stacks on %U",
546 format_dpo_type, dpo->dpoi_type);
547 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
548 "bucket %d stacks on adj %d",
553 FIB_TEST_I((DPO_L2_BRIDGE == dpo->dpoi_type),
554 "bucket %d stacks on %U",
556 format_dpo_type, dpo->dpoi_type);
557 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
558 "bucket %d stacks on adj %d",
563 FIB_TEST_I((DPO_LOAD_BALANCE == dpo->dpoi_type),
564 "bucket %d stacks on %U",
566 format_dpo_type, dpo->dpoi_type);
567 FIB_TEST_LB((exp->lb.lb == dpo->dpoi_index),
568 "bucket %d stacks on lb %d not %d",
573 case FT_LB_BIER_TABLE:
574 FIB_TEST_LB((DPO_BIER_TABLE == dpo->dpoi_type),
575 "bucket %d stacks on %U",
577 format_dpo_type, dpo->dpoi_type);
578 FIB_TEST_LB((exp->bier.table == dpo->dpoi_index),
579 "bucket %d stacks on lb %d",
583 case FT_LB_BIER_FMASK:
584 FIB_TEST_LB((DPO_BIER_FMASK == dpo->dpoi_type),
585 "bucket %d stacks on %U",
587 format_dpo_type, dpo->dpoi_type);
588 FIB_TEST_LB((exp->bier.fmask == dpo->dpoi_index),
589 "bucket %d stacks on lb %d",
594 FIB_TEST_LB((DPO_DROP == dpo->dpoi_type),
595 "bucket %d stacks on %U",
597 format_dpo_type, dpo->dpoi_type);
605 fib_test_validate_lb (const dpo_id_t *dpo,
609 const load_balance_t *lb;
613 va_start(ap, n_buckets);
615 if (FIB_TEST_I((DPO_LOAD_BALANCE == dpo->dpoi_type),
617 format_dpo_type, dpo->dpoi_type))
619 lb = load_balance_get(dpo->dpoi_index);
621 res = fib_test_validate_lb_v(lb, n_buckets, &ap);
634 fib_test_validate_entry (fib_node_index_t fei,
635 fib_forward_chain_type_t fct,
639 dpo_id_t dpo = DPO_INVALID;
646 va_start(ap, n_buckets);
648 fib_entry_get_prefix(fei, &pfx);
649 fib_index = fib_entry_get_fib_index(fei);
650 fib_entry_contribute_forwarding(fei, fct, &dpo);
652 if (DPO_REPLICATE == dpo.dpoi_type)
654 const replicate_t *rep;
656 rep = replicate_get(dpo.dpoi_index);
657 res = fib_test_validate_rep_v(rep, n_buckets, &ap);
661 const load_balance_t *lb;
663 FIB_TEST_LB((DPO_LOAD_BALANCE == dpo.dpoi_type),
665 format_dpo_type, dpo.dpoi_type);
667 lb = load_balance_get(dpo.dpoi_index);
668 res = fib_test_validate_lb_v(lb, n_buckets, &ap);
671 * ensure that the LB contributed by the entry is the
672 * same as the LB in the forwarding tables
674 if (fct == fib_entry_get_default_chain_type(fib_entry_get(fei)))
676 switch (pfx.fp_proto)
678 case FIB_PROTOCOL_IP4:
679 fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx.fp_addr.ip4);
681 case FIB_PROTOCOL_IP6:
682 fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx.fp_addr.ip6);
684 case FIB_PROTOCOL_MPLS:
686 mpls_unicast_header_t hdr = {
687 .label_exp_s_ttl = 0,
690 vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx.fp_label);
691 vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx.fp_eos);
692 hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl);
694 fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr);
700 FIB_TEST_LB((fw_lbi == dpo.dpoi_index),
701 "Contributed LB = FW LB: %U\n %U",
702 format_load_balance, fw_lbi, 0,
703 format_load_balance, dpo.dpoi_index, 0);
718 * In the default table check for the presence and correct forwarding
719 * of the special entries
721 fib_node_index_t dfrt, fei, ai, ai2, locked_ai, ai_01, ai_02, ai_03;
722 const dpo_id_t *dpo, *dpo1, *dpo2, *dpo_drop;
723 const ip_adjacency_t *adj;
724 const load_balance_t *lb;
731 ip46_address_t nh_10_10_10_1 = {
732 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
735 ip46_address_t nh_10_10_10_2 = {
736 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
739 FIB_TEST((0 == pool_elts(load_balance_map_pool)), "LB-map pool size is %d",
740 pool_elts(load_balance_map_pool));
744 /* record the nubmer of load-balances in use before we start */
745 lb_count = pool_elts(load_balance_pool);
747 /* Find or create FIB table 11 */
748 fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4, 11,
751 for (ii = 0; ii < 4; ii++)
753 ip4_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = fib_index;
756 fib_prefix_t pfx_0_0_0_0_s_0 = {
758 .fp_proto = FIB_PROTOCOL_IP4,
768 .fp_proto = FIB_PROTOCOL_IP4,
776 dpo_drop = drop_dpo_get(DPO_PROTO_IP4);
778 dfrt = fib_table_lookup(fib_index, &pfx_0_0_0_0_s_0);
779 FIB_TEST((FIB_NODE_INDEX_INVALID != dfrt), "default route present");
780 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
781 "Default route is DROP");
784 fei = fib_table_lookup(fib_index, &pfx);
785 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all zeros route present");
786 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
787 "all 0s route is DROP");
789 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xffffffff);
791 fei = fib_table_lookup(fib_index, &pfx);
792 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all ones route present");
793 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
794 "all 1s route is DROP");
796 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xe0000000);
798 fei = fib_table_lookup(fib_index, &pfx);
799 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all-mcast route present");
800 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
801 "all-mcast route is DROP");
803 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xf0000000);
805 fei = fib_table_lookup(fib_index, &pfx);
806 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "class-e route present");
807 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
808 "class-e route is DROP");
811 * at this stage there are 5 entries in the test FIB (plus 5 in the default),
812 * all of which are special sourced and so none of which share path-lists.
813 * There are also 2 entries, and 2 non-shared path-lists, in the v6 default
814 * table, and 4 path-lists in the v6 MFIB table
818 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
819 FIB_TEST((PNBR == fib_path_list_pool_size()), "path list pool size is %d",
820 fib_path_list_pool_size());
821 FIB_TEST((ENBR == fib_entry_pool_size()), "entry pool size is %d",
822 fib_entry_pool_size());
825 * add interface routes.
826 * validate presence of /24 attached and /32 recieve.
827 * test for the presence of the receive address in the glean and local adj
829 fib_prefix_t local_pfx = {
831 .fp_proto = FIB_PROTOCOL_IP4,
834 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
839 fib_table_entry_update_one_path(fib_index, &local_pfx,
840 FIB_SOURCE_INTERFACE,
841 (FIB_ENTRY_FLAG_CONNECTED |
842 FIB_ENTRY_FLAG_ATTACHED),
845 tm->hw[0]->sw_if_index,
846 ~0, // invalid fib index
849 FIB_ROUTE_PATH_FLAG_NONE);
850 fei = fib_table_lookup(fib_index, &local_pfx);
851 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
852 FIB_TEST(((FIB_ENTRY_FLAG_ATTACHED | FIB_ENTRY_FLAG_CONNECTED) ==
853 fib_entry_get_flags(fei)),
854 "Flags set on attached interface");
856 ai = fib_entry_get_adj(fei);
857 FIB_TEST((FIB_NODE_INDEX_INVALID != ai),
858 "attached interface route adj present %d", ai);
860 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
861 "attached interface adj is glean");
862 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
863 &adj->sub_type.glean.receive_addr)),
864 "attached interface adj is receive ok");
866 local_pfx.fp_len = 32;
867 fib_table_entry_update_one_path(fib_index, &local_pfx,
868 FIB_SOURCE_INTERFACE,
869 (FIB_ENTRY_FLAG_CONNECTED |
870 FIB_ENTRY_FLAG_LOCAL),
873 tm->hw[0]->sw_if_index,
874 ~0, // invalid fib index
877 FIB_ROUTE_PATH_FLAG_NONE);
878 fei = fib_table_lookup(fib_index, &local_pfx);
879 FIB_TEST(((FIB_ENTRY_FLAG_LOCAL | FIB_ENTRY_FLAG_CONNECTED) ==
880 fib_entry_get_flags(fei)),
881 "Flags set on local interface");
883 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
885 dpo = fib_entry_contribute_ip_forwarding(fei);
886 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
887 "RPF list for local length 0");
888 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
889 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
890 "local interface adj is local");
891 receive_dpo_t *rd = receive_dpo_get(dpo->dpoi_index);
893 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
895 "local interface adj is receive ok");
897 FIB_TEST((2 == fib_table_get_num_entries(fib_index,
899 FIB_SOURCE_INTERFACE)),
900 "2 Interface Source'd prefixes");
903 * +2 interface routes +2 non-shared path-lists
905 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
906 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is%d",
907 fib_path_list_pool_size());
908 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
909 fib_entry_pool_size());
912 * Modify the default route to be via an adj not yet known.
913 * this sources the defalut route with the API source, which is
914 * a higher preference to the DEFAULT_ROUTE source
916 pfx.fp_addr.ip4.as_u32 = 0;
918 fib_table_entry_path_add(fib_index, &pfx,
923 tm->hw[0]->sw_if_index,
924 ~0, // invalid fib index
927 FIB_ROUTE_PATH_FLAG_NONE);
928 fei = fib_table_lookup(fib_index, &pfx);
929 FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)),
930 "Flags set on API route");
932 FIB_TEST((fei == dfrt), "default route same index");
933 ai = fib_entry_get_adj(fei);
934 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "default route adj present");
936 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
937 "adj is incomplete");
938 FIB_TEST((0 == ip46_address_cmp(&nh_10_10_10_1, &adj->sub_type.nbr.next_hop)),
939 "adj nbr next-hop ok");
940 FIB_TEST((1 == fib_table_get_num_entries(fib_index,
943 "1 API Source'd prefixes");
946 * find the adj in the shared db
948 locked_ai = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
951 tm->hw[0]->sw_if_index);
952 FIB_TEST((locked_ai == ai), "ADJ NBR DB find");
953 adj_unlock(locked_ai);
956 * +1 shared path-list
958 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
959 fib_path_list_db_size());
960 FIB_TEST((PNBR+3 == fib_path_list_pool_size()), "path list pool size is%d",
961 fib_path_list_pool_size());
962 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
963 fib_entry_pool_size());
966 * remove the API source from the default route. We expected
967 * the route to remain, sourced by DEFAULT_ROUTE, and hence a DROP
969 pfx.fp_addr.ip4.as_u32 = 0;
971 fib_table_entry_path_remove(fib_index, &pfx,
975 tm->hw[0]->sw_if_index,
976 ~0, // non-recursive path, so no FIB index
978 FIB_ROUTE_PATH_FLAG_NONE);
980 fei = fib_table_lookup(fib_index, &pfx);
982 FIB_TEST((fei == dfrt), "default route same index");
983 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
984 "Default route is DROP");
987 * -1 shared-path-list
989 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
990 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is%d",
991 fib_path_list_pool_size());
992 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
993 fib_entry_pool_size());
996 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
998 fib_prefix_t pfx_10_10_10_1_s_32 = {
1000 .fp_proto = FIB_PROTOCOL_IP4,
1003 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
1006 fib_prefix_t pfx_10_10_10_2_s_32 = {
1008 .fp_proto = FIB_PROTOCOL_IP4,
1011 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
1014 fib_prefix_t pfx_11_11_11_11_s_32 = {
1016 .fp_proto = FIB_PROTOCOL_IP4,
1019 .ip4.as_u32 = clib_host_to_net_u32(0x0b0b0b0b),
1023 0xde, 0xde, 0xde, 0xba, 0xba, 0xba,
1026 ip46_address_t nh_12_12_12_12 = {
1027 .ip4.as_u32 = clib_host_to_net_u32(0x0c0c0c0c),
1029 adj_index_t ai_12_12_12_12;
1032 * Add a route via an incomplete ADJ. then complete the ADJ
1033 * Expect the route LB is updated to use complete adj type.
1035 fei = fib_table_entry_update_one_path(fib_index,
1036 &pfx_11_11_11_11_s_32,
1038 FIB_ENTRY_FLAG_ATTACHED,
1040 &pfx_10_10_10_1_s_32.fp_addr,
1041 tm->hw[0]->sw_if_index,
1042 ~0, // invalid fib index
1045 FIB_ROUTE_PATH_FLAG_NONE);
1047 dpo = fib_entry_contribute_ip_forwarding(fei);
1048 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1049 FIB_TEST(DPO_ADJACENCY_INCOMPLETE == dpo1->dpoi_type,
1050 "11.11.11.11/32 via incomplete adj");
1052 ai_01 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1054 &pfx_10_10_10_1_s_32.fp_addr,
1055 tm->hw[0]->sw_if_index);
1056 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_01), "adj created");
1057 adj = adj_get(ai_01);
1058 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1059 "adj is incomplete");
1060 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_1_s_32.fp_addr,
1061 &adj->sub_type.nbr.next_hop)),
1062 "adj nbr next-hop ok");
1064 adj_nbr_update_rewrite(ai_01, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1065 fib_test_build_rewrite(eth_addr));
1066 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1068 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_1_s_32.fp_addr,
1069 &adj->sub_type.nbr.next_hop)),
1070 "adj nbr next-hop ok");
1071 ai = fib_entry_get_adj(fei);
1072 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
1074 dpo = fib_entry_contribute_ip_forwarding(fei);
1075 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1076 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type,
1077 "11.11.11.11/32 via complete adj");
1078 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
1079 tm->hw[0]->sw_if_index),
1080 "RPF list for adj-fib contains adj");
1082 ai_12_12_12_12 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1085 tm->hw[1]->sw_if_index);
1086 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_12_12_12_12), "adj created");
1087 adj = adj_get(ai_12_12_12_12);
1088 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1089 "adj is incomplete");
1090 FIB_TEST((0 == ip46_address_cmp(&nh_12_12_12_12,
1091 &adj->sub_type.nbr.next_hop)),
1092 "adj nbr next-hop ok");
1093 adj_nbr_update_rewrite(ai_12_12_12_12, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1094 fib_test_build_rewrite(eth_addr));
1095 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1101 fei = fib_table_entry_path_add(fib_index,
1102 &pfx_10_10_10_1_s_32,
1104 FIB_ENTRY_FLAG_ATTACHED,
1106 &pfx_10_10_10_1_s_32.fp_addr,
1107 tm->hw[0]->sw_if_index,
1108 ~0, // invalid fib index
1111 FIB_ROUTE_PATH_FLAG_NONE);
1112 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED == fib_entry_get_flags(fei)),
1113 "Flags set on adj-fib");
1114 ai = fib_entry_get_adj(fei);
1115 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj, %d", ai);
1117 fib_table_entry_path_remove(fib_index,
1118 &pfx_11_11_11_11_s_32,
1121 &pfx_10_10_10_1_s_32.fp_addr,
1122 tm->hw[0]->sw_if_index,
1123 ~0, // invalid fib index
1125 FIB_ROUTE_PATH_FLAG_NONE);
1129 ai_02 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1131 &pfx_10_10_10_2_s_32.fp_addr,
1132 tm->hw[0]->sw_if_index);
1133 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_02), "adj created");
1134 adj = adj_get(ai_02);
1135 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1136 "adj is incomplete");
1137 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_2_s_32.fp_addr,
1138 &adj->sub_type.nbr.next_hop)),
1139 "adj nbr next-hop ok");
1141 adj_nbr_update_rewrite(ai_02, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1142 fib_test_build_rewrite(eth_addr));
1143 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1145 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_2_s_32.fp_addr,
1146 &adj->sub_type.nbr.next_hop)),
1147 "adj nbr next-hop ok");
1148 FIB_TEST((ai_01 != ai_02), "ADJs are different");
1150 fib_table_entry_path_add(fib_index,
1151 &pfx_10_10_10_2_s_32,
1153 FIB_ENTRY_FLAG_ATTACHED,
1155 &pfx_10_10_10_2_s_32.fp_addr,
1156 tm->hw[0]->sw_if_index,
1157 ~0, // invalid fib index
1160 FIB_ROUTE_PATH_FLAG_NONE);
1162 fei = fib_table_lookup(fib_index, &pfx_10_10_10_2_s_32);
1163 ai = fib_entry_get_adj(fei);
1164 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
1167 * +2 adj-fibs, and their non-shared path-lists
1169 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
1170 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
1171 fib_path_list_pool_size());
1172 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
1173 fib_entry_pool_size());
1176 * Add 2 routes via the first ADJ. ensure path-list sharing
1178 fib_prefix_t pfx_1_1_1_1_s_32 = {
1180 .fp_proto = FIB_PROTOCOL_IP4,
1183 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
1187 fib_table_entry_path_add(fib_index,
1190 FIB_ENTRY_FLAG_NONE,
1193 tm->hw[0]->sw_if_index,
1194 ~0, // invalid fib index
1197 FIB_ROUTE_PATH_FLAG_NONE);
1198 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
1199 ai = fib_entry_get_adj(fei);
1200 FIB_TEST((ai_01 == ai), "1.1.1.1 resolves via 10.10.10.1");
1203 * +1 entry and a shared path-list
1205 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is empty");
1206 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1207 fib_path_list_pool_size());
1208 FIB_TEST((ENBR+5 == fib_entry_pool_size()), "entry pool size is %d",
1209 fib_entry_pool_size());
1212 fib_prefix_t pfx_1_1_2_0_s_24 = {
1214 .fp_proto = FIB_PROTOCOL_IP4,
1216 .ip4.as_u32 = clib_host_to_net_u32(0x01010200),
1220 fib_table_entry_path_add(fib_index,
1223 FIB_ENTRY_FLAG_NONE,
1226 tm->hw[0]->sw_if_index,
1227 ~0, // invalid fib index
1230 FIB_ROUTE_PATH_FLAG_NONE);
1231 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1232 ai = fib_entry_get_adj(fei);
1233 FIB_TEST((ai_01 == ai), "1.1.2.0/24 resolves via 10.10.10.1");
1238 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is empty");
1239 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1240 fib_path_list_pool_size());
1241 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1242 fib_entry_pool_size());
1245 * modify 1.1.2.0/24 to use multipath.
1247 fib_table_entry_path_add(fib_index,
1250 FIB_ENTRY_FLAG_NONE,
1253 tm->hw[0]->sw_if_index,
1254 ~0, // invalid fib index
1257 FIB_ROUTE_PATH_FLAG_NONE);
1258 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1259 dpo = fib_entry_contribute_ip_forwarding(fei);
1260 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1261 1, tm->hw[0]->sw_if_index),
1262 "RPF list for 1.1.2.0/24 contains both adjs");
1264 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1265 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type, "type is %d", dpo1->dpoi_type);
1266 FIB_TEST((ai_01 == dpo1->dpoi_index),
1267 "1.1.2.0/24 bucket 0 resolves via 10.10.10.1 (%d=%d)",
1268 ai_01, dpo1->dpoi_index);
1270 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 1);
1271 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type, "type is %d", dpo1->dpoi_type);
1272 FIB_TEST((ai_02 == dpo1->dpoi_index),
1273 "1.1.2.0/24 bucket 1 resolves via 10.10.10.2");
1276 * +1 shared-pathlist
1278 FIB_TEST((2 == fib_path_list_db_size()), "path list DB is empty");
1279 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
1280 fib_path_list_pool_size());
1281 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1282 fib_entry_pool_size());
1287 fib_table_entry_path_remove(fib_index,
1292 tm->hw[0]->sw_if_index,
1295 FIB_ROUTE_PATH_FLAG_NONE);
1296 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1297 dpo = fib_entry_contribute_ip_forwarding(fei);
1298 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1299 1, tm->hw[0]->sw_if_index),
1300 "RPF list for 1.1.2.0/24 contains one adj");
1302 ai = fib_entry_get_adj(fei);
1303 FIB_TEST((ai_01 == ai), "1.1.2.0/24 resolves via 10.10.10.1");
1306 * +1 shared-pathlist
1308 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is %d",
1309 fib_path_list_db_size());
1310 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1311 fib_path_list_pool_size());
1312 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1313 fib_entry_pool_size());
1316 * Add 2 recursive routes:
1317 * 100.100.100.100/32 via 1.1.1.1/32 => the via entry is installed.
1318 * 100.100.100.101/32 via 1.1.1.1/32 => the via entry is installed.
1320 fib_prefix_t bgp_100_pfx = {
1322 .fp_proto = FIB_PROTOCOL_IP4,
1324 /* 100.100.100.100/32 */
1325 .ip4.as_u32 = clib_host_to_net_u32(0x64646464),
1329 ip46_address_t nh_1_1_1_1 = {
1330 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
1333 fei = fib_table_entry_path_add(fib_index,
1336 FIB_ENTRY_FLAG_NONE,
1339 ~0, // no index provided.
1340 fib_index, // nexthop in same fib as route
1343 FIB_ROUTE_PATH_FLAG_NONE);
1345 FIB_TEST_REC_FORW(&bgp_100_pfx, &pfx_1_1_1_1_s_32, 0);
1346 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
1347 tm->hw[0]->sw_if_index),
1348 "RPF list for adj-fib contains adj");
1351 * +1 entry and +1 shared-path-list
1353 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
1354 fib_path_list_db_size());
1355 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
1356 fib_path_list_pool_size());
1357 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
1358 fib_entry_pool_size());
1360 fib_prefix_t bgp_101_pfx = {
1362 .fp_proto = FIB_PROTOCOL_IP4,
1364 /* 100.100.100.101/32 */
1365 .ip4.as_u32 = clib_host_to_net_u32(0x64646465),
1369 fib_table_entry_path_add(fib_index,
1372 FIB_ENTRY_FLAG_NONE,
1375 ~0, // no index provided.
1376 fib_index, // nexthop in same fib as route
1379 FIB_ROUTE_PATH_FLAG_NONE);
1381 FIB_TEST_REC_FORW(&bgp_101_pfx, &pfx_1_1_1_1_s_32, 0);
1382 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
1383 tm->hw[0]->sw_if_index),
1384 "RPF list for adj-fib contains adj");
1387 * +1 entry, but the recursive path-list is shared.
1389 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
1390 fib_path_list_db_size());
1391 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
1392 fib_path_list_pool_size());
1393 FIB_TEST((ENBR+8 == fib_entry_pool_size()), "entry pool size is %d",
1394 fib_entry_pool_size());
1397 * An special route; one where the user (me) provides the
1398 * adjacency through which the route will resovle by setting the flags
1400 fib_prefix_t ex_pfx = {
1402 .fp_proto = FIB_PROTOCOL_IP4,
1405 .ip4.as_u32 = clib_host_to_net_u32(0x04040404),
1409 fib_table_entry_special_add(fib_index,
1412 FIB_ENTRY_FLAG_LOCAL);
1413 fei = fib_table_lookup_exact_match(fib_index, &ex_pfx);
1414 dpo = fib_entry_contribute_ip_forwarding(fei);
1415 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
1416 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
1417 "local interface adj is local");
1419 fib_table_entry_special_remove(fib_index,
1421 FIB_SOURCE_SPECIAL);
1422 FIB_TEST(FIB_NODE_INDEX_INVALID ==
1423 fib_table_lookup_exact_match(fib_index, &ex_pfx),
1424 "Exclusive reoute removed");
1427 * An EXCLUSIVE route; one where the user (me) provides the exclusive
1428 * adjacency through which the route will resovle
1430 dpo_id_t ex_dpo = DPO_INVALID;
1432 lookup_dpo_add_or_lock_w_fib_index(fib_index,
1435 LOOKUP_INPUT_DST_ADDR,
1436 LOOKUP_TABLE_FROM_CONFIG,
1439 fib_table_entry_special_dpo_add(fib_index,
1442 FIB_ENTRY_FLAG_EXCLUSIVE,
1444 fei = fib_table_lookup_exact_match(fib_index, &ex_pfx);
1445 dpo = fib_entry_contribute_ip_forwarding(fei);
1446 FIB_TEST(!dpo_cmp(&ex_dpo, load_balance_get_bucket(dpo->dpoi_index, 0)),
1447 "exclusive remote uses lookup DPO");
1450 * update the exclusive to use a different DPO
1452 ip_null_dpo_add_and_lock(DPO_PROTO_IP4,
1453 IP_NULL_ACTION_SEND_ICMP_UNREACH,
1455 fib_table_entry_special_dpo_update(fib_index,
1458 FIB_ENTRY_FLAG_EXCLUSIVE,
1460 dpo = fib_entry_contribute_ip_forwarding(fei);
1461 FIB_TEST(!dpo_cmp(&ex_dpo, load_balance_get_bucket(dpo->dpoi_index, 0)),
1462 "exclusive remote uses now uses NULL DPO");
1464 fib_table_entry_special_remove(fib_index,
1466 FIB_SOURCE_SPECIAL);
1467 FIB_TEST(FIB_NODE_INDEX_INVALID ==
1468 fib_table_lookup_exact_match(fib_index, &ex_pfx),
1469 "Exclusive reoute removed");
1473 * Add a recursive route:
1474 * 200.200.200.200/32 via 1.1.1.2/32 => the via entry is NOT installed.
1476 fib_prefix_t bgp_200_pfx = {
1478 .fp_proto = FIB_PROTOCOL_IP4,
1480 /* 200.200.200.200/32 */
1481 .ip4.as_u32 = clib_host_to_net_u32(0xc8c8c8c8),
1485 fib_prefix_t pfx_1_1_1_2_s_32 = {
1487 .fp_proto = FIB_PROTOCOL_IP4,
1489 .ip4.as_u32 = clib_host_to_net_u32(0x01010102),
1493 fei = fib_table_entry_path_add(fib_index,
1496 FIB_ENTRY_FLAG_NONE,
1498 &pfx_1_1_1_2_s_32.fp_addr,
1499 ~0, // no index provided.
1500 fib_index, // nexthop in same fib as route
1503 FIB_ROUTE_PATH_FLAG_NONE);
1505 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
1506 "Recursive via unresolved is drop");
1509 * the adj should be recursive via drop, since the route resolves via
1510 * the default route, which is itself a DROP
1512 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
1513 dpo1 = fib_entry_contribute_ip_forwarding(fei);
1514 FIB_TEST(load_balance_is_drop(dpo1), "1.1.1.2/32 is drop");
1515 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
1516 "RPF list for 1.1.1.2/32 contains 0 adjs");
1519 * +2 entry and +1 shared-path-list
1521 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
1522 fib_path_list_db_size());
1523 FIB_TEST((PNBR+7 == fib_path_list_pool_size()), "path list pool size is %d",
1524 fib_path_list_pool_size());
1525 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
1526 fib_entry_pool_size());
1529 * Unequal Cost load-balance. 3:1 ratio. fits in a 4 bucket LB
1530 * The paths are sort by NH first. in this case the the path with greater
1531 * weight is first in the set. This ordering is to test the RPF sort|uniq logic
1533 fib_prefix_t pfx_1_2_3_4_s_32 = {
1535 .fp_proto = FIB_PROTOCOL_IP4,
1537 .ip4.as_u32 = clib_host_to_net_u32(0x01020304),
1540 fib_table_entry_path_add(fib_index,
1543 FIB_ENTRY_FLAG_NONE,
1546 tm->hw[0]->sw_if_index,
1550 FIB_ROUTE_PATH_FLAG_NONE);
1551 fei = fib_table_entry_path_add(fib_index,
1554 FIB_ENTRY_FLAG_NONE,
1557 tm->hw[1]->sw_if_index,
1561 FIB_ROUTE_PATH_FLAG_NONE);
1563 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.4/32 presnet");
1564 dpo = fib_entry_contribute_ip_forwarding(fei);
1565 lb = load_balance_get(dpo->dpoi_index);
1566 FIB_TEST((lb->lb_n_buckets == 4),
1567 "1.2.3.4/32 LB has %d bucket",
1570 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 0, ai_12_12_12_12);
1571 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 1, ai_12_12_12_12);
1572 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 2, ai_12_12_12_12);
1573 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 3, ai_01);
1575 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
1576 tm->hw[0]->sw_if_index,
1577 tm->hw[1]->sw_if_index),
1578 "RPF list for 1.2.3.4/32 contains both adjs");
1582 * Unequal Cost load-balance. 4:1 ratio.
1583 * fits in a 16 bucket LB with ratio 13:3
1585 fib_prefix_t pfx_1_2_3_5_s_32 = {
1587 .fp_proto = FIB_PROTOCOL_IP4,
1589 .ip4.as_u32 = clib_host_to_net_u32(0x01020305),
1592 fib_table_entry_path_add(fib_index,
1595 FIB_ENTRY_FLAG_NONE,
1598 tm->hw[1]->sw_if_index,
1602 FIB_ROUTE_PATH_FLAG_NONE);
1603 fei = fib_table_entry_path_add(fib_index,
1606 FIB_ENTRY_FLAG_NONE,
1609 tm->hw[0]->sw_if_index,
1613 FIB_ROUTE_PATH_FLAG_NONE);
1615 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.5/32 presnet");
1616 dpo = fib_entry_contribute_ip_forwarding(fei);
1617 lb = load_balance_get(dpo->dpoi_index);
1618 FIB_TEST((lb->lb_n_buckets == 16),
1619 "1.2.3.5/32 LB has %d bucket",
1622 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 0, ai_01);
1623 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 1, ai_01);
1624 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 2, ai_01);
1625 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 3, ai_01);
1626 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 4, ai_01);
1627 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 5, ai_01);
1628 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 6, ai_01);
1629 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 7, ai_01);
1630 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 8, ai_01);
1631 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 9, ai_01);
1632 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 10, ai_01);
1633 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 11, ai_01);
1634 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 12, ai_01);
1635 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 13, ai_12_12_12_12);
1636 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 14, ai_12_12_12_12);
1637 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 15, ai_12_12_12_12);
1639 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
1640 tm->hw[0]->sw_if_index,
1641 tm->hw[1]->sw_if_index),
1642 "RPF list for 1.2.3.4/32 contains both adjs");
1645 * Test UCMP with a large weight skew - this produces load-balance objects with large
1646 * numbers of buckets to accommodate the skew. By updating said load-balances we are
1647 * laso testing the LB in placce modify code when number of buckets is large.
1649 fib_prefix_t pfx_6_6_6_6_s_32 = {
1651 .fp_proto = FIB_PROTOCOL_IP4,
1654 .ip4.as_u32 = clib_host_to_net_u32(0x06060606),
1657 fib_test_lb_bucket_t ip_o_10_10_10_1 = {
1663 fib_test_lb_bucket_t ip_o_10_10_10_2 = {
1669 fib_test_lb_bucket_t ip_6_6_6_6_o_12_12_12_12 = {
1672 .adj = ai_12_12_12_12,
1675 fib_table_entry_update_one_path(fib_index,
1678 FIB_ENTRY_FLAG_NONE,
1681 tm->hw[0]->sw_if_index,
1682 ~0, // invalid fib index
1685 FIB_ROUTE_PATH_FLAG_NONE);
1687 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1688 FIB_TEST(fib_test_validate_entry(fei,
1689 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1692 "6.6.6.6/32 via 10.10.10.1");
1694 fib_table_entry_path_add(fib_index,
1697 FIB_ENTRY_FLAG_NONE,
1700 tm->hw[0]->sw_if_index,
1701 ~0, // invalid fib index
1704 FIB_ROUTE_PATH_FLAG_NONE);
1706 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1707 FIB_TEST(fib_test_validate_entry(fei,
1708 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1774 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
1776 fib_table_entry_path_add(fib_index,
1779 FIB_ENTRY_FLAG_NONE,
1782 tm->hw[1]->sw_if_index,
1783 ~0, // invalid fib index
1786 FIB_ROUTE_PATH_FLAG_NONE);
1788 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1789 FIB_TEST(fib_test_validate_entry(fei,
1790 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1857 &ip_6_6_6_6_o_12_12_12_12,
1858 &ip_6_6_6_6_o_12_12_12_12,
1859 &ip_6_6_6_6_o_12_12_12_12,
1860 &ip_6_6_6_6_o_12_12_12_12,
1861 &ip_6_6_6_6_o_12_12_12_12,
1862 &ip_6_6_6_6_o_12_12_12_12,
1863 &ip_6_6_6_6_o_12_12_12_12,
1864 &ip_6_6_6_6_o_12_12_12_12,
1865 &ip_6_6_6_6_o_12_12_12_12,
1866 &ip_6_6_6_6_o_12_12_12_12,
1867 &ip_6_6_6_6_o_12_12_12_12,
1868 &ip_6_6_6_6_o_12_12_12_12,
1869 &ip_6_6_6_6_o_12_12_12_12,
1870 &ip_6_6_6_6_o_12_12_12_12,
1871 &ip_6_6_6_6_o_12_12_12_12,
1872 &ip_6_6_6_6_o_12_12_12_12,
1873 &ip_6_6_6_6_o_12_12_12_12,
1874 &ip_6_6_6_6_o_12_12_12_12,
1875 &ip_6_6_6_6_o_12_12_12_12,
1876 &ip_6_6_6_6_o_12_12_12_12,
1877 &ip_6_6_6_6_o_12_12_12_12,
1878 &ip_6_6_6_6_o_12_12_12_12,
1879 &ip_6_6_6_6_o_12_12_12_12,
1880 &ip_6_6_6_6_o_12_12_12_12,
1881 &ip_6_6_6_6_o_12_12_12_12,
1882 &ip_6_6_6_6_o_12_12_12_12,
1883 &ip_6_6_6_6_o_12_12_12_12,
1884 &ip_6_6_6_6_o_12_12_12_12,
1885 &ip_6_6_6_6_o_12_12_12_12,
1886 &ip_6_6_6_6_o_12_12_12_12,
1887 &ip_6_6_6_6_o_12_12_12_12,
1888 &ip_6_6_6_6_o_12_12_12_12,
1889 &ip_6_6_6_6_o_12_12_12_12,
1890 &ip_6_6_6_6_o_12_12_12_12,
1891 &ip_6_6_6_6_o_12_12_12_12,
1892 &ip_6_6_6_6_o_12_12_12_12,
1893 &ip_6_6_6_6_o_12_12_12_12,
1894 &ip_6_6_6_6_o_12_12_12_12,
1895 &ip_6_6_6_6_o_12_12_12_12,
1896 &ip_6_6_6_6_o_12_12_12_12,
1897 &ip_6_6_6_6_o_12_12_12_12,
1898 &ip_6_6_6_6_o_12_12_12_12,
1899 &ip_6_6_6_6_o_12_12_12_12,
1900 &ip_6_6_6_6_o_12_12_12_12,
1901 &ip_6_6_6_6_o_12_12_12_12,
1902 &ip_6_6_6_6_o_12_12_12_12,
1903 &ip_6_6_6_6_o_12_12_12_12,
1904 &ip_6_6_6_6_o_12_12_12_12,
1905 &ip_6_6_6_6_o_12_12_12_12,
1906 &ip_6_6_6_6_o_12_12_12_12,
1907 &ip_6_6_6_6_o_12_12_12_12,
1908 &ip_6_6_6_6_o_12_12_12_12,
1909 &ip_6_6_6_6_o_12_12_12_12,
1910 &ip_6_6_6_6_o_12_12_12_12,
1911 &ip_6_6_6_6_o_12_12_12_12,
1912 &ip_6_6_6_6_o_12_12_12_12,
1913 &ip_6_6_6_6_o_12_12_12_12,
1914 &ip_6_6_6_6_o_12_12_12_12,
1915 &ip_6_6_6_6_o_12_12_12_12,
1916 &ip_6_6_6_6_o_12_12_12_12,
1917 &ip_6_6_6_6_o_12_12_12_12,
1918 &ip_6_6_6_6_o_12_12_12_12,
1919 &ip_6_6_6_6_o_12_12_12_12),
1920 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
1922 fib_table_entry_path_remove(fib_index,
1927 tm->hw[1]->sw_if_index,
1928 ~0, // invalid fib index
1930 FIB_ROUTE_PATH_FLAG_NONE);
1932 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1933 FIB_TEST(fib_test_validate_entry(fei,
1934 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
2000 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
2002 fib_table_entry_path_remove(fib_index,
2007 tm->hw[0]->sw_if_index,
2008 ~0, // invalid fib index
2010 FIB_ROUTE_PATH_FLAG_NONE);
2012 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
2013 FIB_TEST(fib_test_validate_entry(fei,
2014 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
2017 "6.6.6.6/32 via 10.10.10.1");
2019 fib_table_entry_delete(fib_index, &pfx_6_6_6_6_s_32, FIB_SOURCE_API);
2022 * A recursive via the two unequal cost entries
2024 fib_prefix_t bgp_44_s_32 = {
2026 .fp_proto = FIB_PROTOCOL_IP4,
2028 /* 200.200.200.201/32 */
2029 .ip4.as_u32 = clib_host_to_net_u32(0x44444444),
2032 fei = fib_table_entry_path_add(fib_index,
2035 FIB_ENTRY_FLAG_NONE,
2037 &pfx_1_2_3_4_s_32.fp_addr,
2042 FIB_ROUTE_PATH_FLAG_NONE);
2043 fei = fib_table_entry_path_add(fib_index,
2046 FIB_ENTRY_FLAG_NONE,
2048 &pfx_1_2_3_5_s_32.fp_addr,
2053 FIB_ROUTE_PATH_FLAG_NONE);
2055 FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_4_s_32, 0);
2056 FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_5_s_32, 1);
2057 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
2058 tm->hw[0]->sw_if_index,
2059 tm->hw[1]->sw_if_index),
2060 "RPF list for 1.2.3.4/32 contains both adjs");
2063 * test the uRPF check functions
2065 dpo_id_t dpo_44 = DPO_INVALID;
2068 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, &dpo_44);
2069 urpfi = load_balance_get_urpf(dpo_44.dpoi_index);
2071 FIB_TEST(fib_urpf_check(urpfi, tm->hw[0]->sw_if_index),
2072 "uRPF check for 68.68.68.68/32 on %d OK",
2073 tm->hw[0]->sw_if_index);
2074 FIB_TEST(fib_urpf_check(urpfi, tm->hw[1]->sw_if_index),
2075 "uRPF check for 68.68.68.68/32 on %d OK",
2076 tm->hw[1]->sw_if_index);
2077 FIB_TEST(!fib_urpf_check(urpfi, 99),
2078 "uRPF check for 68.68.68.68/32 on 99 not-OK",
2082 fib_table_entry_delete(fib_index,
2085 fib_table_entry_delete(fib_index,
2088 fib_table_entry_delete(fib_index,
2093 * Add a recursive route:
2094 * 200.200.200.201/32 via 1.1.1.200/32 => the via entry is NOT installed.
2096 fib_prefix_t bgp_201_pfx = {
2098 .fp_proto = FIB_PROTOCOL_IP4,
2100 /* 200.200.200.201/32 */
2101 .ip4.as_u32 = clib_host_to_net_u32(0xc8c8c8c9),
2105 fib_prefix_t pfx_1_1_1_200_s_32 = {
2107 .fp_proto = FIB_PROTOCOL_IP4,
2109 .ip4.as_u32 = clib_host_to_net_u32(0x010101c8),
2113 fei = fib_table_entry_path_add(fib_index,
2116 FIB_ENTRY_FLAG_NONE,
2118 &pfx_1_1_1_200_s_32.fp_addr,
2119 ~0, // no index provided.
2120 fib_index, // nexthop in same fib as route
2123 FIB_ROUTE_PATH_FLAG_NONE);
2125 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2126 "Recursive via unresolved is drop");
2128 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32);
2129 FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)),
2130 "Flags set on RR via non-attached");
2131 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
2132 "RPF list for BGP route empty");
2135 * +2 entry (BGP & RR) and +1 shared-path-list
2137 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2138 fib_path_list_db_size());
2139 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2140 fib_path_list_pool_size());
2141 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2142 fib_entry_pool_size());
2145 * insert a route that covers the missing 1.1.1.2/32. we epxect
2146 * 200.200.200.200/32 and 200.200.200.201/32 to resolve through it.
2148 fib_prefix_t pfx_1_1_1_0_s_24 = {
2150 .fp_proto = FIB_PROTOCOL_IP4,
2153 .ip4.as_u32 = clib_host_to_net_u32(0x01010100),
2157 fib_table_entry_path_add(fib_index,
2160 FIB_ENTRY_FLAG_NONE,
2163 tm->hw[0]->sw_if_index,
2164 ~0, // invalid fib index
2167 FIB_ROUTE_PATH_FLAG_NONE);
2168 fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24);
2169 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2170 ai = fib_entry_get_adj(fei);
2171 FIB_TEST((ai_01 == ai), "1.1.1.0/24 resolves via 10.10.10.1");
2172 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
2173 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2174 ai = fib_entry_get_adj(fei);
2175 FIB_TEST((ai_01 == ai), "1.1.1.2/32 resolves via 10.10.10.1");
2176 fei = fib_table_lookup(fib_index, &pfx_1_1_1_200_s_32);
2177 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2178 ai = fib_entry_get_adj(fei);
2179 FIB_TEST((ai_01 == ai), "1.1.1.200/24 resolves via 10.10.10.1");
2182 * +1 entry. 1.1.1.1/32 already uses 10.10.10.1 so no new pah-list
2184 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2185 fib_path_list_db_size());
2186 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2187 fib_path_list_pool_size());
2188 FIB_TEST((ENBR+13 == fib_entry_pool_size()), "entry pool size is %d",
2189 fib_entry_pool_size());
2192 * the recursive adj for 200.200.200.200 should be updated.
2194 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2195 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2196 fei = fib_table_lookup(fib_index, &bgp_200_pfx);
2197 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
2198 tm->hw[0]->sw_if_index),
2199 "RPF list for BGP route has itf index 0");
2202 * insert a more specific route than 1.1.1.0/24 that also covers the
2203 * missing 1.1.1.2/32, but not 1.1.1.200/32. we epxect
2204 * 200.200.200.200 to resolve through it.
2206 fib_prefix_t pfx_1_1_1_0_s_28 = {
2208 .fp_proto = FIB_PROTOCOL_IP4,
2211 .ip4.as_u32 = clib_host_to_net_u32(0x01010100),
2215 fib_table_entry_path_add(fib_index,
2218 FIB_ENTRY_FLAG_NONE,
2221 tm->hw[0]->sw_if_index,
2222 ~0, // invalid fib index
2225 FIB_ROUTE_PATH_FLAG_NONE);
2226 fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28);
2227 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2228 ai = fib_entry_get_adj(fei);
2229 FIB_TEST((ai_02 == ai), "1.1.1.0/24 resolves via 10.10.10.2");
2232 * +1 entry. +1 shared path-list
2234 FIB_TEST((5 == fib_path_list_db_size()), "path list DB population:%d",
2235 fib_path_list_db_size());
2236 FIB_TEST((PNBR+9 == fib_path_list_pool_size()), "path list pool size is %d",
2237 fib_path_list_pool_size());
2238 FIB_TEST((ENBR+14 == fib_entry_pool_size()), "entry pool size is %d",
2239 fib_entry_pool_size());
2242 * the recursive adj for 200.200.200.200 should be updated.
2243 * 200.200.200.201 remains unchanged.
2245 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2246 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2249 * remove this /28. 200.200.200.200/32 should revert back to via 1.1.1.0/24
2251 fib_table_entry_path_remove(fib_index,
2256 tm->hw[0]->sw_if_index,
2259 FIB_ROUTE_PATH_FLAG_NONE);
2260 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28) ==
2261 FIB_NODE_INDEX_INVALID),
2262 "1.1.1.0/28 removed");
2263 FIB_TEST((fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28) ==
2264 fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24)),
2265 "1.1.1.0/28 lookup via /24");
2266 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2267 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2270 * -1 entry. -1 shared path-list
2272 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2273 fib_path_list_db_size());
2274 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2275 fib_path_list_pool_size());
2276 FIB_TEST((ENBR+13 == fib_entry_pool_size()), "entry pool size is %d",
2277 fib_entry_pool_size());
2280 * remove 1.1.1.0/24. 200.200.200.200/32 should revert back to via 0.0.0.0/0
2282 fib_table_entry_path_remove(fib_index,
2287 tm->hw[0]->sw_if_index,
2290 FIB_ROUTE_PATH_FLAG_NONE);
2291 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_24) ==
2292 FIB_NODE_INDEX_INVALID),
2293 "1.1.1.0/24 removed");
2295 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
2296 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2297 "1.1.1.2/32 route is DROP");
2298 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32);
2299 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2300 "1.1.1.200/32 route is DROP");
2302 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2303 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2305 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
2306 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2312 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2313 fib_path_list_db_size());
2314 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2315 fib_path_list_pool_size());
2316 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2317 fib_entry_pool_size());
2320 * insert the missing 1.1.1.2/32
2322 fei = fib_table_entry_path_add(fib_index,
2325 FIB_ENTRY_FLAG_NONE,
2328 tm->hw[0]->sw_if_index,
2329 ~0, // invalid fib index
2332 FIB_ROUTE_PATH_FLAG_NONE);
2333 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2334 ai = fib_entry_get_adj(fei);
2335 FIB_TEST((ai = ai_01), "1.1.1.2/32 resolves via 10.10.10.1");
2337 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2338 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2340 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2343 * no change. 1.1.1.2/32 was already there RR sourced.
2345 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2346 fib_path_list_db_size());
2347 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2348 fib_path_list_pool_size());
2349 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2350 fib_entry_pool_size());
2353 * give 201 a resolved path.
2354 * it now has the unresolved 1.1.1.200 and the resolved 1.1.1.2,
2355 * only the latter contributes forwarding.
2357 fei = fib_table_entry_path_add(fib_index,
2360 FIB_ENTRY_FLAG_NONE,
2362 &pfx_1_1_1_2_s_32.fp_addr,
2367 FIB_ROUTE_PATH_FLAG_NONE);
2368 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_2_s_32, 0);
2369 fib_table_entry_path_remove(fib_index,
2373 &pfx_1_1_1_2_s_32.fp_addr,
2377 FIB_ROUTE_PATH_FLAG_NONE);
2380 * remove 200.200.200.201/32 which does not have a valid via FIB
2382 fib_table_entry_path_remove(fib_index,
2386 &pfx_1_1_1_200_s_32.fp_addr,
2387 ~0, // no index provided.
2390 FIB_ROUTE_PATH_FLAG_NONE);
2393 * -2 entries (BGP and RR). -1 shared path-list;
2395 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_201_pfx) ==
2396 FIB_NODE_INDEX_INVALID),
2397 "200.200.200.201/32 removed");
2398 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32) ==
2399 FIB_NODE_INDEX_INVALID),
2400 "1.1.1.200/32 removed");
2402 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
2403 fib_path_list_db_size());
2404 FIB_TEST((PNBR+7 == fib_path_list_pool_size()), "path list pool size is %d",
2405 fib_path_list_pool_size());
2406 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2407 fib_entry_pool_size());
2410 * remove 200.200.200.200/32 which does have a valid via FIB
2412 fib_table_entry_path_remove(fib_index,
2416 &pfx_1_1_1_2_s_32.fp_addr,
2417 ~0, // no index provided.
2420 FIB_ROUTE_PATH_FLAG_NONE);
2422 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_200_pfx) ==
2423 FIB_NODE_INDEX_INVALID),
2424 "200.200.200.200/32 removed");
2425 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32) !=
2426 FIB_NODE_INDEX_INVALID),
2427 "1.1.1.2/32 still present");
2430 * -1 entry (BGP, the RR source is also API sourced). -1 shared path-list;
2432 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
2433 fib_path_list_db_size());
2434 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
2435 fib_path_list_pool_size());
2436 FIB_TEST((ENBR+9 == fib_entry_pool_size()), "entry pool size is %d",
2437 fib_entry_pool_size());
2440 * A recursive prefix that has a 2 path load-balance.
2441 * It also shares a next-hop with other BGP prefixes and hence
2442 * test the ref counting of RR sourced prefixes and 2 level LB.
2444 const fib_prefix_t bgp_102 = {
2446 .fp_proto = FIB_PROTOCOL_IP4,
2448 /* 100.100.100.101/32 */
2449 .ip4.as_u32 = clib_host_to_net_u32(0x64646466),
2452 fib_table_entry_path_add(fib_index,
2455 FIB_ENTRY_FLAG_NONE,
2457 &pfx_1_1_1_1_s_32.fp_addr,
2458 ~0, // no index provided.
2459 fib_index, // same as route
2462 FIB_ROUTE_PATH_FLAG_NONE);
2463 fib_table_entry_path_add(fib_index,
2466 FIB_ENTRY_FLAG_NONE,
2468 &pfx_1_1_1_2_s_32.fp_addr,
2469 ~0, // no index provided.
2470 fib_index, // same as route's FIB
2473 FIB_ROUTE_PATH_FLAG_NONE);
2474 fei = fib_table_lookup_exact_match(fib_index, &bgp_102);
2475 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "100.100.100.102/32 presnet");
2476 dpo = fib_entry_contribute_ip_forwarding(fei);
2478 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
2479 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2480 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32);
2481 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2483 lb = load_balance_get(dpo->dpoi_index);
2484 FIB_TEST((lb->lb_n_buckets == 2), "Recursive LB has %d bucket", lb->lb_n_buckets);
2485 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2486 "First via 10.10.10.1");
2487 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo->dpoi_index, 1)),
2488 "Second via 10.10.10.1");
2490 fib_table_entry_path_remove(fib_index,
2494 &pfx_1_1_1_1_s_32.fp_addr,
2495 ~0, // no index provided.
2496 fib_index, // same as route's FIB
2498 FIB_ROUTE_PATH_FLAG_NONE);
2499 fib_table_entry_path_remove(fib_index,
2503 &pfx_1_1_1_2_s_32.fp_addr,
2504 ~0, // no index provided.
2505 fib_index, // same as route's FIB
2507 FIB_ROUTE_PATH_FLAG_NONE);
2508 fei = fib_table_lookup_exact_match(fib_index, &bgp_102);
2509 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "100.100.100.102/32 removed");
2512 * remove the remaining recursives
2514 fib_table_entry_path_remove(fib_index,
2518 &pfx_1_1_1_1_s_32.fp_addr,
2519 ~0, // no index provided.
2520 fib_index, // same as route's FIB
2522 FIB_ROUTE_PATH_FLAG_NONE);
2523 fib_table_entry_path_remove(fib_index,
2527 &pfx_1_1_1_1_s_32.fp_addr,
2528 ~0, // no index provided.
2529 fib_index, // same as route's FIB
2531 FIB_ROUTE_PATH_FLAG_NONE);
2532 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_100_pfx) ==
2533 FIB_NODE_INDEX_INVALID),
2534 "100.100.100.100/32 removed");
2535 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_101_pfx) ==
2536 FIB_NODE_INDEX_INVALID),
2537 "100.100.100.101/32 removed");
2540 * -2 entry (2*BGP, the RR source is also API sourced). -1 shared path-list;
2542 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2543 fib_path_list_db_size());
2544 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2545 fib_path_list_pool_size());
2546 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2547 fib_entry_pool_size());
2550 * Add a recursive route via a connected cover, using an adj-fib that does exist
2552 fib_table_entry_path_add(fib_index,
2555 FIB_ENTRY_FLAG_NONE,
2558 ~0, // no index provided.
2559 fib_index, // Same as route's FIB
2562 FIB_ROUTE_PATH_FLAG_NONE);
2565 * +1 entry. +1 shared path-list (recursive via 10.10.10.1)
2567 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
2568 fib_path_list_db_size());
2569 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
2570 fib_path_list_pool_size());
2571 FIB_TEST((ENBR+8 == fib_entry_pool_size()), "entry pool size is %d",
2572 fib_entry_pool_size());
2574 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
2575 dpo = fib_entry_contribute_ip_forwarding(fei);
2577 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
2578 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2580 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2581 "200.200.200.200/32 is recursive via adj for 10.10.10.1");
2583 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED == fib_entry_get_flags(fei)),
2584 "Flags set on RR via existing attached");
2587 * Add a recursive route via a connected cover, using and adj-fib that does
2590 ip46_address_t nh_10_10_10_3 = {
2591 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
2593 fib_prefix_t pfx_10_10_10_3 = {
2595 .fp_proto = FIB_PROTOCOL_IP4,
2596 .fp_addr = nh_10_10_10_3,
2599 fib_table_entry_path_add(fib_index,
2602 FIB_ENTRY_FLAG_NONE,
2605 ~0, // no index provided.
2609 FIB_ROUTE_PATH_FLAG_NONE);
2612 * +2 entries (BGP and RR). +1 shared path-list (recursive via 10.10.10.3) and
2613 * one unshared non-recursive via 10.10.10.3
2615 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
2616 fib_path_list_db_size());
2617 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2618 fib_path_list_pool_size());
2619 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2620 fib_entry_pool_size());
2622 ai_03 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
2625 tm->hw[0]->sw_if_index);
2627 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2628 dpo = fib_entry_contribute_ip_forwarding(fei);
2629 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3);
2630 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2632 ai = fib_entry_get_adj(fei);
2633 FIB_TEST((ai == ai_03), "adj for 10.10.10.3/32 is via adj for 10.10.10.3");
2634 FIB_TEST(((FIB_ENTRY_FLAG_ATTACHED | FIB_ENTRY_FLAG_CONNECTED) ==
2635 fib_entry_get_flags(fei)),
2636 "Flags set on RR via non-existing attached");
2638 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2639 "adj for 200.200.200.200/32 is recursive via adj for 10.10.10.3");
2644 * remove the recursives
2646 fib_table_entry_path_remove(fib_index,
2651 ~0, // no index provided.
2652 fib_index, // same as route's FIB
2654 FIB_ROUTE_PATH_FLAG_NONE);
2655 fib_table_entry_path_remove(fib_index,
2660 ~0, // no index provided.
2661 fib_index, // same as route's FIB
2663 FIB_ROUTE_PATH_FLAG_NONE);
2665 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_201_pfx) ==
2666 FIB_NODE_INDEX_INVALID),
2667 "200.200.200.201/32 removed");
2668 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_200_pfx) ==
2669 FIB_NODE_INDEX_INVALID),
2670 "200.200.200.200/32 removed");
2671 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3) ==
2672 FIB_NODE_INDEX_INVALID),
2673 "10.10.10.3/32 removed");
2676 * -3 entries (2*BGP and RR). -2 shared path-list (recursive via 10.10.10.3 &
2677 * 10.10.10.1) and one unshared non-recursive via 10.10.10.3
2679 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2680 fib_path_list_db_size());
2681 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2682 fib_path_list_pool_size());
2683 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2684 fib_entry_pool_size());
2689 * Add 5.5.5.5/32 -> 5.5.5.6/32 -> 5.5.5.7/32 -> 5.5.5.5/32
2691 fib_prefix_t pfx_5_5_5_5_s_32 = {
2693 .fp_proto = FIB_PROTOCOL_IP4,
2695 .ip4.as_u32 = clib_host_to_net_u32(0x05050505),
2698 fib_prefix_t pfx_5_5_5_6_s_32 = {
2700 .fp_proto = FIB_PROTOCOL_IP4,
2702 .ip4.as_u32 = clib_host_to_net_u32(0x05050506),
2705 fib_prefix_t pfx_5_5_5_7_s_32 = {
2707 .fp_proto = FIB_PROTOCOL_IP4,
2709 .ip4.as_u32 = clib_host_to_net_u32(0x05050507),
2713 fib_table_entry_path_add(fib_index,
2716 FIB_ENTRY_FLAG_NONE,
2718 &pfx_5_5_5_6_s_32.fp_addr,
2719 ~0, // no index provided.
2723 FIB_ROUTE_PATH_FLAG_NONE);
2724 fib_table_entry_path_add(fib_index,
2727 FIB_ENTRY_FLAG_NONE,
2729 &pfx_5_5_5_7_s_32.fp_addr,
2730 ~0, // no index provided.
2734 FIB_ROUTE_PATH_FLAG_NONE);
2735 fib_table_entry_path_add(fib_index,
2738 FIB_ENTRY_FLAG_NONE,
2740 &pfx_5_5_5_5_s_32.fp_addr,
2741 ~0, // no index provided.
2745 FIB_ROUTE_PATH_FLAG_NONE);
2747 * +3 entries, +3 shared path-list
2749 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2750 fib_path_list_db_size());
2751 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2752 fib_path_list_pool_size());
2753 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2754 fib_entry_pool_size());
2757 * All the entries have only looped paths, so they are all drop
2759 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2760 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2761 "LB for 5.5.5.7/32 is via adj for DROP");
2762 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2763 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2764 "LB for 5.5.5.5/32 is via adj for DROP");
2765 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2766 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2767 "LB for 5.5.5.6/32 is via adj for DROP");
2770 * provide 5.5.5.6/32 with alternate path.
2771 * this will allow only 5.5.5.6/32 to forward with this path, the others
2772 * are still drop since the loop is still present.
2774 fib_table_entry_path_add(fib_index,
2777 FIB_ENTRY_FLAG_NONE,
2780 tm->hw[0]->sw_if_index,
2784 FIB_ROUTE_PATH_FLAG_NONE);
2786 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2787 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2789 lb = load_balance_get(dpo1->dpoi_index);
2790 FIB_TEST((lb->lb_n_buckets == 1), "5.5.5.6 LB has %d bucket", lb->lb_n_buckets);
2792 dpo2 = load_balance_get_bucket(dpo1->dpoi_index, 0);
2793 FIB_TEST(DPO_ADJACENCY == dpo2->dpoi_type, "type is %d", dpo2->dpoi_type);
2794 FIB_TEST((ai_01 == dpo2->dpoi_index),
2795 "5.5.5.6 bucket 0 resolves via 10.10.10.2");
2797 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2798 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2799 "LB for 5.5.5.7/32 is via adj for DROP");
2800 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2801 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2802 "LB for 5.5.5.5/32 is via adj for DROP");
2805 * remove the alternate path for 5.5.5.6/32
2808 fib_table_entry_path_remove(fib_index,
2813 tm->hw[0]->sw_if_index,
2816 FIB_ROUTE_PATH_FLAG_NONE);
2818 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2819 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2820 "LB for 5.5.5.7/32 is via adj for DROP");
2821 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2822 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2823 "LB for 5.5.5.5/32 is via adj for DROP");
2824 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2825 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2826 "LB for 5.5.5.6/32 is via adj for DROP");
2829 * break the loop by giving 5.5.5.5/32 a new set of paths
2830 * expect all to forward via this new path.
2832 fib_table_entry_update_one_path(fib_index,
2835 FIB_ENTRY_FLAG_NONE,
2838 tm->hw[0]->sw_if_index,
2839 ~0, // invalid fib index
2842 FIB_ROUTE_PATH_FLAG_NONE);
2844 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2845 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2846 lb = load_balance_get(dpo1->dpoi_index);
2847 FIB_TEST((lb->lb_n_buckets == 1), "5.5.5.5 LB has %d bucket", lb->lb_n_buckets);
2849 dpo2 = load_balance_get_bucket(dpo1->dpoi_index, 0);
2850 FIB_TEST(DPO_ADJACENCY == dpo2->dpoi_type, "type is %d", dpo2->dpoi_type);
2851 FIB_TEST((ai_01 == dpo2->dpoi_index),
2852 "5.5.5.5 bucket 0 resolves via 10.10.10.2");
2854 fei = fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_7_s_32);
2855 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2857 lb = load_balance_get(dpo2->dpoi_index);
2858 FIB_TEST((lb->lb_n_buckets == 1), "Recursive LB has %d bucket", lb->lb_n_buckets);
2859 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo2->dpoi_index, 0)),
2860 "5.5.5.5.7 via 5.5.5.5");
2862 fei = fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_6_s_32);
2863 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2865 lb = load_balance_get(dpo1->dpoi_index);
2866 FIB_TEST((lb->lb_n_buckets == 1), "Recursive LB has %d bucket", lb->lb_n_buckets);
2867 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
2868 "5.5.5.5.6 via 5.5.5.7");
2871 * revert back to the loop. so we can remove the prefixes with
2874 fib_table_entry_update_one_path(fib_index,
2877 FIB_ENTRY_FLAG_NONE,
2879 &pfx_5_5_5_6_s_32.fp_addr,
2880 ~0, // no index provided.
2884 FIB_ROUTE_PATH_FLAG_NONE);
2886 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2887 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2888 "LB for 5.5.5.7/32 is via adj for DROP");
2889 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2890 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2891 "LB for 5.5.5.5/32 is via adj for DROP");
2892 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2893 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2894 "LB for 5.5.5.6/32 is via adj for DROP");
2897 * remove all the 5.5.5.x/32 prefixes
2899 fib_table_entry_path_remove(fib_index,
2903 &pfx_5_5_5_6_s_32.fp_addr,
2904 ~0, // no index provided.
2905 fib_index, // same as route's FIB
2907 FIB_ROUTE_PATH_FLAG_NONE);
2908 fib_table_entry_path_remove(fib_index,
2912 &pfx_5_5_5_7_s_32.fp_addr,
2913 ~0, // no index provided.
2914 fib_index, // same as route's FIB
2916 FIB_ROUTE_PATH_FLAG_NONE);
2917 fib_table_entry_path_remove(fib_index,
2921 &pfx_5_5_5_5_s_32.fp_addr,
2922 ~0, // no index provided.
2923 fib_index, // same as route's FIB
2925 FIB_ROUTE_PATH_FLAG_NONE);
2926 fib_table_entry_path_remove(fib_index,
2931 ~0, // no index provided.
2932 fib_index, // same as route's FIB
2934 FIB_ROUTE_PATH_FLAG_NONE);
2937 * -3 entries, -3 shared path-list
2939 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2940 fib_path_list_db_size());
2941 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2942 fib_path_list_pool_size());
2943 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2944 fib_entry_pool_size());
2947 * Single level loop 5.5.5.5/32 via 5.5.5.5/32
2949 fib_table_entry_path_add(fib_index,
2952 FIB_ENTRY_FLAG_NONE,
2954 &pfx_5_5_5_6_s_32.fp_addr,
2955 ~0, // no index provided.
2959 FIB_ROUTE_PATH_FLAG_NONE);
2960 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2961 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2962 "1-level 5.5.5.6/32 loop is via adj for DROP");
2964 fib_table_entry_path_remove(fib_index,
2968 &pfx_5_5_5_6_s_32.fp_addr,
2969 ~0, // no index provided.
2970 fib_index, // same as route's FIB
2972 FIB_ROUTE_PATH_FLAG_NONE);
2973 FIB_TEST(FIB_NODE_INDEX_INVALID ==
2974 fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_6_s_32),
2975 "1-level 5.5.5.6/32 loop is removed");
2978 * A recursive route whose next-hop is covered by the prefix.
2979 * This would mean the via-fib, which inherits forwarding from its
2980 * cover, thus picks up forwarding from the prfix, which is via the
2981 * via-fib, and we have a loop.
2983 fib_prefix_t pfx_23_23_23_0_s_24 = {
2985 .fp_proto = FIB_PROTOCOL_IP4,
2987 .ip4.as_u32 = clib_host_to_net_u32(0x17171700),
2990 fib_prefix_t pfx_23_23_23_23_s_32 = {
2992 .fp_proto = FIB_PROTOCOL_IP4,
2994 .ip4.as_u32 = clib_host_to_net_u32(0x17171717),
2997 fei = fib_table_entry_path_add(fib_index,
2998 &pfx_23_23_23_0_s_24,
3000 FIB_ENTRY_FLAG_NONE,
3002 &pfx_23_23_23_23_s_32.fp_addr,
3007 FIB_ROUTE_PATH_FLAG_NONE);
3008 dpo = fib_entry_contribute_ip_forwarding(fei);
3009 FIB_TEST(load_balance_is_drop(dpo),
3010 "23.23.23.0/24 via covered is DROP");
3011 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
3014 * add-remove test. no change.
3016 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3017 fib_path_list_db_size());
3018 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3019 fib_path_list_pool_size());
3020 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3021 fib_entry_pool_size());
3024 * Make the default route recursive via a unknown next-hop. Thus the
3025 * next hop's cover would be the default route
3027 fei = fib_table_entry_path_add(fib_index,
3030 FIB_ENTRY_FLAG_NONE,
3032 &pfx_23_23_23_23_s_32.fp_addr,
3037 FIB_ROUTE_PATH_FLAG_NONE);
3038 dpo = fib_entry_contribute_ip_forwarding(fei);
3039 FIB_TEST(load_balance_is_drop(dpo),
3040 "0.0.0.0.0/0 via is DROP");
3041 FIB_TEST((fib_entry_get_resolving_interface(fei) == ~0),
3042 "no resolving interface for looped 0.0.0.0/0");
3044 fei = fib_table_lookup_exact_match(fib_index, &pfx_23_23_23_23_s_32);
3045 dpo = fib_entry_contribute_ip_forwarding(fei);
3046 FIB_TEST(load_balance_is_drop(dpo),
3047 "23.23.23.23/32 via is DROP");
3048 FIB_TEST((fib_entry_get_resolving_interface(fei) == ~0),
3049 "no resolving interface for looped 23.23.23.23/32");
3051 fib_table_entry_delete(fib_index, &pfx_0_0_0_0_s_0, FIB_SOURCE_API);
3054 * A recursive route with recursion constraints.
3055 * 200.200.200.200/32 via 1.1.1.1 is recurse via host constrained
3057 fib_table_entry_path_add(fib_index,
3060 FIB_ENTRY_FLAG_NONE,
3067 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3069 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
3070 dpo2 = fib_entry_contribute_ip_forwarding(fei);
3072 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3073 dpo1 = fib_entry_contribute_ip_forwarding(fei);
3075 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3076 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3079 * save the load-balance. we expect it to be inplace modified
3081 lb = load_balance_get(dpo1->dpoi_index);
3084 * add a covering prefix for the via fib that would otherwise serve
3085 * as the resolving route when the host is removed
3087 fib_table_entry_path_add(fib_index,
3090 FIB_ENTRY_FLAG_NONE,
3093 tm->hw[0]->sw_if_index,
3094 ~0, // invalid fib index
3097 FIB_ROUTE_PATH_FLAG_NONE);
3098 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28);
3099 ai = fib_entry_get_adj(fei);
3100 FIB_TEST((ai == ai_01),
3101 "adj for 1.1.1.0/28 is via adj for 1.1.1.1");
3104 * remove the host via FIB - expect the BGP prefix to be drop
3106 fib_table_entry_path_remove(fib_index,
3111 tm->hw[0]->sw_if_index,
3112 ~0, // invalid fib index
3114 FIB_ROUTE_PATH_FLAG_NONE);
3116 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3117 "adj for 200.200.200.200/32 is recursive via adj for DROP");
3120 * add the via-entry host reoute back. expect to resolve again
3122 fib_table_entry_path_add(fib_index,
3125 FIB_ENTRY_FLAG_NONE,
3128 tm->hw[0]->sw_if_index,
3129 ~0, // invalid fib index
3132 FIB_ROUTE_PATH_FLAG_NONE);
3133 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3134 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3137 * add another path for the recursive. it will then have 2.
3139 fib_prefix_t pfx_1_1_1_3_s_32 = {
3141 .fp_proto = FIB_PROTOCOL_IP4,
3143 .ip4.as_u32 = clib_host_to_net_u32(0x01010103),
3146 fib_table_entry_path_add(fib_index,
3149 FIB_ENTRY_FLAG_NONE,
3152 tm->hw[0]->sw_if_index,
3153 ~0, // invalid fib index
3156 FIB_ROUTE_PATH_FLAG_NONE);
3158 fib_table_entry_path_add(fib_index,
3161 FIB_ENTRY_FLAG_NONE,
3163 &pfx_1_1_1_3_s_32.fp_addr,
3168 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3171 * add a bunch load more entries using this path combo so that we get
3172 * an LB-map created.
3175 fib_prefix_t bgp_78s[N_P];
3176 for (ii = 0; ii < N_P; ii++)
3178 bgp_78s[ii].fp_len = 32;
3179 bgp_78s[ii].fp_proto = FIB_PROTOCOL_IP4;
3180 bgp_78s[ii].fp_addr.ip4.as_u32 = clib_host_to_net_u32(0x4e000000+ii);
3183 fib_table_entry_path_add(fib_index,
3186 FIB_ENTRY_FLAG_NONE,
3188 &pfx_1_1_1_3_s_32.fp_addr,
3193 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3194 fib_table_entry_path_add(fib_index,
3197 FIB_ENTRY_FLAG_NONE,
3204 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3207 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3208 dpo = fib_entry_contribute_ip_forwarding(fei);
3210 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
3211 dpo2 = fib_entry_contribute_ip_forwarding(fei);
3212 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo->dpoi_index, 0)),
3213 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3214 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_3_s_32);
3215 dpo1 = fib_entry_contribute_ip_forwarding(fei);
3216 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 1)),
3217 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.3");
3220 * expect the lb-map used by the recursive's load-balance is using both buckets
3222 load_balance_map_t *lbm;
3225 lb = load_balance_get(dpo->dpoi_index);
3227 load_balance_map_lock(lbmi);
3228 lbm = load_balance_map_get(lbmi);
3230 FIB_TEST(lbm->lbm_buckets[0] == 0,
3231 "LB maps's bucket 0 is %d",
3232 lbm->lbm_buckets[0]);
3233 FIB_TEST(lbm->lbm_buckets[1] == 1,
3234 "LB maps's bucket 1 is %d",
3235 lbm->lbm_buckets[1]);
3238 * withdraw one of the /32 via-entrys.
3239 * that ECMP path will be unresolved and forwarding should continue on the
3240 * other available path. this is an iBGP PIC edge failover.
3241 * Test the forwarding changes without re-fetching the adj from the
3242 * recursive entry. this ensures its the same one that is updated; i.e. an
3245 fib_table_entry_path_remove(fib_index,
3250 tm->hw[0]->sw_if_index,
3251 ~0, // invalid fib index
3253 FIB_ROUTE_PATH_FLAG_NONE);
3255 /* suspend so the update walk kicks int */
3256 vlib_process_suspend(vlib_get_main(), 1e-5);
3258 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3259 FIB_TEST(!dpo_cmp(dpo, fib_entry_contribute_ip_forwarding(fei)),
3260 "post PIC 200.200.200.200/32 was inplace modified");
3262 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket_i(lb, 0)),
3263 "post PIC adj for 200.200.200.200/32 is recursive"
3264 " via adj for 1.1.1.3");
3267 * the LB maps that was locked above should have been modified to remove
3268 * the path that was down, and thus its bucket points to a path that is
3271 FIB_TEST(lbm->lbm_buckets[0] == 1,
3272 "LB maps's bucket 0 is %d",
3273 lbm->lbm_buckets[0]);
3274 FIB_TEST(lbm->lbm_buckets[1] == 1,
3275 "LB maps's bucket 1 is %d",
3276 lbm->lbm_buckets[1]);
3278 load_balance_map_unlock(lbmi);
3281 * add it back. again
3283 fib_table_entry_path_add(fib_index,
3286 FIB_ENTRY_FLAG_NONE,
3289 tm->hw[0]->sw_if_index,
3290 ~0, // invalid fib index
3293 FIB_ROUTE_PATH_FLAG_NONE);
3295 /* suspend so the update walk kicks in */
3296 vlib_process_suspend(vlib_get_main(), 1e-5);
3298 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket_i(lb, 0)),
3299 "post PIC recovery adj for 200.200.200.200/32 is recursive "
3300 "via adj for 1.1.1.1");
3301 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket_i(lb, 1)),
3302 "post PIC recovery adj for 200.200.200.200/32 is recursive "
3303 "via adj for 1.1.1.3");
3305 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3306 dpo = fib_entry_contribute_ip_forwarding(fei);
3307 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3308 "post PIC 200.200.200.200/32 was inplace modified");
3311 * add a 3rd path. this makes the LB 16 buckets.
3313 fib_table_entry_path_add(fib_index,
3316 FIB_ENTRY_FLAG_NONE,
3318 &pfx_1_1_1_2_s_32.fp_addr,
3323 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3324 for (ii = 0; ii < N_P; ii++)
3326 fib_table_entry_path_add(fib_index,
3329 FIB_ENTRY_FLAG_NONE,
3331 &pfx_1_1_1_2_s_32.fp_addr,
3336 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3339 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3340 dpo = fib_entry_contribute_ip_forwarding(fei);
3341 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3342 "200.200.200.200/32 was inplace modified for 3rd path");
3343 FIB_TEST(16 == lb->lb_n_buckets,
3344 "200.200.200.200/32 was inplace modified for 3rd path to 16 buckets");
3347 load_balance_map_lock(lbmi);
3348 lbm = load_balance_map_get(lbmi);
3350 for (ii = 0; ii < 16; ii++)
3352 FIB_TEST(lbm->lbm_buckets[ii] == ii,
3353 "LB Map for 200.200.200.200/32 at %d is %d",
3354 ii, lbm->lbm_buckets[ii]);
3358 * trigger PIC by removing the first via-entry
3359 * the first 6 buckets of the map should map to the next 6
3361 fib_table_entry_path_remove(fib_index,
3366 tm->hw[0]->sw_if_index,
3369 FIB_ROUTE_PATH_FLAG_NONE);
3370 /* suspend so the update walk kicks int */
3371 vlib_process_suspend(vlib_get_main(), 1e-5);
3373 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3374 dpo = fib_entry_contribute_ip_forwarding(fei);
3375 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3376 "200.200.200.200/32 was inplace modified for 3rd path");
3377 FIB_TEST(2 == lb->lb_n_buckets,
3378 "200.200.200.200/32 was inplace modified for 3rd path remove to 2 buckets");
3380 for (ii = 0; ii < 6; ii++)
3382 FIB_TEST(lbm->lbm_buckets[ii] == ii+6,
3383 "LB Map for 200.200.200.200/32 at %d is %d",
3384 ii, lbm->lbm_buckets[ii]);
3386 for (ii = 6; ii < 16; ii++)
3388 FIB_TEST(lbm->lbm_buckets[ii] == ii,
3389 "LB Map for 200.200.200.200/32 at %d is %d",
3390 ii, lbm->lbm_buckets[ii]);
3392 load_balance_map_unlock(lbmi);
3397 fib_table_entry_path_add(fib_index,
3400 FIB_ENTRY_FLAG_NONE,
3403 tm->hw[0]->sw_if_index,
3407 FIB_ROUTE_PATH_FLAG_NONE);
3409 for (ii = 0; ii < N_P; ii++)
3411 fib_table_entry_delete(fib_index,
3414 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3415 fib_table_lookup_exact_match(fib_index, &bgp_78s[ii])),
3417 format_fib_prefix, &bgp_78s[ii]);
3419 fib_table_entry_path_remove(fib_index,
3423 &pfx_1_1_1_2_s_32.fp_addr,
3427 MPLS_LABEL_INVALID);
3428 fib_table_entry_path_remove(fib_index,
3436 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3437 fib_table_entry_path_remove(fib_index,
3441 &pfx_1_1_1_3_s_32.fp_addr,
3445 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3446 fib_table_entry_delete(fib_index,
3449 fib_table_entry_delete(fib_index,
3452 /* suspend so the update walk kicks int */
3453 vlib_process_suspend(vlib_get_main(), 1e-5);
3454 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3455 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28)),
3456 "1.1.1.1/28 removed");
3457 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3458 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_3_s_32)),
3459 "1.1.1.3/32 removed");
3460 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3461 fib_table_lookup_exact_match(fib_index, &bgp_200_pfx)),
3462 "200.200.200.200/32 removed");
3465 * add-remove test. no change.
3467 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3468 fib_path_list_db_size());
3469 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3470 fib_path_list_pool_size());
3471 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3472 fib_entry_pool_size());
3475 * A route whose paths are built up iteratively and then removed
3478 fib_prefix_t pfx_4_4_4_4_s_32 = {
3480 .fp_proto = FIB_PROTOCOL_IP4,
3483 .ip4.as_u32 = clib_host_to_net_u32(0x04040404),
3487 fib_table_entry_path_add(fib_index,
3490 FIB_ENTRY_FLAG_NONE,
3493 tm->hw[0]->sw_if_index,
3497 FIB_ROUTE_PATH_FLAG_NONE);
3498 fib_table_entry_path_add(fib_index,
3501 FIB_ENTRY_FLAG_NONE,
3504 tm->hw[0]->sw_if_index,
3508 FIB_ROUTE_PATH_FLAG_NONE);
3509 fib_table_entry_path_add(fib_index,
3512 FIB_ENTRY_FLAG_NONE,
3515 tm->hw[0]->sw_if_index,
3519 FIB_ROUTE_PATH_FLAG_NONE);
3520 FIB_TEST(FIB_NODE_INDEX_INVALID !=
3521 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3522 "4.4.4.4/32 present");
3524 fib_table_entry_delete(fib_index,
3527 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3528 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3529 "4.4.4.4/32 removed");
3532 * add-remove test. no change.
3534 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3535 fib_path_list_db_size());
3536 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3537 fib_path_list_pool_size());
3538 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3539 fib_entry_pool_size());
3542 * A route with multiple paths at once
3544 fib_route_path_t *r_paths = NULL;
3546 for (ii = 0; ii < 4; ii++)
3548 fib_route_path_t r_path = {
3549 .frp_proto = DPO_PROTO_IP4,
3551 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02 + ii),
3553 .frp_sw_if_index = tm->hw[0]->sw_if_index,
3555 .frp_fib_index = ~0,
3557 vec_add1(r_paths, r_path);
3560 fib_table_entry_update(fib_index,
3563 FIB_ENTRY_FLAG_NONE,
3566 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3567 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3568 dpo = fib_entry_contribute_ip_forwarding(fei);
3570 lb = load_balance_get(dpo->dpoi_index);
3571 FIB_TEST((lb->lb_n_buckets == 4), "4.4.4.4/32 lb over %d paths", lb->lb_n_buckets);
3573 fib_table_entry_delete(fib_index,
3576 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3577 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3578 "4.4.4.4/32 removed");
3582 * add-remove test. no change.
3584 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3585 fib_path_list_db_size());
3586 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3587 fib_path_list_pool_size());
3588 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3589 fib_entry_pool_size());
3592 * A route deag route
3594 fib_table_entry_path_add(fib_index,
3597 FIB_ENTRY_FLAG_NONE,
3604 FIB_ROUTE_PATH_FLAG_NONE);
3606 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3607 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3609 dpo = fib_entry_contribute_ip_forwarding(fei);
3610 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
3611 lookup_dpo_t *lkd = lookup_dpo_get(dpo->dpoi_index);
3613 FIB_TEST((fib_index == lkd->lkd_fib_index),
3614 "4.4.4.4/32 is deag in %d %U",
3616 format_dpo_id, dpo, 0);
3617 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
3618 "4.4.4.4/32 is source deag in %d %U",
3620 format_dpo_id, dpo, 0);
3622 fib_table_entry_delete(fib_index,
3625 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3626 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3627 "4.4.4.4/32 removed");
3631 * A route deag route in a source lookup table
3633 fib_table_entry_path_add(fib_index,
3636 FIB_ENTRY_FLAG_NONE,
3643 FIB_ROUTE_PATH_SOURCE_LOOKUP);
3645 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3646 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3648 dpo = fib_entry_contribute_ip_forwarding(fei);
3649 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
3650 lkd = lookup_dpo_get(dpo->dpoi_index);
3652 FIB_TEST((fib_index == lkd->lkd_fib_index),
3653 "4.4.4.4/32 is deag in %d %U",
3655 format_dpo_id, dpo, 0);
3656 FIB_TEST((LOOKUP_INPUT_SRC_ADDR == lkd->lkd_input),
3657 "4.4.4.4/32 is source deag in %d %U",
3659 format_dpo_id, dpo, 0);
3661 fib_table_entry_delete(fib_index,
3664 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3665 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3666 "4.4.4.4/32 removed");
3670 * add-remove test. no change.
3672 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3673 fib_path_list_db_size());
3674 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3675 fib_path_list_pool_size());
3676 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3677 fib_entry_pool_size());
3681 * add a recursive with duplicate paths. Expect the duplicate to be ignored.
3683 fib_prefix_t pfx_34_1_1_1_s_32 = {
3685 .fp_proto = FIB_PROTOCOL_IP4,
3687 .ip4.as_u32 = clib_host_to_net_u32(0x22010101),
3690 fib_prefix_t pfx_34_34_1_1_s_32 = {
3692 .fp_proto = FIB_PROTOCOL_IP4,
3694 .ip4.as_u32 = clib_host_to_net_u32(0x22220101),
3697 fei = fib_table_entry_path_add(fib_index,
3698 &pfx_34_34_1_1_s_32,
3700 FIB_ENTRY_FLAG_NONE,
3703 tm->hw[0]->sw_if_index,
3707 FIB_ROUTE_PATH_FLAG_NONE);
3708 fei = fib_table_entry_path_add(fib_index,
3711 FIB_ENTRY_FLAG_NONE,
3713 &pfx_34_34_1_1_s_32.fp_addr,
3718 FIB_ROUTE_PATH_FLAG_NONE);
3719 fei = fib_table_entry_path_add(fib_index,
3722 FIB_ENTRY_FLAG_NONE,
3724 &pfx_34_34_1_1_s_32.fp_addr,
3729 FIB_ROUTE_PATH_FLAG_NONE);
3730 FIB_TEST_REC_FORW(&pfx_34_1_1_1_s_32, &pfx_34_34_1_1_s_32, 0);
3731 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
3732 fib_table_entry_delete(fib_index,
3733 &pfx_34_34_1_1_s_32,
3738 * remove: 1.1.1.2/32, 1.1.2.0/24 and 1.1.1.1/32
3739 * all of which are via 10.10.10.1, Itf1
3741 fib_table_entry_path_remove(fib_index,
3746 tm->hw[0]->sw_if_index,
3749 FIB_ROUTE_PATH_FLAG_NONE);
3750 fib_table_entry_path_remove(fib_index,
3755 tm->hw[0]->sw_if_index,
3758 FIB_ROUTE_PATH_FLAG_NONE);
3759 fib_table_entry_path_remove(fib_index,
3764 tm->hw[0]->sw_if_index,
3767 FIB_ROUTE_PATH_FLAG_NONE);
3769 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3770 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32),
3771 "1.1.1.1/32 removed");
3772 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3773 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32),
3774 "1.1.1.2/32 removed");
3775 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3776 fib_table_lookup_exact_match(fib_index, &pfx_1_1_2_0_s_24),
3777 "1.1.2.0/24 removed");
3780 * -3 entries and -1 shared path-list
3782 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
3783 fib_path_list_db_size());
3784 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
3785 fib_path_list_pool_size());
3786 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
3787 fib_entry_pool_size());
3790 * An attached-host route. Expect to link to the incomplete adj
3792 fib_prefix_t pfx_4_1_1_1_s_32 = {
3794 .fp_proto = FIB_PROTOCOL_IP4,
3797 .ip4.as_u32 = clib_host_to_net_u32(0x04010101),
3800 fib_table_entry_path_add(fib_index,
3803 FIB_ENTRY_FLAG_NONE,
3806 tm->hw[0]->sw_if_index,
3810 FIB_ROUTE_PATH_FLAG_NONE);
3812 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_1_1_1_s_32);
3813 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.1.1.1/32 present");
3814 ai = fib_entry_get_adj(fei);
3816 ai2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
3818 &pfx_4_1_1_1_s_32.fp_addr,
3819 tm->hw[0]->sw_if_index);
3820 FIB_TEST((ai == ai2), "Attached-host link to incomplete ADJ");
3824 * +1 entry and +1 shared path-list
3826 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3827 fib_path_list_db_size());
3828 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3829 fib_path_list_pool_size());
3830 FIB_TEST((ENBR+5 == fib_entry_pool_size()), "entry pool size is %d",
3831 fib_entry_pool_size());
3833 fib_table_entry_delete(fib_index,
3837 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
3838 fib_path_list_db_size());
3839 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
3840 fib_path_list_pool_size());
3841 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
3842 fib_entry_pool_size());
3845 * add a v6 prefix via v4 next-hops
3847 fib_prefix_t pfx_2001_s_64 = {
3849 .fp_proto = FIB_PROTOCOL_IP6,
3851 .ip6.as_u64[0] = clib_host_to_net_u64(0x2001000000000000),
3854 fei = fib_table_entry_path_add(0, //default v6 table
3857 FIB_ENTRY_FLAG_NONE,
3860 tm->hw[0]->sw_if_index,
3864 FIB_ROUTE_PATH_FLAG_NONE);
3866 fei = fib_table_lookup_exact_match(0, &pfx_2001_s_64);
3867 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "2001::/64 present");
3868 ai = fib_entry_get_adj(fei);
3870 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_ARP),
3871 "2001::/64 via ARP-adj");
3872 FIB_TEST((adj->ia_link == VNET_LINK_IP6),
3873 "2001::/64 is link type v6");
3874 FIB_TEST((adj->ia_nh_proto == FIB_PROTOCOL_IP4),
3875 "2001::/64 ADJ-adj is NH proto v4");
3876 fib_table_entry_delete(0, &pfx_2001_s_64, FIB_SOURCE_API);
3879 * add a uRPF exempt prefix:
3881 * - it's forwarding is drop
3882 * - it's uRPF list is not empty
3883 * - the uRPF list for the default route (it's cover) is empty
3885 fei = fib_table_entry_special_add(fib_index,
3887 FIB_SOURCE_URPF_EXEMPT,
3888 FIB_ENTRY_FLAG_DROP);
3889 dpo = fib_entry_contribute_ip_forwarding(fei);
3890 FIB_TEST(load_balance_is_drop(dpo),
3891 "uRPF exempt 4.1.1.1/32 DROP");
3892 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1, 0),
3893 "uRPF list for exempt prefix has itf index 0");
3894 fei = fib_table_lookup_exact_match(fib_index, &pfx_0_0_0_0_s_0);
3895 FIB_TEST(fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
3896 "uRPF list for 0.0.0.0/0 empty");
3898 fib_table_entry_delete(fib_index, &pfx_4_1_1_1_s_32, FIB_SOURCE_URPF_EXEMPT);
3901 * An adj-fib that fails the refinement criteria - no connected cover
3903 fib_prefix_t pfx_12_10_10_2_s_32 = {
3905 .fp_proto = FIB_PROTOCOL_IP4,
3908 .ip4.as_u32 = clib_host_to_net_u32(0x0c0a0a02),
3912 fib_table_entry_path_add(fib_index,
3913 &pfx_12_10_10_2_s_32,
3915 FIB_ENTRY_FLAG_ATTACHED,
3917 &pfx_12_10_10_2_s_32.fp_addr,
3918 tm->hw[0]->sw_if_index,
3919 ~0, // invalid fib index
3922 FIB_ROUTE_PATH_FLAG_NONE);
3924 fei = fib_table_lookup_exact_match(fib_index, &pfx_12_10_10_2_s_32);
3925 dpo = fib_entry_contribute_ip_forwarding(fei);
3926 FIB_TEST(!dpo_id_is_valid(dpo),
3927 "no connected cover adj-fib fails refinement");
3929 fib_table_entry_delete(fib_index,
3930 &pfx_12_10_10_2_s_32,
3934 * An adj-fib that fails the refinement criteria - cover is connected
3935 * but on a different interface
3937 fib_prefix_t pfx_10_10_10_127_s_32 = {
3939 .fp_proto = FIB_PROTOCOL_IP4,
3942 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a7f),
3946 fib_table_entry_path_add(fib_index,
3947 &pfx_10_10_10_127_s_32,
3949 FIB_ENTRY_FLAG_ATTACHED,
3951 &pfx_10_10_10_127_s_32.fp_addr,
3952 tm->hw[1]->sw_if_index,
3953 ~0, // invalid fib index
3956 FIB_ROUTE_PATH_FLAG_NONE);
3958 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_127_s_32);
3959 dpo = fib_entry_contribute_ip_forwarding(fei);
3960 FIB_TEST(!dpo_id_is_valid(dpo),
3961 "wrong interface adj-fib fails refinement");
3963 fib_table_entry_delete(fib_index,
3964 &pfx_10_10_10_127_s_32,
3968 * add a second path to an adj-fib
3969 * this is a sumiluation of another ARP entry created
3970 * on an interface on which the connected prefi does not exist.
3971 * The second path fails refinement. Expect to forward through the
3974 fib_prefix_t pfx_10_10_10_3_s_32 = {
3976 .fp_proto = FIB_PROTOCOL_IP4,
3979 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
3983 ai_03 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
3986 tm->hw[0]->sw_if_index);
3988 fib_test_lb_bucket_t ip_o_10_10_10_3 = {
3994 fei = fib_table_entry_path_add(fib_index,
3995 &pfx_10_10_10_3_s_32,
3997 FIB_ENTRY_FLAG_NONE,
4000 tm->hw[0]->sw_if_index,
4004 FIB_ROUTE_PATH_FLAG_NONE);
4005 fei = fib_table_entry_path_add(fib_index,
4006 &pfx_10_10_10_3_s_32,
4008 FIB_ENTRY_FLAG_NONE,
4011 tm->hw[1]->sw_if_index,
4015 FIB_ROUTE_PATH_FLAG_NONE);
4016 FIB_TEST(fib_test_validate_entry(fei,
4017 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4020 "10.10.10.3 via 10.10.10.3/Eth0 only");
4023 * remove the path that refines the cover, should go unresolved
4025 fib_table_entry_path_remove(fib_index,
4026 &pfx_10_10_10_3_s_32,
4030 tm->hw[0]->sw_if_index,
4033 FIB_ROUTE_PATH_FLAG_NONE);
4034 dpo = fib_entry_contribute_ip_forwarding(fei);
4035 FIB_TEST(!dpo_id_is_valid(dpo),
4036 "wrong interface adj-fib fails refinement");
4039 * add back the path that refines the cover
4041 fei = fib_table_entry_path_add(fib_index,
4042 &pfx_10_10_10_3_s_32,
4044 FIB_ENTRY_FLAG_NONE,
4047 tm->hw[0]->sw_if_index,
4051 FIB_ROUTE_PATH_FLAG_NONE);
4052 FIB_TEST(fib_test_validate_entry(fei,
4053 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4056 "10.10.10.3 via 10.10.10.3/Eth0 only");
4059 * remove the path that does not refine the cover
4061 fib_table_entry_path_remove(fib_index,
4062 &pfx_10_10_10_3_s_32,
4066 tm->hw[1]->sw_if_index,
4069 FIB_ROUTE_PATH_FLAG_NONE);
4070 FIB_TEST(fib_test_validate_entry(fei,
4071 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4074 "10.10.10.3 via 10.10.10.3/Eth0 only");
4077 * remove the path that does refine, it's the last path, so
4078 * the entry should be gone
4080 fib_table_entry_path_remove(fib_index,
4081 &pfx_10_10_10_3_s_32,
4085 tm->hw[0]->sw_if_index,
4088 FIB_ROUTE_PATH_FLAG_NONE);
4089 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
4090 FIB_TEST((fei == FIB_NODE_INDEX_INVALID), "10.10.10.3 gone");
4095 * change the table's flow-hash config - expect the update to propagete to
4096 * the entries' load-balance objects
4098 flow_hash_config_t old_hash_config, new_hash_config;
4100 old_hash_config = fib_table_get_flow_hash_config(fib_index,
4102 new_hash_config = (IP_FLOW_HASH_SRC_ADDR |
4103 IP_FLOW_HASH_DST_ADDR);
4105 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
4106 dpo = fib_entry_contribute_ip_forwarding(fei);
4107 lb = load_balance_get(dpo->dpoi_index);
4108 FIB_TEST((lb->lb_hash_config == old_hash_config),
4109 "Table and LB hash config match: %U",
4110 format_ip_flow_hash_config, lb->lb_hash_config);
4112 fib_table_set_flow_hash_config(fib_index, FIB_PROTOCOL_IP4, new_hash_config);
4114 FIB_TEST((lb->lb_hash_config == new_hash_config),
4115 "Table and LB newhash config match: %U",
4116 format_ip_flow_hash_config, lb->lb_hash_config);
4119 * A route via an L2 Bridge
4121 fei = fib_table_entry_path_add(fib_index,
4122 &pfx_10_10_10_3_s_32,
4124 FIB_ENTRY_FLAG_NONE,
4127 tm->hw[0]->sw_if_index,
4131 FIB_ROUTE_PATH_FLAG_NONE);
4132 dpo_id_t l2_dpo = DPO_INVALID;
4133 l2_bridge_dpo_add_or_lock(tm->hw[0]->sw_if_index, &l2_dpo);
4134 fib_test_lb_bucket_t ip_o_l2 = {
4137 .adj = l2_dpo.dpoi_index,
4141 FIB_TEST(fib_test_validate_entry(fei,
4142 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4145 "10.10.10.3 via L2 on Eth0");
4146 fib_table_entry_path_remove(fib_index,
4147 &pfx_10_10_10_3_s_32,
4151 tm->hw[0]->sw_if_index,
4154 FIB_ROUTE_PATH_FLAG_NONE);
4161 fib_table_entry_delete(fib_index,
4162 &pfx_10_10_10_1_s_32,
4164 fib_table_entry_delete(fib_index,
4165 &pfx_10_10_10_2_s_32,
4167 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4168 fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32),
4169 "10.10.10.1/32 adj-fib removed");
4170 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4171 fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32),
4172 "10.10.10.2/32 adj-fib removed");
4175 * -2 entries and -2 non-shared path-list
4177 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4178 fib_path_list_db_size());
4179 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is %d",
4180 fib_path_list_pool_size());
4181 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
4182 fib_entry_pool_size());
4185 * unlock the adjacencies for which this test provided a rewrite.
4186 * These are the last locks on these adjs. they should thus go away.
4190 adj_unlock(ai_12_12_12_12);
4192 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
4197 * remove the interface prefixes
4199 local_pfx.fp_len = 32;
4200 fib_table_entry_special_remove(fib_index, &local_pfx,
4201 FIB_SOURCE_INTERFACE);
4202 fei = fib_table_lookup(fib_index, &local_pfx);
4204 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4205 fib_table_lookup_exact_match(fib_index, &local_pfx),
4206 "10.10.10.10/32 adj-fib removed");
4208 local_pfx.fp_len = 24;
4209 fib_table_entry_delete(fib_index, &local_pfx,
4210 FIB_SOURCE_INTERFACE);
4212 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4213 fib_table_lookup_exact_match(fib_index, &local_pfx),
4214 "10.10.10.10/24 adj-fib removed");
4217 * -2 entries and -2 non-shared path-list
4219 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4220 fib_path_list_db_size());
4221 FIB_TEST((PNBR == fib_path_list_pool_size()), "path list pool size is %d",
4222 fib_path_list_pool_size());
4223 FIB_TEST((ENBR == fib_entry_pool_size()), "entry pool size is %d",
4224 fib_entry_pool_size());
4227 * Last but not least, remove the VRF
4229 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4232 "NO API Source'd prefixes");
4233 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4236 "NO RR Source'd prefixes");
4237 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4239 FIB_SOURCE_INTERFACE)),
4240 "NO INterface Source'd prefixes");
4242 fib_table_unlock(fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_API);
4244 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4245 fib_path_list_db_size());
4246 FIB_TEST((PNBR-5 == fib_path_list_pool_size()), "path list pool size is %d",
4247 fib_path_list_pool_size());
4248 FIB_TEST((ENBR-5 == fib_entry_pool_size()), "entry pool size is %d",
4249 fib_entry_pool_size());
4250 FIB_TEST((ENBR-5 == pool_elts(fib_urpf_list_pool)), "uRPF pool size is %d",
4251 pool_elts(fib_urpf_list_pool));
4252 FIB_TEST((0 == pool_elts(load_balance_map_pool)), "LB-map pool size is %d",
4253 pool_elts(load_balance_map_pool));
4254 FIB_TEST((lb_count == pool_elts(load_balance_pool)), "LB pool size is %d",
4255 pool_elts(load_balance_pool));
4256 FIB_TEST((0 == pool_elts(l2_bridge_dpo_pool)), "L2 DPO pool size is %d",
4257 pool_elts(l2_bridge_dpo_pool));
4266 * In the default table check for the presence and correct forwarding
4267 * of the special entries
4269 fib_node_index_t dfrt, fei, ai, locked_ai, ai_01, ai_02;
4270 const dpo_id_t *dpo, *dpo_drop;
4271 const ip_adjacency_t *adj;
4272 const receive_dpo_t *rd;
4277 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
4280 /* via 2001:0:0:1::2 */
4281 ip46_address_t nh_2001_2 = {
4284 [0] = clib_host_to_net_u64(0x2001000000000001),
4285 [1] = clib_host_to_net_u64(0x0000000000000002),
4292 dpo_drop = drop_dpo_get(DPO_PROTO_IP6);
4294 /* Find or create FIB table 11 */
4295 fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP6, 11,
4298 for (ii = 0; ii < 4; ii++)
4300 ip6_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = fib_index;
4303 fib_prefix_t pfx_0_0 = {
4305 .fp_proto = FIB_PROTOCOL_IP6,
4313 dfrt = fib_table_lookup(fib_index, &pfx_0_0);
4314 FIB_TEST((FIB_NODE_INDEX_INVALID != dfrt), "default route present");
4315 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
4316 "Default route is DROP");
4318 dpo = fib_entry_contribute_ip_forwarding(dfrt);
4319 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4322 &pfx_0_0.fp_addr.ip6)),
4323 "default-route; fwd and non-fwd tables match");
4325 // FIXME - check specials.
4328 * At this stage there is one v4 FIB with 5 routes and two v6 FIBs
4329 * each with 2 entries and a v6 mfib with 4 path-lists.
4330 * All entries are special so no path-list sharing.
4333 #define PNPS (5+4+4)
4334 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
4335 FIB_TEST((PNPS == fib_path_list_pool_size()), "path list pool size is %d",
4336 fib_path_list_pool_size());
4337 FIB_TEST((ENPS == fib_entry_pool_size()), "entry pool size is %d",
4338 fib_entry_pool_size());
4341 * add interface routes.
4342 * validate presence of /64 attached and /128 recieve.
4343 * test for the presence of the receive address in the glean and local adj
4345 * receive on 2001:0:0:1::1/128
4347 fib_prefix_t local_pfx = {
4349 .fp_proto = FIB_PROTOCOL_IP6,
4353 [0] = clib_host_to_net_u64(0x2001000000000001),
4354 [1] = clib_host_to_net_u64(0x0000000000000001),
4360 fib_table_entry_update_one_path(fib_index, &local_pfx,
4361 FIB_SOURCE_INTERFACE,
4362 (FIB_ENTRY_FLAG_CONNECTED |
4363 FIB_ENTRY_FLAG_ATTACHED),
4366 tm->hw[0]->sw_if_index,
4370 FIB_ROUTE_PATH_FLAG_NONE);
4371 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4373 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
4375 ai = fib_entry_get_adj(fei);
4376 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "attached interface route adj present");
4378 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
4379 "attached interface adj is glean");
4380 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
4381 &adj->sub_type.glean.receive_addr)),
4382 "attached interface adj is receive ok");
4383 dpo = fib_entry_contribute_ip_forwarding(fei);
4384 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4387 &local_pfx.fp_addr.ip6)),
4388 "attached-route; fwd and non-fwd tables match");
4390 local_pfx.fp_len = 128;
4391 fib_table_entry_update_one_path(fib_index, &local_pfx,
4392 FIB_SOURCE_INTERFACE,
4393 (FIB_ENTRY_FLAG_CONNECTED |
4394 FIB_ENTRY_FLAG_LOCAL),
4397 tm->hw[0]->sw_if_index,
4398 ~0, // invalid fib index
4401 FIB_ROUTE_PATH_FLAG_NONE);
4402 fei = fib_table_lookup(fib_index, &local_pfx);
4404 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
4406 dpo = fib_entry_contribute_ip_forwarding(fei);
4407 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4408 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
4409 "local interface adj is local");
4410 rd = receive_dpo_get(dpo->dpoi_index);
4412 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
4414 "local interface adj is receive ok");
4416 dpo = fib_entry_contribute_ip_forwarding(fei);
4417 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4420 &local_pfx.fp_addr.ip6)),
4421 "local-route; fwd and non-fwd tables match");
4424 * +2 entries. +2 unshared path-lists
4426 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
4427 FIB_TEST((PNPS+2 == fib_path_list_pool_size()), "path list pool size is%d",
4428 fib_path_list_pool_size());
4429 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4430 fib_entry_pool_size());
4433 * Modify the default route to be via an adj not yet known.
4434 * this sources the defalut route with the API source, which is
4435 * a higher preference to the DEFAULT_ROUTE source
4437 fib_table_entry_path_add(fib_index, &pfx_0_0,
4439 FIB_ENTRY_FLAG_NONE,
4442 tm->hw[0]->sw_if_index,
4446 FIB_ROUTE_PATH_FLAG_NONE);
4447 fei = fib_table_lookup(fib_index, &pfx_0_0);
4449 FIB_TEST((fei == dfrt), "default route same index");
4450 ai = fib_entry_get_adj(fei);
4451 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "default route adj present");
4453 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4454 "adj is incomplete");
4455 FIB_TEST((0 == ip46_address_cmp(&nh_2001_2, &adj->sub_type.nbr.next_hop)),
4456 "adj nbr next-hop ok");
4459 * find the adj in the shared db
4461 locked_ai = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4464 tm->hw[0]->sw_if_index);
4465 FIB_TEST((locked_ai == ai), "ADJ NBR DB find");
4466 adj_unlock(locked_ai);
4469 * no more entires. +1 shared path-list
4471 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4472 fib_path_list_db_size());
4473 FIB_TEST((PNPS+3 == fib_path_list_pool_size()), "path list pool size is%d",
4474 fib_path_list_pool_size());
4475 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4476 fib_entry_pool_size());
4479 * remove the API source from the default route. We expected
4480 * the route to remain, sourced by DEFAULT_ROUTE, and hence a DROP
4482 fib_table_entry_path_remove(fib_index, &pfx_0_0,
4486 tm->hw[0]->sw_if_index,
4489 FIB_ROUTE_PATH_FLAG_NONE);
4490 fei = fib_table_lookup(fib_index, &pfx_0_0);
4492 FIB_TEST((fei == dfrt), "default route same index");
4493 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
4494 "Default route is DROP");
4497 * no more entires. -1 shared path-list
4499 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4500 fib_path_list_db_size());
4501 FIB_TEST((PNPS+2 == fib_path_list_pool_size()), "path list pool size is%d",
4502 fib_path_list_pool_size());
4503 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4504 fib_entry_pool_size());
4507 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
4509 fib_prefix_t pfx_2001_1_2_s_128 = {
4511 .fp_proto = FIB_PROTOCOL_IP6,
4515 [0] = clib_host_to_net_u64(0x2001000000000001),
4516 [1] = clib_host_to_net_u64(0x0000000000000002),
4521 fib_prefix_t pfx_2001_1_3_s_128 = {
4523 .fp_proto = FIB_PROTOCOL_IP6,
4527 [0] = clib_host_to_net_u64(0x2001000000000001),
4528 [1] = clib_host_to_net_u64(0x0000000000000003),
4534 0xde, 0xde, 0xde, 0xba, 0xba, 0xba,
4537 ai_01 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4539 &pfx_2001_1_2_s_128.fp_addr,
4540 tm->hw[0]->sw_if_index);
4541 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_01), "adj created");
4542 adj = adj_get(ai_01);
4543 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4544 "adj is incomplete");
4545 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_2_s_128.fp_addr,
4546 &adj->sub_type.nbr.next_hop)),
4547 "adj nbr next-hop ok");
4549 adj_nbr_update_rewrite(ai_01, ADJ_NBR_REWRITE_FLAG_COMPLETE,
4550 fib_test_build_rewrite(eth_addr));
4551 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
4553 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_2_s_128.fp_addr,
4554 &adj->sub_type.nbr.next_hop)),
4555 "adj nbr next-hop ok");
4557 fib_table_entry_path_add(fib_index,
4558 &pfx_2001_1_2_s_128,
4560 FIB_ENTRY_FLAG_ATTACHED,
4562 &pfx_2001_1_2_s_128.fp_addr,
4563 tm->hw[0]->sw_if_index,
4567 FIB_ROUTE_PATH_FLAG_NONE);
4569 fei = fib_table_lookup(fib_index, &pfx_2001_1_2_s_128);
4570 ai = fib_entry_get_adj(fei);
4571 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
4575 ai_02 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4577 &pfx_2001_1_3_s_128.fp_addr,
4578 tm->hw[0]->sw_if_index);
4579 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_02), "adj created");
4580 adj = adj_get(ai_02);
4581 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4582 "adj is incomplete");
4583 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_3_s_128.fp_addr,
4584 &adj->sub_type.nbr.next_hop)),
4585 "adj nbr next-hop ok");
4587 adj_nbr_update_rewrite(ai_02, ADJ_NBR_REWRITE_FLAG_COMPLETE,
4588 fib_test_build_rewrite(eth_addr));
4589 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
4591 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_3_s_128.fp_addr,
4592 &adj->sub_type.nbr.next_hop)),
4593 "adj nbr next-hop ok");
4594 FIB_TEST((ai_01 != ai_02), "ADJs are different");
4596 fib_table_entry_path_add(fib_index,
4597 &pfx_2001_1_3_s_128,
4599 FIB_ENTRY_FLAG_ATTACHED,
4601 &pfx_2001_1_3_s_128.fp_addr,
4602 tm->hw[0]->sw_if_index,
4606 FIB_ROUTE_PATH_FLAG_NONE);
4608 fei = fib_table_lookup(fib_index, &pfx_2001_1_3_s_128);
4609 ai = fib_entry_get_adj(fei);
4610 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
4613 * +2 entries, +2 unshread path-lists.
4615 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4616 fib_path_list_db_size());
4617 FIB_TEST((PNPS+4 == fib_path_list_pool_size()), "path list pool size is%d",
4618 fib_path_list_pool_size());
4619 FIB_TEST((ENPS+4 == fib_entry_pool_size()), "entry pool size is %d",
4620 fib_entry_pool_size());
4623 * Add a 2 routes via the first ADJ. ensure path-list sharing
4625 fib_prefix_t pfx_2001_a_s_64 = {
4627 .fp_proto = FIB_PROTOCOL_IP6,
4631 [0] = clib_host_to_net_u64(0x200100000000000a),
4632 [1] = clib_host_to_net_u64(0x0000000000000000),
4637 fib_prefix_t pfx_2001_b_s_64 = {
4639 .fp_proto = FIB_PROTOCOL_IP6,
4643 [0] = clib_host_to_net_u64(0x200100000000000b),
4644 [1] = clib_host_to_net_u64(0x0000000000000000),
4650 fib_table_entry_path_add(fib_index,
4653 FIB_ENTRY_FLAG_NONE,
4656 tm->hw[0]->sw_if_index,
4660 FIB_ROUTE_PATH_FLAG_NONE);
4661 fei = fib_table_lookup(fib_index, &pfx_2001_a_s_64);
4662 ai = fib_entry_get_adj(fei);
4663 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
4664 fib_table_entry_path_add(fib_index,
4667 FIB_ENTRY_FLAG_NONE,
4670 tm->hw[0]->sw_if_index,
4674 FIB_ROUTE_PATH_FLAG_NONE);
4675 fei = fib_table_lookup(fib_index, &pfx_2001_b_s_64);
4676 ai = fib_entry_get_adj(fei);
4677 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
4680 * +2 entries, +1 shared path-list.
4682 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4683 fib_path_list_db_size());
4684 FIB_TEST((PNPS+5 == fib_path_list_pool_size()), "path list pool size is%d",
4685 fib_path_list_pool_size());
4686 FIB_TEST((ENPS+6 == fib_entry_pool_size()), "entry pool size is %d",
4687 fib_entry_pool_size());
4690 * add a v4 prefix via a v6 next-hop
4692 fib_prefix_t pfx_1_1_1_1_s_32 = {
4694 .fp_proto = FIB_PROTOCOL_IP4,
4696 .ip4.as_u32 = 0x01010101,
4699 fei = fib_table_entry_path_add(0, // default table
4702 FIB_ENTRY_FLAG_NONE,
4705 tm->hw[0]->sw_if_index,
4709 FIB_ROUTE_PATH_FLAG_NONE);
4710 FIB_TEST(fei == fib_table_lookup_exact_match(0, &pfx_1_1_1_1_s_32),
4711 "1.1.1.1/32 o v6 route present");
4712 ai = fib_entry_get_adj(fei);
4714 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_ARP),
4715 "1.1.1.1/32 via ARP-adj");
4716 FIB_TEST((adj->ia_link == VNET_LINK_IP4),
4717 "1.1.1.1/32 ADJ-adj is link type v4");
4718 FIB_TEST((adj->ia_nh_proto == FIB_PROTOCOL_IP6),
4719 "1.1.1.1/32 ADJ-adj is NH proto v6");
4720 fib_table_entry_delete(0, &pfx_1_1_1_1_s_32, FIB_SOURCE_API);
4725 fib_prefix_t pfx_2001_c_s_64 = {
4727 .fp_proto = FIB_PROTOCOL_IP6,
4731 [0] = clib_host_to_net_u64(0x200100000000000c),
4732 [1] = clib_host_to_net_u64(0x0000000000000000),
4737 fib_table_entry_path_add(fib_index,
4740 FIB_ENTRY_FLAG_ATTACHED,
4743 tm->hw[0]->sw_if_index,
4747 FIB_ROUTE_PATH_FLAG_NONE);
4748 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64);
4749 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached route present");
4750 ai = fib_entry_get_adj(fei);
4752 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_GLEAN),
4753 "2001:0:0:c/64 attached resolves via glean");
4755 fib_table_entry_path_remove(fib_index,
4760 tm->hw[0]->sw_if_index,
4763 FIB_ROUTE_PATH_FLAG_NONE);
4764 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64);
4765 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "attached route removed");
4768 * Shutdown the interface on which we have a connected and through
4769 * which the routes are reachable.
4770 * This will result in the connected, adj-fibs, and routes linking to drop
4771 * The local/for-us prefix continues to receive.
4773 clib_error_t * error;
4775 error = vnet_sw_interface_set_flags(vnet_get_main(),
4776 tm->hw[0]->sw_if_index,
4777 ~VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4778 FIB_TEST((NULL == error), "Interface shutdown OK");
4780 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4781 dpo = fib_entry_contribute_ip_forwarding(fei);
4782 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4783 "2001::b/64 resolves via drop");
4785 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4786 dpo = fib_entry_contribute_ip_forwarding(fei);
4787 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4788 "2001::a/64 resolves via drop");
4789 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4790 dpo = fib_entry_contribute_ip_forwarding(fei);
4791 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4792 "2001:0:0:1::3/64 resolves via drop");
4793 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4794 dpo = fib_entry_contribute_ip_forwarding(fei);
4795 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4796 "2001:0:0:1::2/64 resolves via drop");
4797 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4798 dpo = fib_entry_contribute_ip_forwarding(fei);
4799 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4800 "2001:0:0:1::1/128 not drop");
4801 local_pfx.fp_len = 64;
4802 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4803 dpo = fib_entry_contribute_ip_forwarding(fei);
4804 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4805 "2001:0:0:1/64 resolves via drop");
4810 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4811 fib_path_list_db_size());
4812 FIB_TEST((PNPS+5 == fib_path_list_pool_size()), "path list pool size is%d",
4813 fib_path_list_pool_size());
4814 FIB_TEST((ENPS+6 == fib_entry_pool_size()), "entry pool size is %d",
4815 fib_entry_pool_size());
4818 * shutdown one of the other interfaces, then add a connected.
4819 * and swap one of the routes to it.
4821 error = vnet_sw_interface_set_flags(vnet_get_main(),
4822 tm->hw[1]->sw_if_index,
4823 ~VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4824 FIB_TEST((NULL == error), "Interface 1 shutdown OK");
4826 fib_prefix_t connected_pfx = {
4828 .fp_proto = FIB_PROTOCOL_IP6,
4831 /* 2001:0:0:2::1/64 */
4833 [0] = clib_host_to_net_u64(0x2001000000000002),
4834 [1] = clib_host_to_net_u64(0x0000000000000001),
4839 fib_table_entry_update_one_path(fib_index, &connected_pfx,
4840 FIB_SOURCE_INTERFACE,
4841 (FIB_ENTRY_FLAG_CONNECTED |
4842 FIB_ENTRY_FLAG_ATTACHED),
4845 tm->hw[1]->sw_if_index,
4849 FIB_ROUTE_PATH_FLAG_NONE);
4850 fei = fib_table_lookup_exact_match(fib_index, &connected_pfx);
4851 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
4852 dpo = fib_entry_contribute_ip_forwarding(fei);
4853 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4854 FIB_TEST(!dpo_cmp(dpo, dpo_drop),
4855 "2001:0:0:2/64 not resolves via drop");
4857 connected_pfx.fp_len = 128;
4858 fib_table_entry_update_one_path(fib_index, &connected_pfx,
4859 FIB_SOURCE_INTERFACE,
4860 (FIB_ENTRY_FLAG_CONNECTED |
4861 FIB_ENTRY_FLAG_LOCAL),
4864 tm->hw[0]->sw_if_index,
4865 ~0, // invalid fib index
4868 FIB_ROUTE_PATH_FLAG_NONE);
4869 fei = fib_table_lookup(fib_index, &connected_pfx);
4871 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
4872 dpo = fib_entry_contribute_ip_forwarding(fei);
4873 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4874 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
4875 "local interface adj is local");
4876 rd = receive_dpo_get(dpo->dpoi_index);
4877 FIB_TEST((0 == ip46_address_cmp(&connected_pfx.fp_addr,
4879 "local interface adj is receive ok");
4882 * +2 entries, +2 unshared path-lists
4884 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4885 fib_path_list_db_size());
4886 FIB_TEST((PNPS+7 == fib_path_list_pool_size()), "path list pool size is%d",
4887 fib_path_list_pool_size());
4888 FIB_TEST((ENPS+8 == fib_entry_pool_size()), "entry pool size is %d",
4889 fib_entry_pool_size());
4893 * bring the interface back up. we expected the routes to return
4894 * to normal forwarding.
4896 error = vnet_sw_interface_set_flags(vnet_get_main(),
4897 tm->hw[0]->sw_if_index,
4898 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4899 FIB_TEST((NULL == error), "Interface bring-up OK");
4900 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4901 ai = fib_entry_get_adj(fei);
4902 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
4903 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4904 ai = fib_entry_get_adj(fei);
4905 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
4906 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4907 ai = fib_entry_get_adj(fei);
4908 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
4909 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4910 ai = fib_entry_get_adj(fei);
4911 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
4912 local_pfx.fp_len = 64;
4913 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4914 ai = fib_entry_get_adj(fei);
4916 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
4917 "attached interface adj is glean");
4920 * Same test as above, but this time the HW interface goes down
4922 error = vnet_hw_interface_set_flags(vnet_get_main(),
4923 tm->hw_if_indicies[0],
4924 ~VNET_HW_INTERFACE_FLAG_LINK_UP);
4925 FIB_TEST((NULL == error), "Interface shutdown OK");
4927 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4928 dpo = fib_entry_contribute_ip_forwarding(fei);
4929 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4930 "2001::b/64 resolves via drop");
4931 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4932 dpo = fib_entry_contribute_ip_forwarding(fei);
4933 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4934 "2001::a/64 resolves via drop");
4935 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4936 dpo = fib_entry_contribute_ip_forwarding(fei);
4937 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4938 "2001:0:0:1::3/128 resolves via drop");
4939 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4940 dpo = fib_entry_contribute_ip_forwarding(fei);
4941 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4942 "2001:0:0:1::2/128 resolves via drop");
4943 local_pfx.fp_len = 128;
4944 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4945 dpo = fib_entry_contribute_ip_forwarding(fei);
4946 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4947 "2001:0:0:1::1/128 not drop");
4948 local_pfx.fp_len = 64;
4949 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4950 dpo = fib_entry_contribute_ip_forwarding(fei);
4951 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4952 "2001:0:0:1/64 resolves via drop");
4954 error = vnet_hw_interface_set_flags(vnet_get_main(),
4955 tm->hw_if_indicies[0],
4956 VNET_HW_INTERFACE_FLAG_LINK_UP);
4957 FIB_TEST((NULL == error), "Interface bring-up OK");
4958 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4959 ai = fib_entry_get_adj(fei);
4960 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
4961 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4962 ai = fib_entry_get_adj(fei);
4963 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
4964 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4965 ai = fib_entry_get_adj(fei);
4966 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
4967 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4968 ai = fib_entry_get_adj(fei);
4969 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
4970 local_pfx.fp_len = 64;
4971 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4972 ai = fib_entry_get_adj(fei);
4974 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
4975 "attached interface adj is glean");
4978 * Delete the interface that the routes reolve through.
4979 * Again no routes are removed. They all point to drop.
4981 * This is considered an error case. The control plane should
4982 * not remove interfaces through which routes resolve, but
4983 * such things can happen. ALL affected routes will drop.
4985 vnet_delete_hw_interface(vnet_get_main(), tm->hw_if_indicies[0]);
4987 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4988 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
4989 "2001::b/64 resolves via drop");
4990 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4991 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
4992 "2001::b/64 resolves via drop");
4993 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4994 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
4995 "2001:0:0:1::3/64 resolves via drop");
4996 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4997 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
4998 "2001:0:0:1::2/64 resolves via drop");
4999 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5000 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5001 "2001:0:0:1::1/128 is drop");
5002 local_pfx.fp_len = 64;
5003 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5004 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5005 "2001:0:0:1/64 resolves via drop");
5010 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
5011 fib_path_list_db_size());
5012 FIB_TEST((PNPS+7 == fib_path_list_pool_size()), "path list pool size is%d",
5013 fib_path_list_pool_size());
5014 FIB_TEST((ENPS+8 == fib_entry_pool_size()), "entry pool size is %d",
5015 fib_entry_pool_size());
5018 * Add the interface back. routes stay unresolved.
5020 error = ethernet_register_interface(vnet_get_main(),
5021 test_interface_device_class.index,
5024 &tm->hw_if_indicies[0],
5025 /* flag change */ 0);
5027 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
5028 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5029 "2001::b/64 resolves via drop");
5030 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
5031 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5032 "2001::b/64 resolves via drop");
5033 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
5034 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5035 "2001:0:0:1::3/64 resolves via drop");
5036 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
5037 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5038 "2001:0:0:1::2/64 resolves via drop");
5039 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5040 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5041 "2001:0:0:1::1/128 is drop");
5042 local_pfx.fp_len = 64;
5043 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5044 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5045 "2001:0:0:1/64 resolves via drop");
5048 * CLEANUP ALL the routes
5050 fib_table_entry_delete(fib_index,
5053 fib_table_entry_delete(fib_index,
5056 fib_table_entry_delete(fib_index,
5059 fib_table_entry_delete(fib_index,
5060 &pfx_2001_1_3_s_128,
5062 fib_table_entry_delete(fib_index,
5063 &pfx_2001_1_2_s_128,
5065 local_pfx.fp_len = 64;
5066 fib_table_entry_delete(fib_index, &local_pfx,
5067 FIB_SOURCE_INTERFACE);
5068 local_pfx.fp_len = 128;
5069 fib_table_entry_special_remove(fib_index, &local_pfx,
5070 FIB_SOURCE_INTERFACE);
5071 connected_pfx.fp_len = 64;
5072 fib_table_entry_delete(fib_index, &connected_pfx,
5073 FIB_SOURCE_INTERFACE);
5074 connected_pfx.fp_len = 128;
5075 fib_table_entry_special_remove(fib_index, &connected_pfx,
5076 FIB_SOURCE_INTERFACE);
5078 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5079 fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64)),
5080 "2001::a/64 removed");
5081 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5082 fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64)),
5083 "2001::b/64 removed");
5084 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5085 fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128)),
5086 "2001:0:0:1::3/128 removed");
5087 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5088 fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128)),
5089 "2001:0:0:1::3/128 removed");
5090 local_pfx.fp_len = 64;
5091 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5092 fib_table_lookup_exact_match(fib_index, &local_pfx)),
5093 "2001:0:0:1/64 removed");
5094 local_pfx.fp_len = 128;
5095 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5096 fib_table_lookup_exact_match(fib_index, &local_pfx)),
5097 "2001:0:0:1::1/128 removed");
5098 connected_pfx.fp_len = 64;
5099 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5100 fib_table_lookup_exact_match(fib_index, &connected_pfx)),
5101 "2001:0:0:2/64 removed");
5102 connected_pfx.fp_len = 128;
5103 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5104 fib_table_lookup_exact_match(fib_index, &connected_pfx)),
5105 "2001:0:0:2::1/128 removed");
5108 * -8 entries. -7 path-lists (1 was shared).
5110 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
5111 fib_path_list_db_size());
5112 FIB_TEST((PNPS == fib_path_list_pool_size()), "path list pool size is%d",
5113 fib_path_list_pool_size());
5114 FIB_TEST((ENPS == fib_entry_pool_size()), "entry pool size is %d",
5115 fib_entry_pool_size());
5118 * now remove the VRF
5120 fib_table_unlock(fib_index, FIB_PROTOCOL_IP6, FIB_SOURCE_API);
5122 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
5123 fib_path_list_db_size());
5124 FIB_TEST((PNPS-2 == fib_path_list_pool_size()), "path list pool size is%d",
5125 fib_path_list_pool_size());
5126 FIB_TEST((ENPS-2 == fib_entry_pool_size()), "entry pool size is %d",
5127 fib_entry_pool_size());
5133 * return the interfaces to up state
5135 error = vnet_sw_interface_set_flags(vnet_get_main(),
5136 tm->hw[0]->sw_if_index,
5137 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5138 error = vnet_sw_interface_set_flags(vnet_get_main(),
5139 tm->hw[1]->sw_if_index,
5140 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5142 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5149 * Test Attached Exports
5154 const dpo_id_t *dpo, *dpo_drop;
5155 const u32 fib_index = 0;
5156 fib_node_index_t fei;
5163 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5167 * add interface routes. We'll assume this works. It's more rigorously
5170 fib_prefix_t local_pfx = {
5172 .fp_proto = FIB_PROTOCOL_IP4,
5176 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
5181 vec_validate(im->fib_index_by_sw_if_index, tm->hw[0]->sw_if_index);
5182 im->fib_index_by_sw_if_index[tm->hw[0]->sw_if_index] = fib_index;
5184 dpo_drop = drop_dpo_get(DPO_PROTO_IP4);
5186 fib_table_entry_update_one_path(fib_index, &local_pfx,
5187 FIB_SOURCE_INTERFACE,
5188 (FIB_ENTRY_FLAG_CONNECTED |
5189 FIB_ENTRY_FLAG_ATTACHED),
5192 tm->hw[0]->sw_if_index,
5196 FIB_ROUTE_PATH_FLAG_NONE);
5197 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5198 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
5199 "attached interface route present");
5201 local_pfx.fp_len = 32;
5202 fib_table_entry_update_one_path(fib_index, &local_pfx,
5203 FIB_SOURCE_INTERFACE,
5204 (FIB_ENTRY_FLAG_CONNECTED |
5205 FIB_ENTRY_FLAG_LOCAL),
5208 tm->hw[0]->sw_if_index,
5209 ~0, // invalid fib index
5212 FIB_ROUTE_PATH_FLAG_NONE);
5213 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5215 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
5216 "local interface route present");
5219 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
5221 fib_prefix_t pfx_10_10_10_1_s_32 = {
5223 .fp_proto = FIB_PROTOCOL_IP4,
5226 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
5229 fib_node_index_t ai;
5231 fib_table_entry_path_add(fib_index,
5232 &pfx_10_10_10_1_s_32,
5234 FIB_ENTRY_FLAG_ATTACHED,
5236 &pfx_10_10_10_1_s_32.fp_addr,
5237 tm->hw[0]->sw_if_index,
5238 ~0, // invalid fib index
5241 FIB_ROUTE_PATH_FLAG_NONE);
5243 fei = fib_table_lookup(fib_index, &pfx_10_10_10_1_s_32);
5244 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 created");
5245 ai = fib_entry_get_adj(fei);
5248 * create another FIB table into which routes will be imported
5250 u32 import_fib_index1;
5252 import_fib_index1 = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
5257 * Add an attached route in the import FIB
5259 local_pfx.fp_len = 24;
5260 fib_table_entry_update_one_path(import_fib_index1,
5263 FIB_ENTRY_FLAG_NONE,
5266 tm->hw[0]->sw_if_index,
5267 ~0, // invalid fib index
5270 FIB_ROUTE_PATH_FLAG_NONE);
5271 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5272 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
5275 * check for the presence of the adj-fibs in the import table
5277 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5278 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5279 FIB_TEST((ai == fib_entry_get_adj(fei)),
5280 "adj-fib1 Import uses same adj as export");
5283 * check for the presence of the local in the import table
5285 local_pfx.fp_len = 32;
5286 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5287 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5290 * Add another adj-fin in the export table. Expect this
5291 * to get magically exported;
5293 fib_prefix_t pfx_10_10_10_2_s_32 = {
5295 .fp_proto = FIB_PROTOCOL_IP4,
5298 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
5302 fib_table_entry_path_add(fib_index,
5303 &pfx_10_10_10_2_s_32,
5305 FIB_ENTRY_FLAG_ATTACHED,
5307 &pfx_10_10_10_2_s_32.fp_addr,
5308 tm->hw[0]->sw_if_index,
5309 ~0, // invalid fib index
5312 FIB_ROUTE_PATH_FLAG_NONE);
5313 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5314 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 present");
5315 ai = fib_entry_get_adj(fei);
5317 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5318 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5319 FIB_TEST((ai == fib_entry_get_adj(fei)),
5320 "Import uses same adj as export");
5321 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags(fei)),
5322 "ADJ-fib2 imported flags %d",
5323 fib_entry_get_flags(fei));
5326 * create a 2nd FIB table into which routes will be imported
5328 u32 import_fib_index2;
5330 import_fib_index2 = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4, 12,
5334 * Add an attached route in the import FIB
5336 local_pfx.fp_len = 24;
5337 fib_table_entry_update_one_path(import_fib_index2,
5340 FIB_ENTRY_FLAG_NONE,
5343 tm->hw[0]->sw_if_index,
5344 ~0, // invalid fib index
5347 FIB_ROUTE_PATH_FLAG_NONE);
5348 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5349 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
5352 * check for the presence of all the adj-fibs and local in the import table
5354 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_1_s_32);
5355 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5356 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_2_s_32);
5357 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5358 local_pfx.fp_len = 32;
5359 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5360 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5363 * add a 3rd adj-fib. expect it to be exported to both tables.
5365 fib_prefix_t pfx_10_10_10_3_s_32 = {
5367 .fp_proto = FIB_PROTOCOL_IP4,
5370 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
5374 fib_table_entry_path_add(fib_index,
5375 &pfx_10_10_10_3_s_32,
5377 FIB_ENTRY_FLAG_ATTACHED,
5379 &pfx_10_10_10_3_s_32.fp_addr,
5380 tm->hw[0]->sw_if_index,
5381 ~0, // invalid fib index
5384 FIB_ROUTE_PATH_FLAG_NONE);
5385 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
5386 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 present");
5387 ai = fib_entry_get_adj(fei);
5389 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_3_s_32);
5390 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 imported to FIB1");
5391 FIB_TEST((ai == fib_entry_get_adj(fei)),
5392 "Import uses same adj as export");
5393 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_3_s_32);
5394 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 imported to FIB2");
5395 FIB_TEST((ai == fib_entry_get_adj(fei)),
5396 "Import uses same adj as export");
5399 * remove the 3rd adj fib. we expect it to be removed from both FIBs
5401 fib_table_entry_delete(fib_index,
5402 &pfx_10_10_10_3_s_32,
5405 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
5406 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 remved");
5408 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_3_s_32);
5409 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 removed from FIB1");
5411 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_3_s_32);
5412 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 removed from FIB2");
5415 * remove the attached route from the 2nd FIB. expect the imported
5416 * entires to be removed
5418 local_pfx.fp_len = 24;
5419 fib_table_entry_delete(import_fib_index2,
5422 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5423 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "attached export removed");
5425 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_1_s_32);
5426 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB2");
5427 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_2_s_32);
5428 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB2");
5429 local_pfx.fp_len = 32;
5430 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5431 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB2");
5433 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5434 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 still in FIB1");
5435 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5436 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 still in FIB1");
5437 local_pfx.fp_len = 32;
5438 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5439 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local still in FIB1");
5442 * modify the route in FIB1 so it is no longer attached. expect the imported
5443 * entires to be removed
5445 local_pfx.fp_len = 24;
5446 fib_table_entry_update_one_path(import_fib_index1,
5449 FIB_ENTRY_FLAG_NONE,
5451 &pfx_10_10_10_2_s_32.fp_addr,
5452 tm->hw[0]->sw_if_index,
5453 ~0, // invalid fib index
5456 FIB_ROUTE_PATH_FLAG_NONE);
5457 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5458 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1");
5459 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5460 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5461 local_pfx.fp_len = 32;
5462 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5463 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5466 * modify it back to attached. expect the adj-fibs back
5468 local_pfx.fp_len = 24;
5469 fib_table_entry_update_one_path(import_fib_index1,
5472 FIB_ENTRY_FLAG_NONE,
5475 tm->hw[0]->sw_if_index,
5476 ~0, // invalid fib index
5479 FIB_ROUTE_PATH_FLAG_NONE);
5480 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5481 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported in FIB1");
5482 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5483 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported in FIB1");
5484 local_pfx.fp_len = 32;
5485 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5486 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported in FIB1");
5489 * add a covering attached next-hop for the interface address, so we have
5490 * a valid adj to find when we check the forwarding tables
5492 fib_prefix_t pfx_10_0_0_0_s_8 = {
5494 .fp_proto = FIB_PROTOCOL_IP4,
5497 .ip4.as_u32 = clib_host_to_net_u32(0x0a000000),
5501 fei = fib_table_entry_update_one_path(fib_index,
5504 FIB_ENTRY_FLAG_NONE,
5506 &pfx_10_10_10_3_s_32.fp_addr,
5507 tm->hw[0]->sw_if_index,
5508 ~0, // invalid fib index
5511 FIB_ROUTE_PATH_FLAG_NONE);
5512 dpo = fib_entry_contribute_ip_forwarding(fei);
5515 * remove the route in the export fib. expect the adj-fibs to be removed
5517 local_pfx.fp_len = 24;
5518 fib_table_entry_delete(fib_index,
5520 FIB_SOURCE_INTERFACE);
5522 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5523 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "Delete export: ADJ-fib1 removed from FIB1");
5524 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5525 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5526 local_pfx.fp_len = 32;
5527 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5528 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5531 * the adj-fibs in the export VRF are present in the FIB table,
5532 * but not installed in forwarding, since they have no attached cover.
5533 * Consequently a lookup in the MTRIE gives the adj for the covering
5536 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5537 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 in export");
5540 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_1_s_32.fp_addr.ip4);
5541 FIB_TEST(lbi == dpo->dpoi_index,
5542 "10.10.10.1 forwards on \n%U not \n%U",
5543 format_load_balance, lbi, 0,
5544 format_dpo_id, dpo, 0);
5545 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_2_s_32.fp_addr.ip4);
5546 FIB_TEST(lbi == dpo->dpoi_index,
5547 "10.10.10.2 forwards on %U", format_dpo_id, dpo, 0);
5548 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_3_s_32.fp_addr.ip4);
5549 FIB_TEST(lbi == dpo->dpoi_index,
5550 "10.10.10.3 forwards on %U", format_dpo_id, dpo, 0);
5553 * add the export prefix back, but not as attached.
5554 * No adj-fibs in export nor import tables
5556 local_pfx.fp_len = 24;
5557 fei = fib_table_entry_update_one_path(fib_index,
5560 FIB_ENTRY_FLAG_NONE,
5562 &pfx_10_10_10_1_s_32.fp_addr,
5563 tm->hw[0]->sw_if_index,
5564 ~0, // invalid fib index
5567 FIB_ROUTE_PATH_FLAG_NONE);
5568 dpo = fib_entry_contribute_ip_forwarding(fei);
5570 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5571 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "non-attached in export: ADJ-fib1 in export");
5572 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_1_s_32.fp_addr.ip4);
5573 FIB_TEST(lbi == dpo->dpoi_index,
5574 "10.10.10.1 forwards on %U", format_dpo_id, dpo, 0);
5575 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5576 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 in export");
5577 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_2_s_32.fp_addr.ip4);
5578 FIB_TEST(lbi == dpo->dpoi_index,
5579 "10.10.10.2 forwards on %U", format_dpo_id, dpo, 0);
5581 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5582 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1");
5583 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5584 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5585 local_pfx.fp_len = 32;
5586 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5587 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5590 * modify the export prefix so it is attached. expect all covereds to return
5592 local_pfx.fp_len = 24;
5593 fib_table_entry_update_one_path(fib_index,
5596 FIB_ENTRY_FLAG_NONE,
5599 tm->hw[0]->sw_if_index,
5600 ~0, // invalid fib index
5603 FIB_ROUTE_PATH_FLAG_NONE);
5605 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5606 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 reinstalled in export");
5607 dpo = fib_entry_contribute_ip_forwarding(fei);
5608 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5609 "Adj-fib1 is not drop in export");
5610 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5611 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 reinstalled in export");
5612 local_pfx.fp_len = 32;
5613 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5614 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local reinstalled in export");
5615 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5616 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached in export: ADJ-fib1 imported");
5617 dpo = fib_entry_contribute_ip_forwarding(fei);
5618 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5619 "Adj-fib1 is not drop in export");
5620 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5621 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5622 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5623 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5624 local_pfx.fp_len = 32;
5625 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5626 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5629 * modify the export prefix so connected. no change.
5631 local_pfx.fp_len = 24;
5632 fib_table_entry_update_one_path(fib_index, &local_pfx,
5633 FIB_SOURCE_INTERFACE,
5634 (FIB_ENTRY_FLAG_CONNECTED |
5635 FIB_ENTRY_FLAG_ATTACHED),
5638 tm->hw[0]->sw_if_index,
5642 FIB_ROUTE_PATH_FLAG_NONE);
5644 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5645 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 reinstalled in export");
5646 dpo = fib_entry_contribute_ip_forwarding(fei);
5647 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5648 "Adj-fib1 is not drop in export");
5649 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5650 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 reinstalled in export");
5651 local_pfx.fp_len = 32;
5652 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5653 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local reinstalled in export");
5654 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5655 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached in export: ADJ-fib1 imported");
5656 dpo = fib_entry_contribute_ip_forwarding(fei);
5657 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5658 "Adj-fib1 is not drop in export");
5659 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5660 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5661 local_pfx.fp_len = 32;
5662 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5663 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5668 fib_table_entry_delete(fib_index,
5671 fib_table_entry_delete(fib_index,
5672 &pfx_10_10_10_1_s_32,
5674 fib_table_entry_delete(fib_index,
5675 &pfx_10_10_10_2_s_32,
5677 local_pfx.fp_len = 32;
5678 fib_table_entry_delete(fib_index,
5680 FIB_SOURCE_INTERFACE);
5681 local_pfx.fp_len = 24;
5682 fib_table_entry_delete(fib_index,
5685 fib_table_entry_delete(fib_index,
5687 FIB_SOURCE_INTERFACE);
5688 local_pfx.fp_len = 24;
5689 fib_table_entry_delete(import_fib_index1,
5693 fib_table_unlock(import_fib_index1, FIB_PROTOCOL_IP4, FIB_SOURCE_CLI);
5694 fib_table_unlock(import_fib_index2, FIB_PROTOCOL_IP4, FIB_SOURCE_CLI);
5696 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5703 * Test Path Preference
5706 fib_test_pref (void)
5708 test_main_t *tm = &test_main;
5710 const fib_prefix_t pfx_1_1_1_1_s_32 = {
5712 .fp_proto = FIB_PROTOCOL_IP4,
5715 .as_u32 = clib_host_to_net_u32(0x01010101),
5721 * 2 high, 2 medium and 2 low preference non-recursive paths
5723 fib_route_path_t nr_path_hi_1 = {
5724 .frp_proto = DPO_PROTO_IP4,
5725 .frp_sw_if_index = tm->hw[0]->sw_if_index,
5726 .frp_fib_index = ~0,
5728 .frp_preference = 0,
5729 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5731 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
5734 fib_route_path_t nr_path_hi_2 = {
5735 .frp_proto = DPO_PROTO_IP4,
5736 .frp_sw_if_index = tm->hw[0]->sw_if_index,
5737 .frp_fib_index = ~0,
5739 .frp_preference = 0,
5740 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5742 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
5745 fib_route_path_t nr_path_med_1 = {
5746 .frp_proto = DPO_PROTO_IP4,
5747 .frp_sw_if_index = tm->hw[1]->sw_if_index,
5748 .frp_fib_index = ~0,
5750 .frp_preference = 1,
5751 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5753 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0c01),
5756 fib_route_path_t nr_path_med_2 = {
5757 .frp_proto = DPO_PROTO_IP4,
5758 .frp_sw_if_index = tm->hw[1]->sw_if_index,
5759 .frp_fib_index = ~0,
5761 .frp_preference = 1,
5762 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5764 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0c01),
5767 fib_route_path_t nr_path_low_1 = {
5768 .frp_proto = DPO_PROTO_IP4,
5769 .frp_sw_if_index = tm->hw[2]->sw_if_index,
5770 .frp_fib_index = ~0,
5772 .frp_preference = 2,
5773 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5775 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b01),
5778 fib_route_path_t nr_path_low_2 = {
5779 .frp_proto = DPO_PROTO_IP4,
5780 .frp_sw_if_index = tm->hw[2]->sw_if_index,
5781 .frp_fib_index = ~0,
5783 .frp_preference = 2,
5784 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5786 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b02),
5789 fib_route_path_t *nr_paths = NULL;
5791 vec_add1(nr_paths, nr_path_hi_1);
5792 vec_add1(nr_paths, nr_path_hi_2);
5793 vec_add1(nr_paths, nr_path_med_1);
5794 vec_add1(nr_paths, nr_path_med_2);
5795 vec_add1(nr_paths, nr_path_low_1);
5796 vec_add1(nr_paths, nr_path_low_2);
5798 adj_index_t ai_hi_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5800 &nr_path_hi_1.frp_addr,
5801 nr_path_hi_1.frp_sw_if_index);
5802 adj_index_t ai_hi_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5804 &nr_path_hi_2.frp_addr,
5805 nr_path_hi_2.frp_sw_if_index);
5806 adj_index_t ai_med_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5808 &nr_path_med_1.frp_addr,
5809 nr_path_med_1.frp_sw_if_index);
5810 adj_index_t ai_med_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5812 &nr_path_med_2.frp_addr,
5813 nr_path_med_2.frp_sw_if_index);
5814 adj_index_t ai_low_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5816 &nr_path_low_1.frp_addr,
5817 nr_path_low_1.frp_sw_if_index);
5818 adj_index_t ai_low_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5820 &nr_path_low_2.frp_addr,
5821 nr_path_low_2.frp_sw_if_index);
5823 fib_test_lb_bucket_t ip_hi_1 = {
5829 fib_test_lb_bucket_t ip_hi_2 = {
5835 fib_test_lb_bucket_t ip_med_1 = {
5841 fib_test_lb_bucket_t ip_med_2 = {
5847 fib_test_lb_bucket_t ip_low_1 = {
5853 fib_test_lb_bucket_t ip_low_2 = {
5860 fib_node_index_t fei;
5862 fei = fib_table_entry_path_add2(0,
5865 FIB_ENTRY_FLAG_NONE,
5868 FIB_TEST(fib_test_validate_entry(fei,
5869 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5873 "1.1.1.1/32 via high preference paths");
5876 * bring down the interface on which the high preference path lie
5878 vnet_sw_interface_set_flags(vnet_get_main(),
5879 tm->hw[0]->sw_if_index,
5882 FIB_TEST(fib_test_validate_entry(fei,
5883 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5887 "1.1.1.1/32 via medium preference paths");
5890 * bring down the interface on which the medium preference path lie
5892 vnet_sw_interface_set_flags(vnet_get_main(),
5893 tm->hw[1]->sw_if_index,
5896 FIB_TEST(fib_test_validate_entry(fei,
5897 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5901 "1.1.1.1/32 via low preference paths");
5904 * bring up the interface on which the high preference path lie
5906 vnet_sw_interface_set_flags(vnet_get_main(),
5907 tm->hw[0]->sw_if_index,
5908 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5910 FIB_TEST(fib_test_validate_entry(fei,
5911 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5915 "1.1.1.1/32 via high preference paths");
5918 * bring up the interface on which the medium preference path lie
5920 vnet_sw_interface_set_flags(vnet_get_main(),
5921 tm->hw[1]->sw_if_index,
5922 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5924 FIB_TEST(fib_test_validate_entry(fei,
5925 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5929 "1.1.1.1/32 via high preference paths");
5931 dpo_id_t ip_1_1_1_1 = DPO_INVALID;
5932 fib_entry_contribute_forwarding(fei,
5933 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5937 * 3 recursive paths of different preference
5939 const fib_prefix_t pfx_1_1_1_2_s_32 = {
5941 .fp_proto = FIB_PROTOCOL_IP4,
5944 .as_u32 = clib_host_to_net_u32(0x01010102),
5948 const fib_prefix_t pfx_1_1_1_3_s_32 = {
5950 .fp_proto = FIB_PROTOCOL_IP4,
5953 .as_u32 = clib_host_to_net_u32(0x01010103),
5957 fei = fib_table_entry_path_add2(0,
5960 FIB_ENTRY_FLAG_NONE,
5962 dpo_id_t ip_1_1_1_2 = DPO_INVALID;
5963 fib_entry_contribute_forwarding(fei,
5964 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5966 fei = fib_table_entry_path_add2(0,
5969 FIB_ENTRY_FLAG_NONE,
5971 dpo_id_t ip_1_1_1_3 = DPO_INVALID;
5972 fib_entry_contribute_forwarding(fei,
5973 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5976 fib_test_lb_bucket_t ip_o_1_1_1_1 = {
5979 .lb = ip_1_1_1_1.dpoi_index,
5982 fib_test_lb_bucket_t ip_o_1_1_1_2 = {
5985 .lb = ip_1_1_1_2.dpoi_index,
5988 fib_test_lb_bucket_t ip_o_1_1_1_3 = {
5991 .lb = ip_1_1_1_3.dpoi_index,
5994 fib_route_path_t r_path_hi = {
5995 .frp_proto = DPO_PROTO_IP4,
5996 .frp_sw_if_index = ~0,
5999 .frp_preference = 0,
6000 .frp_flags = FIB_ROUTE_PATH_RESOLVE_VIA_HOST,
6001 .frp_addr = pfx_1_1_1_1_s_32.fp_addr,
6003 fib_route_path_t r_path_med = {
6004 .frp_proto = DPO_PROTO_IP4,
6005 .frp_sw_if_index = ~0,
6008 .frp_preference = 10,
6009 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
6010 .frp_addr = pfx_1_1_1_2_s_32.fp_addr,
6012 fib_route_path_t r_path_low = {
6013 .frp_proto = DPO_PROTO_IP4,
6014 .frp_sw_if_index = ~0,
6017 .frp_preference = 255,
6018 .frp_flags = FIB_ROUTE_PATH_RESOLVE_VIA_HOST,
6019 .frp_addr = pfx_1_1_1_3_s_32.fp_addr,
6021 fib_route_path_t *r_paths = NULL;
6023 vec_add1(r_paths, r_path_hi);
6024 vec_add1(r_paths, r_path_low);
6025 vec_add1(r_paths, r_path_med);
6028 * add many recursive so we get the LB MAp created
6031 fib_prefix_t pfx_r[N_PFXS];
6032 unsigned int n_pfxs;
6033 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6035 pfx_r[n_pfxs].fp_len = 32;
6036 pfx_r[n_pfxs].fp_proto = FIB_PROTOCOL_IP4;
6037 pfx_r[n_pfxs].fp_addr.ip4.as_u32 =
6038 clib_host_to_net_u32(0x02000000 + n_pfxs);
6040 fei = fib_table_entry_path_add2(0,
6043 FIB_ENTRY_FLAG_NONE,
6046 FIB_TEST(fib_test_validate_entry(fei,
6047 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6050 "recursive via high preference paths");
6053 * withdraw hig pref resolving entry
6055 fib_table_entry_delete(0,
6059 /* suspend so the update walk kicks int */
6060 vlib_process_suspend(vlib_get_main(), 1e-5);
6062 FIB_TEST(fib_test_validate_entry(fei,
6063 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6066 "recursive via medium preference paths");
6069 * withdraw medium pref resolving entry
6071 fib_table_entry_delete(0,
6075 /* suspend so the update walk kicks int */
6076 vlib_process_suspend(vlib_get_main(), 1e-5);
6078 FIB_TEST(fib_test_validate_entry(fei,
6079 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6082 "recursive via low preference paths");
6085 * add back paths for next iteration
6087 fei = fib_table_entry_update(0,
6090 FIB_ENTRY_FLAG_NONE,
6092 fei = fib_table_entry_update(0,
6095 FIB_ENTRY_FLAG_NONE,
6098 /* suspend so the update walk kicks int */
6099 vlib_process_suspend(vlib_get_main(), 1e-5);
6101 fei = fib_table_lookup_exact_match(0, &pfx_r[n_pfxs]);
6102 FIB_TEST(fib_test_validate_entry(fei,
6103 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6106 "recursive via high preference paths");
6110 fib_table_entry_delete(0,
6114 /* suspend so the update walk kicks int */
6115 vlib_process_suspend(vlib_get_main(), 1e-5);
6117 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6119 fei = fib_table_lookup_exact_match(0, &pfx_r[n_pfxs]);
6121 FIB_TEST(fib_test_validate_entry(fei,
6122 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6125 "recursive via medium preference paths");
6127 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6129 fib_table_entry_delete(0,
6137 fib_table_entry_delete(0,
6140 fib_table_entry_delete(0,
6144 dpo_reset(&ip_1_1_1_1);
6145 dpo_reset(&ip_1_1_1_2);
6146 dpo_reset(&ip_1_1_1_3);
6147 adj_unlock(ai_low_2);
6148 adj_unlock(ai_low_1);
6149 adj_unlock(ai_med_2);
6150 adj_unlock(ai_med_1);
6151 adj_unlock(ai_hi_2);
6152 adj_unlock(ai_hi_1);
6157 * Test the recursive route route handling for GRE tunnels
6160 fib_test_label (void)
6162 fib_node_index_t fei, ai_mpls_10_10_10_1, ai_v4_10_10_11_1, ai_v4_10_10_11_2, ai_mpls_10_10_11_2, ai_mpls_10_10_11_1;
6163 const u32 fib_index = 0;
6168 lb_count = pool_elts(load_balance_pool);
6173 * add interface routes. We'll assume this works. It's more rigorously
6176 fib_prefix_t local0_pfx = {
6178 .fp_proto = FIB_PROTOCOL_IP4,
6182 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
6187 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
6190 vec_validate(im->fib_index_by_sw_if_index, tm->hw[0]->sw_if_index);
6191 im->fib_index_by_sw_if_index[tm->hw[0]->sw_if_index] = fib_index;
6193 fib_table_entry_update_one_path(fib_index, &local0_pfx,
6194 FIB_SOURCE_INTERFACE,
6195 (FIB_ENTRY_FLAG_CONNECTED |
6196 FIB_ENTRY_FLAG_ATTACHED),
6199 tm->hw[0]->sw_if_index,
6203 FIB_ROUTE_PATH_FLAG_NONE);
6204 fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
6205 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6206 "attached interface route present");
6208 local0_pfx.fp_len = 32;
6209 fib_table_entry_update_one_path(fib_index, &local0_pfx,
6210 FIB_SOURCE_INTERFACE,
6211 (FIB_ENTRY_FLAG_CONNECTED |
6212 FIB_ENTRY_FLAG_LOCAL),
6215 tm->hw[0]->sw_if_index,
6216 ~0, // invalid fib index
6219 FIB_ROUTE_PATH_FLAG_NONE);
6220 fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
6222 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6223 "local interface route present");
6225 fib_prefix_t local1_pfx = {
6227 .fp_proto = FIB_PROTOCOL_IP4,
6231 .as_u32 = clib_host_to_net_u32(0x0a0a0b0a),
6236 vec_validate(im->fib_index_by_sw_if_index, tm->hw[1]->sw_if_index);
6237 im->fib_index_by_sw_if_index[tm->hw[1]->sw_if_index] = fib_index;
6239 fib_table_entry_update_one_path(fib_index, &local1_pfx,
6240 FIB_SOURCE_INTERFACE,
6241 (FIB_ENTRY_FLAG_CONNECTED |
6242 FIB_ENTRY_FLAG_ATTACHED),
6245 tm->hw[1]->sw_if_index,
6249 FIB_ROUTE_PATH_FLAG_NONE);
6250 fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
6251 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6252 "attached interface route present");
6254 local1_pfx.fp_len = 32;
6255 fib_table_entry_update_one_path(fib_index, &local1_pfx,
6256 FIB_SOURCE_INTERFACE,
6257 (FIB_ENTRY_FLAG_CONNECTED |
6258 FIB_ENTRY_FLAG_LOCAL),
6261 tm->hw[1]->sw_if_index,
6262 ~0, // invalid fib index
6265 FIB_ROUTE_PATH_FLAG_NONE);
6266 fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
6268 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6269 "local interface route present");
6271 ip46_address_t nh_10_10_10_1 = {
6273 .as_u32 = clib_host_to_net_u32(0x0a0a0a01),
6276 ip46_address_t nh_10_10_11_1 = {
6278 .as_u32 = clib_host_to_net_u32(0x0a0a0b01),
6281 ip46_address_t nh_10_10_11_2 = {
6283 .as_u32 = clib_host_to_net_u32(0x0a0a0b02),
6287 ai_v4_10_10_11_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6290 tm->hw[1]->sw_if_index);
6291 ai_v4_10_10_11_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6294 tm->hw[1]->sw_if_index);
6295 ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6298 tm->hw[0]->sw_if_index);
6299 ai_mpls_10_10_11_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6302 tm->hw[1]->sw_if_index);
6303 ai_mpls_10_10_11_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6306 tm->hw[1]->sw_if_index);
6309 * Add an etry with one path with a real out-going label
6311 fib_prefix_t pfx_1_1_1_1_s_32 = {
6313 .fp_proto = FIB_PROTOCOL_IP4,
6315 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
6318 fib_test_lb_bucket_t l99_eos_o_10_10_10_1 = {
6319 .type = FT_LB_LABEL_O_ADJ,
6321 .adj = ai_mpls_10_10_10_1,
6326 fib_test_lb_bucket_t l99_neos_o_10_10_10_1 = {
6327 .type = FT_LB_LABEL_O_ADJ,
6329 .adj = ai_mpls_10_10_10_1,
6331 .eos = MPLS_NON_EOS,
6334 mpls_label_t *l99 = NULL;
6337 fib_table_entry_update_one_path(fib_index,
6340 FIB_ENTRY_FLAG_NONE,
6343 tm->hw[0]->sw_if_index,
6344 ~0, // invalid fib index
6347 FIB_ROUTE_PATH_FLAG_NONE);
6349 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6350 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.1.1.1/32 created");
6352 FIB_TEST(fib_test_validate_entry(fei,
6353 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6355 &l99_eos_o_10_10_10_1),
6356 "1.1.1.1/32 LB 1 bucket via label 99 over 10.10.10.1");
6359 * add a path with an implicit NULL label
6361 fib_test_lb_bucket_t a_o_10_10_11_1 = {
6364 .adj = ai_v4_10_10_11_1,
6367 fib_test_lb_bucket_t a_mpls_o_10_10_11_1 = {
6370 .adj = ai_mpls_10_10_11_1,
6373 mpls_label_t *l_imp_null = NULL;
6374 vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL);
6376 fei = fib_table_entry_path_add(fib_index,
6379 FIB_ENTRY_FLAG_NONE,
6382 tm->hw[1]->sw_if_index,
6383 ~0, // invalid fib index
6386 FIB_ROUTE_PATH_FLAG_NONE);
6388 FIB_TEST(fib_test_validate_entry(fei,
6389 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6391 &l99_eos_o_10_10_10_1,
6393 "1.1.1.1/32 LB 2 buckets via: "
6394 "label 99 over 10.10.10.1, "
6395 "adj over 10.10.11.1");
6398 * assign the route a local label
6400 fib_table_entry_local_label_add(fib_index,
6404 fib_prefix_t pfx_24001_eos = {
6405 .fp_proto = FIB_PROTOCOL_MPLS,
6409 fib_prefix_t pfx_24001_neos = {
6410 .fp_proto = FIB_PROTOCOL_MPLS,
6412 .fp_eos = MPLS_NON_EOS,
6414 fib_test_lb_bucket_t disp_o_10_10_11_1 = {
6415 .type = FT_LB_MPLS_DISP_O_ADJ,
6417 .adj = ai_v4_10_10_11_1,
6422 * The EOS entry should link to both the paths,
6423 * and use an ip adj for the imp-null
6424 * The NON-EOS entry should link to both the paths,
6425 * and use an mpls adj for the imp-null
6427 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6429 FIB_TEST(fib_test_validate_entry(fei,
6430 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6432 &l99_eos_o_10_10_10_1,
6433 &disp_o_10_10_11_1),
6434 "24001/eos LB 2 buckets via: "
6435 "label 99 over 10.10.10.1, "
6436 "mpls disp adj over 10.10.11.1");
6439 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6441 FIB_TEST(fib_test_validate_entry(fei,
6442 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6444 &l99_neos_o_10_10_10_1,
6445 &a_mpls_o_10_10_11_1),
6446 "24001/neos LB 1 bucket via: "
6447 "label 99 over 10.10.10.1 ",
6448 "mpls-adj via 10.10.11.1");
6451 * add an unlabelled path, this is excluded from the neos chains,
6453 fib_test_lb_bucket_t adj_o_10_10_11_2 = {
6456 .adj = ai_v4_10_10_11_2,
6459 fib_test_lb_bucket_t disp_o_10_10_11_2 = {
6460 .type = FT_LB_MPLS_DISP_O_ADJ,
6462 .adj = ai_v4_10_10_11_2,
6467 fei = fib_table_entry_path_add(fib_index,
6470 FIB_ENTRY_FLAG_NONE,
6473 tm->hw[1]->sw_if_index,
6474 ~0, // invalid fib index
6477 FIB_ROUTE_PATH_FLAG_NONE);
6479 FIB_TEST(fib_test_validate_entry(fei,
6480 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6481 16, // 3 choices spread over 16 buckets
6482 &l99_eos_o_10_10_10_1,
6483 &l99_eos_o_10_10_10_1,
6484 &l99_eos_o_10_10_10_1,
6485 &l99_eos_o_10_10_10_1,
6486 &l99_eos_o_10_10_10_1,
6487 &l99_eos_o_10_10_10_1,
6498 "1.1.1.1/32 LB 16 buckets via: "
6499 "label 99 over 10.10.10.1, "
6500 "adj over 10.10.11.1",
6501 "adj over 10.10.11.2");
6504 * get and lock a reference to the non-eos of the via entry 1.1.1.1/32
6506 dpo_id_t non_eos_1_1_1_1 = DPO_INVALID;
6507 fib_entry_contribute_forwarding(fei,
6508 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6512 * n-eos has only the 2 labelled paths
6514 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6517 FIB_TEST(fib_test_validate_entry(fei,
6518 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6520 &l99_neos_o_10_10_10_1,
6521 &a_mpls_o_10_10_11_1),
6522 "24001/neos LB 2 buckets via: "
6523 "label 99 over 10.10.10.1, "
6524 "adj-mpls over 10.10.11.2");
6527 * A labelled recursive
6529 fib_prefix_t pfx_2_2_2_2_s_32 = {
6531 .fp_proto = FIB_PROTOCOL_IP4,
6533 .ip4.as_u32 = clib_host_to_net_u32(0x02020202),
6536 fib_test_lb_bucket_t l1600_eos_o_1_1_1_1 = {
6537 .type = FT_LB_LABEL_O_LB,
6539 .lb = non_eos_1_1_1_1.dpoi_index,
6544 mpls_label_t *l1600 = NULL;
6545 vec_add1(l1600, 1600);
6547 fib_table_entry_update_one_path(fib_index,
6550 FIB_ENTRY_FLAG_NONE,
6552 &pfx_1_1_1_1_s_32.fp_addr,
6557 FIB_ROUTE_PATH_FLAG_NONE);
6559 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
6560 FIB_TEST(fib_test_validate_entry(fei,
6561 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6563 &l1600_eos_o_1_1_1_1),
6564 "2.2.2.2.2/32 LB 1 buckets via: "
6565 "label 1600 over 1.1.1.1");
6567 dpo_id_t dpo_44 = DPO_INVALID;
6570 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, &dpo_44);
6571 urpfi = load_balance_get_urpf(dpo_44.dpoi_index);
6573 FIB_TEST(fib_urpf_check(urpfi, tm->hw[0]->sw_if_index),
6574 "uRPF check for 2.2.2.2/32 on %d OK",
6575 tm->hw[0]->sw_if_index);
6576 FIB_TEST(fib_urpf_check(urpfi, tm->hw[1]->sw_if_index),
6577 "uRPF check for 2.2.2.2/32 on %d OK",
6578 tm->hw[1]->sw_if_index);
6579 FIB_TEST(!fib_urpf_check(urpfi, 99),
6580 "uRPF check for 2.2.2.2/32 on 99 not-OK",
6583 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, &dpo_44);
6584 FIB_TEST(urpfi == load_balance_get_urpf(dpo_44.dpoi_index),
6585 "Shared uRPF on IP and non-EOS chain");
6590 * we are holding a lock on the non-eos LB of the via-entry.
6591 * do a PIC-core failover by shutting the link of the via-entry.
6593 * shut down the link with the valid label
6595 vnet_sw_interface_set_flags(vnet_get_main(),
6596 tm->hw[0]->sw_if_index,
6599 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6600 FIB_TEST(fib_test_validate_entry(fei,
6601 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6605 "1.1.1.1/32 LB 2 buckets via: "
6606 "adj over 10.10.11.1, ",
6607 "adj-v4 over 10.10.11.2");
6609 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6611 FIB_TEST(fib_test_validate_entry(fei,
6612 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6615 &disp_o_10_10_11_2),
6616 "24001/eos LB 2 buckets via: "
6617 "mpls-disp adj over 10.10.11.1, ",
6618 "mpls-disp adj-v4 over 10.10.11.2");
6620 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6622 FIB_TEST(fib_test_validate_entry(fei,
6623 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6625 &a_mpls_o_10_10_11_1),
6626 "24001/neos LB 1 buckets via: "
6627 "adj-mpls over 10.10.11.2");
6630 * test that the pre-failover load-balance has been in-place
6633 dpo_id_t current = DPO_INVALID;
6634 fib_entry_contribute_forwarding(fei,
6635 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6638 FIB_TEST(!dpo_cmp(&non_eos_1_1_1_1,
6640 "PIC-core LB inplace modified %U %U",
6641 format_dpo_id, &non_eos_1_1_1_1, 0,
6642 format_dpo_id, ¤t, 0);
6644 dpo_reset(&non_eos_1_1_1_1);
6645 dpo_reset(¤t);
6648 * no-shut the link with the valid label
6650 vnet_sw_interface_set_flags(vnet_get_main(),
6651 tm->hw[0]->sw_if_index,
6652 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
6654 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6655 FIB_TEST(fib_test_validate_entry(fei,
6656 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6657 16, // 3 choices spread over 16 buckets
6658 &l99_eos_o_10_10_10_1,
6659 &l99_eos_o_10_10_10_1,
6660 &l99_eos_o_10_10_10_1,
6661 &l99_eos_o_10_10_10_1,
6662 &l99_eos_o_10_10_10_1,
6663 &l99_eos_o_10_10_10_1,
6674 "1.1.1.1/32 LB 16 buckets via: "
6675 "label 99 over 10.10.10.1, "
6676 "adj over 10.10.11.1",
6677 "adj-v4 over 10.10.11.2");
6680 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6682 FIB_TEST(fib_test_validate_entry(fei,
6683 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6684 16, // 3 choices spread over 16 buckets
6685 &l99_eos_o_10_10_10_1,
6686 &l99_eos_o_10_10_10_1,
6687 &l99_eos_o_10_10_10_1,
6688 &l99_eos_o_10_10_10_1,
6689 &l99_eos_o_10_10_10_1,
6690 &l99_eos_o_10_10_10_1,
6700 &disp_o_10_10_11_2),
6701 "24001/eos LB 16 buckets via: "
6702 "label 99 over 10.10.10.1, "
6703 "MPLS disp adj over 10.10.11.1",
6704 "MPLS disp adj-v4 over 10.10.11.2");
6706 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6708 FIB_TEST(fib_test_validate_entry(fei,
6709 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6711 &l99_neos_o_10_10_10_1,
6712 &a_mpls_o_10_10_11_1),
6713 "24001/neos LB 2 buckets via: "
6714 "label 99 over 10.10.10.1, "
6715 "adj-mpls over 10.10.11.2");
6718 * remove the first path with the valid label
6720 fib_table_entry_path_remove(fib_index,
6725 tm->hw[0]->sw_if_index,
6726 ~0, // invalid fib index
6728 FIB_ROUTE_PATH_FLAG_NONE);
6730 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6731 FIB_TEST(fib_test_validate_entry(fei,
6732 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6736 "1.1.1.1/32 LB 2 buckets via: "
6737 "adj over 10.10.11.1, "
6738 "adj-v4 over 10.10.11.2");
6740 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6742 FIB_TEST(fib_test_validate_entry(fei,
6743 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6746 &disp_o_10_10_11_2),
6747 "24001/eos LB 2 buckets via: "
6748 "MPLS disp adj over 10.10.11.1, "
6749 "MPLS disp adj-v4 over 10.10.11.2");
6751 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6754 FIB_TEST(fib_test_validate_entry(fei,
6755 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6757 &a_mpls_o_10_10_11_1),
6758 "24001/neos LB 1 buckets via: "
6759 "adj-mpls over 10.10.11.2");
6762 * remove the other path with a valid label
6764 fib_test_lb_bucket_t bucket_drop = {
6767 fib_test_lb_bucket_t mpls_bucket_drop = {
6770 .adj = DPO_PROTO_MPLS,
6774 fib_table_entry_path_remove(fib_index,
6779 tm->hw[1]->sw_if_index,
6780 ~0, // invalid fib index
6782 FIB_ROUTE_PATH_FLAG_NONE);
6784 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6785 FIB_TEST(fib_test_validate_entry(fei,
6786 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6789 "1.1.1.1/32 LB 1 buckets via: "
6790 "adj over 10.10.11.2");
6792 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6794 FIB_TEST(fib_test_validate_entry(fei,
6795 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6797 &disp_o_10_10_11_2),
6798 "24001/eos LB 1 buckets via: "
6799 "MPLS disp adj over 10.10.11.2");
6801 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6803 FIB_TEST(fib_test_validate_entry(fei,
6804 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6807 "24001/neos LB 1 buckets via: DROP");
6810 * add back the path with the valid label
6815 fib_table_entry_path_add(fib_index,
6818 FIB_ENTRY_FLAG_NONE,
6821 tm->hw[0]->sw_if_index,
6822 ~0, // invalid fib index
6825 FIB_ROUTE_PATH_FLAG_NONE);
6827 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6828 FIB_TEST(fib_test_validate_entry(fei,
6829 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6831 &l99_eos_o_10_10_10_1,
6833 "1.1.1.1/32 LB 2 buckets via: "
6834 "label 99 over 10.10.10.1, "
6835 "adj over 10.10.11.2");
6837 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6839 FIB_TEST(fib_test_validate_entry(fei,
6840 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6842 &l99_eos_o_10_10_10_1,
6843 &disp_o_10_10_11_2),
6844 "24001/eos LB 2 buckets via: "
6845 "label 99 over 10.10.10.1, "
6846 "MPLS disp adj over 10.10.11.2");
6848 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6850 FIB_TEST(fib_test_validate_entry(fei,
6851 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6853 &l99_neos_o_10_10_10_1),
6854 "24001/neos LB 1 buckets via: "
6855 "label 99 over 10.10.10.1");
6858 * change the local label
6860 fib_table_entry_local_label_add(fib_index,
6864 fib_prefix_t pfx_25005_eos = {
6865 .fp_proto = FIB_PROTOCOL_MPLS,
6869 fib_prefix_t pfx_25005_neos = {
6870 .fp_proto = FIB_PROTOCOL_MPLS,
6872 .fp_eos = MPLS_NON_EOS,
6875 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6876 fib_table_lookup(fib_index, &pfx_24001_eos)),
6877 "24001/eos removed after label change");
6878 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6879 fib_table_lookup(fib_index, &pfx_24001_neos)),
6880 "24001/eos removed after label change");
6882 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6884 FIB_TEST(fib_test_validate_entry(fei,
6885 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6887 &l99_eos_o_10_10_10_1,
6888 &disp_o_10_10_11_2),
6889 "25005/eos LB 2 buckets via: "
6890 "label 99 over 10.10.10.1, "
6891 "MPLS disp adj over 10.10.11.2");
6893 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6895 FIB_TEST(fib_test_validate_entry(fei,
6896 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6898 &l99_neos_o_10_10_10_1),
6899 "25005/neos LB 1 buckets via: "
6900 "label 99 over 10.10.10.1");
6903 * remove the local label.
6904 * the check that the MPLS entries are gone is done by the fact the
6905 * MPLS table is no longer present.
6907 fib_table_entry_local_label_remove(fib_index,
6911 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6912 FIB_TEST(fib_test_validate_entry(fei,
6913 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6915 &l99_eos_o_10_10_10_1,
6917 "24001/eos LB 2 buckets via: "
6918 "label 99 over 10.10.10.1, "
6919 "adj over 10.10.11.2");
6921 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6922 mpls_fib_index_from_table_id(MPLS_FIB_DEFAULT_TABLE_ID)),
6923 "No more MPLS FIB entries => table removed");
6926 * add another via-entry for the recursive
6928 fib_prefix_t pfx_1_1_1_2_s_32 = {
6930 .fp_proto = FIB_PROTOCOL_IP4,
6932 .ip4.as_u32 = clib_host_to_net_u32(0x01010102),
6935 fib_test_lb_bucket_t l101_eos_o_10_10_10_1 = {
6936 .type = FT_LB_LABEL_O_ADJ,
6938 .adj = ai_mpls_10_10_10_1,
6943 mpls_label_t *l101 = NULL;
6944 vec_add1(l101, 101);
6946 fei = fib_table_entry_update_one_path(fib_index,
6949 FIB_ENTRY_FLAG_NONE,
6952 tm->hw[0]->sw_if_index,
6953 ~0, // invalid fib index
6956 FIB_ROUTE_PATH_FLAG_NONE);
6958 FIB_TEST(fib_test_validate_entry(fei,
6959 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6961 &l101_eos_o_10_10_10_1),
6962 "1.1.1.2/32 LB 1 buckets via: "
6963 "label 101 over 10.10.10.1");
6965 dpo_id_t non_eos_1_1_1_2 = DPO_INVALID;
6966 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
6968 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6970 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
6972 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6975 fib_test_lb_bucket_t l1601_eos_o_1_1_1_2 = {
6976 .type = FT_LB_LABEL_O_LB,
6978 .lb = non_eos_1_1_1_2.dpoi_index,
6983 mpls_label_t *l1601 = NULL;
6984 vec_add1(l1601, 1601);
6986 l1600_eos_o_1_1_1_1.label_o_lb.lb = non_eos_1_1_1_1.dpoi_index;
6988 fei = fib_table_entry_path_add(fib_index,
6991 FIB_ENTRY_FLAG_NONE,
6993 &pfx_1_1_1_2_s_32.fp_addr,
6998 FIB_ROUTE_PATH_FLAG_NONE);
7000 FIB_TEST(fib_test_validate_entry(fei,
7001 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7003 &l1600_eos_o_1_1_1_1,
7004 &l1601_eos_o_1_1_1_2),
7005 "2.2.2.2/32 LB 2 buckets via: "
7006 "label 1600 via 1.1,1.1, "
7007 "label 16001 via 1.1.1.2");
7010 * update the via-entry so it no longer has an imp-null path.
7011 * the LB for the recursive can use an imp-null
7014 vec_add1(l_imp_null, MPLS_IETF_IMPLICIT_NULL_LABEL);
7016 fei = fib_table_entry_update_one_path(fib_index,
7019 FIB_ENTRY_FLAG_NONE,
7022 tm->hw[1]->sw_if_index,
7023 ~0, // invalid fib index
7026 FIB_ROUTE_PATH_FLAG_NONE);
7028 FIB_TEST(fib_test_validate_entry(fei,
7029 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7032 "1.1.1.2/32 LB 1 buckets via: "
7035 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7036 FIB_TEST(fib_test_validate_entry(fei,
7037 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7039 &l1600_eos_o_1_1_1_1,
7040 &l1601_eos_o_1_1_1_2),
7041 "2.2.2.2/32 LB 2 buckets via: "
7042 "label 1600 via 1.1,1.1, "
7043 "label 16001 via 1.1.1.2");
7046 * update the via-entry so it no longer has labelled paths.
7047 * the LB for the recursive should exclue this via form its LB
7049 fei = fib_table_entry_update_one_path(fib_index,
7052 FIB_ENTRY_FLAG_NONE,
7055 tm->hw[1]->sw_if_index,
7056 ~0, // invalid fib index
7059 FIB_ROUTE_PATH_FLAG_NONE);
7061 FIB_TEST(fib_test_validate_entry(fei,
7062 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7065 "1.1.1.2/32 LB 1 buckets via: "
7068 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7069 FIB_TEST(fib_test_validate_entry(fei,
7070 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7072 &l1600_eos_o_1_1_1_1),
7073 "2.2.2.2/32 LB 1 buckets via: "
7074 "label 1600 via 1.1,1.1");
7076 dpo_reset(&non_eos_1_1_1_1);
7077 dpo_reset(&non_eos_1_1_1_2);
7080 * Add a recursive with no out-labels. We expect to use the IP of the via
7082 fib_prefix_t pfx_2_2_2_3_s_32 = {
7084 .fp_proto = FIB_PROTOCOL_IP4,
7086 .ip4.as_u32 = clib_host_to_net_u32(0x02020203),
7089 dpo_id_t ip_1_1_1_1 = DPO_INVALID;
7091 fib_table_entry_update_one_path(fib_index,
7094 FIB_ENTRY_FLAG_NONE,
7096 &pfx_1_1_1_1_s_32.fp_addr,
7101 FIB_ROUTE_PATH_FLAG_NONE);
7103 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
7105 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7108 fib_test_lb_bucket_t ip_o_1_1_1_1 = {
7111 .lb = ip_1_1_1_1.dpoi_index,
7115 fei = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32);
7116 FIB_TEST(fib_test_validate_entry(fei,
7117 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7120 "2.2.2.2.3/32 LB 1 buckets via: "
7124 * Add a recursive with an imp-null out-label.
7125 * We expect to use the IP of the via
7127 fib_prefix_t pfx_2_2_2_4_s_32 = {
7129 .fp_proto = FIB_PROTOCOL_IP4,
7131 .ip4.as_u32 = clib_host_to_net_u32(0x02020204),
7135 fib_table_entry_update_one_path(fib_index,
7138 FIB_ENTRY_FLAG_NONE,
7140 &pfx_1_1_1_1_s_32.fp_addr,
7145 FIB_ROUTE_PATH_FLAG_NONE);
7147 fei = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
7148 FIB_TEST(fib_test_validate_entry(fei,
7149 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7152 "2.2.2.2.4/32 LB 1 buckets via: "
7155 dpo_reset(&ip_1_1_1_1);
7158 * Create an entry with a deep label stack
7160 fib_prefix_t pfx_2_2_5_5_s_32 = {
7162 .fp_proto = FIB_PROTOCOL_IP4,
7164 .ip4.as_u32 = clib_host_to_net_u32(0x02020505),
7167 fib_test_lb_bucket_t ls_eos_o_10_10_10_1 = {
7168 .type = FT_LB_LABEL_STACK_O_ADJ,
7169 .label_stack_o_adj = {
7170 .adj = ai_mpls_10_10_11_1,
7171 .label_stack_size = 8,
7173 200, 201, 202, 203, 204, 205, 206, 207
7178 mpls_label_t *label_stack = NULL;
7179 vec_validate(label_stack, 7);
7180 for (ii = 0; ii < 8; ii++)
7182 label_stack[ii] = ii + 200;
7185 fei = fib_table_entry_update_one_path(fib_index,
7188 FIB_ENTRY_FLAG_NONE,
7191 tm->hw[1]->sw_if_index,
7192 ~0, // invalid fib index
7195 FIB_ROUTE_PATH_FLAG_NONE);
7197 FIB_TEST(fib_test_validate_entry(fei,
7198 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7200 &ls_eos_o_10_10_10_1),
7201 "2.2.5.5/32 LB 1 buckets via: "
7203 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
7208 fib_table_entry_delete(fib_index,
7212 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7213 FIB_TEST(fib_test_validate_entry(fei,
7214 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7216 &l1600_eos_o_1_1_1_1),
7217 "2.2.2.2/32 LB 1 buckets via: "
7218 "label 1600 via 1.1,1.1");
7220 fib_table_entry_delete(fib_index,
7224 FIB_TEST(fib_test_validate_entry(fei,
7225 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7228 "2.2.2.2/32 LB 1 buckets via: DROP");
7230 fib_table_entry_delete(fib_index,
7233 fib_table_entry_delete(fib_index,
7236 fib_table_entry_delete(fib_index,
7240 adj_unlock(ai_mpls_10_10_10_1);
7241 adj_unlock(ai_mpls_10_10_11_2);
7242 adj_unlock(ai_v4_10_10_11_1);
7243 adj_unlock(ai_v4_10_10_11_2);
7244 adj_unlock(ai_mpls_10_10_11_1);
7246 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
7249 local0_pfx.fp_len = 32;
7250 fib_table_entry_delete(fib_index,
7252 FIB_SOURCE_INTERFACE);
7253 local0_pfx.fp_len = 24;
7254 fib_table_entry_delete(fib_index,
7256 FIB_SOURCE_INTERFACE);
7257 local1_pfx.fp_len = 32;
7258 fib_table_entry_delete(fib_index,
7260 FIB_SOURCE_INTERFACE);
7261 local1_pfx.fp_len = 24;
7262 fib_table_entry_delete(fib_index,
7264 FIB_SOURCE_INTERFACE);
7267 * +1 for the drop LB in the MPLS tables.
7269 FIB_TEST(lb_count+1 == pool_elts(load_balance_pool),
7270 "Load-balance resources freed %d of %d",
7271 lb_count+1, pool_elts(load_balance_pool));
7276 #define N_TEST_CHILDREN 4
7277 #define PARENT_INDEX 0
7279 typedef struct fib_node_test_t_
7284 fib_node_back_walk_ctx_t *ctxs;
7288 static fib_node_test_t fib_test_nodes[N_TEST_CHILDREN+1];
7290 #define PARENT() (&fib_test_nodes[PARENT_INDEX].node)
7292 #define FOR_EACH_TEST_CHILD(_tc) \
7293 for (ii = 1, (_tc) = &fib_test_nodes[1]; \
7294 ii < N_TEST_CHILDREN+1; \
7295 ii++, (_tc) = &fib_test_nodes[ii])
7298 fib_test_child_get_node (fib_node_index_t index)
7300 return (&fib_test_nodes[index].node);
7303 static int fib_test_walk_spawns_walks;
7305 static fib_node_back_walk_rc_t
7306 fib_test_child_back_walk_notify (fib_node_t *node,
7307 fib_node_back_walk_ctx_t *ctx)
7309 fib_node_test_t *tc = (fib_node_test_t*) node;
7311 vec_add1(tc->ctxs, *ctx);
7313 if (1 == fib_test_walk_spawns_walks)
7314 fib_walk_sync(FIB_NODE_TYPE_TEST, tc->index, ctx);
7315 if (2 == fib_test_walk_spawns_walks)
7316 fib_walk_async(FIB_NODE_TYPE_TEST, tc->index,
7317 FIB_WALK_PRIORITY_HIGH, ctx);
7319 return (FIB_NODE_BACK_WALK_CONTINUE);
7323 fib_test_child_last_lock_gone (fib_node_t *node)
7325 fib_node_test_t *tc = (fib_node_test_t *)node;
7331 * The FIB walk's graph node virtual function table
7333 static const fib_node_vft_t fib_test_child_vft = {
7334 .fnv_get = fib_test_child_get_node,
7335 .fnv_last_lock = fib_test_child_last_lock_gone,
7336 .fnv_back_walk = fib_test_child_back_walk_notify,
7340 * the function (that should have been static but isn't so I can do this)
7341 * that processes the walk from the async queue,
7343 f64 fib_walk_process_queues(vlib_main_t * vm,
7345 u32 fib_walk_queue_get_size(fib_walk_priority_t prio);
7348 fib_test_walk (void)
7350 fib_node_back_walk_ctx_t high_ctx = {}, low_ctx = {};
7351 fib_node_test_t *tc;
7355 vm = vlib_get_main();
7356 fib_node_register_type(FIB_NODE_TYPE_TEST, &fib_test_child_vft);
7359 * init a fake node on which we will add children
7361 fib_node_init(&fib_test_nodes[PARENT_INDEX].node,
7362 FIB_NODE_TYPE_TEST);
7364 FOR_EACH_TEST_CHILD(tc)
7366 fib_node_init(&tc->node, FIB_NODE_TYPE_TEST);
7367 fib_node_lock(&tc->node);
7370 tc->sibling = fib_node_child_add(FIB_NODE_TYPE_TEST,
7372 FIB_NODE_TYPE_TEST, ii);
7376 * enqueue a walk across the parents children.
7378 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7380 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7381 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7382 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7383 "Parent has %d children pre-walk",
7384 fib_node_list_get_size(PARENT()->fn_children));
7387 * give the walk a large amount of time so it gets to the end
7389 fib_walk_process_queues(vm, 1);
7391 FOR_EACH_TEST_CHILD(tc)
7393 FIB_TEST(1 == vec_len(tc->ctxs),
7394 "%d child visitsed %d times",
7395 ii, vec_len(tc->ctxs));
7398 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7399 "Queue is empty post walk");
7400 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7401 "Parent has %d children post walk",
7402 fib_node_list_get_size(PARENT()->fn_children));
7405 * walk again. should be no increase in the number of visits, since
7406 * the walk will have terminated.
7408 fib_walk_process_queues(vm, 1);
7410 FOR_EACH_TEST_CHILD(tc)
7412 FIB_TEST(0 == vec_len(tc->ctxs),
7413 "%d child visitsed %d times",
7414 ii, vec_len(tc->ctxs));
7418 * schedule a low and hig priority walk. expect the high to be performed
7420 * schedule the high prio walk first so that it is further from the head
7421 * of the dependency list. that way it won't merge with the low one.
7423 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7424 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE;
7426 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7427 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7428 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7429 FIB_WALK_PRIORITY_LOW, &low_ctx);
7431 fib_walk_process_queues(vm, 1);
7433 FOR_EACH_TEST_CHILD(tc)
7435 FIB_TEST(high_ctx.fnbw_reason == tc->ctxs[0].fnbw_reason,
7436 "%d child visitsed by high prio walk", ii);
7437 FIB_TEST(low_ctx.fnbw_reason == tc->ctxs[1].fnbw_reason,
7438 "%d child visitsed by low prio walk", ii);
7441 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7442 "Queue is empty post prio walk");
7443 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7444 "Parent has %d children post prio walk",
7445 fib_node_list_get_size(PARENT()->fn_children));
7448 * schedule 2 walks of the same priority that can be megred.
7449 * expect that each child is thus visited only once.
7451 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7452 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7454 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7455 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7456 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7457 FIB_WALK_PRIORITY_HIGH, &low_ctx);
7459 fib_walk_process_queues(vm, 1);
7461 FOR_EACH_TEST_CHILD(tc)
7463 FIB_TEST(1 == vec_len(tc->ctxs),
7464 "%d child visitsed %d times during merge walk",
7465 ii, vec_len(tc->ctxs));
7468 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7469 "Queue is empty post merge walk");
7470 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7471 "Parent has %d children post merge walk",
7472 fib_node_list_get_size(PARENT()->fn_children));
7475 * schedule 2 walks of the same priority that cannot be megred.
7476 * expect that each child is thus visited twice and in the order
7477 * in which the walks were scheduled.
7479 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7480 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE;
7482 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7483 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7484 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7485 FIB_WALK_PRIORITY_HIGH, &low_ctx);
7487 fib_walk_process_queues(vm, 1);
7489 FOR_EACH_TEST_CHILD(tc)
7491 FIB_TEST(high_ctx.fnbw_reason == tc->ctxs[0].fnbw_reason,
7492 "%d child visitsed by high prio walk", ii);
7493 FIB_TEST(low_ctx.fnbw_reason == tc->ctxs[1].fnbw_reason,
7494 "%d child visitsed by low prio walk", ii);
7497 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7498 "Queue is empty post no-merge walk");
7499 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7500 "Parent has %d children post no-merge walk",
7501 fib_node_list_get_size(PARENT()->fn_children));
7504 * schedule a walk that makes one one child progress.
7505 * we do this by giving the queue draining process zero
7506 * time quanta. it's a do..while loop, so it does something.
7508 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7510 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7511 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7512 fib_walk_process_queues(vm, 0);
7514 FOR_EACH_TEST_CHILD(tc)
7516 if (ii == N_TEST_CHILDREN)
7518 FIB_TEST(1 == vec_len(tc->ctxs),
7519 "%d child visitsed %d times in zero quanta walk",
7520 ii, vec_len(tc->ctxs));
7524 FIB_TEST(0 == vec_len(tc->ctxs),
7525 "%d child visitsed %d times in 0 quanta walk",
7526 ii, vec_len(tc->ctxs));
7529 FIB_TEST(1 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7530 "Queue is not empty post zero quanta walk");
7531 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7532 "Parent has %d children post zero qunta walk",
7533 fib_node_list_get_size(PARENT()->fn_children));
7538 fib_walk_process_queues(vm, 0);
7540 FOR_EACH_TEST_CHILD(tc)
7542 if (ii >= N_TEST_CHILDREN-1)
7544 FIB_TEST(1 == vec_len(tc->ctxs),
7545 "%d child visitsed %d times in 2nd zero quanta walk",
7546 ii, vec_len(tc->ctxs));
7550 FIB_TEST(0 == vec_len(tc->ctxs),
7551 "%d child visitsed %d times in 2nd 0 quanta walk",
7552 ii, vec_len(tc->ctxs));
7555 FIB_TEST(1 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7556 "Queue is not empty post zero quanta walk");
7557 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7558 "Parent has %d children post zero qunta walk",
7559 fib_node_list_get_size(PARENT()->fn_children));
7562 * schedule another walk that will catch-up and merge.
7564 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7565 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7566 fib_walk_process_queues(vm, 1);
7568 FOR_EACH_TEST_CHILD(tc)
7570 if (ii >= N_TEST_CHILDREN-1)
7572 FIB_TEST(2 == vec_len(tc->ctxs),
7573 "%d child visitsed %d times in 2nd zero quanta merge walk",
7574 ii, vec_len(tc->ctxs));
7579 FIB_TEST(1 == vec_len(tc->ctxs),
7580 "%d child visitsed %d times in 2nd 0 quanta merge walk",
7581 ii, vec_len(tc->ctxs));
7585 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7586 "Queue is not empty post 2nd zero quanta merge walk");
7587 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7588 "Parent has %d children post 2nd zero qunta merge walk",
7589 fib_node_list_get_size(PARENT()->fn_children));
7592 * park a async walk in the middle of the list, then have an sync walk catch
7593 * it. same expectations as async catches async.
7595 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7597 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7598 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7600 fib_walk_process_queues(vm, 0);
7601 fib_walk_process_queues(vm, 0);
7603 fib_walk_sync(FIB_NODE_TYPE_TEST, PARENT_INDEX, &high_ctx);
7605 FOR_EACH_TEST_CHILD(tc)
7607 if (ii >= N_TEST_CHILDREN-1)
7609 FIB_TEST(2 == vec_len(tc->ctxs),
7610 "%d child visitsed %d times in sync catches async walk",
7611 ii, vec_len(tc->ctxs));
7616 FIB_TEST(1 == vec_len(tc->ctxs),
7617 "%d child visitsed %d times in sync catches async walk",
7618 ii, vec_len(tc->ctxs));
7622 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7623 "Queue is not empty post 2nd zero quanta merge walk");
7624 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7625 "Parent has %d children post 2nd zero qunta merge walk",
7626 fib_node_list_get_size(PARENT()->fn_children));
7629 * make the parent a child of one of its children, thus inducing a routing loop.
7631 fib_test_nodes[PARENT_INDEX].sibling =
7632 fib_node_child_add(FIB_NODE_TYPE_TEST,
7633 1, // the first child
7638 * execute a sync walk from the parent. each child visited spawns more sync
7639 * walks. we expect the walk to terminate.
7641 fib_test_walk_spawns_walks = 1;
7643 fib_walk_sync(FIB_NODE_TYPE_TEST, PARENT_INDEX, &high_ctx);
7645 FOR_EACH_TEST_CHILD(tc)
7648 * child 1 - which is last in the list - has the loop.
7649 * the other children a re thus visitsed first. the we meet
7650 * child 1. we go round the loop again, visting the other children.
7651 * then we meet the walk in the dep list and bail. child 1 is not visitsed
7656 FIB_TEST(1 == vec_len(tc->ctxs),
7657 "child %d visitsed %d times during looped sync walk",
7658 ii, vec_len(tc->ctxs));
7662 FIB_TEST(2 == vec_len(tc->ctxs),
7663 "child %d visitsed %d times during looped sync walk",
7664 ii, vec_len(tc->ctxs));
7668 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7669 "Parent has %d children post sync loop walk",
7670 fib_node_list_get_size(PARENT()->fn_children));
7673 * the walk doesn't reach the max depth because the infra knows that sync
7674 * meets sync implies a loop and bails early.
7676 FIB_TEST(high_ctx.fnbw_depth == 9,
7677 "Walk context depth %d post sync loop walk",
7678 high_ctx.fnbw_depth);
7681 * execute an async walk of the graph loop, with each child spawns sync walks
7683 high_ctx.fnbw_depth = 0;
7684 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7685 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7687 fib_walk_process_queues(vm, 1);
7689 FOR_EACH_TEST_CHILD(tc)
7692 * we don't really care how many times the children are visisted, as long as
7693 * it is more than once.
7695 FIB_TEST(1 <= vec_len(tc->ctxs),
7696 "child %d visitsed %d times during looped aync spawns sync walk",
7697 ii, vec_len(tc->ctxs));
7702 * execute an async walk of the graph loop, with each child spawns async walks
7704 fib_test_walk_spawns_walks = 2;
7705 high_ctx.fnbw_depth = 0;
7706 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7707 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7709 fib_walk_process_queues(vm, 1);
7711 FOR_EACH_TEST_CHILD(tc)
7714 * we don't really care how many times the children are visisted, as long as
7715 * it is more than once.
7717 FIB_TEST(1 <= vec_len(tc->ctxs),
7718 "child %d visitsed %d times during looped async spawns async walk",
7719 ii, vec_len(tc->ctxs));
7724 fib_node_child_remove(FIB_NODE_TYPE_TEST,
7725 1, // the first child
7726 fib_test_nodes[PARENT_INDEX].sibling);
7731 FOR_EACH_TEST_CHILD(tc)
7733 fib_node_child_remove(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7735 fib_node_deinit(&tc->node);
7736 fib_node_unlock(&tc->node);
7738 fib_node_deinit(PARENT());
7741 * The parent will be destroyed when the last lock on it goes.
7742 * this test ensures all the walk objects are unlocking it.
7744 FIB_TEST((1 == fib_test_nodes[PARENT_INDEX].destroyed),
7745 "Parent was destroyed");
7751 * declaration of the otherwise static callback functions
7753 void fib_bfd_notify (bfd_listen_event_e event,
7754 const bfd_session_t *session);
7755 void adj_bfd_notify (bfd_listen_event_e event,
7756 const bfd_session_t *session);
7759 * Test BFD session interaction with FIB
7764 fib_node_index_t fei;
7768 /* via 10.10.10.1 */
7769 ip46_address_t nh_10_10_10_1 = {
7770 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
7772 /* via 10.10.10.2 */
7773 ip46_address_t nh_10_10_10_2 = {
7774 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
7776 /* via 10.10.10.10 */
7777 ip46_address_t nh_10_10_10_10 = {
7778 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
7780 n_feis = fib_entry_pool_size();
7785 * add interface routes. we'll assume this works. it's tested elsewhere
7787 fib_prefix_t pfx_10_10_10_10_s_24 = {
7789 .fp_proto = FIB_PROTOCOL_IP4,
7790 .fp_addr = nh_10_10_10_10,
7793 fib_table_entry_update_one_path(0, &pfx_10_10_10_10_s_24,
7794 FIB_SOURCE_INTERFACE,
7795 (FIB_ENTRY_FLAG_CONNECTED |
7796 FIB_ENTRY_FLAG_ATTACHED),
7799 tm->hw[0]->sw_if_index,
7800 ~0, // invalid fib index
7803 FIB_ROUTE_PATH_FLAG_NONE);
7805 fib_prefix_t pfx_10_10_10_10_s_32 = {
7807 .fp_proto = FIB_PROTOCOL_IP4,
7808 .fp_addr = nh_10_10_10_10,
7810 fib_table_entry_update_one_path(0, &pfx_10_10_10_10_s_32,
7811 FIB_SOURCE_INTERFACE,
7812 (FIB_ENTRY_FLAG_CONNECTED |
7813 FIB_ENTRY_FLAG_LOCAL),
7816 tm->hw[0]->sw_if_index,
7817 ~0, // invalid fib index
7820 FIB_ROUTE_PATH_FLAG_NONE);
7823 * A BFD session via a neighbour we do not yet know
7825 bfd_session_t bfd_10_10_10_1 = {
7829 .peer_addr = nh_10_10_10_1,
7832 .hop_type = BFD_HOP_TYPE_MULTI,
7833 .local_state = BFD_STATE_init,
7836 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7839 * A new entry will be created that forwards via the adj
7841 adj_index_t ai_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
7844 tm->hw[0]->sw_if_index);
7845 fib_prefix_t pfx_10_10_10_1_s_32 = {
7846 .fp_addr = nh_10_10_10_1,
7848 .fp_proto = FIB_PROTOCOL_IP4,
7850 fib_test_lb_bucket_t adj_o_10_10_10_1 = {
7853 .adj = ai_10_10_10_1,
7857 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7858 FIB_TEST(fib_test_validate_entry(fei,
7859 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7862 "BFD sourced %U via %U",
7863 format_fib_prefix, &pfx_10_10_10_1_s_32,
7864 format_ip_adjacency, ai_10_10_10_1, FORMAT_IP_ADJACENCY_NONE);
7867 * Delete the BFD session. Expect the fib_entry to be removed
7869 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
7871 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7872 FIB_TEST(FIB_NODE_INDEX_INVALID == fei,
7873 "BFD sourced %U removed",
7874 format_fib_prefix, &pfx_10_10_10_1_s_32);
7877 * Add the BFD source back
7879 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7882 * source the entry via the ADJ fib
7884 fei = fib_table_entry_path_add(0,
7885 &pfx_10_10_10_1_s_32,
7887 FIB_ENTRY_FLAG_ATTACHED,
7890 tm->hw[0]->sw_if_index,
7891 ~0, // invalid fib index
7894 FIB_ROUTE_PATH_FLAG_NONE);
7897 * Delete the BFD session. Expect the fib_entry to remain
7899 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
7901 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7902 FIB_TEST(fib_test_validate_entry(fei,
7903 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7906 "BFD sourced %U remains via %U",
7907 format_fib_prefix, &pfx_10_10_10_1_s_32,
7908 format_ip_adjacency, ai_10_10_10_1, FORMAT_IP_ADJACENCY_NONE);
7911 * Add the BFD source back
7913 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7916 * Create another ADJ FIB
7918 fib_prefix_t pfx_10_10_10_2_s_32 = {
7919 .fp_addr = nh_10_10_10_2,
7921 .fp_proto = FIB_PROTOCOL_IP4,
7923 fib_table_entry_path_add(0,
7924 &pfx_10_10_10_2_s_32,
7926 FIB_ENTRY_FLAG_ATTACHED,
7929 tm->hw[0]->sw_if_index,
7930 ~0, // invalid fib index
7933 FIB_ROUTE_PATH_FLAG_NONE);
7935 * A BFD session for the new ADJ FIB
7937 bfd_session_t bfd_10_10_10_2 = {
7941 .peer_addr = nh_10_10_10_2,
7944 .hop_type = BFD_HOP_TYPE_MULTI,
7945 .local_state = BFD_STATE_init,
7948 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_2);
7951 * remove the adj-fib source whilst the session is present
7954 fib_table_entry_delete(0, &pfx_10_10_10_2_s_32, FIB_SOURCE_ADJ);
7955 fib_table_entry_path_add(0,
7956 &pfx_10_10_10_2_s_32,
7958 FIB_ENTRY_FLAG_ATTACHED,
7961 tm->hw[0]->sw_if_index,
7962 ~0, // invalid fib index
7965 FIB_ROUTE_PATH_FLAG_NONE);
7968 * Before adding a recursive via the BFD tracked ADJ-FIBs,
7969 * bring one of the sessions UP, leave the other down
7971 bfd_10_10_10_1.local_state = BFD_STATE_up;
7972 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
7973 bfd_10_10_10_2.local_state = BFD_STATE_down;
7974 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
7977 * A recursive prefix via both of the ADJ FIBs
7979 fib_prefix_t pfx_200_0_0_0_s_24 = {
7980 .fp_proto = FIB_PROTOCOL_IP4,
7983 .ip4.as_u32 = clib_host_to_net_u32(0xc8000000),
7986 const dpo_id_t *dpo_10_10_10_1, *dpo_10_10_10_2;
7989 fib_entry_contribute_ip_forwarding(
7990 fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32));
7992 fib_entry_contribute_ip_forwarding(
7993 fib_table_lookup_exact_match(0, &pfx_10_10_10_2_s_32));
7995 fib_test_lb_bucket_t lb_o_10_10_10_1 = {
7998 .lb = dpo_10_10_10_1->dpoi_index,
8001 fib_test_lb_bucket_t lb_o_10_10_10_2 = {
8004 .lb = dpo_10_10_10_2->dpoi_index,
8009 * A prefix via the adj-fib that is BFD down => DROP
8011 fei = fib_table_entry_path_add(0,
8012 &pfx_200_0_0_0_s_24,
8014 FIB_ENTRY_FLAG_NONE,
8018 0, // default fib index
8021 FIB_ROUTE_PATH_FLAG_NONE);
8022 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
8023 "%U resolves via drop",
8024 format_fib_prefix, &pfx_200_0_0_0_s_24);
8027 * add a path via the UP BFD adj-fib.
8028 * we expect that the DOWN BFD ADJ FIB is not used.
8030 fei = fib_table_entry_path_add(0,
8031 &pfx_200_0_0_0_s_24,
8033 FIB_ENTRY_FLAG_NONE,
8037 0, // default fib index
8040 FIB_ROUTE_PATH_FLAG_NONE);
8042 FIB_TEST(fib_test_validate_entry(fei,
8043 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8046 "Recursive %U only UP BFD adj-fibs",
8047 format_fib_prefix, &pfx_200_0_0_0_s_24);
8050 * Send a BFD state change to UP - both sessions are now up
8051 * the recursive prefix should LB over both
8053 bfd_10_10_10_2.local_state = BFD_STATE_up;
8054 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
8057 FIB_TEST(fib_test_validate_entry(fei,
8058 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8062 "Recursive %U via both UP BFD adj-fibs",
8063 format_fib_prefix, &pfx_200_0_0_0_s_24);
8066 * Send a BFD state change to DOWN
8067 * the recursive prefix should exclude the down
8069 bfd_10_10_10_2.local_state = BFD_STATE_down;
8070 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
8073 FIB_TEST(fib_test_validate_entry(fei,
8074 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8077 "Recursive %U via only UP",
8078 format_fib_prefix, &pfx_200_0_0_0_s_24);
8081 * Delete the BFD session while it is in the DOWN state.
8082 * FIB should consider the entry's state as back up
8084 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_2);
8086 FIB_TEST(fib_test_validate_entry(fei,
8087 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8091 "Recursive %U via both UP BFD adj-fibs post down session delete",
8092 format_fib_prefix, &pfx_200_0_0_0_s_24);
8095 * Delete the BFD other session while it is in the UP state.
8097 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
8099 FIB_TEST(fib_test_validate_entry(fei,
8100 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8104 "Recursive %U via both UP BFD adj-fibs post up session delete",
8105 format_fib_prefix, &pfx_200_0_0_0_s_24);
8110 fib_table_entry_delete(0, &pfx_200_0_0_0_s_24, FIB_SOURCE_API);
8111 fib_table_entry_delete(0, &pfx_10_10_10_1_s_32, FIB_SOURCE_ADJ);
8112 fib_table_entry_delete(0, &pfx_10_10_10_2_s_32, FIB_SOURCE_ADJ);
8114 fib_table_entry_delete(0, &pfx_10_10_10_10_s_32, FIB_SOURCE_INTERFACE);
8115 fib_table_entry_delete(0, &pfx_10_10_10_10_s_24, FIB_SOURCE_INTERFACE);
8117 adj_unlock(ai_10_10_10_1);
8119 * test no-one left behind
8121 FIB_TEST((n_feis == fib_entry_pool_size()), "Entries gone");
8122 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
8125 * Single-hop BFD tests
8127 bfd_10_10_10_1.hop_type = BFD_HOP_TYPE_SINGLE;
8128 bfd_10_10_10_1.udp.key.sw_if_index = tm->hw[0]->sw_if_index;
8130 adj_bfd_notify(BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
8132 ai_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8135 tm->hw[0]->sw_if_index);
8137 * whilst the BFD session is not signalled, the adj is up
8139 FIB_TEST(adj_is_up(ai_10_10_10_1), "Adj state up on uninit session");
8142 * bring the BFD session up
8144 bfd_10_10_10_1.local_state = BFD_STATE_up;
8145 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8146 FIB_TEST(adj_is_up(ai_10_10_10_1), "Adj state up on UP session");
8149 * bring the BFD session down
8151 bfd_10_10_10_1.local_state = BFD_STATE_down;
8152 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8153 FIB_TEST(!adj_is_up(ai_10_10_10_1), "Adj state down on DOWN session");
8157 * add an attached next hop FIB entry via the down adj
8159 fib_prefix_t pfx_5_5_5_5_s_32 = {
8162 .as_u32 = clib_host_to_net_u32(0x05050505),
8166 .fp_proto = FIB_PROTOCOL_IP4,
8169 fei = fib_table_entry_path_add(0,
8172 FIB_ENTRY_FLAG_NONE,
8175 tm->hw[0]->sw_if_index,
8176 ~0, // invalid fib index
8179 FIB_ROUTE_PATH_FLAG_NONE);
8180 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
8181 "%U resolves via drop",
8182 format_fib_prefix, &pfx_5_5_5_5_s_32);
8185 * Add a path via an ADJ that is up
8187 adj_index_t ai_10_10_10_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8190 tm->hw[0]->sw_if_index);
8192 fib_test_lb_bucket_t adj_o_10_10_10_2 = {
8195 .adj = ai_10_10_10_2,
8198 adj_o_10_10_10_1.adj.adj = ai_10_10_10_1;
8200 fei = fib_table_entry_path_add(0,
8203 FIB_ENTRY_FLAG_NONE,
8206 tm->hw[0]->sw_if_index,
8207 ~0, // invalid fib index
8210 FIB_ROUTE_PATH_FLAG_NONE);
8212 FIB_TEST(fib_test_validate_entry(fei,
8213 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8216 "BFD sourced %U via %U",
8217 format_fib_prefix, &pfx_5_5_5_5_s_32,
8218 format_ip_adjacency, ai_10_10_10_2, FORMAT_IP_ADJACENCY_NONE);
8221 * Bring up the down session - should now LB
8223 bfd_10_10_10_1.local_state = BFD_STATE_up;
8224 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8225 FIB_TEST(fib_test_validate_entry(fei,
8226 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8230 "BFD sourced %U via noth adjs",
8231 format_fib_prefix, &pfx_5_5_5_5_s_32);
8234 * remove the BFD session state from the adj
8236 adj_bfd_notify(BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
8241 fib_table_entry_delete(0, &pfx_5_5_5_5_s_32, FIB_SOURCE_CLI);
8242 adj_unlock(ai_10_10_10_1);
8243 adj_unlock(ai_10_10_10_2);
8246 * test no-one left behind
8248 FIB_TEST((n_feis == fib_entry_pool_size()), "Entries gone");
8249 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
8256 const mpls_label_t deag_label = 50;
8257 const u32 lfib_index = 0;
8258 const u32 fib_index = 0;
8259 dpo_id_t dpo = DPO_INVALID;
8260 const dpo_id_t *dpo1;
8261 fib_node_index_t lfe;
8265 adj_index_t ai_mpls_10_10_10_1;
8268 lb_count = pool_elts(load_balance_pool);
8270 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
8274 * MPLS enable an interface so we get the MPLS table created
8276 mpls_table_create(MPLS_FIB_DEFAULT_TABLE_ID, FIB_SOURCE_API, NULL);
8277 mpls_sw_interface_enable_disable(&mpls_main,
8278 tm->hw[0]->sw_if_index,
8281 ip46_address_t nh_10_10_10_1 = {
8282 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
8284 ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8287 tm->hw[0]->sw_if_index);
8290 * Test the specials stack properly.
8292 fib_prefix_t exp_null_v6_pfx = {
8293 .fp_proto = FIB_PROTOCOL_MPLS,
8295 .fp_label = MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL,
8296 .fp_payload_proto = DPO_PROTO_IP6,
8298 lfe = fib_table_lookup(lfib_index, &exp_null_v6_pfx);
8299 FIB_TEST((FIB_NODE_INDEX_INVALID != lfe),
8301 format_mpls_unicast_label, MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL,
8302 format_mpls_eos_bit, MPLS_EOS);
8303 fib_entry_contribute_forwarding(lfe,
8304 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8306 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8307 lkd = lookup_dpo_get(dpo1->dpoi_index);
8309 FIB_TEST((fib_index == lkd->lkd_fib_index),
8310 "%U/%U is deag in %d %U",
8311 format_mpls_unicast_label, deag_label,
8312 format_mpls_eos_bit, MPLS_EOS,
8314 format_dpo_id, &dpo, 0);
8315 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8316 "%U/%U is dst deag",
8317 format_mpls_unicast_label, deag_label,
8318 format_mpls_eos_bit, MPLS_EOS);
8319 FIB_TEST((LOOKUP_TABLE_FROM_INPUT_INTERFACE == lkd->lkd_table),
8320 "%U/%U is lookup in interface's table",
8321 format_mpls_unicast_label, deag_label,
8322 format_mpls_eos_bit, MPLS_EOS);
8323 FIB_TEST((DPO_PROTO_IP6 == lkd->lkd_proto),
8324 "%U/%U is %U dst deag",
8325 format_mpls_unicast_label, deag_label,
8326 format_mpls_eos_bit, MPLS_EOS,
8327 format_dpo_proto, lkd->lkd_proto);
8331 * A route deag route for EOS
8333 fib_prefix_t pfx = {
8334 .fp_proto = FIB_PROTOCOL_MPLS,
8336 .fp_label = deag_label,
8337 .fp_payload_proto = DPO_PROTO_IP4,
8339 lfe = fib_table_entry_path_add(lfib_index,
8342 FIB_ENTRY_FLAG_NONE,
8349 FIB_ROUTE_PATH_FLAG_NONE);
8351 FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
8353 format_mpls_unicast_label, deag_label,
8354 format_mpls_eos_bit, MPLS_EOS);
8356 fib_entry_contribute_forwarding(lfe,
8357 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8359 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8360 lkd = lookup_dpo_get(dpo1->dpoi_index);
8362 FIB_TEST((fib_index == lkd->lkd_fib_index),
8363 "%U/%U is deag in %d %U",
8364 format_mpls_unicast_label, deag_label,
8365 format_mpls_eos_bit, MPLS_EOS,
8367 format_dpo_id, &dpo, 0);
8368 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8369 "%U/%U is dst deag",
8370 format_mpls_unicast_label, deag_label,
8371 format_mpls_eos_bit, MPLS_EOS);
8372 FIB_TEST((DPO_PROTO_IP4 == lkd->lkd_proto),
8373 "%U/%U is %U dst deag",
8374 format_mpls_unicast_label, deag_label,
8375 format_mpls_eos_bit, MPLS_EOS,
8376 format_dpo_proto, lkd->lkd_proto);
8378 fib_table_entry_delete_index(lfe, FIB_SOURCE_CLI);
8380 FIB_TEST((FIB_NODE_INDEX_INVALID == fib_table_lookup(lfib_index,
8382 "%U/%U not present",
8383 format_mpls_unicast_label, deag_label,
8384 format_mpls_eos_bit, MPLS_EOS);
8387 * A route deag route for non-EOS
8389 pfx.fp_eos = MPLS_NON_EOS;
8390 lfe = fib_table_entry_path_add(lfib_index,
8393 FIB_ENTRY_FLAG_NONE,
8400 FIB_ROUTE_PATH_FLAG_NONE);
8402 FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
8404 format_mpls_unicast_label, deag_label,
8405 format_mpls_eos_bit, MPLS_NON_EOS);
8407 fib_entry_contribute_forwarding(lfe,
8408 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8410 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8411 lkd = lookup_dpo_get(dpo1->dpoi_index);
8413 FIB_TEST((fib_index == lkd->lkd_fib_index),
8414 "%U/%U is deag in %d %U",
8415 format_mpls_unicast_label, deag_label,
8416 format_mpls_eos_bit, MPLS_NON_EOS,
8418 format_dpo_id, &dpo, 0);
8419 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8420 "%U/%U is dst deag",
8421 format_mpls_unicast_label, deag_label,
8422 format_mpls_eos_bit, MPLS_NON_EOS);
8424 FIB_TEST((DPO_PROTO_MPLS == lkd->lkd_proto),
8425 "%U/%U is %U dst deag",
8426 format_mpls_unicast_label, deag_label,
8427 format_mpls_eos_bit, MPLS_NON_EOS,
8428 format_dpo_proto, lkd->lkd_proto);
8430 fib_table_entry_delete_index(lfe, FIB_SOURCE_CLI);
8432 FIB_TEST((FIB_NODE_INDEX_INVALID == fib_table_lookup(lfib_index,
8434 "%U/%U not present",
8435 format_mpls_unicast_label, deag_label,
8436 format_mpls_eos_bit, MPLS_EOS);
8443 fib_prefix_t pfx_1200 = {
8445 .fp_proto = FIB_PROTOCOL_MPLS,
8447 .fp_eos = MPLS_NON_EOS,
8449 fib_test_lb_bucket_t neos_o_10_10_10_1 = {
8450 .type = FT_LB_LABEL_STACK_O_ADJ,
8451 .label_stack_o_adj = {
8452 .adj = ai_mpls_10_10_10_1,
8453 .label_stack_size = 4,
8457 .eos = MPLS_NON_EOS,
8460 dpo_id_t neos_1200 = DPO_INVALID;
8461 dpo_id_t ip_1200 = DPO_INVALID;
8462 mpls_label_t *l200 = NULL;
8463 vec_add1(l200, 200);
8464 vec_add1(l200, 300);
8465 vec_add1(l200, 400);
8466 vec_add1(l200, 500);
8468 lfe = fib_table_entry_update_one_path(fib_index,
8471 FIB_ENTRY_FLAG_NONE,
8474 tm->hw[0]->sw_if_index,
8475 ~0, // invalid fib index
8478 FIB_ROUTE_PATH_FLAG_NONE);
8480 FIB_TEST(fib_test_validate_entry(lfe,
8481 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8483 &neos_o_10_10_10_1),
8484 "1200/0 LB 1 buckets via: "
8488 * A recursive route via the MPLS x-connect
8490 fib_prefix_t pfx_2_2_2_3_s_32 = {
8492 .fp_proto = FIB_PROTOCOL_IP4,
8494 .ip4.as_u32 = clib_host_to_net_u32(0x02020203),
8497 fib_route_path_t *rpaths = NULL, rpath = {
8498 .frp_proto = DPO_PROTO_MPLS,
8499 .frp_local_label = 1200,
8500 .frp_eos = MPLS_NON_EOS,
8501 .frp_sw_if_index = ~0, // recurive
8502 .frp_fib_index = 0, // Default MPLS fib
8504 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
8505 .frp_label_stack = NULL,
8507 vec_add1(rpaths, rpath);
8509 fib_table_entry_path_add2(fib_index,
8512 FIB_ENTRY_FLAG_NONE,
8516 * A labelled recursive route via the MPLS x-connect
8518 fib_prefix_t pfx_2_2_2_4_s_32 = {
8520 .fp_proto = FIB_PROTOCOL_IP4,
8522 .ip4.as_u32 = clib_host_to_net_u32(0x02020204),
8525 mpls_label_t *l999 = NULL;
8526 vec_add1(l999, 999);
8527 rpaths[0].frp_label_stack = l999,
8529 fib_table_entry_path_add2(fib_index,
8532 FIB_ENTRY_FLAG_NONE,
8535 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8536 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8538 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8539 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8542 fib_test_lb_bucket_t ip_o_1200 = {
8545 .lb = ip_1200.dpoi_index,
8548 fib_test_lb_bucket_t mpls_o_1200 = {
8549 .type = FT_LB_LABEL_O_LB,
8551 .lb = neos_1200.dpoi_index,
8557 lfe = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32);
8558 FIB_TEST(fib_test_validate_entry(lfe,
8559 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8562 "2.2.2.2.3/32 LB 1 buckets via: label 1200 EOS");
8563 lfe = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
8564 FIB_TEST(fib_test_validate_entry(lfe,
8565 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8568 "2.2.2.2.4/32 LB 1 buckets via: label 1200 non-EOS");
8570 fib_table_entry_delete(fib_index, &pfx_1200, FIB_SOURCE_API);
8571 fib_table_entry_delete(fib_index, &pfx_2_2_2_3_s_32, FIB_SOURCE_API);
8572 fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
8574 dpo_reset(&neos_1200);
8575 dpo_reset(&ip_1200);
8578 * A recursive via a label that does not exist
8580 fib_test_lb_bucket_t bucket_drop = {
8583 .adj = DPO_PROTO_IP4,
8586 fib_test_lb_bucket_t mpls_bucket_drop = {
8589 .adj = DPO_PROTO_MPLS,
8593 rpaths[0].frp_label_stack = NULL;
8594 lfe = fib_table_entry_path_add2(fib_index,
8597 FIB_ENTRY_FLAG_NONE,
8600 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8601 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8603 ip_o_1200.lb.lb = ip_1200.dpoi_index;
8605 FIB_TEST(fib_test_validate_entry(lfe,
8606 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8609 "2.2.2.2.4/32 LB 1 buckets via: drop");
8610 lfe = fib_table_lookup(fib_index, &pfx_1200);
8611 FIB_TEST(fib_test_validate_entry(lfe,
8612 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8615 "1200/neos LB 1 buckets via: ip4-DROP");
8616 FIB_TEST(fib_test_validate_entry(lfe,
8617 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8620 "1200/neos LB 1 buckets via: mpls-DROP");
8622 fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
8624 dpo_reset(&ip_1200);
8627 * An rx-interface route.
8628 * like the tail of an mcast LSP
8630 dpo_id_t idpo = DPO_INVALID;
8632 interface_rx_dpo_add_or_lock(DPO_PROTO_IP4,
8633 tm->hw[0]->sw_if_index,
8636 fib_prefix_t pfx_2500 = {
8638 .fp_proto = FIB_PROTOCOL_MPLS,
8641 .fp_payload_proto = DPO_PROTO_IP4,
8643 fib_test_lb_bucket_t rx_intf_0 = {
8646 .adj = idpo.dpoi_index,
8650 lfe = fib_table_entry_update_one_path(fib_index,
8653 FIB_ENTRY_FLAG_NONE,
8656 tm->hw[0]->sw_if_index,
8657 ~0, // invalid fib index
8660 FIB_ROUTE_PATH_INTF_RX);
8661 FIB_TEST(fib_test_validate_entry(lfe,
8662 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8665 "2500 rx-interface 0");
8666 fib_table_entry_delete(fib_index, &pfx_2500, FIB_SOURCE_API);
8669 * An MPLS mulicast entry
8671 fib_prefix_t pfx_3500 = {
8673 .fp_proto = FIB_PROTOCOL_MPLS,
8676 .fp_payload_proto = DPO_PROTO_IP4,
8678 fib_test_rep_bucket_t mc_0 = {
8679 .type = FT_REP_LABEL_O_ADJ,
8681 .adj = ai_mpls_10_10_10_1,
8686 fib_test_rep_bucket_t mc_intf_0 = {
8687 .type = FT_REP_INTF,
8689 .adj = idpo.dpoi_index,
8692 mpls_label_t *l3300 = NULL;
8693 vec_add1(l3300, 3300);
8695 lfe = fib_table_entry_update_one_path(lfib_index,
8698 FIB_ENTRY_FLAG_MULTICAST,
8701 tm->hw[0]->sw_if_index,
8702 ~0, // invalid fib index
8705 FIB_ROUTE_PATH_FLAG_NONE);
8706 FIB_TEST(fib_test_validate_entry(lfe,
8707 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8710 "3500 via replicate over 10.10.10.1");
8713 * MPLS Bud-node. Add a replication via an interface-receieve path
8715 lfe = fib_table_entry_path_add(lfib_index,
8718 FIB_ENTRY_FLAG_MULTICAST,
8721 tm->hw[0]->sw_if_index,
8722 ~0, // invalid fib index
8725 FIB_ROUTE_PATH_INTF_RX);
8726 FIB_TEST(fib_test_validate_entry(lfe,
8727 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8731 "3500 via replicate over 10.10.10.1 and interface-rx");
8734 * Add a replication via an interface-free for-us path
8736 fib_test_rep_bucket_t mc_disp = {
8737 .type = FT_REP_DISP_MFIB_LOOKUP,
8739 .adj = idpo.dpoi_index,
8742 lfe = fib_table_entry_path_add(lfib_index,
8745 FIB_ENTRY_FLAG_MULTICAST,
8752 FIB_ROUTE_PATH_RPF_ID);
8753 FIB_TEST(fib_test_validate_entry(lfe,
8754 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8759 "3500 via replicate over 10.10.10.1 and interface-rx");
8763 fib_table_entry_delete(fib_index, &pfx_3500, FIB_SOURCE_API);
8769 mpls_sw_interface_enable_disable(&mpls_main,
8770 tm->hw[0]->sw_if_index,
8772 mpls_table_delete(MPLS_FIB_DEFAULT_TABLE_ID, FIB_SOURCE_API);
8774 FIB_TEST(lb_count == pool_elts(load_balance_pool),
8775 "Load-balance resources freed %d of %d",
8776 lb_count, pool_elts(load_balance_pool));
8777 FIB_TEST(0 == pool_elts(interface_rx_dpo_pool),
8778 "interface_rx_dpo resources freed %d of %d",
8779 0, pool_elts(interface_rx_dpo_pool));
8784 static clib_error_t *
8785 fib_test (vlib_main_t * vm,
8786 unformat_input_t * input,
8787 vlib_cli_command_t * cmd_arg)
8792 fib_test_mk_intf(4);
8794 if (unformat (input, "debug"))
8796 fib_test_do_debug = 1;
8799 if (unformat (input, "ip"))
8801 res += fib_test_v4();
8802 res += fib_test_v6();
8804 else if (unformat (input, "label"))
8806 res += fib_test_label();
8808 else if (unformat (input, "ae"))
8810 res += fib_test_ae();
8812 else if (unformat (input, "pref"))
8814 res += fib_test_pref();
8816 else if (unformat (input, "lfib"))
8820 else if (unformat (input, "walk"))
8822 res += fib_test_walk();
8824 else if (unformat (input, "bfd"))
8826 res += fib_test_bfd();
8830 res += fib_test_v4();
8831 res += fib_test_v6();
8832 res += fib_test_ae();
8833 res += fib_test_bfd();
8834 res += fib_test_pref();
8835 res += fib_test_label();
8839 * fib-walk process must be disabled in order for the walk tests to work
8841 fib_walk_process_disable();
8842 res += fib_test_walk();
8843 fib_walk_process_enable();
8848 return clib_error_return(0, "FIB Unit Test Failed");
8856 VLIB_CLI_COMMAND (test_fib_command, static) = {
8858 .short_help = "fib unit tests - DO NOT RUN ON A LIVE SYSTEM",
8859 .function = fib_test,
8863 fib_test_init (vlib_main_t *vm)
8868 VLIB_INIT_FUNCTION (fib_test_init);