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/dvr_dpo.h>
32 #include <vnet/dpo/mpls_disposition.h>
33 #include <vnet/dpo/punt_dpo.h>
35 #include <vnet/mpls/mpls.h>
37 #include <vnet/fib/fib_test.h>
38 #include <vnet/fib/fib_path_list.h>
39 #include <vnet/fib/fib_entry_src.h>
40 #include <vnet/fib/fib_walk.h>
41 #include <vnet/fib/fib_node_list.h>
42 #include <vnet/fib/fib_urpf_list.h>
44 #include <vlib/unix/plugin.h>
47 * Add debugs for passing tests
49 static int fib_test_do_debug;
51 #define FIB_TEST_I(_cond, _comment, _args...) \
53 int _evald = (_cond); \
55 fformat(stderr, "FAIL:%d: " _comment "\n", \
59 if (fib_test_do_debug) \
60 fformat(stderr, "PASS:%d: " _comment "\n", \
65 #define FIB_TEST(_cond, _comment, _args...) \
67 if (FIB_TEST_I(_cond, _comment, ##_args)) { \
69 ASSERT(!("FAIL: " _comment)); \
74 * A 'i'm not fussed is this is not efficient' store of test data
76 typedef struct test_main_t_ {
80 u32 hw_if_indicies[4];
84 vnet_hw_interface_t * hw[4];
87 static test_main_t test_main;
89 /* fake ethernet device class, distinct from "fake-ethX" */
90 static u8 * format_test_interface_name (u8 * s, va_list * args)
92 u32 dev_instance = va_arg (*args, u32);
93 return format (s, "test-eth%d", dev_instance);
96 static uword dummy_interface_tx (vlib_main_t * vm,
97 vlib_node_runtime_t * node,
100 clib_warning ("you shouldn't be here, leaking buffers...");
101 return frame->n_vectors;
104 static clib_error_t *
105 test_interface_admin_up_down (vnet_main_t * vnm,
109 u32 hw_flags = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
110 VNET_HW_INTERFACE_FLAG_LINK_UP : 0;
111 vnet_hw_interface_set_flags (vnm, hw_if_index, hw_flags);
115 VNET_DEVICE_CLASS (test_interface_device_class,static) = {
116 .name = "Test interface",
117 .format_device_name = format_test_interface_name,
118 .tx_function = dummy_interface_tx,
119 .admin_up_down_function = test_interface_admin_up_down,
122 static u8 *hw_address;
125 fib_test_mk_intf (u32 ninterfaces)
127 clib_error_t * error = NULL;
128 test_main_t *tm = &test_main;
133 ASSERT(ninterfaces <= ARRAY_LEN(tm->hw_if_indicies));
138 vec_add1(hw_address, byte);
141 for (i = 0; i < ninterfaces; i++)
145 error = ethernet_register_interface(vnet_get_main(),
146 test_interface_device_class.index,
149 &tm->hw_if_indicies[i],
150 /* flag change */ 0);
152 FIB_TEST((NULL == error), "ADD interface %d", i);
154 error = vnet_hw_interface_set_flags(vnet_get_main(),
155 tm->hw_if_indicies[i],
156 VNET_HW_INTERFACE_FLAG_LINK_UP);
157 tm->hw[i] = vnet_get_hw_interface(vnet_get_main(),
158 tm->hw_if_indicies[i]);
159 vec_validate (ip4_main.fib_index_by_sw_if_index,
160 tm->hw[i]->sw_if_index);
161 vec_validate (ip6_main.fib_index_by_sw_if_index,
162 tm->hw[i]->sw_if_index);
163 ip4_main.fib_index_by_sw_if_index[tm->hw[i]->sw_if_index] = 0;
164 ip6_main.fib_index_by_sw_if_index[tm->hw[i]->sw_if_index] = 0;
166 error = vnet_sw_interface_set_flags(vnet_get_main(),
167 tm->hw[i]->sw_if_index,
168 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
169 FIB_TEST((NULL == error), "UP interface %d", i);
172 * re-eval after the inevitable realloc
174 for (i = 0; i < ninterfaces; i++)
176 tm->hw[i] = vnet_get_hw_interface(vnet_get_main(),
177 tm->hw_if_indicies[i]);
183 #define FIB_TEST_REC_FORW(_rec_prefix, _via_prefix, _bucket) \
185 const dpo_id_t *_rec_dpo = fib_entry_contribute_ip_forwarding( \
186 fib_table_lookup_exact_match(fib_index, (_rec_prefix))); \
187 const dpo_id_t *_via_dpo = fib_entry_contribute_ip_forwarding( \
188 fib_table_lookup(fib_index, (_via_prefix))); \
189 FIB_TEST(!dpo_cmp(_via_dpo, \
190 load_balance_get_bucket(_rec_dpo->dpoi_index, \
192 "%U is recursive via %U", \
193 format_fib_prefix, (_rec_prefix), \
194 format_fib_prefix, _via_prefix); \
197 #define FIB_TEST_LB_BUCKET_VIA_ADJ(_prefix, _bucket, _ai) \
199 const dpo_id_t *_dpo = fib_entry_contribute_ip_forwarding( \
200 fib_table_lookup_exact_match(fib_index, (_prefix))); \
201 const dpo_id_t *_dpo1 = \
202 load_balance_get_bucket(_dpo->dpoi_index, _bucket); \
203 FIB_TEST(DPO_ADJACENCY == _dpo1->dpoi_type, "type is %U", \
204 format_dpo_type, _dpo1->dpoi_type); \
205 FIB_TEST((_ai == _dpo1->dpoi_index), \
206 "%U bucket %d resolves via %U", \
207 format_fib_prefix, (_prefix), \
209 format_dpo_id, _dpo1, 0); \
212 #define FIB_TEST_RPF(_cond, _comment, _args...) \
214 if (FIB_TEST_I(_cond, _comment, ##_args)) { \
220 fib_test_urpf_is_equal (fib_node_index_t fei,
221 fib_forward_chain_type_t fct,
224 dpo_id_t dpo = DPO_INVALID;
225 fib_urpf_list_t *urpf;
233 fib_entry_contribute_forwarding(fei, fct, &dpo);
234 ui = load_balance_get_urpf(dpo.dpoi_index);
236 urpf = fib_urpf_list_get(ui);
238 FIB_TEST_RPF(num == vec_len(urpf->furpf_itfs),
239 "RPF:%U len %d == %d",
240 format_fib_urpf_list, ui,
241 num, vec_len(urpf->furpf_itfs));
242 FIB_TEST_RPF(num == fib_urpf_check_size(ui),
243 "RPF:%U check-size %d == %d",
244 format_fib_urpf_list, ui,
245 num, vec_len(urpf->furpf_itfs));
247 for (ii = 0; ii < num; ii++)
249 adj_index_t ai = va_arg(ap, adj_index_t);
251 FIB_TEST_RPF(ai == urpf->furpf_itfs[ii],
252 "RPF:%d item:%d - %d == %d",
253 ui, ii, ai, urpf->furpf_itfs[ii]);
254 FIB_TEST_RPF(fib_urpf_check(ui, ai),
267 fib_test_build_rewrite (u8 *eth_addr)
271 vec_validate(rewrite, 13);
273 memcpy(rewrite, eth_addr, 6);
274 memcpy(rewrite+6, eth_addr, 6);
279 #define FIB_TEST_LB(_cond, _comment, _args...) \
281 if (FIB_TEST_I(_cond, _comment, ##_args)) { \
287 fib_test_validate_rep_v (const replicate_t *rep,
291 const fib_test_rep_bucket_t *exp;
296 FIB_TEST_LB((n_buckets == rep->rep_n_buckets),
297 "n_buckets = %d", rep->rep_n_buckets);
299 for (bucket = 0; bucket < n_buckets; bucket++)
301 exp = va_arg(*ap, fib_test_rep_bucket_t*);
303 dpo = replicate_get_bucket_i(rep, bucket);
307 case FT_REP_LABEL_O_ADJ:
309 const mpls_label_dpo_t *mld;
312 FIB_TEST_LB((mpls_label_dpo_get_type(MPLS_LABEL_DPO_FLAG_NONE)
314 "bucket %d stacks on %U",
316 format_dpo_type, dpo->dpoi_type);
318 mld = mpls_label_dpo_get(dpo->dpoi_index);
319 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
321 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
322 exp->label_o_adj.label),
323 "bucket %d stacks on label %d",
325 exp->label_o_adj.label);
327 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
328 exp->label_o_adj.eos),
329 "bucket %d stacks on label %d %U",
331 exp->label_o_adj.label,
332 format_mpls_eos_bit, exp->label_o_adj.eos);
334 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
335 "bucket %d label stacks on %U",
337 format_dpo_type, mld->mld_dpo.dpoi_type);
339 FIB_TEST_LB((exp->label_o_adj.adj == mld->mld_dpo.dpoi_index),
340 "bucket %d label stacks on adj %d",
342 exp->label_o_adj.adj);
346 FIB_TEST_LB((DPO_INTERFACE_RX == dpo->dpoi_type),
347 "bucket %d stacks on %U",
349 format_dpo_type, dpo->dpoi_type);
351 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
352 "bucket %d stacks on adj %d",
356 case FT_REP_DISP_MFIB_LOOKUP:
366 fib_test_validate_lb_v (const load_balance_t *lb,
374 FIB_TEST_LB((n_buckets == lb->lb_n_buckets), "n_buckets = %d", lb->lb_n_buckets);
376 for (bucket = 0; bucket < n_buckets; bucket++)
378 const fib_test_lb_bucket_t *exp;
380 exp = va_arg(*ap, fib_test_lb_bucket_t*);
381 dpo = load_balance_get_bucket_i(lb, bucket);
385 case FT_LB_LABEL_STACK_O_ADJ:
387 const mpls_label_dpo_t *mld;
388 mpls_label_dpo_flags_t mf;
392 mf = ((exp->label_stack_o_adj.mode ==
393 FIB_MPLS_LSP_MODE_UNIFORM) ?
394 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE :
395 MPLS_LABEL_DPO_FLAG_NONE);
396 FIB_TEST_LB((mpls_label_dpo_get_type(mf) == dpo->dpoi_type),
397 "bucket %d stacks on %U",
399 format_dpo_type, dpo->dpoi_type);
401 mld = mpls_label_dpo_get(dpo->dpoi_index);
403 FIB_TEST_LB(exp->label_stack_o_adj.label_stack_size == mld->mld_n_labels,
407 for (ii = 0; ii < mld->mld_n_labels; ii++)
409 hdr = clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
410 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
411 exp->label_stack_o_adj.label_stack[ii]),
412 "bucket %d stacks on label %d",
414 exp->label_stack_o_adj.label_stack[ii]);
416 if (ii == mld->mld_n_labels-1)
418 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
419 exp->label_o_adj.eos),
420 "bucket %d stacks on label %d %U!=%U",
422 exp->label_stack_o_adj.label_stack[ii],
423 format_mpls_eos_bit, exp->label_o_adj.eos,
424 format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
428 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) == MPLS_NON_EOS),
429 "bucket %d stacks on label %d %U",
431 exp->label_stack_o_adj.label_stack[ii],
432 format_mpls_eos_bit, vnet_mpls_uc_get_s(hdr));
436 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
437 "bucket %d label stacks on %U",
439 format_dpo_type, mld->mld_dpo.dpoi_type);
441 FIB_TEST_LB((exp->label_stack_o_adj.adj == mld->mld_dpo.dpoi_index),
442 "bucket %d label stacks on adj %d",
444 exp->label_stack_o_adj.adj);
447 case FT_LB_LABEL_O_ADJ:
449 const mpls_label_dpo_t *mld;
451 FIB_TEST_LB((mpls_label_dpo_get_type(MPLS_LABEL_DPO_FLAG_NONE)
453 "bucket %d stacks on %U",
455 format_dpo_type, dpo->dpoi_type);
457 mld = mpls_label_dpo_get(dpo->dpoi_index);
458 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
460 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
461 exp->label_o_adj.label),
462 "bucket %d stacks on label %d",
464 exp->label_o_adj.label);
466 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
467 exp->label_o_adj.eos),
468 "bucket %d stacks on label %d %U",
470 exp->label_o_adj.label,
471 format_mpls_eos_bit, exp->label_o_adj.eos);
473 FIB_TEST_LB((DPO_ADJACENCY_INCOMPLETE == mld->mld_dpo.dpoi_type),
474 "bucket %d label stacks on %U",
476 format_dpo_type, mld->mld_dpo.dpoi_type);
478 FIB_TEST_LB((exp->label_o_adj.adj == mld->mld_dpo.dpoi_index),
479 "bucket %d label stacks on adj %d",
481 exp->label_o_adj.adj);
484 case FT_LB_LABEL_O_LB:
486 const mpls_label_dpo_t *mld;
487 mpls_label_dpo_flags_t mf;
490 mf = ((exp->label_o_lb.mode ==
491 FIB_MPLS_LSP_MODE_UNIFORM) ?
492 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE :
493 MPLS_LABEL_DPO_FLAG_NONE);
494 FIB_TEST_LB((mpls_label_dpo_get_type(mf) == dpo->dpoi_type),
495 "bucket %d stacks on %U",
497 format_dpo_type, dpo->dpoi_type);
499 mld = mpls_label_dpo_get(dpo->dpoi_index);
500 hdr = clib_net_to_host_u32(mld->mld_hdr[0].label_exp_s_ttl);
502 FIB_TEST_LB(1 == mld->mld_n_labels, "label stack size",
504 FIB_TEST_LB((vnet_mpls_uc_get_label(hdr) ==
505 exp->label_o_lb.label),
506 "bucket %d stacks on label %d",
508 exp->label_o_lb.label);
510 FIB_TEST_LB((vnet_mpls_uc_get_s(hdr) ==
511 exp->label_o_lb.eos),
512 "bucket %d stacks on label %d %U",
514 exp->label_o_lb.label,
515 format_mpls_eos_bit, exp->label_o_lb.eos);
517 FIB_TEST_LB((DPO_LOAD_BALANCE == mld->mld_dpo.dpoi_type),
518 "bucket %d label stacks on %U",
520 format_dpo_type, mld->mld_dpo.dpoi_type);
522 FIB_TEST_LB((exp->label_o_lb.lb == mld->mld_dpo.dpoi_index),
523 "bucket %d label stacks on LB %d",
529 res = FIB_TEST_I(((DPO_ADJACENCY == dpo->dpoi_type) ||
530 (DPO_ADJACENCY_INCOMPLETE == dpo->dpoi_type)),
531 "bucket %d stacks on %U",
533 format_dpo_type, dpo->dpoi_type);
534 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
535 "bucket %d stacks on adj %d",
539 case FT_LB_MPLS_DISP_PIPE_O_ADJ:
541 const mpls_disp_dpo_t *mdd;
543 res = FIB_TEST_I((DPO_MPLS_DISPOSITION_PIPE == dpo->dpoi_type),
544 "bucket %d stacks on %U",
546 format_dpo_type, dpo->dpoi_type);
548 mdd = mpls_disp_dpo_get(dpo->dpoi_index);
552 res = FIB_TEST_I(((DPO_ADJACENCY == dpo->dpoi_type) ||
553 (DPO_ADJACENCY_INCOMPLETE == 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",
564 res = FIB_TEST_I((DPO_INTERFACE_RX == dpo->dpoi_type),
565 "bucket %d stacks on %U",
567 format_dpo_type, dpo->dpoi_type);
568 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
569 "bucket %d stacks on adj %d",
574 res = FIB_TEST_I((DPO_DVR == dpo->dpoi_type),
575 "bucket %d stacks on %U",
577 format_dpo_type, dpo->dpoi_type);
578 FIB_TEST_LB((exp->adj.adj == dpo->dpoi_index),
579 "bucket %d stacks on adj %d",
584 res = FIB_TEST_I((DPO_LOAD_BALANCE == dpo->dpoi_type),
585 "bucket %d stacks on %U",
587 format_dpo_type, dpo->dpoi_type);
588 FIB_TEST_LB((exp->lb.lb == dpo->dpoi_index),
589 "bucket %d stacks on lb %d not %d",
594 case FT_LB_BIER_TABLE:
595 FIB_TEST_LB((DPO_BIER_TABLE == dpo->dpoi_type),
596 "bucket %d stacks on %U",
598 format_dpo_type, dpo->dpoi_type);
599 FIB_TEST_LB((exp->bier.table == dpo->dpoi_index),
600 "bucket %d stacks on lb %d",
604 case FT_LB_BIER_FMASK:
605 FIB_TEST_LB((DPO_BIER_FMASK == dpo->dpoi_type),
606 "bucket %d stacks on %U",
608 format_dpo_type, dpo->dpoi_type);
609 FIB_TEST_LB((exp->bier.fmask == dpo->dpoi_index),
610 "bucket %d stacks on lb %d",
615 FIB_TEST_LB((DPO_DROP == dpo->dpoi_type),
616 "bucket %d stacks on %U",
618 format_dpo_type, dpo->dpoi_type);
621 FIB_TEST_LB((DPO_PUNT == dpo->dpoi_type),
622 "bucket %d stacks on %U",
624 format_dpo_type, dpo->dpoi_type);
632 fib_test_validate_lb (const dpo_id_t *dpo,
636 const load_balance_t *lb;
641 va_start(ap, n_buckets);
643 if (FIB_TEST_I((DPO_LOAD_BALANCE == dpo->dpoi_type),
645 format_dpo_type, dpo->dpoi_type))
647 lb = load_balance_get(dpo->dpoi_index);
649 res = fib_test_validate_lb_v(lb, n_buckets, &ap);
662 fib_test_validate_entry (fib_node_index_t fei,
663 fib_forward_chain_type_t fct,
667 dpo_id_t dpo = DPO_INVALID;
668 const fib_prefix_t *pfx;
674 va_start(ap, n_buckets);
677 pfx = fib_entry_get_prefix(fei);
678 fib_index = fib_entry_get_fib_index(fei);
679 fib_entry_contribute_forwarding(fei, fct, &dpo);
681 if (DPO_REPLICATE == dpo.dpoi_type)
683 const replicate_t *rep;
685 rep = replicate_get(dpo.dpoi_index);
686 res = fib_test_validate_rep_v(rep, n_buckets, &ap);
690 const load_balance_t *lb;
692 FIB_TEST_LB((DPO_LOAD_BALANCE == dpo.dpoi_type),
693 "%U Entry links to %U",
694 format_fib_prefix, pfx,
695 format_dpo_type, dpo.dpoi_type);
697 lb = load_balance_get(dpo.dpoi_index);
698 res = fib_test_validate_lb_v(lb, n_buckets, &ap);
701 * ensure that the LB contributed by the entry is the
702 * same as the LB in the forwarding tables
704 if (fct == fib_entry_get_default_chain_type(fib_entry_get(fei)))
706 switch (pfx->fp_proto)
708 case FIB_PROTOCOL_IP4:
709 fw_lbi = ip4_fib_forwarding_lookup(fib_index, &pfx->fp_addr.ip4);
711 case FIB_PROTOCOL_IP6:
712 fw_lbi = ip6_fib_table_fwding_lookup(&ip6_main, fib_index, &pfx->fp_addr.ip6);
714 case FIB_PROTOCOL_MPLS:
716 mpls_unicast_header_t hdr = {
717 .label_exp_s_ttl = 0,
720 vnet_mpls_uc_set_label(&hdr.label_exp_s_ttl, pfx->fp_label);
721 vnet_mpls_uc_set_s(&hdr.label_exp_s_ttl, pfx->fp_eos);
722 hdr.label_exp_s_ttl = clib_host_to_net_u32(hdr.label_exp_s_ttl);
724 fw_lbi = mpls_fib_table_forwarding_lookup(fib_index, &hdr);
730 FIB_TEST_LB((fw_lbi == dpo.dpoi_index),
731 "Contributed LB = FW LB:\n fwd:%U\n cont:%U",
732 format_load_balance, fw_lbi, 0,
733 format_load_balance, dpo.dpoi_index, 0);
748 * In the default table check for the presence and correct forwarding
749 * of the special entries
751 fib_node_index_t dfrt, fei, ai, ai2, locked_ai, ai_01, ai_02, ai_03;
752 const dpo_id_t *dpo, *dpo1, *dpo2, *dpo_drop;
753 const ip_adjacency_t *adj;
754 const load_balance_t *lb;
762 ip46_address_t nh_10_10_10_1 = {
763 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
766 ip46_address_t nh_10_10_10_2 = {
767 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
770 FIB_TEST((0 == pool_elts(load_balance_map_pool)), "LB-map pool size is %d",
771 pool_elts(load_balance_map_pool));
775 /* record the nubmer of load-balances in use before we start */
776 lb_count = pool_elts(load_balance_pool);
778 /* Find or create FIB table 11 */
779 fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4, 11,
782 for (ii = 0; ii < 4; ii++)
784 ip4_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = fib_index;
787 fib_prefix_t pfx_0_0_0_0_s_0 = {
789 .fp_proto = FIB_PROTOCOL_IP4,
799 .fp_proto = FIB_PROTOCOL_IP4,
807 dpo_drop = drop_dpo_get(DPO_PROTO_IP4);
809 dfrt = fib_table_lookup(fib_index, &pfx_0_0_0_0_s_0);
810 FIB_TEST((FIB_NODE_INDEX_INVALID != dfrt), "default route present");
811 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
812 "Default route is DROP");
815 fei = fib_table_lookup(fib_index, &pfx);
816 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all zeros route present");
817 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
818 "all 0s route is DROP");
820 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xffffffff);
822 fei = fib_table_lookup(fib_index, &pfx);
823 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all ones route present");
824 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
825 "all 1s route is DROP");
827 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xe0000000);
829 fei = fib_table_lookup(fib_index, &pfx);
830 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "all-mcast route present");
831 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
832 "all-mcast route is DROP");
834 pfx.fp_addr.ip4.as_u32 = clib_host_to_net_u32(0xf0000000);
836 fei = fib_table_lookup(fib_index, &pfx);
837 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "class-e route present");
838 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
839 "class-e route is DROP");
842 * at this stage there are 5 entries in the test FIB (plus 5 in the default),
843 * all of which are special sourced and so none of which share path-lists.
844 * There are also 2 entries, and 2 non-shared path-lists, in the v6 default
845 * table, and 4 path-lists in the v6 MFIB table
852 * if the IGMP plugin is loaded this adds two more entries to the v4 MFIB
854 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
855 FIB_TEST((PNBR == fib_path_list_pool_size()), "path list pool size is %d",
856 fib_path_list_pool_size());
857 FIB_TEST((ENBR == fib_entry_pool_size()), "entry pool size is %d",
858 fib_entry_pool_size());
861 * add interface routes.
862 * validate presence of /24 attached and /32 recieve.
863 * test for the presence of the receive address in the glean and local adj
865 fib_prefix_t local_pfx = {
867 .fp_proto = FIB_PROTOCOL_IP4,
870 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
875 fib_table_entry_update_one_path(fib_index, &local_pfx,
876 FIB_SOURCE_INTERFACE,
877 (FIB_ENTRY_FLAG_CONNECTED |
878 FIB_ENTRY_FLAG_ATTACHED),
881 tm->hw[0]->sw_if_index,
882 ~0, // invalid fib index
885 FIB_ROUTE_PATH_FLAG_NONE);
886 fei = fib_table_lookup(fib_index, &local_pfx);
887 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
888 FIB_TEST(((FIB_ENTRY_FLAG_ATTACHED | FIB_ENTRY_FLAG_CONNECTED) ==
889 fib_entry_get_flags(fei)),
890 "Flags set on attached interface");
892 ai = fib_entry_get_adj(fei);
893 FIB_TEST((FIB_NODE_INDEX_INVALID != ai),
894 "attached interface route adj present %d", ai);
896 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
897 "attached interface adj is glean");
898 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
899 &adj->sub_type.glean.receive_addr)),
900 "attached interface adj is receive ok");
902 local_pfx.fp_len = 32;
903 fib_table_entry_update_one_path(fib_index, &local_pfx,
904 FIB_SOURCE_INTERFACE,
905 (FIB_ENTRY_FLAG_CONNECTED |
906 FIB_ENTRY_FLAG_LOCAL),
909 tm->hw[0]->sw_if_index,
910 ~0, // invalid fib index
913 FIB_ROUTE_PATH_FLAG_NONE);
914 fei = fib_table_lookup(fib_index, &local_pfx);
915 FIB_TEST(((FIB_ENTRY_FLAG_LOCAL | FIB_ENTRY_FLAG_CONNECTED) ==
916 fib_entry_get_flags(fei)),
917 "Flags set on local interface");
919 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
921 dpo = fib_entry_contribute_ip_forwarding(fei);
922 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
923 "RPF list for local length 0");
924 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
925 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
926 "local interface adj is local");
927 receive_dpo_t *rd = receive_dpo_get(dpo->dpoi_index);
929 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
931 "local interface adj is receive ok");
933 FIB_TEST((2 == fib_table_get_num_entries(fib_index,
935 FIB_SOURCE_INTERFACE)),
936 "2 Interface Source'd prefixes");
939 * +2 interface routes +2 non-shared path-lists
941 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
942 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is%d",
943 fib_path_list_pool_size());
944 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
945 fib_entry_pool_size());
948 * Modify the default route to be via an adj not yet known.
949 * this sources the defalut route with the API source, which is
950 * a higher preference to the DEFAULT_ROUTE source
952 pfx.fp_addr.ip4.as_u32 = 0;
954 fib_table_entry_path_add(fib_index, &pfx,
959 tm->hw[0]->sw_if_index,
960 ~0, // invalid fib index
963 FIB_ROUTE_PATH_FLAG_NONE);
964 fei = fib_table_lookup(fib_index, &pfx);
965 FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)),
966 "Flags set on API route");
968 FIB_TEST((fei == dfrt), "default route same index");
969 ai = fib_entry_get_adj(fei);
970 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "default route adj present");
972 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
973 "adj is incomplete");
974 FIB_TEST((0 == ip46_address_cmp(&nh_10_10_10_1, &adj->sub_type.nbr.next_hop)),
975 "adj nbr next-hop ok");
976 FIB_TEST((1 == fib_table_get_num_entries(fib_index,
979 "1 API Source'd prefixes");
982 * find the adj in the shared db
984 locked_ai = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
987 tm->hw[0]->sw_if_index);
988 FIB_TEST((locked_ai == ai), "ADJ NBR DB find");
989 adj_unlock(locked_ai);
992 * +1 shared path-list
994 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
995 fib_path_list_db_size());
996 FIB_TEST((PNBR+3 == fib_path_list_pool_size()), "path list pool size is%d",
997 fib_path_list_pool_size());
998 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
999 fib_entry_pool_size());
1002 * remove the API source from the default route. We expected
1003 * the route to remain, sourced by DEFAULT_ROUTE, and hence a DROP
1005 pfx.fp_addr.ip4.as_u32 = 0;
1007 fib_table_entry_path_remove(fib_index, &pfx,
1011 tm->hw[0]->sw_if_index,
1012 ~0, // non-recursive path, so no FIB index
1014 FIB_ROUTE_PATH_FLAG_NONE);
1016 fei = fib_table_lookup(fib_index, &pfx);
1018 FIB_TEST((fei == dfrt), "default route same index");
1019 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
1020 "Default route is DROP");
1023 * -1 shared-path-list
1025 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
1026 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is%d",
1027 fib_path_list_pool_size());
1028 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
1029 fib_entry_pool_size());
1032 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
1034 fib_prefix_t pfx_10_10_10_1_s_32 = {
1036 .fp_proto = FIB_PROTOCOL_IP4,
1039 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
1042 fib_prefix_t pfx_10_10_10_2_s_32 = {
1044 .fp_proto = FIB_PROTOCOL_IP4,
1047 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
1050 fib_prefix_t pfx_11_11_11_11_s_32 = {
1052 .fp_proto = FIB_PROTOCOL_IP4,
1055 .ip4.as_u32 = clib_host_to_net_u32(0x0b0b0b0b),
1059 0xde, 0xde, 0xde, 0xba, 0xba, 0xba,
1062 ip46_address_t nh_12_12_12_12 = {
1063 .ip4.as_u32 = clib_host_to_net_u32(0x0c0c0c0c),
1065 adj_index_t ai_12_12_12_12;
1068 * Add a route via an incomplete ADJ. then complete the ADJ
1069 * Expect the route LB is updated to use complete adj type.
1071 fei = fib_table_entry_update_one_path(fib_index,
1072 &pfx_11_11_11_11_s_32,
1074 FIB_ENTRY_FLAG_ATTACHED,
1076 &pfx_10_10_10_1_s_32.fp_addr,
1077 tm->hw[0]->sw_if_index,
1078 ~0, // invalid fib index
1081 FIB_ROUTE_PATH_FLAG_NONE);
1083 dpo = fib_entry_contribute_ip_forwarding(fei);
1084 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1085 FIB_TEST(DPO_ADJACENCY_INCOMPLETE == dpo1->dpoi_type,
1086 "11.11.11.11/32 via incomplete adj");
1088 ai_01 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1090 &pfx_10_10_10_1_s_32.fp_addr,
1091 tm->hw[0]->sw_if_index);
1092 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_01), "adj created");
1093 adj = adj_get(ai_01);
1094 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1095 "adj is incomplete");
1096 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_1_s_32.fp_addr,
1097 &adj->sub_type.nbr.next_hop)),
1098 "adj nbr next-hop ok");
1100 adj_nbr_update_rewrite(ai_01, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1101 fib_test_build_rewrite(eth_addr));
1102 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1104 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_1_s_32.fp_addr,
1105 &adj->sub_type.nbr.next_hop)),
1106 "adj nbr next-hop ok");
1107 ai = fib_entry_get_adj(fei);
1108 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
1110 dpo = fib_entry_contribute_ip_forwarding(fei);
1111 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1112 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type,
1113 "11.11.11.11/32 via complete adj");
1114 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
1115 tm->hw[0]->sw_if_index),
1116 "RPF list for adj-fib contains adj");
1118 ai_12_12_12_12 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1121 tm->hw[1]->sw_if_index);
1122 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_12_12_12_12), "adj created");
1123 adj = adj_get(ai_12_12_12_12);
1124 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1125 "adj is incomplete");
1126 FIB_TEST((0 == ip46_address_cmp(&nh_12_12_12_12,
1127 &adj->sub_type.nbr.next_hop)),
1128 "adj nbr next-hop ok");
1129 adj_nbr_update_rewrite(ai_12_12_12_12, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1130 fib_test_build_rewrite(eth_addr));
1131 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1137 fei = fib_table_entry_path_add(fib_index,
1138 &pfx_10_10_10_1_s_32,
1140 FIB_ENTRY_FLAG_ATTACHED,
1142 &pfx_10_10_10_1_s_32.fp_addr,
1143 tm->hw[0]->sw_if_index,
1144 ~0, // invalid fib index
1147 FIB_ROUTE_PATH_FLAG_NONE);
1148 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED == fib_entry_get_flags(fei)),
1149 "Flags set on adj-fib");
1150 ai = fib_entry_get_adj(fei);
1151 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj, %d", ai);
1153 fib_table_entry_path_remove(fib_index,
1154 &pfx_11_11_11_11_s_32,
1157 &pfx_10_10_10_1_s_32.fp_addr,
1158 tm->hw[0]->sw_if_index,
1159 ~0, // invalid fib index
1161 FIB_ROUTE_PATH_FLAG_NONE);
1165 ai_02 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
1167 &pfx_10_10_10_2_s_32.fp_addr,
1168 tm->hw[0]->sw_if_index);
1169 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_02), "adj created");
1170 adj = adj_get(ai_02);
1171 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
1172 "adj is incomplete");
1173 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_2_s_32.fp_addr,
1174 &adj->sub_type.nbr.next_hop)),
1175 "adj nbr next-hop ok");
1177 adj_nbr_update_rewrite(ai_02, ADJ_NBR_REWRITE_FLAG_COMPLETE,
1178 fib_test_build_rewrite(eth_addr));
1179 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
1181 FIB_TEST((0 == ip46_address_cmp(&pfx_10_10_10_2_s_32.fp_addr,
1182 &adj->sub_type.nbr.next_hop)),
1183 "adj nbr next-hop ok");
1184 FIB_TEST((ai_01 != ai_02), "ADJs are different");
1186 fib_table_entry_path_add(fib_index,
1187 &pfx_10_10_10_2_s_32,
1189 FIB_ENTRY_FLAG_ATTACHED,
1191 &pfx_10_10_10_2_s_32.fp_addr,
1192 tm->hw[0]->sw_if_index,
1193 ~0, // invalid fib index
1196 FIB_ROUTE_PATH_FLAG_NONE);
1198 fei = fib_table_lookup(fib_index, &pfx_10_10_10_2_s_32);
1199 ai = fib_entry_get_adj(fei);
1200 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
1203 * +2 adj-fibs, and their non-shared path-lists
1205 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
1206 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
1207 fib_path_list_pool_size());
1208 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
1209 fib_entry_pool_size());
1212 * Add 2 routes via the first ADJ. ensure path-list sharing
1214 fib_prefix_t pfx_1_1_1_1_s_32 = {
1216 .fp_proto = FIB_PROTOCOL_IP4,
1219 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
1223 fib_table_entry_path_add(fib_index,
1226 FIB_ENTRY_FLAG_NONE,
1229 tm->hw[0]->sw_if_index,
1230 ~0, // invalid fib index
1233 FIB_ROUTE_PATH_FLAG_NONE);
1234 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
1235 ai = fib_entry_get_adj(fei);
1236 FIB_TEST((ai_01 == ai), "1.1.1.1 resolves via 10.10.10.1");
1239 * +1 entry and a shared path-list
1241 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is empty");
1242 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1243 fib_path_list_pool_size());
1244 FIB_TEST((ENBR+5 == fib_entry_pool_size()), "entry pool size is %d",
1245 fib_entry_pool_size());
1248 fib_prefix_t pfx_1_1_2_0_s_24 = {
1250 .fp_proto = FIB_PROTOCOL_IP4,
1252 .ip4.as_u32 = clib_host_to_net_u32(0x01010200),
1256 fib_table_entry_path_add(fib_index,
1259 FIB_ENTRY_FLAG_NONE,
1262 tm->hw[0]->sw_if_index,
1263 ~0, // invalid fib index
1266 FIB_ROUTE_PATH_FLAG_NONE);
1267 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1268 ai = fib_entry_get_adj(fei);
1269 FIB_TEST((ai_01 == ai), "1.1.2.0/24 resolves via 10.10.10.1");
1274 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is empty");
1275 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1276 fib_path_list_pool_size());
1277 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1278 fib_entry_pool_size());
1281 * modify 1.1.2.0/24 to use multipath.
1283 fib_table_entry_path_add(fib_index,
1286 FIB_ENTRY_FLAG_NONE,
1289 tm->hw[0]->sw_if_index,
1290 ~0, // invalid fib index
1293 FIB_ROUTE_PATH_FLAG_NONE);
1294 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1295 dpo = fib_entry_contribute_ip_forwarding(fei);
1296 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1297 1, tm->hw[0]->sw_if_index),
1298 "RPF list for 1.1.2.0/24 contains both adjs");
1300 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 0);
1301 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type, "type is %d", dpo1->dpoi_type);
1302 FIB_TEST((ai_01 == dpo1->dpoi_index),
1303 "1.1.2.0/24 bucket 0 resolves via 10.10.10.1 (%d=%d)",
1304 ai_01, dpo1->dpoi_index);
1306 dpo1 = load_balance_get_bucket(dpo->dpoi_index, 1);
1307 FIB_TEST(DPO_ADJACENCY == dpo1->dpoi_type, "type is %d", dpo1->dpoi_type);
1308 FIB_TEST((ai_02 == dpo1->dpoi_index),
1309 "1.1.2.0/24 bucket 1 resolves via 10.10.10.2");
1312 * +1 shared-pathlist
1314 FIB_TEST((2 == fib_path_list_db_size()), "path list DB is empty");
1315 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
1316 fib_path_list_pool_size());
1317 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1318 fib_entry_pool_size());
1323 fib_table_entry_path_remove(fib_index,
1328 tm->hw[0]->sw_if_index,
1331 FIB_ROUTE_PATH_FLAG_NONE);
1332 fei = fib_table_lookup(fib_index, &pfx_1_1_2_0_s_24);
1333 dpo = fib_entry_contribute_ip_forwarding(fei);
1334 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1335 1, tm->hw[0]->sw_if_index),
1336 "RPF list for 1.1.2.0/24 contains one adj");
1338 ai = fib_entry_get_adj(fei);
1339 FIB_TEST((ai_01 == ai), "1.1.2.0/24 resolves via 10.10.10.1");
1342 * +1 shared-pathlist
1344 FIB_TEST((1 == fib_path_list_db_size()), "path list DB is %d",
1345 fib_path_list_db_size());
1346 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
1347 fib_path_list_pool_size());
1348 FIB_TEST((ENBR+6 == fib_entry_pool_size()), "entry pool size is %d",
1349 fib_entry_pool_size());
1352 * Add 2 recursive routes:
1353 * 100.100.100.100/32 via 1.1.1.1/32 => the via entry is installed.
1354 * 100.100.100.101/32 via 1.1.1.1/32 => the via entry is installed.
1356 fib_prefix_t bgp_100_pfx = {
1358 .fp_proto = FIB_PROTOCOL_IP4,
1360 /* 100.100.100.100/32 */
1361 .ip4.as_u32 = clib_host_to_net_u32(0x64646464),
1365 ip46_address_t nh_1_1_1_1 = {
1366 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
1369 fei = 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_100_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 and +1 shared-path-list
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+7 == fib_entry_pool_size()), "entry pool size is %d",
1394 fib_entry_pool_size());
1396 fib_prefix_t bgp_101_pfx = {
1398 .fp_proto = FIB_PROTOCOL_IP4,
1400 /* 100.100.100.101/32 */
1401 .ip4.as_u32 = clib_host_to_net_u32(0x64646465),
1405 fib_table_entry_path_add(fib_index,
1408 FIB_ENTRY_FLAG_NONE,
1411 ~0, // no index provided.
1412 fib_index, // nexthop in same fib as route
1415 FIB_ROUTE_PATH_FLAG_NONE);
1417 FIB_TEST_REC_FORW(&bgp_101_pfx, &pfx_1_1_1_1_s_32, 0);
1418 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
1419 tm->hw[0]->sw_if_index),
1420 "RPF list for adj-fib contains adj");
1423 * +1 entry, but the recursive path-list is shared.
1425 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
1426 fib_path_list_db_size());
1427 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
1428 fib_path_list_pool_size());
1429 FIB_TEST((ENBR+8 == fib_entry_pool_size()), "entry pool size is %d",
1430 fib_entry_pool_size());
1433 * An special route; one where the user (me) provides the
1434 * adjacency through which the route will resovle by setting the flags
1436 fib_prefix_t ex_pfx = {
1438 .fp_proto = FIB_PROTOCOL_IP4,
1441 .ip4.as_u32 = clib_host_to_net_u32(0x04040404),
1445 fib_table_entry_special_add(fib_index,
1448 FIB_ENTRY_FLAG_LOCAL);
1449 fei = fib_table_lookup_exact_match(fib_index, &ex_pfx);
1450 dpo = fib_entry_contribute_ip_forwarding(fei);
1451 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
1452 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
1453 "local interface adj is local");
1455 fib_table_entry_special_remove(fib_index,
1457 FIB_SOURCE_SPECIAL);
1458 FIB_TEST(FIB_NODE_INDEX_INVALID ==
1459 fib_table_lookup_exact_match(fib_index, &ex_pfx),
1460 "Exclusive reoute removed");
1463 * An EXCLUSIVE route; one where the user (me) provides the exclusive
1464 * adjacency through which the route will resovle
1466 dpo_id_t ex_dpo = DPO_INVALID;
1468 lookup_dpo_add_or_lock_w_fib_index(fib_index,
1471 LOOKUP_INPUT_DST_ADDR,
1472 LOOKUP_TABLE_FROM_CONFIG,
1475 fib_table_entry_special_dpo_add(fib_index,
1478 FIB_ENTRY_FLAG_EXCLUSIVE,
1480 fei = fib_table_lookup_exact_match(fib_index, &ex_pfx);
1481 dpo = fib_entry_contribute_ip_forwarding(fei);
1482 FIB_TEST(!dpo_cmp(&ex_dpo, load_balance_get_bucket(dpo->dpoi_index, 0)),
1483 "exclusive remote uses lookup DPO");
1486 * update the exclusive to use a different DPO
1488 ip_null_dpo_add_and_lock(DPO_PROTO_IP4,
1489 IP_NULL_ACTION_SEND_ICMP_UNREACH,
1491 fib_table_entry_special_dpo_update(fib_index,
1494 FIB_ENTRY_FLAG_EXCLUSIVE,
1496 dpo = fib_entry_contribute_ip_forwarding(fei);
1497 FIB_TEST(!dpo_cmp(&ex_dpo, load_balance_get_bucket(dpo->dpoi_index, 0)),
1498 "exclusive remote uses now uses NULL DPO");
1500 fib_table_entry_special_remove(fib_index,
1502 FIB_SOURCE_SPECIAL);
1503 FIB_TEST(FIB_NODE_INDEX_INVALID ==
1504 fib_table_lookup_exact_match(fib_index, &ex_pfx),
1505 "Exclusive reoute removed");
1509 * Add a recursive route:
1510 * 200.200.200.200/32 via 1.1.1.2/32 => the via entry is NOT installed.
1512 fib_prefix_t bgp_200_pfx = {
1514 .fp_proto = FIB_PROTOCOL_IP4,
1516 /* 200.200.200.200/32 */
1517 .ip4.as_u32 = clib_host_to_net_u32(0xc8c8c8c8),
1521 fib_prefix_t pfx_1_1_1_2_s_32 = {
1523 .fp_proto = FIB_PROTOCOL_IP4,
1525 .ip4.as_u32 = clib_host_to_net_u32(0x01010102),
1529 fei = fib_table_entry_path_add(fib_index,
1532 FIB_ENTRY_FLAG_NONE,
1534 &pfx_1_1_1_2_s_32.fp_addr,
1535 ~0, // no index provided.
1536 fib_index, // nexthop in same fib as route
1539 FIB_ROUTE_PATH_FLAG_NONE);
1541 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
1542 "Recursive via unresolved is drop");
1545 * the adj should be recursive via drop, since the route resolves via
1546 * the default route, which is itself a DROP
1548 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
1549 dpo1 = fib_entry_contribute_ip_forwarding(fei);
1550 FIB_TEST(load_balance_is_drop(dpo1), "1.1.1.2/32 is drop");
1551 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
1552 "RPF list for 1.1.1.2/32 contains 0 adjs");
1555 * +2 entry and +1 shared-path-list
1557 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
1558 fib_path_list_db_size());
1559 FIB_TEST((PNBR+7 == fib_path_list_pool_size()), "path list pool size is %d",
1560 fib_path_list_pool_size());
1561 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
1562 fib_entry_pool_size());
1565 * Unequal Cost load-balance. 3:1 ratio. fits in a 4 bucket LB
1566 * The paths are sort by NH first. in this case the the path with greater
1567 * weight is first in the set. This ordering is to test the RPF sort|uniq logic
1569 fib_prefix_t pfx_1_2_3_4_s_32 = {
1571 .fp_proto = FIB_PROTOCOL_IP4,
1573 .ip4.as_u32 = clib_host_to_net_u32(0x01020304),
1576 fib_table_entry_path_add(fib_index,
1579 FIB_ENTRY_FLAG_NONE,
1582 tm->hw[0]->sw_if_index,
1586 FIB_ROUTE_PATH_FLAG_NONE);
1587 fei = fib_table_entry_path_add(fib_index,
1590 FIB_ENTRY_FLAG_NONE,
1593 tm->hw[1]->sw_if_index,
1597 FIB_ROUTE_PATH_FLAG_NONE);
1599 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.4/32 presnet");
1600 dpo = fib_entry_contribute_ip_forwarding(fei);
1601 lb = load_balance_get(dpo->dpoi_index);
1602 FIB_TEST((lb->lb_n_buckets == 4),
1603 "1.2.3.4/32 LB has %d bucket",
1606 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 0, ai_12_12_12_12);
1607 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 1, ai_12_12_12_12);
1608 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 2, ai_12_12_12_12);
1609 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_4_s_32, 3, ai_01);
1611 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
1612 tm->hw[0]->sw_if_index,
1613 tm->hw[1]->sw_if_index),
1614 "RPF list for 1.2.3.4/32 contains both adjs");
1618 * Unequal Cost load-balance. 4:1 ratio.
1619 * fits in a 16 bucket LB with ratio 13:3
1621 fib_prefix_t pfx_1_2_3_5_s_32 = {
1623 .fp_proto = FIB_PROTOCOL_IP4,
1625 .ip4.as_u32 = clib_host_to_net_u32(0x01020305),
1628 fib_table_entry_path_add(fib_index,
1631 FIB_ENTRY_FLAG_NONE,
1634 tm->hw[1]->sw_if_index,
1638 FIB_ROUTE_PATH_FLAG_NONE);
1639 fei = fib_table_entry_path_add(fib_index,
1642 FIB_ENTRY_FLAG_NONE,
1645 tm->hw[0]->sw_if_index,
1649 FIB_ROUTE_PATH_FLAG_NONE);
1651 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.2.3.5/32 presnet");
1652 dpo = fib_entry_contribute_ip_forwarding(fei);
1653 lb = load_balance_get(dpo->dpoi_index);
1654 FIB_TEST((lb->lb_n_buckets == 16),
1655 "1.2.3.5/32 LB has %d bucket",
1658 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 0, ai_01);
1659 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 1, ai_01);
1660 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 2, ai_01);
1661 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 3, ai_01);
1662 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 4, ai_01);
1663 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 5, ai_01);
1664 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 6, ai_01);
1665 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 7, ai_01);
1666 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 8, ai_01);
1667 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 9, ai_01);
1668 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 10, ai_01);
1669 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 11, ai_01);
1670 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 12, ai_01);
1671 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 13, ai_12_12_12_12);
1672 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 14, ai_12_12_12_12);
1673 FIB_TEST_LB_BUCKET_VIA_ADJ(&pfx_1_2_3_5_s_32, 15, ai_12_12_12_12);
1675 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
1676 tm->hw[0]->sw_if_index,
1677 tm->hw[1]->sw_if_index),
1678 "RPF list for 1.2.3.4/32 contains both adjs");
1681 * Test UCMP with a large weight skew - this produces load-balance objects with large
1682 * numbers of buckets to accommodate the skew. By updating said load-balances we are
1683 * laso testing the LB in placce modify code when number of buckets is large.
1685 fib_prefix_t pfx_6_6_6_6_s_32 = {
1687 .fp_proto = FIB_PROTOCOL_IP4,
1690 .ip4.as_u32 = clib_host_to_net_u32(0x06060606),
1693 fib_test_lb_bucket_t ip_o_10_10_10_1 = {
1699 fib_test_lb_bucket_t ip_o_10_10_10_2 = {
1705 fib_test_lb_bucket_t ip_6_6_6_6_o_12_12_12_12 = {
1708 .adj = ai_12_12_12_12,
1711 fib_table_entry_update_one_path(fib_index,
1714 FIB_ENTRY_FLAG_NONE,
1717 tm->hw[0]->sw_if_index,
1718 ~0, // invalid fib index
1721 FIB_ROUTE_PATH_FLAG_NONE);
1723 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1724 FIB_TEST(!fib_test_validate_entry(fei,
1725 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1728 "6.6.6.6/32 via 10.10.10.1");
1730 fib_table_entry_path_add(fib_index,
1733 FIB_ENTRY_FLAG_NONE,
1736 tm->hw[0]->sw_if_index,
1737 ~0, // invalid fib index
1740 FIB_ROUTE_PATH_FLAG_NONE);
1742 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1743 FIB_TEST(!fib_test_validate_entry(fei,
1744 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
1810 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
1812 fib_table_entry_path_add(fib_index,
1815 FIB_ENTRY_FLAG_NONE,
1818 tm->hw[1]->sw_if_index,
1819 ~0, // invalid fib index
1822 FIB_ROUTE_PATH_FLAG_NONE);
1824 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1825 FIB_TEST(!fib_test_validate_entry(fei,
1826 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
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 &ip_6_6_6_6_o_12_12_12_12,
1921 &ip_6_6_6_6_o_12_12_12_12,
1922 &ip_6_6_6_6_o_12_12_12_12,
1923 &ip_6_6_6_6_o_12_12_12_12,
1924 &ip_6_6_6_6_o_12_12_12_12,
1925 &ip_6_6_6_6_o_12_12_12_12,
1926 &ip_6_6_6_6_o_12_12_12_12,
1927 &ip_6_6_6_6_o_12_12_12_12,
1928 &ip_6_6_6_6_o_12_12_12_12,
1929 &ip_6_6_6_6_o_12_12_12_12,
1930 &ip_6_6_6_6_o_12_12_12_12,
1931 &ip_6_6_6_6_o_12_12_12_12,
1932 &ip_6_6_6_6_o_12_12_12_12,
1933 &ip_6_6_6_6_o_12_12_12_12,
1934 &ip_6_6_6_6_o_12_12_12_12,
1935 &ip_6_6_6_6_o_12_12_12_12,
1936 &ip_6_6_6_6_o_12_12_12_12,
1937 &ip_6_6_6_6_o_12_12_12_12,
1938 &ip_6_6_6_6_o_12_12_12_12,
1939 &ip_6_6_6_6_o_12_12_12_12,
1940 &ip_6_6_6_6_o_12_12_12_12,
1941 &ip_6_6_6_6_o_12_12_12_12,
1942 &ip_6_6_6_6_o_12_12_12_12,
1943 &ip_6_6_6_6_o_12_12_12_12,
1944 &ip_6_6_6_6_o_12_12_12_12,
1945 &ip_6_6_6_6_o_12_12_12_12,
1946 &ip_6_6_6_6_o_12_12_12_12,
1947 &ip_6_6_6_6_o_12_12_12_12,
1948 &ip_6_6_6_6_o_12_12_12_12,
1949 &ip_6_6_6_6_o_12_12_12_12,
1950 &ip_6_6_6_6_o_12_12_12_12,
1951 &ip_6_6_6_6_o_12_12_12_12,
1952 &ip_6_6_6_6_o_12_12_12_12,
1953 &ip_6_6_6_6_o_12_12_12_12,
1954 &ip_6_6_6_6_o_12_12_12_12,
1955 &ip_6_6_6_6_o_12_12_12_12),
1956 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
1958 fib_table_entry_path_remove(fib_index,
1963 tm->hw[1]->sw_if_index,
1964 ~0, // invalid fib index
1966 FIB_ROUTE_PATH_FLAG_NONE);
1968 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
1969 FIB_TEST(!fib_test_validate_entry(fei,
1970 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
2036 "6.6.6.6/32 via 10.10.10.1 and 10.10.10.2 in 63:1 ratio");
2038 fib_table_entry_path_remove(fib_index,
2043 tm->hw[0]->sw_if_index,
2044 ~0, // invalid fib index
2046 FIB_ROUTE_PATH_FLAG_NONE);
2048 fei = fib_table_lookup(fib_index, &pfx_6_6_6_6_s_32);
2049 FIB_TEST(!fib_test_validate_entry(fei,
2050 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
2053 "6.6.6.6/32 via 10.10.10.1");
2055 fib_table_entry_delete(fib_index, &pfx_6_6_6_6_s_32, FIB_SOURCE_API);
2058 * A recursive via the two unequal cost entries
2060 fib_prefix_t bgp_44_s_32 = {
2062 .fp_proto = FIB_PROTOCOL_IP4,
2064 /* 200.200.200.201/32 */
2065 .ip4.as_u32 = clib_host_to_net_u32(0x44444444),
2068 fei = fib_table_entry_path_add(fib_index,
2071 FIB_ENTRY_FLAG_NONE,
2073 &pfx_1_2_3_4_s_32.fp_addr,
2078 FIB_ROUTE_PATH_FLAG_NONE);
2079 fei = fib_table_entry_path_add(fib_index,
2082 FIB_ENTRY_FLAG_NONE,
2084 &pfx_1_2_3_5_s_32.fp_addr,
2089 FIB_ROUTE_PATH_FLAG_NONE);
2091 FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_4_s_32, 0);
2092 FIB_TEST_REC_FORW(&bgp_44_s_32, &pfx_1_2_3_5_s_32, 1);
2093 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 2,
2094 tm->hw[0]->sw_if_index,
2095 tm->hw[1]->sw_if_index),
2096 "RPF list for 1.2.3.4/32 contains both adjs");
2099 * test the uRPF check functions
2101 dpo_id_t dpo_44 = DPO_INVALID;
2104 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, &dpo_44);
2105 urpfi = load_balance_get_urpf(dpo_44.dpoi_index);
2107 FIB_TEST(fib_urpf_check(urpfi, tm->hw[0]->sw_if_index),
2108 "uRPF check for 68.68.68.68/32 on %d OK",
2109 tm->hw[0]->sw_if_index);
2110 FIB_TEST(fib_urpf_check(urpfi, tm->hw[1]->sw_if_index),
2111 "uRPF check for 68.68.68.68/32 on %d OK",
2112 tm->hw[1]->sw_if_index);
2113 FIB_TEST(!fib_urpf_check(urpfi, 99),
2114 "uRPF check for 68.68.68.68/32 on 99 not-OK",
2118 fib_table_entry_delete(fib_index,
2121 fib_table_entry_delete(fib_index,
2124 fib_table_entry_delete(fib_index,
2129 * Add a recursive route:
2130 * 200.200.200.201/32 via 1.1.1.200/32 => the via entry is NOT installed.
2132 fib_prefix_t bgp_201_pfx = {
2134 .fp_proto = FIB_PROTOCOL_IP4,
2136 /* 200.200.200.201/32 */
2137 .ip4.as_u32 = clib_host_to_net_u32(0xc8c8c8c9),
2141 fib_prefix_t pfx_1_1_1_200_s_32 = {
2143 .fp_proto = FIB_PROTOCOL_IP4,
2145 .ip4.as_u32 = clib_host_to_net_u32(0x010101c8),
2149 fei = fib_table_entry_path_add(fib_index,
2152 FIB_ENTRY_FLAG_NONE,
2154 &pfx_1_1_1_200_s_32.fp_addr,
2155 ~0, // no index provided.
2156 fib_index, // nexthop in same fib as route
2159 FIB_ROUTE_PATH_FLAG_NONE);
2161 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2162 "Recursive via unresolved is drop");
2164 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32);
2165 FIB_TEST((FIB_ENTRY_FLAG_NONE == fib_entry_get_flags(fei)),
2166 "Flags set on RR via non-attached");
2167 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
2168 "RPF list for BGP route empty");
2171 * +2 entry (BGP & RR) and +1 shared-path-list
2173 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2174 fib_path_list_db_size());
2175 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2176 fib_path_list_pool_size());
2177 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2178 fib_entry_pool_size());
2181 * insert a route that covers the missing 1.1.1.2/32. we epxect
2182 * 200.200.200.200/32 and 200.200.200.201/32 to resolve through it.
2184 fib_prefix_t pfx_1_1_1_0_s_24 = {
2186 .fp_proto = FIB_PROTOCOL_IP4,
2189 .ip4.as_u32 = clib_host_to_net_u32(0x01010100),
2193 fib_table_entry_path_add(fib_index,
2196 FIB_ENTRY_FLAG_NONE,
2199 tm->hw[0]->sw_if_index,
2200 ~0, // invalid fib index
2203 FIB_ROUTE_PATH_FLAG_NONE);
2204 fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24);
2205 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2206 ai = fib_entry_get_adj(fei);
2207 FIB_TEST((ai_01 == ai), "1.1.1.0/24 resolves via 10.10.10.1");
2208 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
2209 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2210 ai = fib_entry_get_adj(fei);
2211 FIB_TEST((ai_01 == ai), "1.1.1.2/32 resolves via 10.10.10.1");
2212 fei = fib_table_lookup(fib_index, &pfx_1_1_1_200_s_32);
2213 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2214 ai = fib_entry_get_adj(fei);
2215 FIB_TEST((ai_01 == ai), "1.1.1.200/24 resolves via 10.10.10.1");
2218 * +1 entry. 1.1.1.1/32 already uses 10.10.10.1 so no new pah-list
2220 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2221 fib_path_list_db_size());
2222 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2223 fib_path_list_pool_size());
2224 FIB_TEST((ENBR+13 == fib_entry_pool_size()), "entry pool size is %d",
2225 fib_entry_pool_size());
2228 * the recursive adj for 200.200.200.200 should be updated.
2230 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2231 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2232 fei = fib_table_lookup(fib_index, &bgp_200_pfx);
2233 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1,
2234 tm->hw[0]->sw_if_index),
2235 "RPF list for BGP route has itf index 0");
2238 * insert a more specific route than 1.1.1.0/24 that also covers the
2239 * missing 1.1.1.2/32, but not 1.1.1.200/32. we expect
2240 * 200.200.200.200 to resolve through it.
2242 fib_prefix_t pfx_1_1_1_0_s_28 = {
2244 .fp_proto = FIB_PROTOCOL_IP4,
2247 .ip4.as_u32 = clib_host_to_net_u32(0x01010100),
2251 fib_table_entry_path_add(fib_index,
2254 FIB_ENTRY_FLAG_NONE,
2257 tm->hw[0]->sw_if_index,
2258 ~0, // invalid fib index
2261 FIB_ROUTE_PATH_FLAG_NONE);
2262 fei = fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28);
2263 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2264 ai = fib_entry_get_adj(fei);
2265 FIB_TEST((ai_02 == ai), "1.1.1.0/24 resolves via 10.10.10.2");
2268 * +1 entry. +1 shared path-list
2270 FIB_TEST((5 == fib_path_list_db_size()), "path list DB population:%d",
2271 fib_path_list_db_size());
2272 FIB_TEST((PNBR+9 == fib_path_list_pool_size()), "path list pool size is %d",
2273 fib_path_list_pool_size());
2274 FIB_TEST((ENBR+14 == fib_entry_pool_size()), "entry pool size is %d",
2275 fib_entry_pool_size());
2278 * the recursive adj for 200.200.200.200 should be updated.
2279 * 200.200.200.201 remains unchanged.
2281 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2282 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2285 * remove this /28. 200.200.200.200/32 should revert back to via 1.1.1.0/24
2287 fib_table_entry_path_remove(fib_index,
2292 tm->hw[0]->sw_if_index,
2295 FIB_ROUTE_PATH_FLAG_NONE);
2296 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28) ==
2297 FIB_NODE_INDEX_INVALID),
2298 "1.1.1.0/28 removed");
2299 FIB_TEST((fib_table_lookup(fib_index, &pfx_1_1_1_0_s_28) ==
2300 fib_table_lookup(fib_index, &pfx_1_1_1_0_s_24)),
2301 "1.1.1.0/28 lookup via /24");
2302 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_200_s_32, 0);
2303 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2306 * -1 entry. -1 shared path-list
2308 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2309 fib_path_list_db_size());
2310 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2311 fib_path_list_pool_size());
2312 FIB_TEST((ENBR+13 == fib_entry_pool_size()), "entry pool size is %d",
2313 fib_entry_pool_size());
2316 * remove 1.1.1.0/24. 200.200.200.200/32 should revert back to via 0.0.0.0/0
2318 fib_table_entry_path_remove(fib_index,
2323 tm->hw[0]->sw_if_index,
2326 FIB_ROUTE_PATH_FLAG_NONE);
2327 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_24) ==
2328 FIB_NODE_INDEX_INVALID),
2329 "1.1.1.0/24 removed");
2331 fei = fib_table_lookup(fib_index, &pfx_1_1_1_2_s_32);
2332 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2333 "1.1.1.2/32 route is DROP");
2334 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32);
2335 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2336 "1.1.1.200/32 route is DROP");
2338 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2339 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2341 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
2342 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2348 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2349 fib_path_list_db_size());
2350 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2351 fib_path_list_pool_size());
2352 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2353 fib_entry_pool_size());
2356 * insert the missing 1.1.1.2/32
2358 fei = fib_table_entry_path_add(fib_index,
2361 FIB_ENTRY_FLAG_NONE,
2364 tm->hw[0]->sw_if_index,
2365 ~0, // invalid fib index
2368 FIB_ROUTE_PATH_FLAG_NONE);
2369 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2370 ai = fib_entry_get_adj(fei);
2371 FIB_TEST((ai = ai_01), "1.1.1.2/32 resolves via 10.10.10.1");
2373 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2374 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2376 FIB_TEST_REC_FORW(&bgp_200_pfx, &pfx_1_1_1_2_s_32, 0);
2379 * no change. 1.1.1.2/32 was already there RR sourced.
2381 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2382 fib_path_list_db_size());
2383 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2384 fib_path_list_pool_size());
2385 FIB_TEST((ENBR+12 == fib_entry_pool_size()), "entry pool size is %d",
2386 fib_entry_pool_size());
2389 * give 201 a resolved path.
2390 * it now has the unresolved 1.1.1.200 and the resolved 1.1.1.2,
2391 * only the latter contributes forwarding.
2393 fei = fib_table_entry_path_add(fib_index,
2396 FIB_ENTRY_FLAG_NONE,
2398 &pfx_1_1_1_2_s_32.fp_addr,
2403 FIB_ROUTE_PATH_FLAG_NONE);
2404 FIB_TEST_REC_FORW(&bgp_201_pfx, &pfx_1_1_1_2_s_32, 0);
2405 fib_table_entry_path_remove(fib_index,
2409 &pfx_1_1_1_2_s_32.fp_addr,
2413 FIB_ROUTE_PATH_FLAG_NONE);
2416 * remove 200.200.200.201/32 which does not have a valid via FIB
2418 fib_table_entry_path_remove(fib_index,
2422 &pfx_1_1_1_200_s_32.fp_addr,
2423 ~0, // no index provided.
2426 FIB_ROUTE_PATH_FLAG_NONE);
2429 * -2 entries (BGP and RR). -1 shared path-list;
2431 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_201_pfx) ==
2432 FIB_NODE_INDEX_INVALID),
2433 "200.200.200.201/32 removed");
2434 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_200_s_32) ==
2435 FIB_NODE_INDEX_INVALID),
2436 "1.1.1.200/32 removed");
2438 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
2439 fib_path_list_db_size());
2440 FIB_TEST((PNBR+7 == fib_path_list_pool_size()), "path list pool size is %d",
2441 fib_path_list_pool_size());
2442 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2443 fib_entry_pool_size());
2446 * remove 200.200.200.200/32 which does have a valid via FIB
2448 fib_table_entry_path_remove(fib_index,
2452 &pfx_1_1_1_2_s_32.fp_addr,
2453 ~0, // no index provided.
2456 FIB_ROUTE_PATH_FLAG_NONE);
2458 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_200_pfx) ==
2459 FIB_NODE_INDEX_INVALID),
2460 "200.200.200.200/32 removed");
2461 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32) !=
2462 FIB_NODE_INDEX_INVALID),
2463 "1.1.1.2/32 still present");
2466 * -1 entry (BGP, the RR source is also API sourced). -1 shared path-list;
2468 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
2469 fib_path_list_db_size());
2470 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
2471 fib_path_list_pool_size());
2472 FIB_TEST((ENBR+9 == fib_entry_pool_size()), "entry pool size is %d",
2473 fib_entry_pool_size());
2476 * A recursive prefix that has a 2 path load-balance.
2477 * It also shares a next-hop with other BGP prefixes and hence
2478 * test the ref counting of RR sourced prefixes and 2 level LB.
2480 const fib_prefix_t bgp_102 = {
2482 .fp_proto = FIB_PROTOCOL_IP4,
2484 /* 100.100.100.101/32 */
2485 .ip4.as_u32 = clib_host_to_net_u32(0x64646466),
2488 fib_table_entry_path_add(fib_index,
2491 FIB_ENTRY_FLAG_NONE,
2493 &pfx_1_1_1_1_s_32.fp_addr,
2494 ~0, // no index provided.
2495 fib_index, // same as route
2498 FIB_ROUTE_PATH_FLAG_NONE);
2499 fib_table_entry_path_add(fib_index,
2502 FIB_ENTRY_FLAG_NONE,
2504 &pfx_1_1_1_2_s_32.fp_addr,
2505 ~0, // no index provided.
2506 fib_index, // same as route's FIB
2509 FIB_ROUTE_PATH_FLAG_NONE);
2510 fei = fib_table_lookup_exact_match(fib_index, &bgp_102);
2511 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "100.100.100.102/32 presnet");
2512 dpo = fib_entry_contribute_ip_forwarding(fei);
2514 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
2515 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2516 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32);
2517 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2519 lb = load_balance_get(dpo->dpoi_index);
2520 FIB_TEST((lb->lb_n_buckets == 2), "Recursive LB has %d bucket", lb->lb_n_buckets);
2521 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2522 "First via 10.10.10.1");
2523 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo->dpoi_index, 1)),
2524 "Second via 10.10.10.1");
2526 fib_table_entry_path_remove(fib_index,
2530 &pfx_1_1_1_1_s_32.fp_addr,
2531 ~0, // no index provided.
2532 fib_index, // same as route's FIB
2534 FIB_ROUTE_PATH_FLAG_NONE);
2535 fib_table_entry_path_remove(fib_index,
2539 &pfx_1_1_1_2_s_32.fp_addr,
2540 ~0, // no index provided.
2541 fib_index, // same as route's FIB
2543 FIB_ROUTE_PATH_FLAG_NONE);
2544 fei = fib_table_lookup_exact_match(fib_index, &bgp_102);
2545 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "100.100.100.102/32 removed");
2548 * remove the remaining recursives
2550 fib_table_entry_path_remove(fib_index,
2554 &pfx_1_1_1_1_s_32.fp_addr,
2555 ~0, // no index provided.
2556 fib_index, // same as route's FIB
2558 FIB_ROUTE_PATH_FLAG_NONE);
2559 fib_table_entry_path_remove(fib_index,
2563 &pfx_1_1_1_1_s_32.fp_addr,
2564 ~0, // no index provided.
2565 fib_index, // same as route's FIB
2567 FIB_ROUTE_PATH_FLAG_NONE);
2568 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_100_pfx) ==
2569 FIB_NODE_INDEX_INVALID),
2570 "100.100.100.100/32 removed");
2571 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_101_pfx) ==
2572 FIB_NODE_INDEX_INVALID),
2573 "100.100.100.101/32 removed");
2576 * -2 entry (2*BGP, the RR source is also API sourced). -1 shared path-list;
2578 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2579 fib_path_list_db_size());
2580 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2581 fib_path_list_pool_size());
2582 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2583 fib_entry_pool_size());
2586 * Add a recursive route via a connected cover, using an adj-fib that does exist
2588 fib_table_entry_path_add(fib_index,
2591 FIB_ENTRY_FLAG_NONE,
2594 ~0, // no index provided.
2595 fib_index, // Same as route's FIB
2598 FIB_ROUTE_PATH_FLAG_NONE);
2601 * +1 entry. +1 shared path-list (recursive via 10.10.10.1)
2603 FIB_TEST((2 == fib_path_list_db_size()), "path list DB population:%d",
2604 fib_path_list_db_size());
2605 FIB_TEST((PNBR+6 == fib_path_list_pool_size()), "path list pool size is %d",
2606 fib_path_list_pool_size());
2607 FIB_TEST((ENBR+8 == fib_entry_pool_size()), "entry pool size is %d",
2608 fib_entry_pool_size());
2610 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
2611 dpo = fib_entry_contribute_ip_forwarding(fei);
2613 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
2614 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2616 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2617 "200.200.200.200/32 is recursive via adj for 10.10.10.1");
2619 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED == fib_entry_get_flags(fei)),
2620 "Flags set on RR via existing attached");
2623 * Add a recursive route via a connected cover, using and adj-fib that does
2626 ip46_address_t nh_10_10_10_3 = {
2627 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
2629 fib_prefix_t pfx_10_10_10_3 = {
2631 .fp_proto = FIB_PROTOCOL_IP4,
2632 .fp_addr = nh_10_10_10_3,
2635 fib_table_entry_path_add(fib_index,
2638 FIB_ENTRY_FLAG_NONE,
2641 ~0, // no index provided.
2645 FIB_ROUTE_PATH_FLAG_NONE);
2648 * +2 entries (BGP and RR). +1 shared path-list (recursive via 10.10.10.3) and
2649 * one unshared non-recursive via 10.10.10.3
2651 FIB_TEST((3 == fib_path_list_db_size()), "path list DB population:%d",
2652 fib_path_list_db_size());
2653 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2654 fib_path_list_pool_size());
2655 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2656 fib_entry_pool_size());
2658 ai_03 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
2661 tm->hw[0]->sw_if_index);
2663 fei = fib_table_lookup_exact_match(fib_index, &bgp_201_pfx);
2664 dpo = fib_entry_contribute_ip_forwarding(fei);
2665 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3);
2666 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2668 ai = fib_entry_get_adj(fei);
2669 FIB_TEST((ai == ai_03), "adj for 10.10.10.3/32 is via adj for 10.10.10.3");
2670 FIB_TEST(((FIB_ENTRY_FLAG_ATTACHED | FIB_ENTRY_FLAG_CONNECTED) ==
2671 fib_entry_get_flags(fei)),
2672 "Flags set on RR via non-existing attached");
2674 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 0)),
2675 "adj for 200.200.200.200/32 is recursive via adj for 10.10.10.3");
2680 * remove the recursives
2682 fib_table_entry_path_remove(fib_index,
2687 ~0, // no index provided.
2688 fib_index, // same as route's FIB
2690 FIB_ROUTE_PATH_FLAG_NONE);
2691 fib_table_entry_path_remove(fib_index,
2696 ~0, // no index provided.
2697 fib_index, // same as route's FIB
2699 FIB_ROUTE_PATH_FLAG_NONE);
2701 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_201_pfx) ==
2702 FIB_NODE_INDEX_INVALID),
2703 "200.200.200.201/32 removed");
2704 FIB_TEST((fib_table_lookup_exact_match(fib_index, &bgp_200_pfx) ==
2705 FIB_NODE_INDEX_INVALID),
2706 "200.200.200.200/32 removed");
2707 FIB_TEST((fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3) ==
2708 FIB_NODE_INDEX_INVALID),
2709 "10.10.10.3/32 removed");
2712 * -3 entries (2*BGP and RR). -2 shared path-list (recursive via 10.10.10.3 &
2713 * 10.10.10.1) and one unshared non-recursive via 10.10.10.3
2715 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2716 fib_path_list_db_size());
2717 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2718 fib_path_list_pool_size());
2719 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2720 fib_entry_pool_size());
2725 * Add 5.5.5.5/32 -> 5.5.5.6/32 -> 5.5.5.7/32 -> 5.5.5.5/32
2727 fib_prefix_t pfx_5_5_5_5_s_32 = {
2729 .fp_proto = FIB_PROTOCOL_IP4,
2731 .ip4.as_u32 = clib_host_to_net_u32(0x05050505),
2734 fib_prefix_t pfx_5_5_5_6_s_32 = {
2736 .fp_proto = FIB_PROTOCOL_IP4,
2738 .ip4.as_u32 = clib_host_to_net_u32(0x05050506),
2741 fib_prefix_t pfx_5_5_5_7_s_32 = {
2743 .fp_proto = FIB_PROTOCOL_IP4,
2745 .ip4.as_u32 = clib_host_to_net_u32(0x05050507),
2749 fib_table_entry_path_add(fib_index,
2752 FIB_ENTRY_FLAG_NONE,
2754 &pfx_5_5_5_6_s_32.fp_addr,
2755 ~0, // no index provided.
2759 FIB_ROUTE_PATH_FLAG_NONE);
2760 fib_table_entry_path_add(fib_index,
2763 FIB_ENTRY_FLAG_NONE,
2765 &pfx_5_5_5_7_s_32.fp_addr,
2766 ~0, // no index provided.
2770 FIB_ROUTE_PATH_FLAG_NONE);
2771 fib_table_entry_path_add(fib_index,
2774 FIB_ENTRY_FLAG_NONE,
2776 &pfx_5_5_5_5_s_32.fp_addr,
2777 ~0, // no index provided.
2781 FIB_ROUTE_PATH_FLAG_NONE);
2783 * +3 entries, +3 shared path-list
2785 FIB_TEST((4 == fib_path_list_db_size()), "path list DB population:%d",
2786 fib_path_list_db_size());
2787 FIB_TEST((PNBR+8 == fib_path_list_pool_size()), "path list pool size is %d",
2788 fib_path_list_pool_size());
2789 FIB_TEST((ENBR+10 == fib_entry_pool_size()), "entry pool size is %d",
2790 fib_entry_pool_size());
2793 * All the entries have only looped paths, so they are all drop
2795 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2796 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2797 "LB for 5.5.5.7/32 is via adj for DROP");
2798 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2799 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2800 "LB for 5.5.5.5/32 is via adj for DROP");
2801 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2802 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2803 "LB for 5.5.5.6/32 is via adj for DROP");
2806 * provide 5.5.5.6/32 with alternate path.
2807 * this will allow only 5.5.5.6/32 to forward with this path, the others
2808 * are still drop since the loop is still present.
2810 fib_table_entry_path_add(fib_index,
2813 FIB_ENTRY_FLAG_NONE,
2816 tm->hw[0]->sw_if_index,
2820 FIB_ROUTE_PATH_FLAG_NONE);
2822 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2823 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2825 lb = load_balance_get(dpo1->dpoi_index);
2826 FIB_TEST((lb->lb_n_buckets == 1), "5.5.5.6 LB has %d bucket", lb->lb_n_buckets);
2828 dpo2 = load_balance_get_bucket(dpo1->dpoi_index, 0);
2829 FIB_TEST(DPO_ADJACENCY == dpo2->dpoi_type, "type is %d", dpo2->dpoi_type);
2830 FIB_TEST((ai_01 == dpo2->dpoi_index),
2831 "5.5.5.6 bucket 0 resolves via 10.10.10.2");
2833 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2834 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2835 "LB for 5.5.5.7/32 is via adj for DROP");
2836 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2837 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2838 "LB for 5.5.5.5/32 is via adj for DROP");
2841 * remove the alternate path for 5.5.5.6/32
2844 fib_table_entry_path_remove(fib_index,
2849 tm->hw[0]->sw_if_index,
2852 FIB_ROUTE_PATH_FLAG_NONE);
2854 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2855 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2856 "LB for 5.5.5.7/32 is via adj for DROP");
2857 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2858 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2859 "LB for 5.5.5.5/32 is via adj for DROP");
2860 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2861 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2862 "LB for 5.5.5.6/32 is via adj for DROP");
2865 * break the loop by giving 5.5.5.5/32 a new set of paths
2866 * expect all to forward via this new path.
2868 fib_table_entry_update_one_path(fib_index,
2871 FIB_ENTRY_FLAG_NONE,
2874 tm->hw[0]->sw_if_index,
2875 ~0, // invalid fib index
2878 FIB_ROUTE_PATH_FLAG_NONE);
2880 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2881 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2882 lb = load_balance_get(dpo1->dpoi_index);
2883 FIB_TEST((lb->lb_n_buckets == 1), "5.5.5.5 LB has %d bucket", lb->lb_n_buckets);
2885 dpo2 = load_balance_get_bucket(dpo1->dpoi_index, 0);
2886 FIB_TEST(DPO_ADJACENCY == dpo2->dpoi_type, "type is %d", dpo2->dpoi_type);
2887 FIB_TEST((ai_01 == dpo2->dpoi_index),
2888 "5.5.5.5 bucket 0 resolves via 10.10.10.2");
2890 fei = fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_7_s_32);
2891 dpo2 = fib_entry_contribute_ip_forwarding(fei);
2893 lb = load_balance_get(dpo2->dpoi_index);
2894 FIB_TEST((lb->lb_n_buckets == 1), "Recursive LB has %d bucket", lb->lb_n_buckets);
2895 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo2->dpoi_index, 0)),
2896 "5.5.5.5.7 via 5.5.5.5");
2898 fei = fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_6_s_32);
2899 dpo1 = fib_entry_contribute_ip_forwarding(fei);
2901 lb = load_balance_get(dpo1->dpoi_index);
2902 FIB_TEST((lb->lb_n_buckets == 1), "Recursive LB has %d bucket", lb->lb_n_buckets);
2903 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
2904 "5.5.5.5.6 via 5.5.5.7");
2907 * revert back to the loop. so we can remove the prefixes with
2910 fib_table_entry_update_one_path(fib_index,
2913 FIB_ENTRY_FLAG_NONE,
2915 &pfx_5_5_5_6_s_32.fp_addr,
2916 ~0, // no index provided.
2920 FIB_ROUTE_PATH_FLAG_NONE);
2922 fei = fib_table_lookup(fib_index, &pfx_5_5_5_7_s_32);
2923 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2924 "LB for 5.5.5.7/32 is via adj for DROP");
2925 fei = fib_table_lookup(fib_index, &pfx_5_5_5_5_s_32);
2926 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2927 "LB for 5.5.5.5/32 is via adj for DROP");
2928 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2929 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2930 "LB for 5.5.5.6/32 is via adj for DROP");
2933 * remove all the 5.5.5.x/32 prefixes
2935 fib_table_entry_path_remove(fib_index,
2939 &pfx_5_5_5_6_s_32.fp_addr,
2940 ~0, // no index provided.
2941 fib_index, // same as route's FIB
2943 FIB_ROUTE_PATH_FLAG_NONE);
2944 fib_table_entry_path_remove(fib_index,
2948 &pfx_5_5_5_7_s_32.fp_addr,
2949 ~0, // no index provided.
2950 fib_index, // same as route's FIB
2952 FIB_ROUTE_PATH_FLAG_NONE);
2953 fib_table_entry_path_remove(fib_index,
2957 &pfx_5_5_5_5_s_32.fp_addr,
2958 ~0, // no index provided.
2959 fib_index, // same as route's FIB
2961 FIB_ROUTE_PATH_FLAG_NONE);
2962 fib_table_entry_path_remove(fib_index,
2967 ~0, // no index provided.
2968 fib_index, // same as route's FIB
2970 FIB_ROUTE_PATH_FLAG_NONE);
2973 * -3 entries, -3 shared path-list
2975 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
2976 fib_path_list_db_size());
2977 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
2978 fib_path_list_pool_size());
2979 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
2980 fib_entry_pool_size());
2983 * Single level loop 5.5.5.5/32 via 5.5.5.5/32
2985 fib_table_entry_path_add(fib_index,
2988 FIB_ENTRY_FLAG_NONE,
2990 &pfx_5_5_5_6_s_32.fp_addr,
2991 ~0, // no index provided.
2995 FIB_ROUTE_PATH_FLAG_NONE);
2996 fei = fib_table_lookup(fib_index, &pfx_5_5_5_6_s_32);
2997 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
2998 "1-level 5.5.5.6/32 loop is via adj for DROP");
3000 fib_table_entry_path_remove(fib_index,
3004 &pfx_5_5_5_6_s_32.fp_addr,
3005 ~0, // no index provided.
3006 fib_index, // same as route's FIB
3008 FIB_ROUTE_PATH_FLAG_NONE);
3009 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3010 fib_table_lookup_exact_match(fib_index, &pfx_5_5_5_6_s_32),
3011 "1-level 5.5.5.6/32 loop is removed");
3014 * A recursive route whose next-hop is covered by the prefix.
3015 * This would mean the via-fib, which inherits forwarding from its
3016 * cover, thus picks up forwarding from the prfix, which is via the
3017 * via-fib, and we have a loop.
3019 fib_prefix_t pfx_23_23_23_0_s_24 = {
3021 .fp_proto = FIB_PROTOCOL_IP4,
3023 .ip4.as_u32 = clib_host_to_net_u32(0x17171700),
3026 fib_prefix_t pfx_23_23_23_23_s_32 = {
3028 .fp_proto = FIB_PROTOCOL_IP4,
3030 .ip4.as_u32 = clib_host_to_net_u32(0x17171717),
3033 fei = fib_table_entry_path_add(fib_index,
3034 &pfx_23_23_23_0_s_24,
3036 FIB_ENTRY_FLAG_NONE,
3038 &pfx_23_23_23_23_s_32.fp_addr,
3043 FIB_ROUTE_PATH_FLAG_NONE);
3044 dpo = fib_entry_contribute_ip_forwarding(fei);
3045 FIB_TEST(load_balance_is_drop(dpo),
3046 "23.23.23.0/24 via covered is DROP");
3047 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
3050 * add-remove test. no change.
3052 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3053 fib_path_list_db_size());
3054 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3055 fib_path_list_pool_size());
3056 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3057 fib_entry_pool_size());
3060 * Make the default route recursive via a unknown next-hop. Thus the
3061 * next hop's cover would be the default route
3063 fei = fib_table_entry_path_add(fib_index,
3066 FIB_ENTRY_FLAG_NONE,
3068 &pfx_23_23_23_23_s_32.fp_addr,
3073 FIB_ROUTE_PATH_FLAG_NONE);
3074 dpo = fib_entry_contribute_ip_forwarding(fei);
3075 FIB_TEST(load_balance_is_drop(dpo),
3076 "0.0.0.0.0/0 via is DROP");
3077 FIB_TEST((fib_entry_get_resolving_interface(fei) == ~0),
3078 "no resolving interface for looped 0.0.0.0/0");
3080 fei = fib_table_lookup_exact_match(fib_index, &pfx_23_23_23_23_s_32);
3081 dpo = fib_entry_contribute_ip_forwarding(fei);
3082 FIB_TEST(load_balance_is_drop(dpo),
3083 "23.23.23.23/32 via is DROP");
3084 FIB_TEST((fib_entry_get_resolving_interface(fei) == ~0),
3085 "no resolving interface for looped 23.23.23.23/32");
3087 fib_table_entry_delete(fib_index, &pfx_0_0_0_0_s_0, FIB_SOURCE_API);
3090 * A recursive route with recursion constraints.
3091 * 200.200.200.200/32 via 1.1.1.1 is recurse via host constrained
3093 fib_table_entry_path_add(fib_index,
3096 FIB_ENTRY_FLAG_NONE,
3103 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3105 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
3106 dpo2 = fib_entry_contribute_ip_forwarding(fei);
3108 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3109 dpo1 = fib_entry_contribute_ip_forwarding(fei);
3111 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3112 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3115 * save the load-balance. we expect it to be inplace modified
3117 lb = load_balance_get(dpo1->dpoi_index);
3120 * add a covering prefix for the via fib that would otherwise serve
3121 * as the resolving route when the host is removed
3123 fib_table_entry_path_add(fib_index,
3126 FIB_ENTRY_FLAG_NONE,
3129 tm->hw[0]->sw_if_index,
3130 ~0, // invalid fib index
3133 FIB_ROUTE_PATH_FLAG_NONE);
3134 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28);
3135 ai = fib_entry_get_adj(fei);
3136 FIB_TEST((ai == ai_01),
3137 "adj for 1.1.1.0/28 is via adj for 1.1.1.1");
3140 * remove the host via FIB - expect the BGP prefix to be drop
3142 fib_table_entry_path_remove(fib_index,
3147 tm->hw[0]->sw_if_index,
3148 ~0, // invalid fib index
3150 FIB_ROUTE_PATH_FLAG_NONE);
3152 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3153 "adj for 200.200.200.200/32 is recursive via adj for DROP");
3156 * add the via-entry host reoute back. expect to resolve again
3158 fib_table_entry_path_add(fib_index,
3161 FIB_ENTRY_FLAG_NONE,
3164 tm->hw[0]->sw_if_index,
3165 ~0, // invalid fib index
3168 FIB_ROUTE_PATH_FLAG_NONE);
3169 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo1->dpoi_index, 0)),
3170 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3173 * add another path for the recursive. it will then have 2.
3175 fib_prefix_t pfx_1_1_1_3_s_32 = {
3177 .fp_proto = FIB_PROTOCOL_IP4,
3179 .ip4.as_u32 = clib_host_to_net_u32(0x01010103),
3182 fib_table_entry_path_add(fib_index,
3185 FIB_ENTRY_FLAG_NONE,
3188 tm->hw[0]->sw_if_index,
3189 ~0, // invalid fib index
3192 FIB_ROUTE_PATH_FLAG_NONE);
3194 fib_table_entry_path_add(fib_index,
3197 FIB_ENTRY_FLAG_NONE,
3199 &pfx_1_1_1_3_s_32.fp_addr,
3204 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3207 * add a bunch load more entries using this path combo so that we get
3208 * an LB-map created.
3211 fib_prefix_t bgp_78s[N_P];
3212 for (ii = 0; ii < N_P; ii++)
3214 bgp_78s[ii].fp_len = 32;
3215 bgp_78s[ii].fp_proto = FIB_PROTOCOL_IP4;
3216 bgp_78s[ii].fp_addr.ip4.as_u32 = clib_host_to_net_u32(0x4e000000+ii);
3219 fib_table_entry_path_add(fib_index,
3222 FIB_ENTRY_FLAG_NONE,
3224 &pfx_1_1_1_3_s_32.fp_addr,
3229 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3230 fib_table_entry_path_add(fib_index,
3233 FIB_ENTRY_FLAG_NONE,
3240 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3243 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3244 dpo = fib_entry_contribute_ip_forwarding(fei);
3246 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32);
3247 dpo2 = fib_entry_contribute_ip_forwarding(fei);
3248 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket(dpo->dpoi_index, 0)),
3249 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.1");
3250 fei = fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_3_s_32);
3251 dpo1 = fib_entry_contribute_ip_forwarding(fei);
3252 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket(dpo->dpoi_index, 1)),
3253 "adj for 200.200.200.200/32 is recursive via adj for 1.1.1.3");
3256 * expect the lb-map used by the recursive's load-balance is using both buckets
3258 load_balance_map_t *lbm;
3261 lb = load_balance_get(dpo->dpoi_index);
3263 load_balance_map_lock(lbmi);
3264 lbm = load_balance_map_get(lbmi);
3266 FIB_TEST(lbm->lbm_buckets[0] == 0,
3267 "LB maps's bucket 0 is %d",
3268 lbm->lbm_buckets[0]);
3269 FIB_TEST(lbm->lbm_buckets[1] == 1,
3270 "LB maps's bucket 1 is %d",
3271 lbm->lbm_buckets[1]);
3274 * withdraw one of the /32 via-entrys.
3275 * that ECMP path will be unresolved and forwarding should continue on the
3276 * other available path. this is an iBGP PIC edge failover.
3277 * Test the forwarding changes without re-fetching the adj from the
3278 * recursive entry. this ensures its the same one that is updated; i.e. an
3281 fib_table_entry_path_remove(fib_index,
3286 tm->hw[0]->sw_if_index,
3287 ~0, // invalid fib index
3289 FIB_ROUTE_PATH_FLAG_NONE);
3291 /* suspend so the update walk kicks int */
3292 vlib_process_suspend(vlib_get_main(), 1e-5);
3294 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3295 FIB_TEST(!dpo_cmp(dpo, fib_entry_contribute_ip_forwarding(fei)),
3296 "post PIC 200.200.200.200/32 was inplace modified");
3298 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket_i(lb, 0)),
3299 "post PIC adj for 200.200.200.200/32 is recursive"
3300 " via adj for 1.1.1.3");
3303 * the LB maps that was locked above should have been modified to remove
3304 * the path that was down, and thus its bucket points to a path that is
3307 FIB_TEST(lbm->lbm_buckets[0] == 1,
3308 "LB maps's bucket 0 is %d",
3309 lbm->lbm_buckets[0]);
3310 FIB_TEST(lbm->lbm_buckets[1] == 1,
3311 "LB maps's bucket 1 is %d",
3312 lbm->lbm_buckets[1]);
3314 load_balance_map_unlock(lbmi);
3317 * add it back. again
3319 fib_table_entry_path_add(fib_index,
3322 FIB_ENTRY_FLAG_NONE,
3325 tm->hw[0]->sw_if_index,
3326 ~0, // invalid fib index
3329 FIB_ROUTE_PATH_FLAG_NONE);
3331 /* suspend so the update walk kicks in */
3332 vlib_process_suspend(vlib_get_main(), 1e-5);
3334 FIB_TEST(!dpo_cmp(dpo2, load_balance_get_bucket_i(lb, 0)),
3335 "post PIC recovery adj for 200.200.200.200/32 is recursive "
3336 "via adj for 1.1.1.1");
3337 FIB_TEST(!dpo_cmp(dpo1, load_balance_get_bucket_i(lb, 1)),
3338 "post PIC recovery adj for 200.200.200.200/32 is recursive "
3339 "via adj for 1.1.1.3");
3341 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3342 dpo = fib_entry_contribute_ip_forwarding(fei);
3343 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3344 "post PIC 200.200.200.200/32 was inplace modified");
3347 * add a 3rd path. this makes the LB 16 buckets.
3349 fib_table_entry_path_add(fib_index,
3352 FIB_ENTRY_FLAG_NONE,
3354 &pfx_1_1_1_2_s_32.fp_addr,
3359 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3360 for (ii = 0; ii < N_P; ii++)
3362 fib_table_entry_path_add(fib_index,
3365 FIB_ENTRY_FLAG_NONE,
3367 &pfx_1_1_1_2_s_32.fp_addr,
3372 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3375 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3376 dpo = fib_entry_contribute_ip_forwarding(fei);
3377 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3378 "200.200.200.200/32 was inplace modified for 3rd path");
3379 FIB_TEST(16 == lb->lb_n_buckets,
3380 "200.200.200.200/32 was inplace modified for 3rd path to 16 buckets");
3383 load_balance_map_lock(lbmi);
3384 lbm = load_balance_map_get(lbmi);
3386 for (ii = 0; 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]);
3394 * trigger PIC by removing the first via-entry
3395 * the first 6 buckets of the map should map to the next 6
3397 fib_table_entry_path_remove(fib_index,
3402 tm->hw[0]->sw_if_index,
3405 FIB_ROUTE_PATH_FLAG_NONE);
3406 /* suspend so the update walk kicks int */
3407 vlib_process_suspend(vlib_get_main(), 1e-5);
3409 fei = fib_table_lookup_exact_match(fib_index, &bgp_200_pfx);
3410 dpo = fib_entry_contribute_ip_forwarding(fei);
3411 FIB_TEST(lb == load_balance_get(dpo->dpoi_index),
3412 "200.200.200.200/32 was inplace modified for 3rd path");
3413 FIB_TEST(2 == lb->lb_n_buckets,
3414 "200.200.200.200/32 was inplace modified for 3rd path remove to 2 buckets");
3416 for (ii = 0; ii < 6; ii++)
3418 FIB_TEST(lbm->lbm_buckets[ii] == ii+6,
3419 "LB Map for 200.200.200.200/32 at %d is %d",
3420 ii, lbm->lbm_buckets[ii]);
3422 for (ii = 6; ii < 16; ii++)
3424 FIB_TEST(lbm->lbm_buckets[ii] == ii,
3425 "LB Map for 200.200.200.200/32 at %d is %d",
3426 ii, lbm->lbm_buckets[ii]);
3428 load_balance_map_unlock(lbmi);
3433 fib_table_entry_path_add(fib_index,
3436 FIB_ENTRY_FLAG_NONE,
3439 tm->hw[0]->sw_if_index,
3443 FIB_ROUTE_PATH_FLAG_NONE);
3445 for (ii = 0; ii < N_P; ii++)
3447 fib_table_entry_delete(fib_index,
3450 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3451 fib_table_lookup_exact_match(fib_index, &bgp_78s[ii])),
3453 format_fib_prefix, &bgp_78s[ii]);
3455 fib_table_entry_path_remove(fib_index,
3459 &pfx_1_1_1_2_s_32.fp_addr,
3463 MPLS_LABEL_INVALID);
3464 fib_table_entry_path_remove(fib_index,
3472 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3473 fib_table_entry_path_remove(fib_index,
3477 &pfx_1_1_1_3_s_32.fp_addr,
3481 FIB_ROUTE_PATH_RESOLVE_VIA_HOST);
3482 fib_table_entry_delete(fib_index,
3485 fib_table_entry_delete(fib_index,
3488 /* suspend so the update walk kicks int */
3489 vlib_process_suspend(vlib_get_main(), 1e-5);
3490 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3491 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_0_s_28)),
3492 "1.1.1.1/28 removed");
3493 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3494 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_3_s_32)),
3495 "1.1.1.3/32 removed");
3496 FIB_TEST((FIB_NODE_INDEX_INVALID ==
3497 fib_table_lookup_exact_match(fib_index, &bgp_200_pfx)),
3498 "200.200.200.200/32 removed");
3501 * add-remove test. no change.
3503 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3504 fib_path_list_db_size());
3505 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3506 fib_path_list_pool_size());
3507 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3508 fib_entry_pool_size());
3511 * A route whose paths are built up iteratively and then removed
3514 fib_prefix_t pfx_4_4_4_4_s_32 = {
3516 .fp_proto = FIB_PROTOCOL_IP4,
3519 .ip4.as_u32 = clib_host_to_net_u32(0x04040404),
3523 fib_table_entry_path_add(fib_index,
3526 FIB_ENTRY_FLAG_NONE,
3529 tm->hw[0]->sw_if_index,
3533 FIB_ROUTE_PATH_FLAG_NONE);
3534 fib_table_entry_path_add(fib_index,
3537 FIB_ENTRY_FLAG_NONE,
3540 tm->hw[0]->sw_if_index,
3544 FIB_ROUTE_PATH_FLAG_NONE);
3545 fib_table_entry_path_add(fib_index,
3548 FIB_ENTRY_FLAG_NONE,
3551 tm->hw[0]->sw_if_index,
3555 FIB_ROUTE_PATH_FLAG_NONE);
3556 FIB_TEST(FIB_NODE_INDEX_INVALID !=
3557 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3558 "4.4.4.4/32 present");
3560 fib_table_entry_delete(fib_index,
3563 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3564 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3565 "4.4.4.4/32 removed");
3568 * add-remove test. no change.
3570 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3571 fib_path_list_db_size());
3572 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3573 fib_path_list_pool_size());
3574 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3575 fib_entry_pool_size());
3578 * A route with multiple paths at once
3580 fib_route_path_t *r_paths = NULL;
3582 for (ii = 0; ii < 4; ii++)
3584 fib_route_path_t r_path = {
3585 .frp_proto = DPO_PROTO_IP4,
3587 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02 + ii),
3589 .frp_sw_if_index = tm->hw[0]->sw_if_index,
3591 .frp_fib_index = ~0,
3593 vec_add1(r_paths, r_path);
3596 fib_table_entry_update(fib_index,
3599 FIB_ENTRY_FLAG_NONE,
3602 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3603 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3604 dpo = fib_entry_contribute_ip_forwarding(fei);
3606 lb = load_balance_get(dpo->dpoi_index);
3607 FIB_TEST((lb->lb_n_buckets == 4), "4.4.4.4/32 lb over %d paths", lb->lb_n_buckets);
3609 fib_table_entry_delete(fib_index,
3612 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3613 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3614 "4.4.4.4/32 removed");
3618 * add-remove test. no change.
3620 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3621 fib_path_list_db_size());
3622 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3623 fib_path_list_pool_size());
3624 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3625 fib_entry_pool_size());
3628 * A route deag route
3630 fib_table_entry_path_add(fib_index,
3633 FIB_ENTRY_FLAG_NONE,
3640 FIB_ROUTE_PATH_FLAG_NONE);
3642 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3643 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3645 dpo = fib_entry_contribute_ip_forwarding(fei);
3646 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
3647 lookup_dpo_t *lkd = lookup_dpo_get(dpo->dpoi_index);
3649 FIB_TEST((fib_index == lkd->lkd_fib_index),
3650 "4.4.4.4/32 is deag in %d %U",
3652 format_dpo_id, dpo, 0);
3653 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
3654 "4.4.4.4/32 is source deag in %d %U",
3656 format_dpo_id, dpo, 0);
3658 fib_table_entry_delete(fib_index,
3661 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3662 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3663 "4.4.4.4/32 removed");
3667 * A route deag route in a source lookup table
3669 fib_table_entry_path_add(fib_index,
3672 FIB_ENTRY_FLAG_NONE,
3679 FIB_ROUTE_PATH_SOURCE_LOOKUP);
3681 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32);
3682 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.4.4.4/32 present");
3684 dpo = fib_entry_contribute_ip_forwarding(fei);
3685 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
3686 lkd = lookup_dpo_get(dpo->dpoi_index);
3688 FIB_TEST((fib_index == lkd->lkd_fib_index),
3689 "4.4.4.4/32 is deag in %d %U",
3691 format_dpo_id, dpo, 0);
3692 FIB_TEST((LOOKUP_INPUT_SRC_ADDR == lkd->lkd_input),
3693 "4.4.4.4/32 is source deag in %d %U",
3695 format_dpo_id, dpo, 0);
3697 fib_table_entry_delete(fib_index,
3700 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3701 fib_table_lookup_exact_match(fib_index, &pfx_4_4_4_4_s_32),
3702 "4.4.4.4/32 removed");
3706 * add-remove test. no change.
3708 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3709 fib_path_list_db_size());
3710 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3711 fib_path_list_pool_size());
3712 FIB_TEST((ENBR+7 == fib_entry_pool_size()), "entry pool size is %d",
3713 fib_entry_pool_size());
3717 * add a recursive with duplicate paths. Expect the duplicate to be ignored.
3719 fib_prefix_t pfx_34_1_1_1_s_32 = {
3721 .fp_proto = FIB_PROTOCOL_IP4,
3723 .ip4.as_u32 = clib_host_to_net_u32(0x22010101),
3726 fib_prefix_t pfx_34_34_1_1_s_32 = {
3728 .fp_proto = FIB_PROTOCOL_IP4,
3730 .ip4.as_u32 = clib_host_to_net_u32(0x22220101),
3733 fei = fib_table_entry_path_add(fib_index,
3734 &pfx_34_34_1_1_s_32,
3736 FIB_ENTRY_FLAG_NONE,
3739 tm->hw[0]->sw_if_index,
3743 FIB_ROUTE_PATH_FLAG_NONE);
3744 fei = fib_table_entry_path_add(fib_index,
3747 FIB_ENTRY_FLAG_NONE,
3749 &pfx_34_34_1_1_s_32.fp_addr,
3754 FIB_ROUTE_PATH_FLAG_NONE);
3755 fei = fib_table_entry_path_add(fib_index,
3758 FIB_ENTRY_FLAG_NONE,
3760 &pfx_34_34_1_1_s_32.fp_addr,
3765 FIB_ROUTE_PATH_FLAG_NONE);
3766 FIB_TEST_REC_FORW(&pfx_34_1_1_1_s_32, &pfx_34_34_1_1_s_32, 0);
3767 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
3768 fib_table_entry_delete(fib_index,
3769 &pfx_34_34_1_1_s_32,
3774 * remove: 1.1.1.2/32, 1.1.2.0/24 and 1.1.1.1/32
3775 * all of which are via 10.10.10.1, Itf1
3777 fib_table_entry_path_remove(fib_index,
3782 tm->hw[0]->sw_if_index,
3785 FIB_ROUTE_PATH_FLAG_NONE);
3786 fib_table_entry_path_remove(fib_index,
3791 tm->hw[0]->sw_if_index,
3794 FIB_ROUTE_PATH_FLAG_NONE);
3795 fib_table_entry_path_remove(fib_index,
3800 tm->hw[0]->sw_if_index,
3803 FIB_ROUTE_PATH_FLAG_NONE);
3805 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3806 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_1_s_32),
3807 "1.1.1.1/32 removed");
3808 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3809 fib_table_lookup_exact_match(fib_index, &pfx_1_1_1_2_s_32),
3810 "1.1.1.2/32 removed");
3811 FIB_TEST(FIB_NODE_INDEX_INVALID ==
3812 fib_table_lookup_exact_match(fib_index, &pfx_1_1_2_0_s_24),
3813 "1.1.2.0/24 removed");
3816 * -3 entries and -1 shared path-list
3818 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
3819 fib_path_list_db_size());
3820 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
3821 fib_path_list_pool_size());
3822 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
3823 fib_entry_pool_size());
3826 * An attached-host route. Expect to link to the incomplete adj
3828 fib_prefix_t pfx_4_1_1_1_s_32 = {
3830 .fp_proto = FIB_PROTOCOL_IP4,
3833 .ip4.as_u32 = clib_host_to_net_u32(0x04010101),
3836 fib_table_entry_path_add(fib_index,
3839 FIB_ENTRY_FLAG_NONE,
3842 tm->hw[0]->sw_if_index,
3846 FIB_ROUTE_PATH_FLAG_NONE);
3848 fei = fib_table_lookup_exact_match(fib_index, &pfx_4_1_1_1_s_32);
3849 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "4.1.1.1/32 present");
3850 ai = fib_entry_get_adj(fei);
3852 ai2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
3854 &pfx_4_1_1_1_s_32.fp_addr,
3855 tm->hw[0]->sw_if_index);
3856 FIB_TEST((ai == ai2), "Attached-host link to incomplete ADJ");
3860 * +1 entry and +1 shared path-list
3862 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
3863 fib_path_list_db_size());
3864 FIB_TEST((PNBR+5 == fib_path_list_pool_size()), "path list pool size is %d",
3865 fib_path_list_pool_size());
3866 FIB_TEST((ENBR+5 == fib_entry_pool_size()), "entry pool size is %d",
3867 fib_entry_pool_size());
3869 fib_table_entry_delete(fib_index,
3873 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
3874 fib_path_list_db_size());
3875 FIB_TEST((PNBR+4 == fib_path_list_pool_size()), "path list pool size is %d",
3876 fib_path_list_pool_size());
3877 FIB_TEST((ENBR+4 == fib_entry_pool_size()), "entry pool size is %d",
3878 fib_entry_pool_size());
3881 * add a v6 prefix via v4 next-hops
3883 fib_prefix_t pfx_2001_s_64 = {
3885 .fp_proto = FIB_PROTOCOL_IP6,
3887 .ip6.as_u64[0] = clib_host_to_net_u64(0x2001000000000000),
3890 fei = fib_table_entry_path_add(0, //default v6 table
3893 FIB_ENTRY_FLAG_NONE,
3896 tm->hw[0]->sw_if_index,
3900 FIB_ROUTE_PATH_FLAG_NONE);
3902 fei = fib_table_lookup_exact_match(0, &pfx_2001_s_64);
3903 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "2001::/64 present");
3904 ai = fib_entry_get_adj(fei);
3906 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_ARP),
3907 "2001::/64 via ARP-adj");
3908 FIB_TEST((adj->ia_link == VNET_LINK_IP6),
3909 "2001::/64 is link type v6");
3910 FIB_TEST((adj->ia_nh_proto == FIB_PROTOCOL_IP4),
3911 "2001::/64 ADJ-adj is NH proto v4");
3912 fib_table_entry_delete(0, &pfx_2001_s_64, FIB_SOURCE_API);
3915 * add a uRPF exempt prefix:
3917 * - it's forwarding is drop
3918 * - it's uRPF list is not empty
3919 * - the uRPF list for the default route (it's cover) is empty
3921 fei = fib_table_entry_special_add(fib_index,
3923 FIB_SOURCE_URPF_EXEMPT,
3924 FIB_ENTRY_FLAG_DROP);
3925 dpo = fib_entry_contribute_ip_forwarding(fei);
3926 FIB_TEST(load_balance_is_drop(dpo),
3927 "uRPF exempt 4.1.1.1/32 DROP");
3928 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 1, 0),
3929 "uRPF list for exempt prefix has itf index 0");
3930 fei = fib_table_lookup_exact_match(fib_index, &pfx_0_0_0_0_s_0);
3931 FIB_TEST(!fib_test_urpf_is_equal(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, 0),
3932 "uRPF list for 0.0.0.0/0 empty");
3934 fib_table_entry_delete(fib_index, &pfx_4_1_1_1_s_32, FIB_SOURCE_URPF_EXEMPT);
3937 * An adj-fib that fails the refinement criteria - no connected cover
3939 fib_prefix_t pfx_12_10_10_2_s_32 = {
3941 .fp_proto = FIB_PROTOCOL_IP4,
3944 .ip4.as_u32 = clib_host_to_net_u32(0x0c0a0a02),
3948 fib_table_entry_path_add(fib_index,
3949 &pfx_12_10_10_2_s_32,
3951 FIB_ENTRY_FLAG_ATTACHED,
3953 &pfx_12_10_10_2_s_32.fp_addr,
3954 tm->hw[0]->sw_if_index,
3955 ~0, // invalid fib index
3958 FIB_ROUTE_PATH_FLAG_NONE);
3960 fei = fib_table_lookup_exact_match(fib_index, &pfx_12_10_10_2_s_32);
3961 dpo = fib_entry_contribute_ip_forwarding(fei);
3962 FIB_TEST(dpo_is_drop(dpo),
3963 "no connected cover adj-fib fails refinement: %U",
3964 format_dpo_id, dpo, 0);
3966 fib_table_entry_delete(fib_index,
3967 &pfx_12_10_10_2_s_32,
3971 * An adj-fib that fails the refinement criteria - cover is connected
3972 * but on a different interface
3974 fib_prefix_t pfx_10_10_10_127_s_32 = {
3976 .fp_proto = FIB_PROTOCOL_IP4,
3979 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a7f),
3983 fib_table_entry_path_add(fib_index,
3984 &pfx_10_10_10_127_s_32,
3986 FIB_ENTRY_FLAG_ATTACHED,
3988 &pfx_10_10_10_127_s_32.fp_addr,
3989 tm->hw[1]->sw_if_index,
3990 ~0, // invalid fib index
3993 FIB_ROUTE_PATH_FLAG_NONE);
3995 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_127_s_32);
3996 dpo = fib_entry_contribute_ip_forwarding(fei);
3997 FIB_TEST(dpo_is_drop(dpo),
3998 "wrong interface adj-fib fails refinement");
4000 fib_table_entry_delete(fib_index,
4001 &pfx_10_10_10_127_s_32,
4005 * add a second path to an adj-fib
4006 * this is a sumiluation of another ARP entry created
4007 * on an interface on which the connected prefix does not exist.
4008 * The second path fails refinement. Expect to forward through the
4011 fib_prefix_t pfx_10_10_10_3_s_32 = {
4013 .fp_proto = FIB_PROTOCOL_IP4,
4016 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
4020 ai_03 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
4023 tm->hw[0]->sw_if_index);
4025 fib_test_lb_bucket_t ip_o_10_10_10_3 = {
4031 fei = fib_table_entry_path_add(fib_index,
4032 &pfx_10_10_10_3_s_32,
4034 FIB_ENTRY_FLAG_NONE,
4037 tm->hw[0]->sw_if_index,
4041 FIB_ROUTE_PATH_FLAG_NONE);
4042 fei = fib_table_entry_path_add(fib_index,
4043 &pfx_10_10_10_3_s_32,
4045 FIB_ENTRY_FLAG_NONE,
4048 tm->hw[1]->sw_if_index,
4052 FIB_ROUTE_PATH_FLAG_NONE);
4053 FIB_TEST(!fib_test_validate_entry(fei,
4054 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4057 "10.10.10.3 via 10.10.10.3/Eth0 only");
4060 * remove the path that refines the cover, should go unresolved
4062 fib_table_entry_path_remove(fib_index,
4063 &pfx_10_10_10_3_s_32,
4067 tm->hw[0]->sw_if_index,
4070 FIB_ROUTE_PATH_FLAG_NONE);
4071 dpo = fib_entry_contribute_ip_forwarding(fei);
4072 FIB_TEST(dpo_is_drop(dpo),
4073 "wrong interface adj-fib fails refinement");
4076 * add back the path that refines the cover
4078 fei = fib_table_entry_path_add(fib_index,
4079 &pfx_10_10_10_3_s_32,
4081 FIB_ENTRY_FLAG_NONE,
4084 tm->hw[0]->sw_if_index,
4088 FIB_ROUTE_PATH_FLAG_NONE);
4089 FIB_TEST(!fib_test_validate_entry(fei,
4090 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4093 "10.10.10.3 via 10.10.10.3/Eth0 only");
4096 * remove the path that does not refine the cover
4098 fib_table_entry_path_remove(fib_index,
4099 &pfx_10_10_10_3_s_32,
4103 tm->hw[1]->sw_if_index,
4106 FIB_ROUTE_PATH_FLAG_NONE);
4107 FIB_TEST(!fib_test_validate_entry(fei,
4108 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4111 "10.10.10.3 via 10.10.10.3/Eth0 only");
4114 * remove the path that does refine, it's the last path, so
4115 * the entry should be gone
4117 fib_table_entry_path_remove(fib_index,
4118 &pfx_10_10_10_3_s_32,
4122 tm->hw[0]->sw_if_index,
4125 FIB_ROUTE_PATH_FLAG_NONE);
4126 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
4127 FIB_TEST((fei == FIB_NODE_INDEX_INVALID), "10.10.10.3 gone");
4132 * change the table's flow-hash config - expect the update to propagete to
4133 * the entries' load-balance objects
4135 flow_hash_config_t old_hash_config, new_hash_config;
4137 old_hash_config = fib_table_get_flow_hash_config(fib_index,
4139 new_hash_config = (IP_FLOW_HASH_SRC_ADDR |
4140 IP_FLOW_HASH_DST_ADDR);
4142 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
4143 dpo = fib_entry_contribute_ip_forwarding(fei);
4144 lb = load_balance_get(dpo->dpoi_index);
4145 FIB_TEST((lb->lb_hash_config == old_hash_config),
4146 "Table and LB hash config match: %U",
4147 format_ip_flow_hash_config, lb->lb_hash_config);
4149 fib_table_set_flow_hash_config(fib_index, FIB_PROTOCOL_IP4, new_hash_config);
4151 FIB_TEST((lb->lb_hash_config == new_hash_config),
4152 "Table and LB newhash config match: %U",
4153 format_ip_flow_hash_config, lb->lb_hash_config);
4156 * A route via DVR DPO
4158 fei = fib_table_entry_path_add(fib_index,
4159 &pfx_10_10_10_3_s_32,
4161 FIB_ENTRY_FLAG_NONE,
4164 tm->hw[0]->sw_if_index,
4168 FIB_ROUTE_PATH_DVR);
4169 dpo_id_t dvr_dpo = DPO_INVALID;
4170 dvr_dpo_add_or_lock(tm->hw[0]->sw_if_index, DPO_PROTO_IP4, &dvr_dpo);
4171 fib_test_lb_bucket_t ip_o_l2 = {
4174 .adj = dvr_dpo.dpoi_index,
4178 FIB_TEST(!fib_test_validate_entry(fei,
4179 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
4182 "10.10.10.3 via L2 on Eth0");
4183 fib_table_entry_path_remove(fib_index,
4184 &pfx_10_10_10_3_s_32,
4188 tm->hw[0]->sw_if_index,
4191 FIB_ROUTE_PATH_DVR);
4192 dpo_reset(&dvr_dpo);
4198 fib_table_entry_delete(fib_index,
4199 &pfx_10_10_10_1_s_32,
4201 fib_table_entry_delete(fib_index,
4202 &pfx_10_10_10_2_s_32,
4204 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4205 fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32),
4206 "10.10.10.1/32 adj-fib removed");
4207 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4208 fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32),
4209 "10.10.10.2/32 adj-fib removed");
4212 * -2 entries and -2 non-shared path-list
4214 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4215 fib_path_list_db_size());
4216 FIB_TEST((PNBR+2 == fib_path_list_pool_size()), "path list pool size is %d",
4217 fib_path_list_pool_size());
4218 FIB_TEST((ENBR+2 == fib_entry_pool_size()), "entry pool size is %d",
4219 fib_entry_pool_size());
4222 * unlock the adjacencies for which this test provided a rewrite.
4223 * These are the last locks on these adjs. they should thus go away.
4227 adj_unlock(ai_12_12_12_12);
4229 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
4234 * remove the interface prefixes
4236 local_pfx.fp_len = 32;
4237 fib_table_entry_special_remove(fib_index, &local_pfx,
4238 FIB_SOURCE_INTERFACE);
4239 fei = fib_table_lookup(fib_index, &local_pfx);
4241 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4242 fib_table_lookup_exact_match(fib_index, &local_pfx),
4243 "10.10.10.10/32 adj-fib removed");
4245 local_pfx.fp_len = 24;
4246 fib_table_entry_delete(fib_index, &local_pfx,
4247 FIB_SOURCE_INTERFACE);
4249 FIB_TEST(FIB_NODE_INDEX_INVALID ==
4250 fib_table_lookup_exact_match(fib_index, &local_pfx),
4251 "10.10.10.10/24 adj-fib removed");
4254 * -2 entries and -2 non-shared path-list
4256 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4257 fib_path_list_db_size());
4258 FIB_TEST((PNBR == fib_path_list_pool_size()), "path list pool size is %d",
4259 fib_path_list_pool_size());
4260 FIB_TEST((ENBR == fib_entry_pool_size()), "entry pool size is %d",
4261 fib_entry_pool_size());
4264 * Last but not least, remove the VRF
4266 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4269 "NO API Source'd prefixes");
4270 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4273 "NO RR Source'd prefixes");
4274 FIB_TEST((0 == fib_table_get_num_entries(fib_index,
4276 FIB_SOURCE_INTERFACE)),
4277 "NO INterface Source'd prefixes");
4279 fib_table_unlock(fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_API);
4281 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4282 fib_path_list_db_size());
4283 FIB_TEST((PNBR-5 == fib_path_list_pool_size()), "path list pool size is %d",
4284 fib_path_list_pool_size());
4285 FIB_TEST((ENBR-5 == fib_entry_pool_size()), "entry pool size is %d",
4286 fib_entry_pool_size());
4287 FIB_TEST((ENBR-5 == pool_elts(fib_urpf_list_pool)), "uRPF pool size is %d",
4288 pool_elts(fib_urpf_list_pool));
4289 FIB_TEST((0 == pool_elts(load_balance_map_pool)), "LB-map pool size is %d",
4290 pool_elts(load_balance_map_pool));
4291 FIB_TEST((lb_count == pool_elts(load_balance_pool)), "LB pool size is %d",
4292 pool_elts(load_balance_pool));
4293 FIB_TEST((0 == pool_elts(dvr_dpo_pool)), "L2 DPO pool size is %d",
4294 pool_elts(dvr_dpo_pool));
4303 * In the default table check for the presence and correct forwarding
4304 * of the special entries
4306 fib_node_index_t dfrt, fei, ai, locked_ai, ai_01, ai_02;
4307 const dpo_id_t *dpo, *dpo_drop;
4308 const ip_adjacency_t *adj;
4309 const receive_dpo_t *rd;
4315 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
4318 /* via 2001:0:0:1::2 */
4319 ip46_address_t nh_2001_2 = {
4322 [0] = clib_host_to_net_u64(0x2001000000000001),
4323 [1] = clib_host_to_net_u64(0x0000000000000002),
4330 dpo_drop = drop_dpo_get(DPO_PROTO_IP6);
4332 /* Find or create FIB table 11 */
4333 fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP6, 11,
4336 for (ii = 0; ii < 4; ii++)
4338 ip6_main.fib_index_by_sw_if_index[tm->hw[ii]->sw_if_index] = fib_index;
4341 fib_prefix_t pfx_0_0 = {
4343 .fp_proto = FIB_PROTOCOL_IP6,
4351 dfrt = fib_table_lookup(fib_index, &pfx_0_0);
4352 FIB_TEST((FIB_NODE_INDEX_INVALID != dfrt), "default route present");
4353 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
4354 "Default route is DROP");
4356 dpo = fib_entry_contribute_ip_forwarding(dfrt);
4357 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4360 &pfx_0_0.fp_addr.ip6)),
4361 "default-route; fwd and non-fwd tables match");
4363 // FIXME - check specials.
4366 * At this stage there is one v4 FIB with 5 routes and two v6 FIBs
4367 * each with 2 entries and a v6 mfib with 4 path-lists.
4368 * All entries are special so no path-list sharing.
4373 * if the IGMP plugin is loaded this adds two more entries to the v4 MFIB
4375 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
4376 FIB_TEST((PNPS == fib_path_list_pool_size()), "path list pool size is %d",
4377 fib_path_list_pool_size());
4378 FIB_TEST((ENPS == fib_entry_pool_size()), "entry pool size is %d",
4379 fib_entry_pool_size());
4382 * add interface routes.
4383 * validate presence of /64 attached and /128 recieve.
4384 * test for the presence of the receive address in the glean and local adj
4386 * receive on 2001:0:0:1::1/128
4388 fib_prefix_t local_pfx = {
4390 .fp_proto = FIB_PROTOCOL_IP6,
4394 [0] = clib_host_to_net_u64(0x2001000000000001),
4395 [1] = clib_host_to_net_u64(0x0000000000000001),
4401 fib_table_entry_update_one_path(fib_index, &local_pfx,
4402 FIB_SOURCE_INTERFACE,
4403 (FIB_ENTRY_FLAG_CONNECTED |
4404 FIB_ENTRY_FLAG_ATTACHED),
4407 tm->hw[0]->sw_if_index,
4411 FIB_ROUTE_PATH_FLAG_NONE);
4412 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4414 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
4416 ai = fib_entry_get_adj(fei);
4417 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "attached interface route adj present");
4419 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
4420 "attached interface adj is glean");
4421 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
4422 &adj->sub_type.glean.receive_addr)),
4423 "attached interface adj is receive ok");
4424 dpo = fib_entry_contribute_ip_forwarding(fei);
4425 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4428 &local_pfx.fp_addr.ip6)),
4429 "attached-route; fwd and non-fwd tables match");
4431 local_pfx.fp_len = 128;
4432 fib_table_entry_update_one_path(fib_index, &local_pfx,
4433 FIB_SOURCE_INTERFACE,
4434 (FIB_ENTRY_FLAG_CONNECTED |
4435 FIB_ENTRY_FLAG_LOCAL),
4438 tm->hw[0]->sw_if_index,
4439 ~0, // invalid fib index
4442 FIB_ROUTE_PATH_FLAG_NONE);
4443 fei = fib_table_lookup(fib_index, &local_pfx);
4445 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
4447 dpo = fib_entry_contribute_ip_forwarding(fei);
4448 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4449 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
4450 "local interface adj is local");
4451 rd = receive_dpo_get(dpo->dpoi_index);
4453 FIB_TEST((0 == ip46_address_cmp(&local_pfx.fp_addr,
4455 "local interface adj is receive ok");
4457 dpo = fib_entry_contribute_ip_forwarding(fei);
4458 FIB_TEST((dpo->dpoi_index == ip6_fib_table_fwding_lookup(
4461 &local_pfx.fp_addr.ip6)),
4462 "local-route; fwd and non-fwd tables match");
4465 * +2 entries. +2 unshared path-lists
4467 FIB_TEST((0 == fib_path_list_db_size()), "path list DB is empty");
4468 FIB_TEST((PNPS+2 == fib_path_list_pool_size()), "path list pool size is%d",
4469 fib_path_list_pool_size());
4470 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4471 fib_entry_pool_size());
4474 * Modify the default route to be via an adj not yet known.
4475 * this sources the defalut route with the API source, which is
4476 * a higher preference to the DEFAULT_ROUTE source
4478 fib_table_entry_path_add(fib_index, &pfx_0_0,
4480 FIB_ENTRY_FLAG_NONE,
4483 tm->hw[0]->sw_if_index,
4487 FIB_ROUTE_PATH_FLAG_NONE);
4488 fei = fib_table_lookup(fib_index, &pfx_0_0);
4490 FIB_TEST((fei == dfrt), "default route same index");
4491 ai = fib_entry_get_adj(fei);
4492 FIB_TEST((FIB_NODE_INDEX_INVALID != ai), "default route adj present");
4494 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4495 "adj is incomplete");
4496 FIB_TEST((0 == ip46_address_cmp(&nh_2001_2, &adj->sub_type.nbr.next_hop)),
4497 "adj nbr next-hop ok");
4500 * find the adj in the shared db
4502 locked_ai = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4505 tm->hw[0]->sw_if_index);
4506 FIB_TEST((locked_ai == ai), "ADJ NBR DB find");
4507 adj_unlock(locked_ai);
4510 * no more entires. +1 shared path-list
4512 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4513 fib_path_list_db_size());
4514 FIB_TEST((PNPS+3 == fib_path_list_pool_size()), "path list pool size is%d",
4515 fib_path_list_pool_size());
4516 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4517 fib_entry_pool_size());
4520 * remove the API source from the default route. We expected
4521 * the route to remain, sourced by DEFAULT_ROUTE, and hence a DROP
4523 fib_table_entry_path_remove(fib_index, &pfx_0_0,
4527 tm->hw[0]->sw_if_index,
4530 FIB_ROUTE_PATH_FLAG_NONE);
4531 fei = fib_table_lookup(fib_index, &pfx_0_0);
4533 FIB_TEST((fei == dfrt), "default route same index");
4534 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(dfrt)),
4535 "Default route is DROP");
4538 * no more entires. -1 shared path-list
4540 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4541 fib_path_list_db_size());
4542 FIB_TEST((PNPS+2 == fib_path_list_pool_size()), "path list pool size is%d",
4543 fib_path_list_pool_size());
4544 FIB_TEST((ENPS+2 == fib_entry_pool_size()), "entry pool size is %d",
4545 fib_entry_pool_size());
4548 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
4550 fib_prefix_t pfx_2001_1_2_s_128 = {
4552 .fp_proto = FIB_PROTOCOL_IP6,
4556 [0] = clib_host_to_net_u64(0x2001000000000001),
4557 [1] = clib_host_to_net_u64(0x0000000000000002),
4562 fib_prefix_t pfx_2001_1_3_s_128 = {
4564 .fp_proto = FIB_PROTOCOL_IP6,
4568 [0] = clib_host_to_net_u64(0x2001000000000001),
4569 [1] = clib_host_to_net_u64(0x0000000000000003),
4575 0xde, 0xde, 0xde, 0xba, 0xba, 0xba,
4578 ai_01 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4580 &pfx_2001_1_2_s_128.fp_addr,
4581 tm->hw[0]->sw_if_index);
4582 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_01), "adj created");
4583 adj = adj_get(ai_01);
4584 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4585 "adj is incomplete");
4586 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_2_s_128.fp_addr,
4587 &adj->sub_type.nbr.next_hop)),
4588 "adj nbr next-hop ok");
4590 adj_nbr_update_rewrite(ai_01, ADJ_NBR_REWRITE_FLAG_COMPLETE,
4591 fib_test_build_rewrite(eth_addr));
4592 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
4594 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_2_s_128.fp_addr,
4595 &adj->sub_type.nbr.next_hop)),
4596 "adj nbr next-hop ok");
4598 fib_table_entry_path_add(fib_index,
4599 &pfx_2001_1_2_s_128,
4601 FIB_ENTRY_FLAG_ATTACHED,
4603 &pfx_2001_1_2_s_128.fp_addr,
4604 tm->hw[0]->sw_if_index,
4608 FIB_ROUTE_PATH_FLAG_NONE);
4610 fei = fib_table_lookup(fib_index, &pfx_2001_1_2_s_128);
4611 ai = fib_entry_get_adj(fei);
4612 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
4616 ai_02 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
4618 &pfx_2001_1_3_s_128.fp_addr,
4619 tm->hw[0]->sw_if_index);
4620 FIB_TEST((FIB_NODE_INDEX_INVALID != ai_02), "adj created");
4621 adj = adj_get(ai_02);
4622 FIB_TEST((IP_LOOKUP_NEXT_ARP == adj->lookup_next_index),
4623 "adj is incomplete");
4624 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_3_s_128.fp_addr,
4625 &adj->sub_type.nbr.next_hop)),
4626 "adj nbr next-hop ok");
4628 adj_nbr_update_rewrite(ai_02, ADJ_NBR_REWRITE_FLAG_COMPLETE,
4629 fib_test_build_rewrite(eth_addr));
4630 FIB_TEST((IP_LOOKUP_NEXT_REWRITE == adj->lookup_next_index),
4632 FIB_TEST((0 == ip46_address_cmp(&pfx_2001_1_3_s_128.fp_addr,
4633 &adj->sub_type.nbr.next_hop)),
4634 "adj nbr next-hop ok");
4635 FIB_TEST((ai_01 != ai_02), "ADJs are different");
4637 fib_table_entry_path_add(fib_index,
4638 &pfx_2001_1_3_s_128,
4640 FIB_ENTRY_FLAG_ATTACHED,
4642 &pfx_2001_1_3_s_128.fp_addr,
4643 tm->hw[0]->sw_if_index,
4647 FIB_ROUTE_PATH_FLAG_NONE);
4649 fei = fib_table_lookup(fib_index, &pfx_2001_1_3_s_128);
4650 ai = fib_entry_get_adj(fei);
4651 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
4654 * +2 entries, +2 unshread path-lists.
4656 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
4657 fib_path_list_db_size());
4658 FIB_TEST((PNPS+4 == fib_path_list_pool_size()), "path list pool size is%d",
4659 fib_path_list_pool_size());
4660 FIB_TEST((ENPS+4 == fib_entry_pool_size()), "entry pool size is %d",
4661 fib_entry_pool_size());
4664 * Add a 2 routes via the first ADJ. ensure path-list sharing
4666 fib_prefix_t pfx_2001_a_s_64 = {
4668 .fp_proto = FIB_PROTOCOL_IP6,
4672 [0] = clib_host_to_net_u64(0x200100000000000a),
4673 [1] = clib_host_to_net_u64(0x0000000000000000),
4678 fib_prefix_t pfx_2001_b_s_64 = {
4680 .fp_proto = FIB_PROTOCOL_IP6,
4684 [0] = clib_host_to_net_u64(0x200100000000000b),
4685 [1] = clib_host_to_net_u64(0x0000000000000000),
4691 fib_table_entry_path_add(fib_index,
4694 FIB_ENTRY_FLAG_NONE,
4697 tm->hw[0]->sw_if_index,
4701 FIB_ROUTE_PATH_FLAG_NONE);
4702 fei = fib_table_lookup(fib_index, &pfx_2001_a_s_64);
4703 ai = fib_entry_get_adj(fei);
4704 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
4705 fib_table_entry_path_add(fib_index,
4708 FIB_ENTRY_FLAG_NONE,
4711 tm->hw[0]->sw_if_index,
4715 FIB_ROUTE_PATH_FLAG_NONE);
4716 fei = fib_table_lookup(fib_index, &pfx_2001_b_s_64);
4717 ai = fib_entry_get_adj(fei);
4718 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
4721 * +2 entries, +1 shared path-list.
4723 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4724 fib_path_list_db_size());
4725 FIB_TEST((PNPS+5 == fib_path_list_pool_size()), "path list pool size is%d",
4726 fib_path_list_pool_size());
4727 FIB_TEST((ENPS+6 == fib_entry_pool_size()), "entry pool size is %d",
4728 fib_entry_pool_size());
4731 * add a v4 prefix via a v6 next-hop
4733 fib_prefix_t pfx_1_1_1_1_s_32 = {
4735 .fp_proto = FIB_PROTOCOL_IP4,
4737 .ip4.as_u32 = 0x01010101,
4740 fei = fib_table_entry_path_add(0, // default table
4743 FIB_ENTRY_FLAG_NONE,
4746 tm->hw[0]->sw_if_index,
4750 FIB_ROUTE_PATH_FLAG_NONE);
4751 FIB_TEST(fei == fib_table_lookup_exact_match(0, &pfx_1_1_1_1_s_32),
4752 "1.1.1.1/32 o v6 route present");
4753 ai = fib_entry_get_adj(fei);
4755 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_ARP),
4756 "1.1.1.1/32 via ARP-adj");
4757 FIB_TEST((adj->ia_link == VNET_LINK_IP4),
4758 "1.1.1.1/32 ADJ-adj is link type v4");
4759 FIB_TEST((adj->ia_nh_proto == FIB_PROTOCOL_IP6),
4760 "1.1.1.1/32 ADJ-adj is NH proto v6");
4761 fib_table_entry_delete(0, &pfx_1_1_1_1_s_32, FIB_SOURCE_API);
4766 fib_prefix_t pfx_2001_c_s_64 = {
4768 .fp_proto = FIB_PROTOCOL_IP6,
4772 [0] = clib_host_to_net_u64(0x200100000000000c),
4773 [1] = clib_host_to_net_u64(0x0000000000000000),
4778 fib_table_entry_path_add(fib_index,
4781 FIB_ENTRY_FLAG_ATTACHED,
4784 tm->hw[0]->sw_if_index,
4788 FIB_ROUTE_PATH_FLAG_NONE);
4789 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64);
4790 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached route present");
4791 ai = fib_entry_get_adj(fei);
4793 FIB_TEST((adj->lookup_next_index == IP_LOOKUP_NEXT_GLEAN),
4794 "2001:0:0:c/64 attached resolves via glean");
4796 fib_table_entry_path_remove(fib_index,
4801 tm->hw[0]->sw_if_index,
4804 FIB_ROUTE_PATH_FLAG_NONE);
4805 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_c_s_64);
4806 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "attached route removed");
4809 * Shutdown the interface on which we have a connected and through
4810 * which the routes are reachable.
4811 * This will result in the connected, adj-fibs, and routes linking to drop
4812 * The local/for-us prefix continues to receive.
4814 clib_error_t * error;
4816 error = vnet_sw_interface_set_flags(vnet_get_main(),
4817 tm->hw[0]->sw_if_index,
4818 ~VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4819 FIB_TEST((NULL == error), "Interface shutdown OK");
4821 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4822 dpo = fib_entry_contribute_ip_forwarding(fei);
4823 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4824 "2001::b/64 resolves via drop");
4826 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4827 dpo = fib_entry_contribute_ip_forwarding(fei);
4828 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4829 "2001::a/64 resolves via drop");
4830 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4831 dpo = fib_entry_contribute_ip_forwarding(fei);
4832 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4833 "2001:0:0:1::3/64 resolves via drop");
4834 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4835 dpo = fib_entry_contribute_ip_forwarding(fei);
4836 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4837 "2001:0:0:1::2/64 resolves via drop");
4838 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4839 dpo = fib_entry_contribute_ip_forwarding(fei);
4840 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4841 "2001:0:0:1::1/128 not drop");
4842 local_pfx.fp_len = 64;
4843 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4844 dpo = fib_entry_contribute_ip_forwarding(fei);
4845 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4846 "2001:0:0:1/64 resolves via drop");
4851 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4852 fib_path_list_db_size());
4853 FIB_TEST((PNPS+5 == fib_path_list_pool_size()), "path list pool size is%d",
4854 fib_path_list_pool_size());
4855 FIB_TEST((ENPS+6 == fib_entry_pool_size()), "entry pool size is %d",
4856 fib_entry_pool_size());
4859 * shutdown one of the other interfaces, then add a connected.
4860 * and swap one of the routes to it.
4862 error = vnet_sw_interface_set_flags(vnet_get_main(),
4863 tm->hw[1]->sw_if_index,
4864 ~VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4865 FIB_TEST((NULL == error), "Interface 1 shutdown OK");
4867 fib_prefix_t connected_pfx = {
4869 .fp_proto = FIB_PROTOCOL_IP6,
4872 /* 2001:0:0:2::1/64 */
4874 [0] = clib_host_to_net_u64(0x2001000000000002),
4875 [1] = clib_host_to_net_u64(0x0000000000000001),
4880 fib_table_entry_update_one_path(fib_index, &connected_pfx,
4881 FIB_SOURCE_INTERFACE,
4882 (FIB_ENTRY_FLAG_CONNECTED |
4883 FIB_ENTRY_FLAG_ATTACHED),
4886 tm->hw[1]->sw_if_index,
4890 FIB_ROUTE_PATH_FLAG_NONE);
4891 fei = fib_table_lookup_exact_match(fib_index, &connected_pfx);
4892 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached interface route present");
4893 dpo = fib_entry_contribute_ip_forwarding(fei);
4894 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4895 FIB_TEST(!dpo_cmp(dpo, dpo_drop),
4896 "2001:0:0:2/64 not resolves via drop");
4898 connected_pfx.fp_len = 128;
4899 fib_table_entry_update_one_path(fib_index, &connected_pfx,
4900 FIB_SOURCE_INTERFACE,
4901 (FIB_ENTRY_FLAG_CONNECTED |
4902 FIB_ENTRY_FLAG_LOCAL),
4905 tm->hw[0]->sw_if_index,
4906 ~0, // invalid fib index
4909 FIB_ROUTE_PATH_FLAG_NONE);
4910 fei = fib_table_lookup(fib_index, &connected_pfx);
4912 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local interface route present");
4913 dpo = fib_entry_contribute_ip_forwarding(fei);
4914 dpo = load_balance_get_bucket(dpo->dpoi_index, 0);
4915 FIB_TEST((DPO_RECEIVE == dpo->dpoi_type),
4916 "local interface adj is local");
4917 rd = receive_dpo_get(dpo->dpoi_index);
4918 FIB_TEST((0 == ip46_address_cmp(&connected_pfx.fp_addr,
4920 "local interface adj is receive ok");
4923 * +2 entries, +2 unshared path-lists
4925 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
4926 fib_path_list_db_size());
4927 FIB_TEST((PNPS+7 == fib_path_list_pool_size()), "path list pool size is%d",
4928 fib_path_list_pool_size());
4929 FIB_TEST((ENPS+8 == fib_entry_pool_size()), "entry pool size is %d",
4930 fib_entry_pool_size());
4934 * bring the interface back up. we expected the routes to return
4935 * to normal forwarding.
4937 error = vnet_sw_interface_set_flags(vnet_get_main(),
4938 tm->hw[0]->sw_if_index,
4939 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
4940 FIB_TEST((NULL == error), "Interface bring-up OK");
4941 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4942 ai = fib_entry_get_adj(fei);
4943 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
4944 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4945 ai = fib_entry_get_adj(fei);
4946 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
4947 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4948 ai = fib_entry_get_adj(fei);
4949 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
4950 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4951 ai = fib_entry_get_adj(fei);
4952 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
4953 local_pfx.fp_len = 64;
4954 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4955 ai = fib_entry_get_adj(fei);
4957 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
4958 "attached interface adj is glean");
4961 * Same test as above, but this time the HW interface goes down
4963 error = vnet_hw_interface_set_flags(vnet_get_main(),
4964 tm->hw_if_indicies[0],
4965 ~VNET_HW_INTERFACE_FLAG_LINK_UP);
4966 FIB_TEST((NULL == error), "Interface shutdown OK");
4968 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
4969 dpo = fib_entry_contribute_ip_forwarding(fei);
4970 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4971 "2001::b/64 resolves via drop");
4972 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
4973 dpo = fib_entry_contribute_ip_forwarding(fei);
4974 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4975 "2001::a/64 resolves via drop");
4976 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
4977 dpo = fib_entry_contribute_ip_forwarding(fei);
4978 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4979 "2001:0:0:1::3/128 resolves via drop");
4980 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
4981 dpo = fib_entry_contribute_ip_forwarding(fei);
4982 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4983 "2001:0:0:1::2/128 resolves via drop");
4984 local_pfx.fp_len = 128;
4985 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4986 dpo = fib_entry_contribute_ip_forwarding(fei);
4987 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4988 "2001:0:0:1::1/128 not drop");
4989 local_pfx.fp_len = 64;
4990 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
4991 dpo = fib_entry_contribute_ip_forwarding(fei);
4992 FIB_TEST(!dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
4993 "2001:0:0:1/64 resolves via drop");
4995 error = vnet_hw_interface_set_flags(vnet_get_main(),
4996 tm->hw_if_indicies[0],
4997 VNET_HW_INTERFACE_FLAG_LINK_UP);
4998 FIB_TEST((NULL == error), "Interface bring-up OK");
4999 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
5000 ai = fib_entry_get_adj(fei);
5001 FIB_TEST((ai_01 == ai), "2001::a/64 resolves via 2001:0:0:1::1");
5002 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
5003 ai = fib_entry_get_adj(fei);
5004 FIB_TEST((ai_01 == ai), "2001::b/64 resolves via 2001:0:0:1::1");
5005 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
5006 ai = fib_entry_get_adj(fei);
5007 FIB_TEST((ai_02 == ai), "ADJ-FIB resolves via adj");
5008 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
5009 ai = fib_entry_get_adj(fei);
5010 FIB_TEST((ai_01 == ai), "ADJ-FIB resolves via adj");
5011 local_pfx.fp_len = 64;
5012 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5013 ai = fib_entry_get_adj(fei);
5015 FIB_TEST((IP_LOOKUP_NEXT_GLEAN == adj->lookup_next_index),
5016 "attached interface adj is glean");
5019 * Delete the interface that the routes reolve through.
5020 * Again no routes are removed. They all point to drop.
5022 * This is considered an error case. The control plane should
5023 * not remove interfaces through which routes resolve, but
5024 * such things can happen. ALL affected routes will drop.
5026 vnet_delete_hw_interface(vnet_get_main(), tm->hw_if_indicies[0]);
5028 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
5029 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5030 "2001::b/64 resolves via drop");
5031 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
5032 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5033 "2001::b/64 resolves via drop");
5034 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
5035 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5036 "2001:0:0:1::3/64 resolves via drop");
5037 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
5038 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5039 "2001:0:0:1::2/64 resolves via drop");
5040 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5041 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5042 "2001:0:0:1::1/128 is drop");
5043 local_pfx.fp_len = 64;
5044 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5045 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5046 "2001:0:0:1/64 resolves via drop");
5051 FIB_TEST((1 == fib_path_list_db_size()), "path list DB population:%d",
5052 fib_path_list_db_size());
5053 FIB_TEST((PNPS+7 == fib_path_list_pool_size()), "path list pool size is%d",
5054 fib_path_list_pool_size());
5055 FIB_TEST((ENPS+8 == fib_entry_pool_size()), "entry pool size is %d",
5056 fib_entry_pool_size());
5059 * Add the interface back. routes stay unresolved.
5061 error = ethernet_register_interface(vnet_get_main(),
5062 test_interface_device_class.index,
5065 &tm->hw_if_indicies[0],
5066 /* flag change */ 0);
5068 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64);
5069 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5070 "2001::b/64 resolves via drop");
5071 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64);
5072 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5073 "2001::b/64 resolves via drop");
5074 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128);
5075 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5076 "2001:0:0:1::3/64 resolves via drop");
5077 fei = fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128);
5078 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5079 "2001:0:0:1::2/64 resolves via drop");
5080 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5081 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5082 "2001:0:0:1::1/128 is drop");
5083 local_pfx.fp_len = 64;
5084 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5085 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
5086 "2001:0:0:1/64 resolves via drop");
5089 * CLEANUP ALL the routes
5091 fib_table_entry_delete(fib_index,
5094 fib_table_entry_delete(fib_index,
5097 fib_table_entry_delete(fib_index,
5100 fib_table_entry_delete(fib_index,
5101 &pfx_2001_1_3_s_128,
5103 fib_table_entry_delete(fib_index,
5104 &pfx_2001_1_2_s_128,
5106 local_pfx.fp_len = 64;
5107 fib_table_entry_delete(fib_index, &local_pfx,
5108 FIB_SOURCE_INTERFACE);
5109 local_pfx.fp_len = 128;
5110 fib_table_entry_special_remove(fib_index, &local_pfx,
5111 FIB_SOURCE_INTERFACE);
5112 connected_pfx.fp_len = 64;
5113 fib_table_entry_delete(fib_index, &connected_pfx,
5114 FIB_SOURCE_INTERFACE);
5115 connected_pfx.fp_len = 128;
5116 fib_table_entry_special_remove(fib_index, &connected_pfx,
5117 FIB_SOURCE_INTERFACE);
5119 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5120 fib_table_lookup_exact_match(fib_index, &pfx_2001_a_s_64)),
5121 "2001::a/64 removed");
5122 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5123 fib_table_lookup_exact_match(fib_index, &pfx_2001_b_s_64)),
5124 "2001::b/64 removed");
5125 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5126 fib_table_lookup_exact_match(fib_index, &pfx_2001_1_3_s_128)),
5127 "2001:0:0:1::3/128 removed");
5128 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5129 fib_table_lookup_exact_match(fib_index, &pfx_2001_1_2_s_128)),
5130 "2001:0:0:1::3/128 removed");
5131 local_pfx.fp_len = 64;
5132 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5133 fib_table_lookup_exact_match(fib_index, &local_pfx)),
5134 "2001:0:0:1/64 removed");
5135 local_pfx.fp_len = 128;
5136 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5137 fib_table_lookup_exact_match(fib_index, &local_pfx)),
5138 "2001:0:0:1::1/128 removed");
5139 connected_pfx.fp_len = 64;
5140 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5141 fib_table_lookup_exact_match(fib_index, &connected_pfx)),
5142 "2001:0:0:2/64 removed");
5143 connected_pfx.fp_len = 128;
5144 FIB_TEST((FIB_NODE_INDEX_INVALID ==
5145 fib_table_lookup_exact_match(fib_index, &connected_pfx)),
5146 "2001:0:0:2::1/128 removed");
5149 * -8 entries. -7 path-lists (1 was shared).
5151 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
5152 fib_path_list_db_size());
5153 FIB_TEST((PNPS == fib_path_list_pool_size()), "path list pool size is%d",
5154 fib_path_list_pool_size());
5155 FIB_TEST((ENPS == fib_entry_pool_size()), "entry pool size is %d",
5156 fib_entry_pool_size());
5159 * now remove the VRF
5161 fib_table_unlock(fib_index, FIB_PROTOCOL_IP6, FIB_SOURCE_API);
5163 FIB_TEST((0 == fib_path_list_db_size()), "path list DB population:%d",
5164 fib_path_list_db_size());
5165 FIB_TEST((PNPS-2 == fib_path_list_pool_size()), "path list pool size is%d",
5166 fib_path_list_pool_size());
5167 FIB_TEST((ENPS-2 == fib_entry_pool_size()), "entry pool size is %d",
5168 fib_entry_pool_size());
5174 * return the interfaces to up state
5176 error = vnet_sw_interface_set_flags(vnet_get_main(),
5177 tm->hw[0]->sw_if_index,
5178 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5179 error = vnet_sw_interface_set_flags(vnet_get_main(),
5180 tm->hw[1]->sw_if_index,
5181 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5183 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5190 * Test Attached Exports
5195 const dpo_id_t *dpo, *dpo_drop;
5196 const u32 fib_index = 0;
5197 fib_node_index_t fei;
5206 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5210 * add interface routes. We'll assume this works. It's more rigorously
5213 fib_prefix_t local_pfx = {
5215 .fp_proto = FIB_PROTOCOL_IP4,
5219 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
5224 vec_validate(im->fib_index_by_sw_if_index, tm->hw[0]->sw_if_index);
5225 im->fib_index_by_sw_if_index[tm->hw[0]->sw_if_index] = fib_index;
5227 dpo_drop = drop_dpo_get(DPO_PROTO_IP4);
5229 fib_table_entry_update_one_path(fib_index, &local_pfx,
5230 FIB_SOURCE_INTERFACE,
5231 (FIB_ENTRY_FLAG_CONNECTED |
5232 FIB_ENTRY_FLAG_ATTACHED),
5235 tm->hw[0]->sw_if_index,
5239 FIB_ROUTE_PATH_FLAG_NONE);
5240 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5241 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
5242 "attached interface route present");
5244 local_pfx.fp_len = 32;
5245 fib_table_entry_update_one_path(fib_index, &local_pfx,
5246 FIB_SOURCE_INTERFACE,
5247 (FIB_ENTRY_FLAG_CONNECTED |
5248 FIB_ENTRY_FLAG_LOCAL),
5251 tm->hw[0]->sw_if_index,
5252 ~0, // invalid fib index
5255 FIB_ROUTE_PATH_FLAG_NONE);
5256 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5258 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
5259 "local interface route present");
5262 * Add an 2 ARP entry => a complete ADJ plus adj-fib.
5264 fib_prefix_t pfx_10_10_10_1_s_32 = {
5266 .fp_proto = FIB_PROTOCOL_IP4,
5269 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
5272 fib_node_index_t ai;
5274 fib_table_entry_path_add(fib_index,
5275 &pfx_10_10_10_1_s_32,
5277 FIB_ENTRY_FLAG_ATTACHED,
5279 &pfx_10_10_10_1_s_32.fp_addr,
5280 tm->hw[0]->sw_if_index,
5281 ~0, // invalid fib index
5284 FIB_ROUTE_PATH_FLAG_NONE);
5286 fei = fib_table_lookup(fib_index, &pfx_10_10_10_1_s_32);
5287 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 created");
5288 ai = fib_entry_get_adj(fei);
5291 * create another FIB table into which routes will be imported
5293 u32 import_fib_index1;
5295 import_fib_index1 = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
5300 * Add an attached route in the import FIB
5302 local_pfx.fp_len = 24;
5303 fib_table_entry_update_one_path(import_fib_index1,
5306 FIB_ENTRY_FLAG_NONE,
5309 tm->hw[0]->sw_if_index,
5310 ~0, // invalid fib index
5313 FIB_ROUTE_PATH_FLAG_NONE);
5314 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5315 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
5318 * check for the presence of the adj-fibs in the import table
5320 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5321 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5322 FIB_TEST((ai == fib_entry_get_adj(fei)),
5323 "adj-fib1 Import uses same adj as export");
5326 * check for the presence of the local in the import table
5328 local_pfx.fp_len = 32;
5329 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5330 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5333 * Add another adj-fin in the export table. Expect this
5334 * to get magically exported;
5336 fib_prefix_t pfx_10_10_10_2_s_32 = {
5338 .fp_proto = FIB_PROTOCOL_IP4,
5341 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
5345 fib_table_entry_path_add(fib_index,
5346 &pfx_10_10_10_2_s_32,
5348 FIB_ENTRY_FLAG_ATTACHED,
5350 &pfx_10_10_10_2_s_32.fp_addr,
5351 tm->hw[0]->sw_if_index,
5352 ~0, // invalid fib index
5355 FIB_ROUTE_PATH_FLAG_NONE);
5356 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5357 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 present");
5358 ai = fib_entry_get_adj(fei);
5360 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5361 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5362 FIB_TEST((ai == fib_entry_get_adj(fei)),
5363 "Import uses same adj as export");
5364 FIB_TEST((FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags(fei)),
5365 "ADJ-fib2 imported flags %d",
5366 fib_entry_get_flags(fei));
5369 * create a 2nd FIB table into which routes will be imported
5371 u32 import_fib_index2;
5373 import_fib_index2 = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4, 12,
5377 * Add an attached route in the import FIB
5379 local_pfx.fp_len = 24;
5380 fib_table_entry_update_one_path(import_fib_index2,
5383 FIB_ENTRY_FLAG_NONE,
5386 tm->hw[0]->sw_if_index,
5387 ~0, // invalid fib index
5390 FIB_ROUTE_PATH_FLAG_NONE);
5391 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5392 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached export created");
5395 * check for the presence of all the adj-fibs and local in the import table
5397 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_1_s_32);
5398 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5399 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_2_s_32);
5400 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5401 local_pfx.fp_len = 32;
5402 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5403 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5406 * add a 3rd adj-fib. expect it to be exported to both tables.
5408 fib_prefix_t pfx_10_10_10_3_s_32 = {
5410 .fp_proto = FIB_PROTOCOL_IP4,
5413 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
5417 fib_table_entry_path_add(fib_index,
5418 &pfx_10_10_10_3_s_32,
5420 FIB_ENTRY_FLAG_ATTACHED,
5422 &pfx_10_10_10_3_s_32.fp_addr,
5423 tm->hw[0]->sw_if_index,
5424 ~0, // invalid fib index
5427 FIB_ROUTE_PATH_FLAG_NONE);
5428 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
5429 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 present");
5430 ai = fib_entry_get_adj(fei);
5432 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_3_s_32);
5433 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 imported to FIB1");
5434 FIB_TEST((ai == fib_entry_get_adj(fei)),
5435 "Import uses same adj as export");
5436 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_3_s_32);
5437 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib3 imported to FIB2");
5438 FIB_TEST((ai == fib_entry_get_adj(fei)),
5439 "Import uses same adj as export");
5442 * remove the 3rd adj fib. we expect it to be removed from both FIBs
5444 fib_table_entry_delete(fib_index,
5445 &pfx_10_10_10_3_s_32,
5448 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_3_s_32);
5449 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 remved");
5451 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_3_s_32);
5452 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 removed from FIB1");
5454 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_3_s_32);
5455 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib3 removed from FIB2");
5458 * remove the attached route from the 2nd FIB. expect the imported
5459 * entires to be removed
5461 local_pfx.fp_len = 24;
5462 fib_table_entry_delete(import_fib_index2,
5465 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5466 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "attached export removed");
5468 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_1_s_32);
5469 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB2");
5470 fei = fib_table_lookup_exact_match(import_fib_index2, &pfx_10_10_10_2_s_32);
5471 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB2");
5472 local_pfx.fp_len = 32;
5473 fei = fib_table_lookup_exact_match(import_fib_index2, &local_pfx);
5474 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB2");
5476 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5477 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 still in FIB1");
5478 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5479 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 still in FIB1");
5480 local_pfx.fp_len = 32;
5481 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5482 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local still in FIB1");
5485 * modify the route in FIB1 so it is no longer attached. expect the imported
5486 * entires to be removed
5488 local_pfx.fp_len = 24;
5489 fib_table_entry_update_one_path(import_fib_index1,
5492 FIB_ENTRY_FLAG_NONE,
5494 &pfx_10_10_10_2_s_32.fp_addr,
5495 tm->hw[0]->sw_if_index,
5496 ~0, // invalid fib index
5499 FIB_ROUTE_PATH_FLAG_NONE);
5500 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5501 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1");
5502 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5503 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5504 local_pfx.fp_len = 32;
5505 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5506 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5509 * modify it back to attached. expect the adj-fibs back
5511 local_pfx.fp_len = 24;
5512 fib_table_entry_update_one_path(import_fib_index1,
5515 FIB_ENTRY_FLAG_NONE,
5518 tm->hw[0]->sw_if_index,
5519 ~0, // invalid fib index
5522 FIB_ROUTE_PATH_FLAG_NONE);
5523 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5524 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported in FIB1");
5525 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5526 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported in FIB1");
5527 local_pfx.fp_len = 32;
5528 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5529 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported in FIB1");
5532 * add a covering attached next-hop for the interface address, so we have
5533 * a valid adj to find when we check the forwarding tables
5535 fib_prefix_t pfx_10_0_0_0_s_8 = {
5537 .fp_proto = FIB_PROTOCOL_IP4,
5540 .ip4.as_u32 = clib_host_to_net_u32(0x0a000000),
5544 fei = fib_table_entry_update_one_path(fib_index,
5547 FIB_ENTRY_FLAG_NONE,
5549 &pfx_10_10_10_3_s_32.fp_addr,
5550 tm->hw[0]->sw_if_index,
5551 ~0, // invalid fib index
5554 FIB_ROUTE_PATH_FLAG_NONE);
5555 dpo = fib_entry_contribute_ip_forwarding(fei);
5558 * remove the route in the export fib. expect the adj-fibs to be removed
5560 local_pfx.fp_len = 24;
5561 fib_table_entry_delete(fib_index,
5563 FIB_SOURCE_INTERFACE);
5565 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5566 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "Delete export: ADJ-fib1 removed from FIB1");
5567 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5568 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5569 local_pfx.fp_len = 32;
5570 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5571 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5574 * the adj-fibs in the export VRF are present in the FIB table,
5575 * but not installed in forwarding, since they have no attached cover.
5576 * Consequently a lookup in the MTRIE gives the adj for the covering
5579 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5580 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 in export");
5583 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_1_s_32.fp_addr.ip4);
5584 FIB_TEST(lbi == dpo->dpoi_index,
5585 "10.10.10.1 forwards on \n%U not \n%U",
5586 format_load_balance, lbi, 0,
5587 format_dpo_id, dpo, 0);
5588 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_2_s_32.fp_addr.ip4);
5589 FIB_TEST(lbi == dpo->dpoi_index,
5590 "10.10.10.2 forwards on %U", format_dpo_id, dpo, 0);
5591 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_3_s_32.fp_addr.ip4);
5592 FIB_TEST(lbi == dpo->dpoi_index,
5593 "10.10.10.3 forwards on %U", format_dpo_id, dpo, 0);
5596 * add the export prefix back, but not as attached.
5597 * No adj-fibs in export nor import tables
5599 local_pfx.fp_len = 24;
5600 fei = fib_table_entry_update_one_path(fib_index,
5603 FIB_ENTRY_FLAG_NONE,
5605 &pfx_10_10_10_1_s_32.fp_addr,
5606 tm->hw[0]->sw_if_index,
5607 ~0, // invalid fib index
5610 FIB_ROUTE_PATH_FLAG_NONE);
5611 dpo = fib_entry_contribute_ip_forwarding(fei);
5613 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5614 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "non-attached in export: ADJ-fib1 in export");
5615 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_1_s_32.fp_addr.ip4);
5616 FIB_TEST(lbi == dpo->dpoi_index,
5617 "10.10.10.1 forwards on %U", format_dpo_id, dpo, 0);
5618 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5619 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 in export");
5620 lbi = ip4_fib_forwarding_lookup(fib_index, &pfx_10_10_10_2_s_32.fp_addr.ip4);
5621 FIB_TEST(lbi == dpo->dpoi_index,
5622 "10.10.10.2 forwards on %U", format_dpo_id, dpo, 0);
5624 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5625 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib1 removed from FIB1");
5626 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5627 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "ADJ-fib2 removed from FIB1");
5628 local_pfx.fp_len = 32;
5629 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5630 FIB_TEST((FIB_NODE_INDEX_INVALID == fei), "local removed from FIB1");
5633 * modify the export prefix so it is attached. expect all covereds to return
5635 local_pfx.fp_len = 24;
5636 fib_table_entry_update_one_path(fib_index,
5639 FIB_ENTRY_FLAG_NONE,
5642 tm->hw[0]->sw_if_index,
5643 ~0, // invalid fib index
5646 FIB_ROUTE_PATH_FLAG_NONE);
5648 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5649 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 reinstalled in export");
5650 dpo = fib_entry_contribute_ip_forwarding(fei);
5651 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5652 "Adj-fib1 is not drop in export");
5653 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5654 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 reinstalled in export");
5655 local_pfx.fp_len = 32;
5656 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5657 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local reinstalled in export");
5658 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5659 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached in export: ADJ-fib1 imported");
5660 dpo = fib_entry_contribute_ip_forwarding(fei);
5661 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5662 "Adj-fib1 is not drop in export: %U %U",
5663 format_dpo_id, dpo, 0,
5664 format_dpo_id, load_balance_get_bucket(dpo->dpoi_index, 0), 0);
5665 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5666 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 imported");
5667 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5668 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5669 local_pfx.fp_len = 32;
5670 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5671 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5674 * modify the export prefix so connected. no change.
5676 local_pfx.fp_len = 24;
5677 fib_table_entry_update_one_path(fib_index, &local_pfx,
5678 FIB_SOURCE_INTERFACE,
5679 (FIB_ENTRY_FLAG_CONNECTED |
5680 FIB_ENTRY_FLAG_ATTACHED),
5683 tm->hw[0]->sw_if_index,
5687 FIB_ROUTE_PATH_FLAG_NONE);
5689 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_1_s_32);
5690 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib1 reinstalled in export");
5691 dpo = fib_entry_contribute_ip_forwarding(fei);
5692 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5693 "Adj-fib1 is not drop in export");
5694 fei = fib_table_lookup_exact_match(fib_index, &pfx_10_10_10_2_s_32);
5695 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 reinstalled in export");
5696 local_pfx.fp_len = 32;
5697 fei = fib_table_lookup_exact_match(fib_index, &local_pfx);
5698 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local reinstalled in export");
5699 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_1_s_32);
5700 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "attached in export: ADJ-fib1 imported");
5701 dpo = fib_entry_contribute_ip_forwarding(fei);
5702 FIB_TEST(dpo_cmp(dpo_drop, load_balance_get_bucket(dpo->dpoi_index, 0)),
5703 "Adj-fib1 is not drop in export");
5704 fei = fib_table_lookup_exact_match(import_fib_index1, &pfx_10_10_10_2_s_32);
5705 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "ADJ-fib2 imported");
5706 local_pfx.fp_len = 32;
5707 fei = fib_table_lookup_exact_match(import_fib_index1, &local_pfx);
5708 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "local imported");
5713 fib_table_entry_delete(fib_index,
5716 fib_table_entry_delete(fib_index,
5717 &pfx_10_10_10_1_s_32,
5719 fib_table_entry_delete(fib_index,
5720 &pfx_10_10_10_2_s_32,
5722 local_pfx.fp_len = 32;
5723 fib_table_entry_delete(fib_index,
5725 FIB_SOURCE_INTERFACE);
5726 local_pfx.fp_len = 24;
5727 fib_table_entry_delete(fib_index,
5730 fib_table_entry_delete(fib_index,
5732 FIB_SOURCE_INTERFACE);
5733 local_pfx.fp_len = 24;
5734 fib_table_entry_delete(import_fib_index1,
5738 fib_table_unlock(import_fib_index1, FIB_PROTOCOL_IP4, FIB_SOURCE_CLI);
5739 fib_table_unlock(import_fib_index2, FIB_PROTOCOL_IP4, FIB_SOURCE_CLI);
5741 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
5748 * Test Path Preference
5751 fib_test_pref (void)
5753 test_main_t *tm = &test_main;
5757 const fib_prefix_t pfx_1_1_1_1_s_32 = {
5759 .fp_proto = FIB_PROTOCOL_IP4,
5762 .as_u32 = clib_host_to_net_u32(0x01010101),
5768 * 2 high, 2 medium and 2 low preference non-recursive paths
5770 fib_route_path_t nr_path_hi_1 = {
5771 .frp_proto = DPO_PROTO_IP4,
5772 .frp_sw_if_index = tm->hw[0]->sw_if_index,
5773 .frp_fib_index = ~0,
5775 .frp_preference = 0,
5776 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5778 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
5781 fib_route_path_t nr_path_hi_2 = {
5782 .frp_proto = DPO_PROTO_IP4,
5783 .frp_sw_if_index = tm->hw[0]->sw_if_index,
5784 .frp_fib_index = ~0,
5786 .frp_preference = 0,
5787 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5789 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
5792 fib_route_path_t nr_path_med_1 = {
5793 .frp_proto = DPO_PROTO_IP4,
5794 .frp_sw_if_index = tm->hw[1]->sw_if_index,
5795 .frp_fib_index = ~0,
5797 .frp_preference = 1,
5798 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5800 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0c01),
5803 fib_route_path_t nr_path_med_2 = {
5804 .frp_proto = DPO_PROTO_IP4,
5805 .frp_sw_if_index = tm->hw[1]->sw_if_index,
5806 .frp_fib_index = ~0,
5808 .frp_preference = 1,
5809 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5811 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0c01),
5814 fib_route_path_t nr_path_low_1 = {
5815 .frp_proto = DPO_PROTO_IP4,
5816 .frp_sw_if_index = tm->hw[2]->sw_if_index,
5817 .frp_fib_index = ~0,
5819 .frp_preference = 2,
5820 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5822 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b01),
5825 fib_route_path_t nr_path_low_2 = {
5826 .frp_proto = DPO_PROTO_IP4,
5827 .frp_sw_if_index = tm->hw[2]->sw_if_index,
5828 .frp_fib_index = ~0,
5830 .frp_preference = 2,
5831 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
5833 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0b02),
5836 fib_route_path_t *nr_paths = NULL;
5838 vec_add1(nr_paths, nr_path_hi_1);
5839 vec_add1(nr_paths, nr_path_hi_2);
5840 vec_add1(nr_paths, nr_path_med_1);
5841 vec_add1(nr_paths, nr_path_med_2);
5842 vec_add1(nr_paths, nr_path_low_1);
5843 vec_add1(nr_paths, nr_path_low_2);
5845 adj_index_t ai_hi_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5847 &nr_path_hi_1.frp_addr,
5848 nr_path_hi_1.frp_sw_if_index);
5849 adj_index_t ai_hi_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5851 &nr_path_hi_2.frp_addr,
5852 nr_path_hi_2.frp_sw_if_index);
5853 adj_index_t ai_med_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5855 &nr_path_med_1.frp_addr,
5856 nr_path_med_1.frp_sw_if_index);
5857 adj_index_t ai_med_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5859 &nr_path_med_2.frp_addr,
5860 nr_path_med_2.frp_sw_if_index);
5861 adj_index_t ai_low_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5863 &nr_path_low_1.frp_addr,
5864 nr_path_low_1.frp_sw_if_index);
5865 adj_index_t ai_low_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
5867 &nr_path_low_2.frp_addr,
5868 nr_path_low_2.frp_sw_if_index);
5870 fib_test_lb_bucket_t ip_hi_1 = {
5876 fib_test_lb_bucket_t ip_hi_2 = {
5882 fib_test_lb_bucket_t ip_med_1 = {
5888 fib_test_lb_bucket_t ip_med_2 = {
5894 fib_test_lb_bucket_t ip_low_1 = {
5900 fib_test_lb_bucket_t ip_low_2 = {
5907 fib_node_index_t fei;
5909 fei = fib_table_entry_path_add2(0,
5912 FIB_ENTRY_FLAG_NONE,
5915 FIB_TEST(!fib_test_validate_entry(fei,
5916 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5920 "1.1.1.1/32 via high preference paths");
5923 * bring down the interface on which the high preference path lie
5925 vnet_sw_interface_set_flags(vnet_get_main(),
5926 tm->hw[0]->sw_if_index,
5929 FIB_TEST(!fib_test_validate_entry(fei,
5930 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5934 "1.1.1.1/32 via medium preference paths");
5937 * bring down the interface on which the medium preference path lie
5939 vnet_sw_interface_set_flags(vnet_get_main(),
5940 tm->hw[1]->sw_if_index,
5943 FIB_TEST(!fib_test_validate_entry(fei,
5944 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5948 "1.1.1.1/32 via low preference paths");
5951 * bring up the interface on which the high preference path lie
5953 vnet_sw_interface_set_flags(vnet_get_main(),
5954 tm->hw[0]->sw_if_index,
5955 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5957 FIB_TEST(!fib_test_validate_entry(fei,
5958 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5962 "1.1.1.1/32 via high preference paths");
5965 * bring up the interface on which the medium preference path lie
5967 vnet_sw_interface_set_flags(vnet_get_main(),
5968 tm->hw[1]->sw_if_index,
5969 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
5971 FIB_TEST(!fib_test_validate_entry(fei,
5972 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5976 "1.1.1.1/32 via high preference paths");
5978 dpo_id_t ip_1_1_1_1 = DPO_INVALID;
5979 fib_entry_contribute_forwarding(fei,
5980 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
5984 * 3 recursive paths of different preference
5986 const fib_prefix_t pfx_1_1_1_2_s_32 = {
5988 .fp_proto = FIB_PROTOCOL_IP4,
5991 .as_u32 = clib_host_to_net_u32(0x01010102),
5995 const fib_prefix_t pfx_1_1_1_3_s_32 = {
5997 .fp_proto = FIB_PROTOCOL_IP4,
6000 .as_u32 = clib_host_to_net_u32(0x01010103),
6004 fei = fib_table_entry_path_add2(0,
6007 FIB_ENTRY_FLAG_NONE,
6009 dpo_id_t ip_1_1_1_2 = DPO_INVALID;
6010 fib_entry_contribute_forwarding(fei,
6011 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6013 fei = fib_table_entry_path_add2(0,
6016 FIB_ENTRY_FLAG_NONE,
6018 dpo_id_t ip_1_1_1_3 = DPO_INVALID;
6019 fib_entry_contribute_forwarding(fei,
6020 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6023 fib_test_lb_bucket_t ip_o_1_1_1_1 = {
6026 .lb = ip_1_1_1_1.dpoi_index,
6029 fib_test_lb_bucket_t ip_o_1_1_1_2 = {
6032 .lb = ip_1_1_1_2.dpoi_index,
6035 fib_test_lb_bucket_t ip_o_1_1_1_3 = {
6038 .lb = ip_1_1_1_3.dpoi_index,
6041 fib_route_path_t r_path_hi = {
6042 .frp_proto = DPO_PROTO_IP4,
6043 .frp_sw_if_index = ~0,
6046 .frp_preference = 0,
6047 .frp_flags = FIB_ROUTE_PATH_RESOLVE_VIA_HOST,
6048 .frp_addr = pfx_1_1_1_1_s_32.fp_addr,
6050 fib_route_path_t r_path_med = {
6051 .frp_proto = DPO_PROTO_IP4,
6052 .frp_sw_if_index = ~0,
6055 .frp_preference = 10,
6056 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
6057 .frp_addr = pfx_1_1_1_2_s_32.fp_addr,
6059 fib_route_path_t r_path_low = {
6060 .frp_proto = DPO_PROTO_IP4,
6061 .frp_sw_if_index = ~0,
6064 .frp_preference = 255,
6065 .frp_flags = FIB_ROUTE_PATH_RESOLVE_VIA_HOST,
6066 .frp_addr = pfx_1_1_1_3_s_32.fp_addr,
6068 fib_route_path_t *r_paths = NULL;
6070 vec_add1(r_paths, r_path_hi);
6071 vec_add1(r_paths, r_path_low);
6072 vec_add1(r_paths, r_path_med);
6075 * add many recursive so we get the LB MAp created
6078 fib_prefix_t pfx_r[N_PFXS];
6079 unsigned int n_pfxs;
6080 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6082 pfx_r[n_pfxs].fp_len = 32;
6083 pfx_r[n_pfxs].fp_proto = FIB_PROTOCOL_IP4;
6084 pfx_r[n_pfxs].fp_addr.ip4.as_u32 =
6085 clib_host_to_net_u32(0x02000000 + n_pfxs);
6087 fei = fib_table_entry_path_add2(0,
6090 FIB_ENTRY_FLAG_NONE,
6093 FIB_TEST(!fib_test_validate_entry(fei,
6094 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6097 "recursive via high preference paths");
6100 * withdraw hig pref resolving entry
6102 fib_table_entry_delete(0,
6106 /* suspend so the update walk kicks int */
6107 vlib_process_suspend(vlib_get_main(), 1e-5);
6109 FIB_TEST(!fib_test_validate_entry(fei,
6110 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6113 "recursive via medium preference paths");
6116 * withdraw medium pref resolving entry
6118 fib_table_entry_delete(0,
6122 /* suspend so the update walk kicks int */
6123 vlib_process_suspend(vlib_get_main(), 1e-5);
6125 FIB_TEST(!fib_test_validate_entry(fei,
6126 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6129 "recursive via low preference paths");
6132 * add back paths for next iteration
6134 fei = fib_table_entry_update(0,
6137 FIB_ENTRY_FLAG_NONE,
6139 fei = fib_table_entry_update(0,
6142 FIB_ENTRY_FLAG_NONE,
6145 /* suspend so the update walk kicks int */
6146 vlib_process_suspend(vlib_get_main(), 1e-5);
6148 fei = fib_table_lookup_exact_match(0, &pfx_r[n_pfxs]);
6149 FIB_TEST(!fib_test_validate_entry(fei,
6150 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6153 "recursive via high preference paths");
6157 fib_table_entry_delete(0,
6161 /* suspend so the update walk kicks int */
6162 vlib_process_suspend(vlib_get_main(), 1e-5);
6164 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6166 fei = fib_table_lookup_exact_match(0, &pfx_r[n_pfxs]);
6168 FIB_TEST(!fib_test_validate_entry(fei,
6169 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6172 "recursive via medium preference paths");
6174 for (n_pfxs = 0; n_pfxs < N_PFXS; n_pfxs++)
6176 fib_table_entry_delete(0,
6184 fib_table_entry_delete(0,
6187 fib_table_entry_delete(0,
6191 dpo_reset(&ip_1_1_1_1);
6192 dpo_reset(&ip_1_1_1_2);
6193 dpo_reset(&ip_1_1_1_3);
6194 adj_unlock(ai_low_2);
6195 adj_unlock(ai_low_1);
6196 adj_unlock(ai_med_2);
6197 adj_unlock(ai_med_1);
6198 adj_unlock(ai_hi_2);
6199 adj_unlock(ai_hi_1);
6205 * Test the recursive route route handling for GRE tunnels
6208 fib_test_label (void)
6210 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;
6211 const u32 fib_index = 0;
6212 int lb_count, ii, res;
6217 lb_count = pool_elts(load_balance_pool);
6222 * add interface routes. We'll assume this works. It's more rigorously
6225 fib_prefix_t local0_pfx = {
6227 .fp_proto = FIB_PROTOCOL_IP4,
6231 .as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
6236 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
6239 vec_validate(im->fib_index_by_sw_if_index, tm->hw[0]->sw_if_index);
6240 im->fib_index_by_sw_if_index[tm->hw[0]->sw_if_index] = fib_index;
6242 fib_table_entry_update_one_path(fib_index, &local0_pfx,
6243 FIB_SOURCE_INTERFACE,
6244 (FIB_ENTRY_FLAG_CONNECTED |
6245 FIB_ENTRY_FLAG_ATTACHED),
6248 tm->hw[0]->sw_if_index,
6252 FIB_ROUTE_PATH_FLAG_NONE);
6253 fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
6254 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6255 "attached interface route present");
6257 local0_pfx.fp_len = 32;
6258 fib_table_entry_update_one_path(fib_index, &local0_pfx,
6259 FIB_SOURCE_INTERFACE,
6260 (FIB_ENTRY_FLAG_CONNECTED |
6261 FIB_ENTRY_FLAG_LOCAL),
6264 tm->hw[0]->sw_if_index,
6265 ~0, // invalid fib index
6268 FIB_ROUTE_PATH_FLAG_NONE);
6269 fei = fib_table_lookup_exact_match(fib_index, &local0_pfx);
6271 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6272 "local interface route present");
6274 fib_prefix_t local1_pfx = {
6276 .fp_proto = FIB_PROTOCOL_IP4,
6280 .as_u32 = clib_host_to_net_u32(0x0a0a0b0a),
6285 vec_validate(im->fib_index_by_sw_if_index, tm->hw[1]->sw_if_index);
6286 im->fib_index_by_sw_if_index[tm->hw[1]->sw_if_index] = fib_index;
6288 fib_table_entry_update_one_path(fib_index, &local1_pfx,
6289 FIB_SOURCE_INTERFACE,
6290 (FIB_ENTRY_FLAG_CONNECTED |
6291 FIB_ENTRY_FLAG_ATTACHED),
6294 tm->hw[1]->sw_if_index,
6298 FIB_ROUTE_PATH_FLAG_NONE);
6299 fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
6300 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6301 "attached interface route present");
6303 local1_pfx.fp_len = 32;
6304 fib_table_entry_update_one_path(fib_index, &local1_pfx,
6305 FIB_SOURCE_INTERFACE,
6306 (FIB_ENTRY_FLAG_CONNECTED |
6307 FIB_ENTRY_FLAG_LOCAL),
6310 tm->hw[1]->sw_if_index,
6311 ~0, // invalid fib index
6314 FIB_ROUTE_PATH_FLAG_NONE);
6315 fei = fib_table_lookup_exact_match(fib_index, &local1_pfx);
6317 FIB_TEST((FIB_NODE_INDEX_INVALID != fei),
6318 "local interface route present");
6320 ip46_address_t nh_10_10_10_1 = {
6322 .as_u32 = clib_host_to_net_u32(0x0a0a0a01),
6325 ip46_address_t nh_10_10_11_1 = {
6327 .as_u32 = clib_host_to_net_u32(0x0a0a0b01),
6330 ip46_address_t nh_10_10_11_2 = {
6332 .as_u32 = clib_host_to_net_u32(0x0a0a0b02),
6336 ai_v4_10_10_11_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6339 tm->hw[1]->sw_if_index);
6340 ai_v4_10_10_11_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6343 tm->hw[1]->sw_if_index);
6344 ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6347 tm->hw[0]->sw_if_index);
6348 ai_mpls_10_10_11_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6351 tm->hw[1]->sw_if_index);
6352 ai_mpls_10_10_11_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
6355 tm->hw[1]->sw_if_index);
6358 * Add an etry with one path with a real out-going label
6360 fib_prefix_t pfx_1_1_1_1_s_32 = {
6362 .fp_proto = FIB_PROTOCOL_IP4,
6364 .ip4.as_u32 = clib_host_to_net_u32(0x01010101),
6367 fib_test_lb_bucket_t l99_eos_o_10_10_10_1 = {
6368 .type = FT_LB_LABEL_O_ADJ,
6370 .adj = ai_mpls_10_10_10_1,
6375 fib_test_lb_bucket_t l99_neos_o_10_10_10_1 = {
6376 .type = FT_LB_LABEL_O_ADJ,
6378 .adj = ai_mpls_10_10_10_1,
6380 .eos = MPLS_NON_EOS,
6383 fib_mpls_label_t *l99 = NULL, fml99 = {
6386 vec_add1(l99, fml99);
6388 fib_table_entry_update_one_path(fib_index,
6391 FIB_ENTRY_FLAG_NONE,
6394 tm->hw[0]->sw_if_index,
6395 ~0, // invalid fib index
6398 FIB_ROUTE_PATH_FLAG_NONE);
6400 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6401 FIB_TEST((FIB_NODE_INDEX_INVALID != fei), "1.1.1.1/32 created");
6403 FIB_TEST(!fib_test_validate_entry(fei,
6404 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6406 &l99_eos_o_10_10_10_1),
6407 "1.1.1.1/32 LB 1 bucket via label 99 over 10.10.10.1");
6410 * add a path with an implicit NULL label
6412 fib_test_lb_bucket_t a_o_10_10_11_1 = {
6415 .adj = ai_v4_10_10_11_1,
6418 fib_test_lb_bucket_t a_mpls_o_10_10_11_1 = {
6421 .adj = ai_mpls_10_10_11_1,
6424 fib_mpls_label_t *l_imp_null = NULL, fml_imp_null = {
6425 .fml_value = MPLS_IETF_IMPLICIT_NULL_LABEL,
6427 vec_add1(l_imp_null, fml_imp_null);
6429 fei = fib_table_entry_path_add(fib_index,
6432 FIB_ENTRY_FLAG_NONE,
6435 tm->hw[1]->sw_if_index,
6436 ~0, // invalid fib index
6439 FIB_ROUTE_PATH_FLAG_NONE);
6441 FIB_TEST(!fib_test_validate_entry(fei,
6442 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6444 &l99_eos_o_10_10_10_1,
6446 "1.1.1.1/32 LB 2 buckets via: "
6447 "label 99 over 10.10.10.1, "
6448 "adj over 10.10.11.1");
6451 * assign the route a local label
6453 fib_table_entry_local_label_add(fib_index,
6457 fib_prefix_t pfx_24001_eos = {
6458 .fp_proto = FIB_PROTOCOL_MPLS,
6462 fib_prefix_t pfx_24001_neos = {
6463 .fp_proto = FIB_PROTOCOL_MPLS,
6465 .fp_eos = MPLS_NON_EOS,
6467 fib_test_lb_bucket_t disp_o_10_10_11_1 = {
6468 .type = FT_LB_MPLS_DISP_PIPE_O_ADJ,
6470 .adj = ai_v4_10_10_11_1,
6475 * The EOS entry should link to both the paths,
6476 * and use an ip adj for the imp-null
6477 * The NON-EOS entry should link to both the paths,
6478 * and use an mpls adj for the imp-null
6480 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6482 FIB_TEST(!fib_test_validate_entry(fei,
6483 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6485 &l99_eos_o_10_10_10_1,
6486 &disp_o_10_10_11_1),
6487 "24001/eos LB 2 buckets via: "
6488 "label 99 over 10.10.10.1, "
6489 "mpls disp adj over 10.10.11.1");
6492 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6494 FIB_TEST(!fib_test_validate_entry(fei,
6495 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6497 &l99_neos_o_10_10_10_1,
6498 &a_mpls_o_10_10_11_1),
6499 "24001/neos LB 1 bucket via: "
6500 "label 99 over 10.10.10.1 ",
6501 "mpls-adj via 10.10.11.1");
6504 * add an unlabelled path, this is excluded from the neos chains,
6506 fib_test_lb_bucket_t adj_o_10_10_11_2 = {
6509 .adj = ai_v4_10_10_11_2,
6512 fib_test_lb_bucket_t disp_o_10_10_11_2 = {
6513 .type = FT_LB_MPLS_DISP_PIPE_O_ADJ,
6515 .adj = ai_v4_10_10_11_2,
6520 fei = fib_table_entry_path_add(fib_index,
6523 FIB_ENTRY_FLAG_NONE,
6526 tm->hw[1]->sw_if_index,
6527 ~0, // invalid fib index
6530 FIB_ROUTE_PATH_FLAG_NONE);
6532 FIB_TEST(!fib_test_validate_entry(fei,
6533 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6534 16, // 3 choices spread over 16 buckets
6535 &l99_eos_o_10_10_10_1,
6536 &l99_eos_o_10_10_10_1,
6537 &l99_eos_o_10_10_10_1,
6538 &l99_eos_o_10_10_10_1,
6539 &l99_eos_o_10_10_10_1,
6540 &l99_eos_o_10_10_10_1,
6551 "1.1.1.1/32 LB 16 buckets via: "
6552 "label 99 over 10.10.10.1, "
6553 "adj over 10.10.11.1",
6554 "adj over 10.10.11.2");
6557 * get and lock a reference to the non-eos of the via entry 1.1.1.1/32
6559 dpo_id_t non_eos_1_1_1_1 = DPO_INVALID;
6560 fib_entry_contribute_forwarding(fei,
6561 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6565 * n-eos has only the 2 labelled paths
6567 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6570 FIB_TEST(!fib_test_validate_entry(fei,
6571 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6573 &l99_neos_o_10_10_10_1,
6574 &a_mpls_o_10_10_11_1),
6575 "24001/neos LB 2 buckets via: "
6576 "label 99 over 10.10.10.1, "
6577 "adj-mpls over 10.10.11.2");
6580 * A labelled recursive
6582 fib_prefix_t pfx_2_2_2_2_s_32 = {
6584 .fp_proto = FIB_PROTOCOL_IP4,
6586 .ip4.as_u32 = clib_host_to_net_u32(0x02020202),
6589 fib_test_lb_bucket_t l1600_eos_o_1_1_1_1 = {
6590 .type = FT_LB_LABEL_O_LB,
6592 .lb = non_eos_1_1_1_1.dpoi_index,
6595 .mode = FIB_MPLS_LSP_MODE_UNIFORM,
6598 fib_mpls_label_t *l1600 = NULL, fml1600 = {
6600 .fml_mode = FIB_MPLS_LSP_MODE_UNIFORM,
6602 vec_add1(l1600, fml1600);
6604 fei = fib_table_entry_update_one_path(fib_index,
6607 FIB_ENTRY_FLAG_NONE,
6609 &pfx_1_1_1_1_s_32.fp_addr,
6614 FIB_ROUTE_PATH_FLAG_NONE);
6616 FIB_TEST(!fib_test_validate_entry(fei,
6617 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6619 &l1600_eos_o_1_1_1_1),
6620 "2.2.2.2.2/32 LB 1 buckets via: "
6621 "label 1600 over 1.1.1.1");
6623 dpo_id_t dpo_44 = DPO_INVALID;
6626 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_UNICAST_IP4, &dpo_44);
6627 urpfi = load_balance_get_urpf(dpo_44.dpoi_index);
6629 FIB_TEST(fib_urpf_check(urpfi, tm->hw[0]->sw_if_index),
6630 "uRPF check for 2.2.2.2/32 on %d OK",
6631 tm->hw[0]->sw_if_index);
6632 FIB_TEST(fib_urpf_check(urpfi, tm->hw[1]->sw_if_index),
6633 "uRPF check for 2.2.2.2/32 on %d OK",
6634 tm->hw[1]->sw_if_index);
6635 FIB_TEST(!fib_urpf_check(urpfi, 99),
6636 "uRPF check for 2.2.2.2/32 on 99 not-OK",
6639 fib_entry_contribute_forwarding(fei, FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, &dpo_44);
6640 FIB_TEST(urpfi == load_balance_get_urpf(dpo_44.dpoi_index),
6641 "Shared uRPF on IP and non-EOS chain");
6646 * we are holding a lock on the non-eos LB of the via-entry.
6647 * do a PIC-core failover by shutting the link of the via-entry.
6649 * shut down the link with the valid label
6651 vnet_sw_interface_set_flags(vnet_get_main(),
6652 tm->hw[0]->sw_if_index,
6655 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6656 FIB_TEST(!fib_test_validate_entry(fei,
6657 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6661 "1.1.1.1/32 LB 2 buckets via: "
6662 "adj over 10.10.11.1, ",
6663 "adj-v4 over 10.10.11.2");
6665 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6667 FIB_TEST(!fib_test_validate_entry(fei,
6668 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6671 &disp_o_10_10_11_2),
6672 "24001/eos LB 2 buckets via: "
6673 "mpls-disp adj over 10.10.11.1, ",
6674 "mpls-disp adj-v4 over 10.10.11.2");
6676 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6678 FIB_TEST(!fib_test_validate_entry(fei,
6679 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6681 &a_mpls_o_10_10_11_1),
6682 "24001/neos LB 1 buckets via: "
6683 "adj-mpls over 10.10.11.2");
6686 * test that the pre-failover load-balance has been in-place
6689 dpo_id_t current = DPO_INVALID;
6690 fib_entry_contribute_forwarding(fei,
6691 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6694 FIB_TEST(!dpo_cmp(&non_eos_1_1_1_1,
6696 "PIC-core LB inplace modified %U %U",
6697 format_dpo_id, &non_eos_1_1_1_1, 0,
6698 format_dpo_id, ¤t, 0);
6700 dpo_reset(&non_eos_1_1_1_1);
6701 dpo_reset(¤t);
6704 * no-shut the link with the valid label
6706 vnet_sw_interface_set_flags(vnet_get_main(),
6707 tm->hw[0]->sw_if_index,
6708 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
6710 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6711 FIB_TEST(!fib_test_validate_entry(fei,
6712 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6713 16, // 3 choices spread over 16 buckets
6714 &l99_eos_o_10_10_10_1,
6715 &l99_eos_o_10_10_10_1,
6716 &l99_eos_o_10_10_10_1,
6717 &l99_eos_o_10_10_10_1,
6718 &l99_eos_o_10_10_10_1,
6719 &l99_eos_o_10_10_10_1,
6730 "1.1.1.1/32 LB 16 buckets via: "
6731 "label 99 over 10.10.10.1, "
6732 "adj over 10.10.11.1",
6733 "adj-v4 over 10.10.11.2");
6736 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6738 FIB_TEST(!fib_test_validate_entry(fei,
6739 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6740 16, // 3 choices spread over 16 buckets
6741 &l99_eos_o_10_10_10_1,
6742 &l99_eos_o_10_10_10_1,
6743 &l99_eos_o_10_10_10_1,
6744 &l99_eos_o_10_10_10_1,
6745 &l99_eos_o_10_10_10_1,
6746 &l99_eos_o_10_10_10_1,
6756 &disp_o_10_10_11_2),
6757 "24001/eos LB 16 buckets via: "
6758 "label 99 over 10.10.10.1, "
6759 "MPLS disp adj over 10.10.11.1",
6760 "MPLS disp adj-v4 over 10.10.11.2");
6762 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6764 FIB_TEST(!fib_test_validate_entry(fei,
6765 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6767 &l99_neos_o_10_10_10_1,
6768 &a_mpls_o_10_10_11_1),
6769 "24001/neos LB 2 buckets via: "
6770 "label 99 over 10.10.10.1, "
6771 "adj-mpls over 10.10.11.2");
6774 * remove the first path with the valid label
6776 fib_table_entry_path_remove(fib_index,
6781 tm->hw[0]->sw_if_index,
6782 ~0, // invalid fib index
6784 FIB_ROUTE_PATH_FLAG_NONE);
6786 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6787 FIB_TEST(!fib_test_validate_entry(fei,
6788 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6792 "1.1.1.1/32 LB 2 buckets via: "
6793 "adj over 10.10.11.1, "
6794 "adj-v4 over 10.10.11.2");
6796 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6798 FIB_TEST(!fib_test_validate_entry(fei,
6799 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6802 &disp_o_10_10_11_2),
6803 "24001/eos LB 2 buckets via: "
6804 "MPLS disp adj over 10.10.11.1, "
6805 "MPLS disp adj-v4 over 10.10.11.2");
6807 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6810 FIB_TEST(!fib_test_validate_entry(fei,
6811 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6813 &a_mpls_o_10_10_11_1),
6814 "24001/neos LB 1 buckets via: "
6815 "adj-mpls over 10.10.11.2");
6818 * remove the other path with a valid label
6820 fib_test_lb_bucket_t bucket_drop = {
6823 fib_test_lb_bucket_t mpls_bucket_drop = {
6826 .adj = DPO_PROTO_MPLS,
6830 fib_table_entry_path_remove(fib_index,
6835 tm->hw[1]->sw_if_index,
6836 ~0, // invalid fib index
6838 FIB_ROUTE_PATH_FLAG_NONE);
6840 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6841 FIB_TEST(!fib_test_validate_entry(fei,
6842 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6845 "1.1.1.1/32 LB 1 buckets via: "
6846 "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_EOS,
6853 &disp_o_10_10_11_2),
6854 "24001/eos LB 1 buckets via: "
6855 "MPLS disp adj over 10.10.11.2");
6857 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6859 FIB_TEST(!fib_test_validate_entry(fei,
6860 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6863 "24001/neos LB 1 buckets via: DROP");
6866 * add back the path with the valid label
6869 vec_add1(l99, fml99);
6871 fib_table_entry_path_add(fib_index,
6874 FIB_ENTRY_FLAG_NONE,
6877 tm->hw[0]->sw_if_index,
6878 ~0, // invalid fib index
6881 FIB_ROUTE_PATH_FLAG_NONE);
6883 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6884 FIB_TEST(!fib_test_validate_entry(fei,
6885 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6887 &l99_eos_o_10_10_10_1,
6889 "1.1.1.1/32 LB 2 buckets via: "
6890 "label 99 over 10.10.10.1, "
6891 "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_EOS,
6898 &l99_eos_o_10_10_10_1,
6899 &disp_o_10_10_11_2),
6900 "24001/eos LB 2 buckets via: "
6901 "label 99 over 10.10.10.1, "
6902 "MPLS disp adj over 10.10.11.2");
6904 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6906 FIB_TEST(!fib_test_validate_entry(fei,
6907 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6909 &l99_neos_o_10_10_10_1),
6910 "24001/neos LB 1 buckets via: "
6911 "label 99 over 10.10.10.1");
6914 * change the local label
6916 fib_table_entry_local_label_add(fib_index,
6920 fib_prefix_t pfx_25005_eos = {
6921 .fp_proto = FIB_PROTOCOL_MPLS,
6925 fib_prefix_t pfx_25005_neos = {
6926 .fp_proto = FIB_PROTOCOL_MPLS,
6928 .fp_eos = MPLS_NON_EOS,
6931 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6932 fib_table_lookup(fib_index, &pfx_24001_eos)),
6933 "24001/eos removed after label change");
6934 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6935 fib_table_lookup(fib_index, &pfx_24001_neos)),
6936 "24001/eos removed after label change");
6938 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6940 FIB_TEST(!fib_test_validate_entry(fei,
6941 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
6943 &l99_eos_o_10_10_10_1,
6944 &disp_o_10_10_11_2),
6945 "25005/eos LB 2 buckets via: "
6946 "label 99 over 10.10.10.1, "
6947 "MPLS disp adj over 10.10.11.2");
6949 fei = fib_table_lookup(MPLS_FIB_DEFAULT_TABLE_ID,
6951 FIB_TEST(!fib_test_validate_entry(fei,
6952 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
6954 &l99_neos_o_10_10_10_1),
6955 "25005/neos LB 1 buckets via: "
6956 "label 99 over 10.10.10.1");
6959 * remove the local label.
6960 * the check that the MPLS entries are gone is done by the fact the
6961 * MPLS table is no longer present.
6963 fib_table_entry_local_label_remove(fib_index,
6967 fei = fib_table_lookup(fib_index, &pfx_1_1_1_1_s_32);
6968 FIB_TEST(!fib_test_validate_entry(fei,
6969 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
6971 &l99_eos_o_10_10_10_1,
6973 "24001/eos LB 2 buckets via: "
6974 "label 99 over 10.10.10.1, "
6975 "adj over 10.10.11.2");
6977 FIB_TEST((FIB_NODE_INDEX_INVALID ==
6978 mpls_fib_index_from_table_id(MPLS_FIB_DEFAULT_TABLE_ID)),
6979 "No more MPLS FIB entries => table removed");
6982 * add another via-entry for the recursive
6984 fib_prefix_t pfx_1_1_1_2_s_32 = {
6986 .fp_proto = FIB_PROTOCOL_IP4,
6988 .ip4.as_u32 = clib_host_to_net_u32(0x01010102),
6991 fib_test_lb_bucket_t l101_eos_o_10_10_10_1 = {
6992 .type = FT_LB_LABEL_O_ADJ,
6994 .adj = ai_mpls_10_10_10_1,
6999 fib_mpls_label_t *l101 = NULL, fml101 = {
7002 vec_add1(l101, fml101);
7004 fei = fib_table_entry_update_one_path(fib_index,
7007 FIB_ENTRY_FLAG_NONE,
7010 tm->hw[0]->sw_if_index,
7011 ~0, // invalid fib index
7014 FIB_ROUTE_PATH_FLAG_NONE);
7016 FIB_TEST(!fib_test_validate_entry(fei,
7017 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7019 &l101_eos_o_10_10_10_1),
7020 "1.1.1.2/32 LB 1 buckets via: "
7021 "label 101 over 10.10.10.1");
7023 dpo_id_t non_eos_1_1_1_2 = DPO_INVALID;
7024 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
7026 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
7028 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
7030 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
7033 fib_test_lb_bucket_t l1601_eos_o_1_1_1_2 = {
7034 .type = FT_LB_LABEL_O_LB,
7036 .lb = non_eos_1_1_1_2.dpoi_index,
7041 fib_mpls_label_t *l1601 = NULL, fml1601 = {
7044 vec_add1(l1601, fml1601);
7046 l1600_eos_o_1_1_1_1.label_o_lb.lb = non_eos_1_1_1_1.dpoi_index;
7048 fei = fib_table_entry_path_add(fib_index,
7051 FIB_ENTRY_FLAG_NONE,
7053 &pfx_1_1_1_2_s_32.fp_addr,
7058 FIB_ROUTE_PATH_FLAG_NONE);
7060 FIB_TEST(!fib_test_validate_entry(fei,
7061 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7063 &l1600_eos_o_1_1_1_1,
7064 &l1601_eos_o_1_1_1_2),
7065 "2.2.2.2/32 LB 2 buckets via: "
7066 "label 1600 via 1.1,1.1, "
7067 "label 16001 via 1.1.1.2");
7070 * update the via-entry so it no longer has an imp-null path.
7071 * the LB for the recursive can use an imp-null
7074 vec_add1(l_imp_null, fml_imp_null);
7076 fei = fib_table_entry_update_one_path(fib_index,
7079 FIB_ENTRY_FLAG_NONE,
7082 tm->hw[1]->sw_if_index,
7083 ~0, // invalid fib index
7086 FIB_ROUTE_PATH_FLAG_NONE);
7088 FIB_TEST(!fib_test_validate_entry(fei,
7089 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7092 "1.1.1.2/32 LB 1 buckets via: "
7095 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7096 FIB_TEST(!fib_test_validate_entry(fei,
7097 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7099 &l1600_eos_o_1_1_1_1,
7100 &l1601_eos_o_1_1_1_2),
7101 "2.2.2.2/32 LB 2 buckets via: "
7102 "label 1600 via 1.1,1.1, "
7103 "label 16001 via 1.1.1.2");
7106 * update the via-entry so it no longer has labelled paths.
7107 * the LB for the recursive should exclue this via form its LB
7109 fei = fib_table_entry_update_one_path(fib_index,
7112 FIB_ENTRY_FLAG_NONE,
7115 tm->hw[1]->sw_if_index,
7116 ~0, // invalid fib index
7119 FIB_ROUTE_PATH_FLAG_NONE);
7121 FIB_TEST(!fib_test_validate_entry(fei,
7122 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7125 "1.1.1.2/32 LB 1 buckets via: "
7128 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7129 FIB_TEST(!fib_test_validate_entry(fei,
7130 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7132 &l1600_eos_o_1_1_1_1),
7133 "2.2.2.2/32 LB 1 buckets via: "
7134 "label 1600 via 1.1,1.1");
7136 dpo_reset(&non_eos_1_1_1_1);
7137 dpo_reset(&non_eos_1_1_1_2);
7140 * Add a recursive with no out-labels. We expect to use the IP of the via
7142 fib_prefix_t pfx_2_2_2_3_s_32 = {
7144 .fp_proto = FIB_PROTOCOL_IP4,
7146 .ip4.as_u32 = clib_host_to_net_u32(0x02020203),
7149 dpo_id_t ip_1_1_1_1 = DPO_INVALID;
7151 fib_table_entry_update_one_path(fib_index,
7154 FIB_ENTRY_FLAG_NONE,
7156 &pfx_1_1_1_1_s_32.fp_addr,
7161 FIB_ROUTE_PATH_FLAG_NONE);
7163 fib_entry_contribute_forwarding(fib_table_lookup(fib_index,
7165 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7168 fib_test_lb_bucket_t ip_o_1_1_1_1 = {
7171 .lb = ip_1_1_1_1.dpoi_index,
7175 fei = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32);
7176 FIB_TEST(!fib_test_validate_entry(fei,
7177 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7180 "2.2.2.2.3/32 LB 1 buckets via: "
7184 * Add a recursive with an imp-null out-label.
7185 * We expect to use the IP of the via
7187 fib_prefix_t pfx_2_2_2_4_s_32 = {
7189 .fp_proto = FIB_PROTOCOL_IP4,
7191 .ip4.as_u32 = clib_host_to_net_u32(0x02020204),
7195 fib_table_entry_update_one_path(fib_index,
7198 FIB_ENTRY_FLAG_NONE,
7200 &pfx_1_1_1_1_s_32.fp_addr,
7205 FIB_ROUTE_PATH_FLAG_NONE);
7207 fei = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
7208 FIB_TEST(!fib_test_validate_entry(fei,
7209 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7212 "2.2.2.2.4/32 LB 1 buckets via: "
7215 dpo_reset(&ip_1_1_1_1);
7218 * Create an entry with a deep label stack
7220 fib_prefix_t pfx_2_2_5_5_s_32 = {
7222 .fp_proto = FIB_PROTOCOL_IP4,
7224 .ip4.as_u32 = clib_host_to_net_u32(0x02020505),
7227 fib_test_lb_bucket_t ls_eos_o_10_10_10_1 = {
7228 .type = FT_LB_LABEL_STACK_O_ADJ,
7229 .label_stack_o_adj = {
7230 .adj = ai_mpls_10_10_11_1,
7231 .label_stack_size = 8,
7233 200, 201, 202, 203, 204, 205, 206, 207
7238 fib_mpls_label_t *label_stack = NULL;
7239 vec_validate(label_stack, 7);
7240 for (ii = 0; ii < 8; ii++)
7242 label_stack[ii].fml_value = ii + 200;
7245 fei = fib_table_entry_update_one_path(fib_index,
7248 FIB_ENTRY_FLAG_NONE,
7251 tm->hw[1]->sw_if_index,
7252 ~0, // invalid fib index
7255 FIB_ROUTE_PATH_FLAG_NONE);
7257 FIB_TEST(!fib_test_validate_entry(fei,
7258 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7260 &ls_eos_o_10_10_10_1),
7261 "2.2.5.5/32 LB 1 buckets via: "
7263 fib_table_entry_delete_index(fei, FIB_SOURCE_API);
7268 fib_table_entry_delete(fib_index,
7272 fei = fib_table_lookup(fib_index, &pfx_2_2_2_2_s_32);
7273 FIB_TEST(!fib_test_validate_entry(fei,
7274 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7276 &l1600_eos_o_1_1_1_1),
7277 "2.2.2.2/32 LB 1 buckets via: "
7278 "label 1600 via 1.1,1.1");
7280 fib_table_entry_delete(fib_index,
7284 FIB_TEST(!fib_test_validate_entry(fei,
7285 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7288 "2.2.2.2/32 LB 1 buckets via: DROP");
7290 fib_table_entry_delete(fib_index,
7293 fib_table_entry_delete(fib_index,
7296 fib_table_entry_delete(fib_index,
7300 adj_unlock(ai_mpls_10_10_10_1);
7301 adj_unlock(ai_mpls_10_10_11_2);
7302 adj_unlock(ai_v4_10_10_11_1);
7303 adj_unlock(ai_v4_10_10_11_2);
7304 adj_unlock(ai_mpls_10_10_11_1);
7306 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
7309 local0_pfx.fp_len = 32;
7310 fib_table_entry_delete(fib_index,
7312 FIB_SOURCE_INTERFACE);
7313 local0_pfx.fp_len = 24;
7314 fib_table_entry_delete(fib_index,
7316 FIB_SOURCE_INTERFACE);
7317 local1_pfx.fp_len = 32;
7318 fib_table_entry_delete(fib_index,
7320 FIB_SOURCE_INTERFACE);
7321 local1_pfx.fp_len = 24;
7322 fib_table_entry_delete(fib_index,
7324 FIB_SOURCE_INTERFACE);
7327 * +1 for the drop LB in the MPLS tables.
7329 FIB_TEST(lb_count+1 == pool_elts(load_balance_pool),
7330 "Load-balance resources freed %d of %d",
7331 lb_count+1, pool_elts(load_balance_pool));
7336 #define N_TEST_CHILDREN 4
7337 #define PARENT_INDEX 0
7339 typedef struct fib_node_test_t_
7344 fib_node_back_walk_ctx_t *ctxs;
7348 static fib_node_test_t fib_test_nodes[N_TEST_CHILDREN+1];
7350 #define PARENT() (&fib_test_nodes[PARENT_INDEX].node)
7352 #define FOR_EACH_TEST_CHILD(_tc) \
7353 for (ii = 1, (_tc) = &fib_test_nodes[1]; \
7354 ii < N_TEST_CHILDREN+1; \
7355 ii++, (_tc) = &fib_test_nodes[ii])
7358 fib_test_child_get_node (fib_node_index_t index)
7360 return (&fib_test_nodes[index].node);
7363 static int fib_test_walk_spawns_walks;
7365 static fib_node_back_walk_rc_t
7366 fib_test_child_back_walk_notify (fib_node_t *node,
7367 fib_node_back_walk_ctx_t *ctx)
7369 fib_node_test_t *tc = (fib_node_test_t*) node;
7371 vec_add1(tc->ctxs, *ctx);
7373 if (1 == fib_test_walk_spawns_walks)
7374 fib_walk_sync(FIB_NODE_TYPE_TEST, tc->index, ctx);
7375 if (2 == fib_test_walk_spawns_walks)
7376 fib_walk_async(FIB_NODE_TYPE_TEST, tc->index,
7377 FIB_WALK_PRIORITY_HIGH, ctx);
7379 return (FIB_NODE_BACK_WALK_CONTINUE);
7383 fib_test_child_last_lock_gone (fib_node_t *node)
7385 fib_node_test_t *tc = (fib_node_test_t *)node;
7391 * The FIB walk's graph node virtual function table
7393 static const fib_node_vft_t fib_test_child_vft = {
7394 .fnv_get = fib_test_child_get_node,
7395 .fnv_last_lock = fib_test_child_last_lock_gone,
7396 .fnv_back_walk = fib_test_child_back_walk_notify,
7400 * the function (that should have been static but isn't so I can do this)
7401 * that processes the walk from the async queue,
7403 f64 fib_walk_process_queues(vlib_main_t * vm,
7405 u32 fib_walk_queue_get_size(fib_walk_priority_t prio);
7408 fib_test_walk (void)
7410 fib_node_back_walk_ctx_t high_ctx = {}, low_ctx = {};
7411 fib_node_test_t *tc;
7416 vm = vlib_get_main();
7417 fib_node_register_type(FIB_NODE_TYPE_TEST, &fib_test_child_vft);
7420 * init a fake node on which we will add children
7422 fib_node_init(&fib_test_nodes[PARENT_INDEX].node,
7423 FIB_NODE_TYPE_TEST);
7425 FOR_EACH_TEST_CHILD(tc)
7427 fib_node_init(&tc->node, FIB_NODE_TYPE_TEST);
7428 fib_node_lock(&tc->node);
7431 tc->sibling = fib_node_child_add(FIB_NODE_TYPE_TEST,
7433 FIB_NODE_TYPE_TEST, ii);
7437 * enqueue a walk across the parents children.
7439 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7441 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7442 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7443 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7444 "Parent has %d children pre-walk",
7445 fib_node_list_get_size(PARENT()->fn_children));
7448 * give the walk a large amount of time so it gets to the end
7450 fib_walk_process_queues(vm, 1);
7452 FOR_EACH_TEST_CHILD(tc)
7454 FIB_TEST(1 == vec_len(tc->ctxs),
7455 "%d child visitsed %d times",
7456 ii, vec_len(tc->ctxs));
7459 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7460 "Queue is empty post walk");
7461 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7462 "Parent has %d children post walk",
7463 fib_node_list_get_size(PARENT()->fn_children));
7466 * walk again. should be no increase in the number of visits, since
7467 * the walk will have terminated.
7469 fib_walk_process_queues(vm, 1);
7471 FOR_EACH_TEST_CHILD(tc)
7473 FIB_TEST(0 == vec_len(tc->ctxs),
7474 "%d child visitsed %d times",
7475 ii, vec_len(tc->ctxs));
7479 * schedule a low and hig priority walk. expect the high to be performed
7481 * schedule the high prio walk first so that it is further from the head
7482 * of the dependency list. that way it won't merge with the low one.
7484 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7485 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE;
7487 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7488 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7489 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7490 FIB_WALK_PRIORITY_LOW, &low_ctx);
7492 fib_walk_process_queues(vm, 1);
7494 FOR_EACH_TEST_CHILD(tc)
7496 FIB_TEST(high_ctx.fnbw_reason == tc->ctxs[0].fnbw_reason,
7497 "%d child visitsed by high prio walk", ii);
7498 FIB_TEST(low_ctx.fnbw_reason == tc->ctxs[1].fnbw_reason,
7499 "%d child visitsed by low prio walk", ii);
7502 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7503 "Queue is empty post prio walk");
7504 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7505 "Parent has %d children post prio walk",
7506 fib_node_list_get_size(PARENT()->fn_children));
7509 * schedule 2 walks of the same priority that can be megred.
7510 * expect that each child is thus visited only once.
7512 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7513 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7515 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7516 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7517 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7518 FIB_WALK_PRIORITY_HIGH, &low_ctx);
7520 fib_walk_process_queues(vm, 1);
7522 FOR_EACH_TEST_CHILD(tc)
7524 FIB_TEST(1 == vec_len(tc->ctxs),
7525 "%d child visitsed %d times during merge walk",
7526 ii, vec_len(tc->ctxs));
7529 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7530 "Queue is empty post merge walk");
7531 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7532 "Parent has %d children post merge walk",
7533 fib_node_list_get_size(PARENT()->fn_children));
7536 * schedule 2 walks of the same priority that cannot be megred.
7537 * expect that each child is thus visited twice and in the order
7538 * in which the walks were scheduled.
7540 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7541 low_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE;
7543 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7544 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7545 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7546 FIB_WALK_PRIORITY_HIGH, &low_ctx);
7548 fib_walk_process_queues(vm, 1);
7550 FOR_EACH_TEST_CHILD(tc)
7552 FIB_TEST(high_ctx.fnbw_reason == tc->ctxs[0].fnbw_reason,
7553 "%d child visitsed by high prio walk", ii);
7554 FIB_TEST(low_ctx.fnbw_reason == tc->ctxs[1].fnbw_reason,
7555 "%d child visitsed by low prio walk", ii);
7558 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7559 "Queue is empty post no-merge walk");
7560 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7561 "Parent has %d children post no-merge walk",
7562 fib_node_list_get_size(PARENT()->fn_children));
7565 * schedule a walk that makes one one child progress.
7566 * we do this by giving the queue draining process zero
7567 * time quanta. it's a do..while loop, so it does something.
7569 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7571 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7572 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7573 fib_walk_process_queues(vm, 0);
7575 FOR_EACH_TEST_CHILD(tc)
7577 if (ii == N_TEST_CHILDREN)
7579 FIB_TEST(1 == vec_len(tc->ctxs),
7580 "%d child visitsed %d times in zero quanta walk",
7581 ii, vec_len(tc->ctxs));
7585 FIB_TEST(0 == vec_len(tc->ctxs),
7586 "%d child visitsed %d times in 0 quanta walk",
7587 ii, vec_len(tc->ctxs));
7590 FIB_TEST(1 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7591 "Queue is not empty post zero quanta walk");
7592 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7593 "Parent has %d children post zero qunta walk",
7594 fib_node_list_get_size(PARENT()->fn_children));
7599 fib_walk_process_queues(vm, 0);
7601 FOR_EACH_TEST_CHILD(tc)
7603 if (ii >= N_TEST_CHILDREN-1)
7605 FIB_TEST(1 == vec_len(tc->ctxs),
7606 "%d child visitsed %d times in 2nd zero quanta walk",
7607 ii, vec_len(tc->ctxs));
7611 FIB_TEST(0 == vec_len(tc->ctxs),
7612 "%d child visitsed %d times in 2nd 0 quanta walk",
7613 ii, vec_len(tc->ctxs));
7616 FIB_TEST(1 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7617 "Queue is not empty post zero quanta walk");
7618 FIB_TEST(N_TEST_CHILDREN+1 == fib_node_list_get_size(PARENT()->fn_children),
7619 "Parent has %d children post zero qunta walk",
7620 fib_node_list_get_size(PARENT()->fn_children));
7623 * schedule another walk that will catch-up and merge.
7625 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7626 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7627 fib_walk_process_queues(vm, 1);
7629 FOR_EACH_TEST_CHILD(tc)
7631 if (ii >= N_TEST_CHILDREN-1)
7633 FIB_TEST(2 == vec_len(tc->ctxs),
7634 "%d child visitsed %d times in 2nd zero quanta merge walk",
7635 ii, vec_len(tc->ctxs));
7640 FIB_TEST(1 == vec_len(tc->ctxs),
7641 "%d child visitsed %d times in 2nd 0 quanta merge walk",
7642 ii, vec_len(tc->ctxs));
7646 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7647 "Queue is not empty post 2nd zero quanta merge walk");
7648 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7649 "Parent has %d children post 2nd zero qunta merge walk",
7650 fib_node_list_get_size(PARENT()->fn_children));
7653 * park a async walk in the middle of the list, then have an sync walk catch
7654 * it. same expectations as async catches async.
7656 high_ctx.fnbw_reason = FIB_NODE_BW_REASON_FLAG_RESOLVE;
7658 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7659 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7661 fib_walk_process_queues(vm, 0);
7662 fib_walk_process_queues(vm, 0);
7664 fib_walk_sync(FIB_NODE_TYPE_TEST, PARENT_INDEX, &high_ctx);
7666 FOR_EACH_TEST_CHILD(tc)
7668 if (ii >= N_TEST_CHILDREN-1)
7670 FIB_TEST(2 == vec_len(tc->ctxs),
7671 "%d child visitsed %d times in sync catches async walk",
7672 ii, vec_len(tc->ctxs));
7677 FIB_TEST(1 == vec_len(tc->ctxs),
7678 "%d child visitsed %d times in sync catches async walk",
7679 ii, vec_len(tc->ctxs));
7683 FIB_TEST(0 == fib_walk_queue_get_size(FIB_WALK_PRIORITY_HIGH),
7684 "Queue is not empty post 2nd zero quanta merge walk");
7685 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7686 "Parent has %d children post 2nd zero qunta merge walk",
7687 fib_node_list_get_size(PARENT()->fn_children));
7690 * make the parent a child of one of its children, thus inducing a routing loop.
7692 fib_test_nodes[PARENT_INDEX].sibling =
7693 fib_node_child_add(FIB_NODE_TYPE_TEST,
7694 1, // the first child
7699 * execute a sync walk from the parent. each child visited spawns more sync
7700 * walks. we expect the walk to terminate.
7702 fib_test_walk_spawns_walks = 1;
7704 fib_walk_sync(FIB_NODE_TYPE_TEST, PARENT_INDEX, &high_ctx);
7706 FOR_EACH_TEST_CHILD(tc)
7709 * child 1 - which is last in the list - has the loop.
7710 * the other children a re thus visitsed first. the we meet
7711 * child 1. we go round the loop again, visting the other children.
7712 * then we meet the walk in the dep list and bail. child 1 is not visitsed
7717 FIB_TEST(1 == vec_len(tc->ctxs),
7718 "child %d visitsed %d times during looped sync walk",
7719 ii, vec_len(tc->ctxs));
7723 FIB_TEST(2 == vec_len(tc->ctxs),
7724 "child %d visitsed %d times during looped sync walk",
7725 ii, vec_len(tc->ctxs));
7729 FIB_TEST(N_TEST_CHILDREN == fib_node_list_get_size(PARENT()->fn_children),
7730 "Parent has %d children post sync loop walk",
7731 fib_node_list_get_size(PARENT()->fn_children));
7734 * the walk doesn't reach the max depth because the infra knows that sync
7735 * meets sync implies a loop and bails early.
7737 FIB_TEST(high_ctx.fnbw_depth == 9,
7738 "Walk context depth %d post sync loop walk",
7739 high_ctx.fnbw_depth);
7742 * execute an async walk of the graph loop, with each child spawns sync walks
7744 high_ctx.fnbw_depth = 0;
7745 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7746 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7748 fib_walk_process_queues(vm, 1);
7750 FOR_EACH_TEST_CHILD(tc)
7753 * we don't really care how many times the children are visisted, as long as
7754 * it is more than once.
7756 FIB_TEST(1 <= vec_len(tc->ctxs),
7757 "child %d visitsed %d times during looped aync spawns sync walk",
7758 ii, vec_len(tc->ctxs));
7763 * execute an async walk of the graph loop, with each child spawns async walks
7765 fib_test_walk_spawns_walks = 2;
7766 high_ctx.fnbw_depth = 0;
7767 fib_walk_async(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7768 FIB_WALK_PRIORITY_HIGH, &high_ctx);
7770 fib_walk_process_queues(vm, 1);
7772 FOR_EACH_TEST_CHILD(tc)
7775 * we don't really care how many times the children are visisted, as long as
7776 * it is more than once.
7778 FIB_TEST(1 <= vec_len(tc->ctxs),
7779 "child %d visitsed %d times during looped async spawns async walk",
7780 ii, vec_len(tc->ctxs));
7785 fib_node_child_remove(FIB_NODE_TYPE_TEST,
7786 1, // the first child
7787 fib_test_nodes[PARENT_INDEX].sibling);
7792 FOR_EACH_TEST_CHILD(tc)
7794 fib_node_child_remove(FIB_NODE_TYPE_TEST, PARENT_INDEX,
7796 fib_node_deinit(&tc->node);
7797 fib_node_unlock(&tc->node);
7799 fib_node_deinit(PARENT());
7802 * The parent will be destroyed when the last lock on it goes.
7803 * this test ensures all the walk objects are unlocking it.
7805 FIB_TEST((1 == fib_test_nodes[PARENT_INDEX].destroyed),
7806 "Parent was destroyed");
7812 * declaration of the otherwise static callback functions
7814 void fib_bfd_notify (bfd_listen_event_e event,
7815 const bfd_session_t *session);
7816 void adj_bfd_notify (bfd_listen_event_e event,
7817 const bfd_session_t *session);
7820 * Test BFD session interaction with FIB
7825 fib_node_index_t fei;
7830 /* via 10.10.10.1 */
7831 ip46_address_t nh_10_10_10_1 = {
7832 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
7834 /* via 10.10.10.2 */
7835 ip46_address_t nh_10_10_10_2 = {
7836 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
7838 /* via 10.10.10.10 */
7839 ip46_address_t nh_10_10_10_10 = {
7840 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a0a),
7842 n_feis = fib_entry_pool_size();
7847 * add interface routes. we'll assume this works. it's tested elsewhere
7849 fib_prefix_t pfx_10_10_10_10_s_24 = {
7851 .fp_proto = FIB_PROTOCOL_IP4,
7852 .fp_addr = nh_10_10_10_10,
7855 fib_table_entry_update_one_path(0, &pfx_10_10_10_10_s_24,
7856 FIB_SOURCE_INTERFACE,
7857 (FIB_ENTRY_FLAG_CONNECTED |
7858 FIB_ENTRY_FLAG_ATTACHED),
7861 tm->hw[0]->sw_if_index,
7862 ~0, // invalid fib index
7865 FIB_ROUTE_PATH_FLAG_NONE);
7867 fib_prefix_t pfx_10_10_10_10_s_32 = {
7869 .fp_proto = FIB_PROTOCOL_IP4,
7870 .fp_addr = nh_10_10_10_10,
7872 fib_table_entry_update_one_path(0, &pfx_10_10_10_10_s_32,
7873 FIB_SOURCE_INTERFACE,
7874 (FIB_ENTRY_FLAG_CONNECTED |
7875 FIB_ENTRY_FLAG_LOCAL),
7878 tm->hw[0]->sw_if_index,
7879 ~0, // invalid fib index
7882 FIB_ROUTE_PATH_FLAG_NONE);
7885 * A BFD session via a neighbour we do not yet know
7887 bfd_session_t bfd_10_10_10_1 = {
7891 .peer_addr = nh_10_10_10_1,
7894 .hop_type = BFD_HOP_TYPE_MULTI,
7895 .local_state = BFD_STATE_init,
7898 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7901 * A new entry will be created that forwards via the adj
7903 adj_index_t ai_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
7906 tm->hw[0]->sw_if_index);
7907 fib_prefix_t pfx_10_10_10_1_s_32 = {
7908 .fp_addr = nh_10_10_10_1,
7910 .fp_proto = FIB_PROTOCOL_IP4,
7912 fib_test_lb_bucket_t adj_o_10_10_10_1 = {
7915 .adj = ai_10_10_10_1,
7919 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7920 FIB_TEST(!fib_test_validate_entry(fei,
7921 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7924 "BFD sourced %U via %U",
7925 format_fib_prefix, &pfx_10_10_10_1_s_32,
7926 format_ip_adjacency, ai_10_10_10_1, FORMAT_IP_ADJACENCY_NONE);
7929 * Delete the BFD session. Expect the fib_entry to be removed
7931 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
7933 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7934 FIB_TEST(FIB_NODE_INDEX_INVALID == fei,
7935 "BFD sourced %U removed",
7936 format_fib_prefix, &pfx_10_10_10_1_s_32);
7939 * Add the BFD source back
7941 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7944 * source the entry via the ADJ fib
7946 fei = fib_table_entry_path_add(0,
7947 &pfx_10_10_10_1_s_32,
7949 FIB_ENTRY_FLAG_ATTACHED,
7952 tm->hw[0]->sw_if_index,
7953 ~0, // invalid fib index
7956 FIB_ROUTE_PATH_FLAG_NONE);
7959 * Delete the BFD session. Expect the fib_entry to remain
7961 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
7963 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32);
7964 FIB_TEST(!fib_test_validate_entry(fei,
7965 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
7968 "BFD sourced %U remains via %U",
7969 format_fib_prefix, &pfx_10_10_10_1_s_32,
7970 format_ip_adjacency, ai_10_10_10_1, FORMAT_IP_ADJACENCY_NONE);
7973 * Add the BFD source back
7975 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
7978 * Create another ADJ FIB
7980 fib_prefix_t pfx_10_10_10_2_s_32 = {
7981 .fp_addr = nh_10_10_10_2,
7983 .fp_proto = FIB_PROTOCOL_IP4,
7985 fib_table_entry_path_add(0,
7986 &pfx_10_10_10_2_s_32,
7988 FIB_ENTRY_FLAG_ATTACHED,
7991 tm->hw[0]->sw_if_index,
7992 ~0, // invalid fib index
7995 FIB_ROUTE_PATH_FLAG_NONE);
7997 * A BFD session for the new ADJ FIB
7999 bfd_session_t bfd_10_10_10_2 = {
8003 .peer_addr = nh_10_10_10_2,
8006 .hop_type = BFD_HOP_TYPE_MULTI,
8007 .local_state = BFD_STATE_init,
8010 fib_bfd_notify (BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_2);
8013 * remove the adj-fib source whilst the session is present
8016 fib_table_entry_delete(0, &pfx_10_10_10_2_s_32, FIB_SOURCE_ADJ);
8017 fib_table_entry_path_add(0,
8018 &pfx_10_10_10_2_s_32,
8020 FIB_ENTRY_FLAG_ATTACHED,
8023 tm->hw[0]->sw_if_index,
8024 ~0, // invalid fib index
8027 FIB_ROUTE_PATH_FLAG_NONE);
8030 * Before adding a recursive via the BFD tracked ADJ-FIBs,
8031 * bring one of the sessions UP, leave the other down
8033 bfd_10_10_10_1.local_state = BFD_STATE_up;
8034 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8035 bfd_10_10_10_2.local_state = BFD_STATE_down;
8036 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
8039 * A recursive prefix via both of the ADJ FIBs
8041 fib_prefix_t pfx_200_0_0_0_s_24 = {
8042 .fp_proto = FIB_PROTOCOL_IP4,
8045 .ip4.as_u32 = clib_host_to_net_u32(0xc8000000),
8048 const dpo_id_t *dpo_10_10_10_1, *dpo_10_10_10_2;
8051 fib_entry_contribute_ip_forwarding(
8052 fib_table_lookup_exact_match(0, &pfx_10_10_10_1_s_32));
8054 fib_entry_contribute_ip_forwarding(
8055 fib_table_lookup_exact_match(0, &pfx_10_10_10_2_s_32));
8057 fib_test_lb_bucket_t lb_o_10_10_10_1 = {
8060 .lb = dpo_10_10_10_1->dpoi_index,
8063 fib_test_lb_bucket_t lb_o_10_10_10_2 = {
8066 .lb = dpo_10_10_10_2->dpoi_index,
8071 * A prefix via the adj-fib that is BFD down => DROP
8073 fei = fib_table_entry_path_add(0,
8074 &pfx_200_0_0_0_s_24,
8076 FIB_ENTRY_FLAG_NONE,
8080 0, // default fib index
8083 FIB_ROUTE_PATH_FLAG_NONE);
8084 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
8085 "%U resolves via drop",
8086 format_fib_prefix, &pfx_200_0_0_0_s_24);
8089 * add a path via the UP BFD adj-fib.
8090 * we expect that the DOWN BFD ADJ FIB is not used.
8092 fei = fib_table_entry_path_add(0,
8093 &pfx_200_0_0_0_s_24,
8095 FIB_ENTRY_FLAG_NONE,
8099 0, // default fib index
8102 FIB_ROUTE_PATH_FLAG_NONE);
8104 FIB_TEST(!fib_test_validate_entry(fei,
8105 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8108 "Recursive %U only UP BFD adj-fibs",
8109 format_fib_prefix, &pfx_200_0_0_0_s_24);
8112 * Send a BFD state change to UP - both sessions are now up
8113 * the recursive prefix should LB over both
8115 bfd_10_10_10_2.local_state = BFD_STATE_up;
8116 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
8119 FIB_TEST(!fib_test_validate_entry(fei,
8120 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8124 "Recursive %U via both UP BFD adj-fibs",
8125 format_fib_prefix, &pfx_200_0_0_0_s_24);
8128 * Send a BFD state change to DOWN
8129 * the recursive prefix should exclude the down
8131 bfd_10_10_10_2.local_state = BFD_STATE_down;
8132 fib_bfd_notify (BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_2);
8135 FIB_TEST(!fib_test_validate_entry(fei,
8136 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8139 "Recursive %U via only UP",
8140 format_fib_prefix, &pfx_200_0_0_0_s_24);
8143 * Delete the BFD session while it is in the DOWN state.
8144 * FIB should consider the entry's state as back up
8146 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_2);
8148 FIB_TEST(!fib_test_validate_entry(fei,
8149 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8153 "Recursive %U via both UP BFD adj-fibs post down session delete",
8154 format_fib_prefix, &pfx_200_0_0_0_s_24);
8157 * Delete the BFD other session while it is in the UP state.
8159 fib_bfd_notify (BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
8161 FIB_TEST(!fib_test_validate_entry(fei,
8162 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8166 "Recursive %U via both UP BFD adj-fibs post up session delete",
8167 format_fib_prefix, &pfx_200_0_0_0_s_24);
8172 fib_table_entry_delete(0, &pfx_200_0_0_0_s_24, FIB_SOURCE_API);
8173 fib_table_entry_delete(0, &pfx_10_10_10_1_s_32, FIB_SOURCE_ADJ);
8174 fib_table_entry_delete(0, &pfx_10_10_10_2_s_32, FIB_SOURCE_ADJ);
8176 fib_table_entry_delete(0, &pfx_10_10_10_10_s_32, FIB_SOURCE_INTERFACE);
8177 fib_table_entry_delete(0, &pfx_10_10_10_10_s_24, FIB_SOURCE_INTERFACE);
8179 adj_unlock(ai_10_10_10_1);
8181 * test no-one left behind
8183 FIB_TEST((n_feis == fib_entry_pool_size()), "Entries gone");
8184 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
8187 * Single-hop BFD tests
8189 bfd_10_10_10_1.hop_type = BFD_HOP_TYPE_SINGLE;
8190 bfd_10_10_10_1.udp.key.sw_if_index = tm->hw[0]->sw_if_index;
8192 adj_bfd_notify(BFD_LISTEN_EVENT_CREATE, &bfd_10_10_10_1);
8194 ai_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8197 tm->hw[0]->sw_if_index);
8199 * whilst the BFD session is not signalled, the adj is up
8201 FIB_TEST(!adj_is_up(ai_10_10_10_1), "Adj state down on uninit session");
8204 * bring the BFD session up
8206 bfd_10_10_10_1.local_state = BFD_STATE_up;
8207 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8208 FIB_TEST(adj_is_up(ai_10_10_10_1), "Adj state up on UP session");
8211 * bring the BFD session down
8213 bfd_10_10_10_1.local_state = BFD_STATE_down;
8214 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8215 FIB_TEST(!adj_is_up(ai_10_10_10_1), "Adj state down on DOWN session");
8218 * add an attached next hop FIB entry via the down adj
8220 fib_prefix_t pfx_5_5_5_5_s_32 = {
8223 .as_u32 = clib_host_to_net_u32(0x05050505),
8227 .fp_proto = FIB_PROTOCOL_IP4,
8230 fei = fib_table_entry_path_add(0,
8233 FIB_ENTRY_FLAG_NONE,
8236 tm->hw[0]->sw_if_index,
8237 ~0, // invalid fib index
8240 FIB_ROUTE_PATH_FLAG_NONE);
8241 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
8242 "%U resolves via drop",
8243 format_fib_prefix, &pfx_5_5_5_5_s_32);
8246 * Add a path via an ADJ that is up
8248 adj_index_t ai_10_10_10_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8251 tm->hw[0]->sw_if_index);
8253 fib_test_lb_bucket_t adj_o_10_10_10_2 = {
8256 .adj = ai_10_10_10_2,
8259 adj_o_10_10_10_1.adj.adj = ai_10_10_10_1;
8261 fei = fib_table_entry_path_add(0,
8264 FIB_ENTRY_FLAG_NONE,
8267 tm->hw[0]->sw_if_index,
8268 ~0, // invalid fib index
8271 FIB_ROUTE_PATH_FLAG_NONE);
8273 FIB_TEST(!fib_test_validate_entry(fei,
8274 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8277 "BFD sourced %U via %U",
8278 format_fib_prefix, &pfx_5_5_5_5_s_32,
8279 format_ip_adjacency, ai_10_10_10_2, FORMAT_IP_ADJACENCY_NONE);
8282 * Bring up the down session - should now LB
8284 bfd_10_10_10_1.local_state = BFD_STATE_up;
8285 adj_bfd_notify(BFD_LISTEN_EVENT_UPDATE, &bfd_10_10_10_1);
8286 FIB_TEST(!fib_test_validate_entry(fei,
8287 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8291 "BFD sourced %U via noth adjs",
8292 format_fib_prefix, &pfx_5_5_5_5_s_32);
8295 * remove the BFD session state from the adj
8297 adj_bfd_notify(BFD_LISTEN_EVENT_DELETE, &bfd_10_10_10_1);
8302 fib_table_entry_delete(0, &pfx_5_5_5_5_s_32, FIB_SOURCE_CLI);
8303 adj_unlock(ai_10_10_10_1);
8304 adj_unlock(ai_10_10_10_2);
8307 * test no-one left behind
8309 FIB_TEST((n_feis == fib_entry_pool_size()), "Entries gone");
8310 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
8318 const mpls_label_t deag_label = 50;
8319 adj_index_t ai_mpls_10_10_10_1;
8320 dpo_id_t dpo = DPO_INVALID;
8321 const u32 lfib_index = 0;
8322 const u32 fib_index = 0;
8323 const dpo_id_t *dpo1;
8324 fib_node_index_t lfe;
8331 lb_count = pool_elts(load_balance_pool);
8333 FIB_TEST((0 == adj_nbr_db_size()), "ADJ DB size is %d",
8337 * MPLS enable an interface so we get the MPLS table created
8339 mpls_table_create(MPLS_FIB_DEFAULT_TABLE_ID, FIB_SOURCE_API, NULL);
8340 mpls_sw_interface_enable_disable(&mpls_main,
8341 tm->hw[0]->sw_if_index,
8344 ip46_address_t nh_10_10_10_1 = {
8345 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
8347 ai_mpls_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
8350 tm->hw[0]->sw_if_index);
8353 * Test the specials stack properly.
8355 fib_prefix_t exp_null_v6_pfx = {
8356 .fp_proto = FIB_PROTOCOL_MPLS,
8358 .fp_label = MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL,
8359 .fp_payload_proto = DPO_PROTO_IP6,
8361 lfe = fib_table_lookup(lfib_index, &exp_null_v6_pfx);
8362 FIB_TEST((FIB_NODE_INDEX_INVALID != lfe),
8364 format_mpls_unicast_label, MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL,
8365 format_mpls_eos_bit, MPLS_EOS);
8366 fib_entry_contribute_forwarding(lfe,
8367 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8369 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8370 lkd = lookup_dpo_get(dpo1->dpoi_index);
8372 FIB_TEST((fib_index == lkd->lkd_fib_index),
8373 "%U/%U is deag in %d %U",
8374 format_mpls_unicast_label, deag_label,
8375 format_mpls_eos_bit, MPLS_EOS,
8377 format_dpo_id, &dpo, 0);
8378 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8379 "%U/%U is dst deag",
8380 format_mpls_unicast_label, deag_label,
8381 format_mpls_eos_bit, MPLS_EOS);
8382 FIB_TEST((LOOKUP_TABLE_FROM_INPUT_INTERFACE == lkd->lkd_table),
8383 "%U/%U is lookup in interface's table",
8384 format_mpls_unicast_label, deag_label,
8385 format_mpls_eos_bit, MPLS_EOS);
8386 FIB_TEST((DPO_PROTO_IP6 == lkd->lkd_proto),
8387 "%U/%U is %U dst deag",
8388 format_mpls_unicast_label, deag_label,
8389 format_mpls_eos_bit, MPLS_EOS,
8390 format_dpo_proto, lkd->lkd_proto);
8393 * A route deag route for EOS
8395 fib_prefix_t pfx = {
8396 .fp_proto = FIB_PROTOCOL_MPLS,
8398 .fp_label = deag_label,
8399 .fp_payload_proto = DPO_PROTO_IP4,
8401 mpls_disp_dpo_t *mdd;
8402 lfe = fib_table_entry_path_add(lfib_index,
8405 FIB_ENTRY_FLAG_NONE,
8412 FIB_ROUTE_PATH_FLAG_NONE);
8414 FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
8416 format_mpls_unicast_label, deag_label,
8417 format_mpls_eos_bit, MPLS_EOS);
8419 fib_entry_contribute_forwarding(lfe,
8420 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8422 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8423 mdd = mpls_disp_dpo_get(dpo1->dpoi_index);
8425 FIB_TEST((FIB_MPLS_LSP_MODE_PIPE == mdd->mdd_mode),
8426 "%U/%U disp is pipe mode",
8427 format_mpls_unicast_label, deag_label,
8428 format_mpls_eos_bit, MPLS_EOS);
8430 lkd = lookup_dpo_get(mdd->mdd_dpo.dpoi_index);
8432 FIB_TEST((fib_index == lkd->lkd_fib_index),
8433 "%U/%U is deag in %d %U",
8434 format_mpls_unicast_label, deag_label,
8435 format_mpls_eos_bit, MPLS_EOS,
8437 format_dpo_id, &dpo, 0);
8438 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8439 "%U/%U is dst deag",
8440 format_mpls_unicast_label, deag_label,
8441 format_mpls_eos_bit, MPLS_EOS);
8442 FIB_TEST((DPO_PROTO_IP4 == lkd->lkd_proto),
8443 "%U/%U is %U dst deag",
8444 format_mpls_unicast_label, deag_label,
8445 format_mpls_eos_bit, MPLS_EOS,
8446 format_dpo_proto, lkd->lkd_proto);
8448 fib_table_entry_delete_index(lfe, FIB_SOURCE_CLI);
8450 FIB_TEST((FIB_NODE_INDEX_INVALID == fib_table_lookup(lfib_index,
8452 "%U/%U not present",
8453 format_mpls_unicast_label, deag_label,
8454 format_mpls_eos_bit, MPLS_EOS);
8458 * A route deag route for EOS with LSP mode uniform
8460 fib_mpls_label_t *l_pops = NULL, l_pop = {
8461 .fml_value = MPLS_LABEL_POP,
8462 .fml_mode = FIB_MPLS_LSP_MODE_UNIFORM,
8464 vec_add1(l_pops, l_pop);
8465 lfe = fib_table_entry_path_add(lfib_index,
8468 FIB_ENTRY_FLAG_NONE,
8475 FIB_ROUTE_PATH_FLAG_NONE);
8477 FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
8479 format_mpls_unicast_label, deag_label,
8480 format_mpls_eos_bit, MPLS_EOS);
8482 fib_entry_contribute_forwarding(lfe,
8483 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8485 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8486 mdd = mpls_disp_dpo_get(dpo1->dpoi_index);
8488 FIB_TEST((FIB_MPLS_LSP_MODE_UNIFORM == mdd->mdd_mode),
8489 "%U/%U disp is uniform mode",
8490 format_mpls_unicast_label, deag_label,
8491 format_mpls_eos_bit, MPLS_EOS);
8493 lkd = lookup_dpo_get(mdd->mdd_dpo.dpoi_index);
8495 FIB_TEST((fib_index == lkd->lkd_fib_index),
8496 "%U/%U is deag in %d %U",
8497 format_mpls_unicast_label, deag_label,
8498 format_mpls_eos_bit, MPLS_EOS,
8500 format_dpo_id, &dpo, 0);
8501 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8502 "%U/%U is dst deag",
8503 format_mpls_unicast_label, deag_label,
8504 format_mpls_eos_bit, MPLS_EOS);
8505 FIB_TEST((DPO_PROTO_IP4 == lkd->lkd_proto),
8506 "%U/%U is %U dst deag",
8507 format_mpls_unicast_label, deag_label,
8508 format_mpls_eos_bit, MPLS_EOS,
8509 format_dpo_proto, lkd->lkd_proto);
8511 fib_table_entry_delete_index(lfe, FIB_SOURCE_CLI);
8513 FIB_TEST((FIB_NODE_INDEX_INVALID == fib_table_lookup(lfib_index,
8515 "%U/%U not present",
8516 format_mpls_unicast_label, deag_label,
8517 format_mpls_eos_bit, MPLS_EOS);
8521 * A route deag route for non-EOS
8523 pfx.fp_eos = MPLS_NON_EOS;
8524 lfe = fib_table_entry_path_add(lfib_index,
8527 FIB_ENTRY_FLAG_NONE,
8534 FIB_ROUTE_PATH_FLAG_NONE);
8536 FIB_TEST((lfe == fib_table_lookup(lfib_index, &pfx)),
8538 format_mpls_unicast_label, deag_label,
8539 format_mpls_eos_bit, MPLS_NON_EOS);
8541 fib_entry_contribute_forwarding(lfe,
8542 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8544 dpo1 = load_balance_get_bucket(dpo.dpoi_index, 0);
8545 lkd = lookup_dpo_get(dpo1->dpoi_index);
8547 FIB_TEST((fib_index == lkd->lkd_fib_index),
8548 "%U/%U is deag in %d %U",
8549 format_mpls_unicast_label, deag_label,
8550 format_mpls_eos_bit, MPLS_NON_EOS,
8552 format_dpo_id, &dpo, 0);
8553 FIB_TEST((LOOKUP_INPUT_DST_ADDR == lkd->lkd_input),
8554 "%U/%U is dst deag",
8555 format_mpls_unicast_label, deag_label,
8556 format_mpls_eos_bit, MPLS_NON_EOS);
8558 FIB_TEST((DPO_PROTO_MPLS == lkd->lkd_proto),
8559 "%U/%U is %U dst deag",
8560 format_mpls_unicast_label, deag_label,
8561 format_mpls_eos_bit, MPLS_NON_EOS,
8562 format_dpo_proto, lkd->lkd_proto);
8564 fib_table_entry_delete_index(lfe, FIB_SOURCE_CLI);
8566 FIB_TEST((FIB_NODE_INDEX_INVALID == fib_table_lookup(lfib_index,
8568 "%U/%U not present",
8569 format_mpls_unicast_label, deag_label,
8570 format_mpls_eos_bit, MPLS_EOS);
8577 fib_prefix_t pfx_1200 = {
8579 .fp_proto = FIB_PROTOCOL_MPLS,
8581 .fp_eos = MPLS_NON_EOS,
8583 fib_test_lb_bucket_t neos_o_10_10_10_1 = {
8584 .type = FT_LB_LABEL_STACK_O_ADJ,
8585 .label_stack_o_adj = {
8586 .adj = ai_mpls_10_10_10_1,
8587 .label_stack_size = 4,
8591 .eos = MPLS_NON_EOS,
8594 dpo_id_t neos_1200 = DPO_INVALID;
8595 dpo_id_t ip_1200 = DPO_INVALID;
8596 fib_mpls_label_t *l200 = NULL;
8598 for (ii = 0; ii < 4; ii++)
8600 fib_mpls_label_t fml = {
8601 .fml_value = 200 + (ii * 100),
8603 vec_add1(l200, fml);
8606 lfe = fib_table_entry_update_one_path(fib_index,
8609 FIB_ENTRY_FLAG_NONE,
8612 tm->hw[0]->sw_if_index,
8613 ~0, // invalid fib index
8616 FIB_ROUTE_PATH_FLAG_NONE);
8618 FIB_TEST(!fib_test_validate_entry(lfe,
8619 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8621 &neos_o_10_10_10_1),
8622 "1200/0 LB 1 buckets via: "
8626 * A recursive route via the MPLS x-connect
8628 fib_prefix_t pfx_2_2_2_3_s_32 = {
8630 .fp_proto = FIB_PROTOCOL_IP4,
8632 .ip4.as_u32 = clib_host_to_net_u32(0x02020203),
8635 fib_route_path_t *rpaths = NULL, rpath = {
8636 .frp_proto = DPO_PROTO_MPLS,
8637 .frp_local_label = 1200,
8638 .frp_eos = MPLS_NON_EOS,
8639 .frp_sw_if_index = ~0, // recurive
8640 .frp_fib_index = 0, // Default MPLS fib
8642 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
8643 .frp_label_stack = NULL,
8645 vec_add1(rpaths, rpath);
8647 fib_table_entry_path_add2(fib_index,
8650 FIB_ENTRY_FLAG_NONE,
8654 * A labelled recursive route via the MPLS x-connect
8656 fib_prefix_t pfx_2_2_2_4_s_32 = {
8658 .fp_proto = FIB_PROTOCOL_IP4,
8660 .ip4.as_u32 = clib_host_to_net_u32(0x02020204),
8663 fib_mpls_label_t *l999 = NULL, fml_999 = {
8666 vec_add1(l999, fml_999);
8667 rpaths[0].frp_label_stack = l999,
8669 fib_table_entry_path_add2(fib_index,
8672 FIB_ENTRY_FLAG_NONE,
8675 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8676 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8678 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8679 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8682 fib_test_lb_bucket_t ip_o_1200 = {
8685 .lb = ip_1200.dpoi_index,
8688 fib_test_lb_bucket_t mpls_o_1200 = {
8689 .type = FT_LB_LABEL_O_LB,
8691 .lb = neos_1200.dpoi_index,
8697 lfe = fib_table_lookup(fib_index, &pfx_2_2_2_3_s_32);
8698 FIB_TEST(!fib_test_validate_entry(lfe,
8699 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8702 "2.2.2.2.3/32 LB 1 buckets via: label 1200 EOS");
8703 lfe = fib_table_lookup(fib_index, &pfx_2_2_2_4_s_32);
8704 FIB_TEST(!fib_test_validate_entry(lfe,
8705 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8708 "2.2.2.2.4/32 LB 1 buckets via: label 1200 non-EOS");
8710 fib_table_entry_delete(fib_index, &pfx_1200, FIB_SOURCE_API);
8711 fib_table_entry_delete(fib_index, &pfx_2_2_2_3_s_32, FIB_SOURCE_API);
8712 fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
8714 dpo_reset(&neos_1200);
8715 dpo_reset(&ip_1200);
8718 * A recursive via a label that does not exist
8720 fib_test_lb_bucket_t bucket_drop = {
8723 .adj = DPO_PROTO_IP4,
8726 fib_test_lb_bucket_t mpls_bucket_drop = {
8729 .adj = DPO_PROTO_MPLS,
8733 rpaths[0].frp_label_stack = NULL;
8734 lfe = fib_table_entry_path_add2(fib_index,
8737 FIB_ENTRY_FLAG_NONE,
8740 fib_entry_contribute_forwarding(fib_table_lookup(fib_index, &pfx_1200),
8741 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8743 ip_o_1200.lb.lb = ip_1200.dpoi_index;
8745 FIB_TEST(!fib_test_validate_entry(lfe,
8746 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8749 "2.2.2.2.4/32 LB 1 buckets via: drop");
8750 lfe = fib_table_lookup(fib_index, &pfx_1200);
8751 FIB_TEST(!fib_test_validate_entry(lfe,
8752 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
8755 "1200/neos LB 1 buckets via: ip4-DROP");
8756 FIB_TEST(!fib_test_validate_entry(lfe,
8757 FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS,
8760 "1200/neos LB 1 buckets via: mpls-DROP");
8762 fib_table_entry_delete(fib_index, &pfx_2_2_2_4_s_32, FIB_SOURCE_API);
8764 dpo_reset(&ip_1200);
8767 * An rx-interface route.
8768 * like the tail of an mcast LSP
8770 dpo_id_t idpo = DPO_INVALID;
8772 interface_rx_dpo_add_or_lock(DPO_PROTO_IP4,
8773 tm->hw[0]->sw_if_index,
8776 fib_prefix_t pfx_2500 = {
8778 .fp_proto = FIB_PROTOCOL_MPLS,
8781 .fp_payload_proto = DPO_PROTO_IP4,
8783 fib_test_lb_bucket_t rx_intf_0 = {
8786 .adj = idpo.dpoi_index,
8790 lfe = fib_table_entry_update_one_path(fib_index,
8793 FIB_ENTRY_FLAG_NONE,
8796 tm->hw[0]->sw_if_index,
8797 ~0, // invalid fib index
8800 FIB_ROUTE_PATH_INTF_RX);
8801 FIB_TEST(!fib_test_validate_entry(lfe,
8802 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8805 "2500 rx-interface 0");
8806 fib_table_entry_delete(fib_index, &pfx_2500, FIB_SOURCE_API);
8809 * An MPLS mulicast entry
8811 fib_prefix_t pfx_3500 = {
8813 .fp_proto = FIB_PROTOCOL_MPLS,
8816 .fp_payload_proto = DPO_PROTO_IP4,
8818 fib_test_rep_bucket_t mc_0 = {
8819 .type = FT_REP_LABEL_O_ADJ,
8821 .adj = ai_mpls_10_10_10_1,
8826 fib_test_rep_bucket_t mc_intf_0 = {
8827 .type = FT_REP_INTF,
8829 .adj = idpo.dpoi_index,
8832 fib_mpls_label_t *l3300 = NULL, fml_3300 = {
8835 vec_add1(l3300, fml_3300);
8837 lfe = fib_table_entry_update_one_path(lfib_index,
8840 FIB_ENTRY_FLAG_MULTICAST,
8843 tm->hw[0]->sw_if_index,
8844 ~0, // invalid fib index
8847 FIB_ROUTE_PATH_FLAG_NONE);
8848 FIB_TEST(!fib_test_validate_entry(lfe,
8849 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8852 "3500 via replicate over 10.10.10.1");
8855 * MPLS Bud-node. Add a replication via an interface-receieve path
8857 lfe = fib_table_entry_path_add(lfib_index,
8860 FIB_ENTRY_FLAG_MULTICAST,
8863 tm->hw[0]->sw_if_index,
8864 ~0, // invalid fib index
8867 FIB_ROUTE_PATH_INTF_RX);
8868 FIB_TEST(!fib_test_validate_entry(lfe,
8869 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8873 "3500 via replicate over 10.10.10.1 and interface-rx");
8876 * Add a replication via an interface-free for-us path
8878 fib_test_rep_bucket_t mc_disp = {
8879 .type = FT_REP_DISP_MFIB_LOOKUP,
8881 .adj = idpo.dpoi_index,
8884 lfe = fib_table_entry_path_add(lfib_index,
8887 FIB_ENTRY_FLAG_MULTICAST,
8894 FIB_ROUTE_PATH_RPF_ID);
8895 FIB_TEST(!fib_test_validate_entry(lfe,
8896 FIB_FORW_CHAIN_TYPE_MPLS_EOS,
8901 "3500 via replicate over 10.10.10.1 and interface-rx");
8905 fib_table_entry_delete(fib_index, &pfx_3500, FIB_SOURCE_API);
8911 mpls_sw_interface_enable_disable(&mpls_main,
8912 tm->hw[0]->sw_if_index,
8914 mpls_table_delete(MPLS_FIB_DEFAULT_TABLE_ID, FIB_SOURCE_API);
8916 FIB_TEST(0 == pool_elts(mpls_disp_dpo_pool),
8917 "mpls_disp_dpo resources freed %d of %d",
8918 0, pool_elts(mpls_disp_dpo_pool));
8919 FIB_TEST(lb_count == pool_elts(load_balance_pool),
8920 "Load-balance resources freed %d of %d",
8921 lb_count, pool_elts(load_balance_pool));
8922 FIB_TEST(0 == pool_elts(interface_rx_dpo_pool),
8923 "interface_rx_dpo resources freed %d of %d",
8924 0, pool_elts(interface_rx_dpo_pool));
8930 fib_test_inherit (void)
8932 fib_node_index_t fei;
8937 n_feis = fib_entry_pool_size();
8940 const ip46_address_t nh_10_10_10_1 = {
8941 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a01),
8943 const ip46_address_t nh_10_10_10_2 = {
8944 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a02),
8946 const ip46_address_t nh_10_10_10_3 = {
8947 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a03),
8949 const ip46_address_t nh_10_10_10_16 = {
8950 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a10),
8952 const ip46_address_t nh_10_10_10_20 = {
8953 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a14),
8955 const ip46_address_t nh_10_10_10_21 = {
8956 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a15),
8958 const ip46_address_t nh_10_10_10_22 = {
8959 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a16),
8961 const ip46_address_t nh_10_10_10_255 = {
8962 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0aff),
8964 const ip46_address_t nh_10_10_10_0 = {
8965 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0a00),
8967 const ip46_address_t nh_10_10_0_0 = {
8968 .ip4.as_u32 = clib_host_to_net_u32(0x0a0a0000),
8970 const ip46_address_t nh_11_11_11_11 = {
8971 .ip4.as_u32 = clib_host_to_net_u32(0x0b0b0b0b),
8973 const ip46_address_t nh_11_11_11_0 = {
8974 .ip4.as_u32 = clib_host_to_net_u32(0x0b0b0b00),
8978 * prefixes at the base of a sub-tree
8980 const fib_prefix_t pfx_10_10_10_21_s_32 = {
8982 .fp_proto = FIB_PROTOCOL_IP4,
8983 .fp_addr = nh_10_10_10_21,
8985 const fib_prefix_t pfx_10_10_10_22_s_32 = {
8987 .fp_proto = FIB_PROTOCOL_IP4,
8988 .fp_addr = nh_10_10_10_22,
8990 const fib_prefix_t pfx_10_10_10_255_s_32 = {
8992 .fp_proto = FIB_PROTOCOL_IP4,
8993 .fp_addr = nh_10_10_10_255,
8995 const u32 N_PLS = fib_path_list_pool_size();
8997 fib_table_entry_special_add(0,
8998 &pfx_10_10_10_21_s_32,
9000 FIB_ENTRY_FLAG_DROP);
9001 fib_table_entry_special_add(0,
9002 &pfx_10_10_10_22_s_32,
9004 FIB_ENTRY_FLAG_DROP);
9005 fib_table_entry_special_add(0,
9006 &pfx_10_10_10_255_s_32,
9008 FIB_ENTRY_FLAG_DROP);
9011 * source an entry that pushes its state down the sub-tree
9013 const fib_prefix_t pfx_10_10_10_16_s_28 = {
9015 .fp_proto = FIB_PROTOCOL_IP4,
9016 .fp_addr = nh_10_10_10_16,
9018 fib_table_entry_update_one_path(0,
9019 &pfx_10_10_10_16_s_28,
9021 FIB_ENTRY_FLAG_COVERED_INHERIT,
9024 tm->hw[0]->sw_if_index,
9028 FIB_ROUTE_PATH_FLAG_NONE);
9031 * this covering entry and all those below it should have
9032 * the same forwarding information.
9034 adj_index_t ai_10_10_10_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
9037 tm->hw[0]->sw_if_index);
9038 fib_test_lb_bucket_t adj_o_10_10_10_1 = {
9041 .adj = ai_10_10_10_1,
9045 fei = fib_table_lookup(0, &pfx_10_10_10_16_s_28);
9046 FIB_TEST(!fib_test_validate_entry(fei,
9047 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9050 "%U via 10.10.10.1",
9051 format_fib_prefix, &pfx_10_10_10_16_s_28);
9052 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9053 FIB_TEST(!fib_test_validate_entry(fei,
9054 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9057 "%U via 10.10.10.1",
9058 format_fib_prefix, &pfx_10_10_10_21_s_32);
9059 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9060 FIB_TEST(!fib_test_validate_entry(fei,
9061 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9064 "%U via 10.10.10.1",
9065 format_fib_prefix, &pfx_10_10_10_22_s_32);
9066 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9067 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9068 "%U resolves via drop",
9069 format_fib_prefix, &pfx_10_10_10_255_s_32);
9072 * remove the inherting cover - covereds go back to drop
9074 fib_table_entry_delete(0, &pfx_10_10_10_16_s_28, FIB_SOURCE_API);
9076 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9077 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9078 "%U resolves via drop",
9079 format_fib_prefix, &pfx_10_10_10_21_s_32);
9082 * source an entry that pushes its state down the sub-tree
9084 const fib_prefix_t pfx_10_10_10_0_s_24 = {
9086 .fp_proto = FIB_PROTOCOL_IP4,
9087 .fp_addr = nh_10_10_10_0,
9089 fib_table_entry_update_one_path(0,
9090 &pfx_10_10_10_0_s_24,
9092 FIB_ENTRY_FLAG_COVERED_INHERIT,
9095 tm->hw[0]->sw_if_index,
9099 FIB_ROUTE_PATH_FLAG_NONE);
9102 * whole sub-tree now covered
9104 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9105 FIB_TEST(!fib_test_validate_entry(fei,
9106 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9109 "%U via 10.10.10.1",
9110 format_fib_prefix, &pfx_10_10_10_0_s_24);
9111 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9112 FIB_TEST(!fib_test_validate_entry(fei,
9113 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9116 "%U via 10.10.10.1",
9117 format_fib_prefix, &pfx_10_10_10_21_s_32);
9118 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9119 FIB_TEST(!fib_test_validate_entry(fei,
9120 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9123 "%U via 10.10.10.1",
9124 format_fib_prefix, &pfx_10_10_10_22_s_32);
9125 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9126 FIB_TEST(!fib_test_validate_entry(fei,
9127 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9130 "%U via 10.10.10.1",
9131 format_fib_prefix, &pfx_10_10_10_255_s_32);
9134 * insert a more specific into the sub-tree - expect inheritance
9135 * this one is directly covered by the root
9137 fib_table_entry_special_add(0,
9138 &pfx_10_10_10_16_s_28,
9140 FIB_ENTRY_FLAG_DROP);
9141 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_16_s_28);
9142 FIB_TEST(!fib_test_validate_entry(fei,
9143 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9146 "%U via 10.10.10.1",
9147 format_fib_prefix, &pfx_10_10_10_16_s_28);
9150 * insert a more specific into the sub-tree - expect inheritance
9151 * this one is indirectly covered by the root
9153 const fib_prefix_t pfx_10_10_10_20_s_30 = {
9155 .fp_proto = FIB_PROTOCOL_IP4,
9156 .fp_addr = nh_10_10_10_20,
9158 fib_table_entry_special_add(0,
9159 &pfx_10_10_10_20_s_30,
9161 FIB_ENTRY_FLAG_DROP);
9162 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_20_s_30);
9163 FIB_TEST(!fib_test_validate_entry(fei,
9164 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9167 "%U via 10.10.10.1",
9168 format_fib_prefix, &pfx_10_10_10_20_s_30);
9171 * remove the prefix from the middle of the sub-tree
9172 * the inherited source will be the only one remaining - expect
9173 * it to be withdrawn and hence the prefix is removed.
9175 fib_table_entry_special_remove(0,
9176 &pfx_10_10_10_20_s_30,
9178 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_20_s_30);
9179 FIB_TEST((FIB_NODE_INDEX_INVALID == fei),
9181 format_fib_prefix, &pfx_10_10_10_20_s_30);
9184 * inheriting source is modifed - expect the modification to be present
9185 * throughout the sub-tree
9187 adj_index_t ai_10_10_10_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
9190 tm->hw[0]->sw_if_index);
9191 fib_test_lb_bucket_t adj_o_10_10_10_2 = {
9194 .adj = ai_10_10_10_2,
9198 fib_table_entry_update_one_path(0,
9199 &pfx_10_10_10_0_s_24,
9201 FIB_ENTRY_FLAG_COVERED_INHERIT,
9204 tm->hw[0]->sw_if_index,
9208 FIB_ROUTE_PATH_FLAG_NONE);
9209 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9210 FIB_TEST(!fib_test_validate_entry(fei,
9211 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9214 "%U via 10.10.10.2",
9215 format_fib_prefix, &pfx_10_10_10_21_s_32);
9216 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9217 FIB_TEST(!fib_test_validate_entry(fei,
9218 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9221 "%U via 10.10.10.2",
9222 format_fib_prefix, &pfx_10_10_10_22_s_32);
9223 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9224 FIB_TEST(!fib_test_validate_entry(fei,
9225 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9228 "%U via 10.10.10.2",
9229 format_fib_prefix, &pfx_10_10_10_255_s_32);
9230 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9231 FIB_TEST(!fib_test_validate_entry(fei,
9232 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9235 "%U via 10.10.10.2",
9236 format_fib_prefix, &pfx_10_10_10_0_s_24);
9239 * add the source that replaces inherited state.
9240 * inheriting source is not the best, so it doesn't push state.
9242 fib_table_entry_update_one_path(0,
9243 &pfx_10_10_10_0_s_24,
9244 FIB_SOURCE_PLUGIN_HI,
9245 FIB_ENTRY_FLAG_NONE,
9248 tm->hw[0]->sw_if_index,
9252 FIB_ROUTE_PATH_FLAG_NONE);
9253 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9254 FIB_TEST(!fib_test_validate_entry(fei,
9255 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9258 "%U via 10.10.10.1",
9259 format_fib_prefix, &pfx_10_10_10_0_s_24);
9261 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9262 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9263 "%U resolves via drop",
9264 format_fib_prefix, &pfx_10_10_10_21_s_32);
9265 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9266 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9267 "%U resolves via drop",
9268 format_fib_prefix, &pfx_10_10_10_22_s_32);
9269 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9270 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9271 "%U resolves via drop",
9272 format_fib_prefix, &pfx_10_10_10_255_s_32);
9273 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_16_s_28);
9274 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
9275 "%U resolves via drop",
9276 format_fib_prefix, &pfx_10_10_10_16_s_28);
9279 * withdraw the higher priority source and expect the inherited to return
9280 * throughout the sub-tree
9282 fib_table_entry_delete(0, &pfx_10_10_10_0_s_24, FIB_SOURCE_PLUGIN_HI);
9284 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9285 FIB_TEST(!fib_test_validate_entry(fei,
9286 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9289 "%U via 10.10.10.2",
9290 format_fib_prefix, &pfx_10_10_10_21_s_32);
9291 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9292 FIB_TEST(!fib_test_validate_entry(fei,
9293 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9296 "%U via 10.10.10.2",
9297 format_fib_prefix, &pfx_10_10_10_22_s_32);
9298 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9299 FIB_TEST(!fib_test_validate_entry(fei,
9300 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9303 "%U via 10.10.10.2",
9304 format_fib_prefix, &pfx_10_10_10_255_s_32);
9305 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9306 FIB_TEST(!fib_test_validate_entry(fei,
9307 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9310 "%U via 10.10.10.2",
9311 format_fib_prefix, &pfx_10_10_10_0_s_24);
9312 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_16_s_28);
9313 FIB_TEST(!fib_test_validate_entry(fei,
9314 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9317 "%U via 10.10.10.2",
9318 format_fib_prefix, &pfx_10_10_10_16_s_28);
9321 * source a covered entry in the sub-tree with the same inherting source
9322 * - expect that it now owns the sub-tree and thus over-rides its cover
9324 fib_table_entry_update_one_path(0,
9325 &pfx_10_10_10_16_s_28,
9327 FIB_ENTRY_FLAG_COVERED_INHERIT,
9330 tm->hw[0]->sw_if_index,
9334 FIB_ROUTE_PATH_FLAG_NONE);
9335 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_16_s_28);
9336 FIB_TEST(!fib_test_validate_entry(fei,
9337 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9340 "%U via 10.10.10.1",
9341 format_fib_prefix, &pfx_10_10_10_16_s_28);
9342 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9343 FIB_TEST(!fib_test_validate_entry(fei,
9344 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9347 "%U via 10.10.10.2",
9348 format_fib_prefix, &pfx_10_10_10_22_s_32);
9349 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9350 FIB_TEST(!fib_test_validate_entry(fei,
9351 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9354 "%U via 10.10.10.2",
9355 format_fib_prefix, &pfx_10_10_10_21_s_32);
9357 /* these two unaffected by the sub-tree change */
9358 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9359 FIB_TEST(!fib_test_validate_entry(fei,
9360 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9363 "%U via 10.10.10.2",
9364 format_fib_prefix, &pfx_10_10_10_255_s_32);
9365 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9366 FIB_TEST(!fib_test_validate_entry(fei,
9367 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9370 "%U via 10.10.10.2",
9371 format_fib_prefix, &pfx_10_10_10_0_s_24);
9374 * removes the more specific, expect the /24 to now re-owns the sub-tree
9376 fib_table_entry_delete(0, &pfx_10_10_10_16_s_28, FIB_SOURCE_API);
9378 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9379 FIB_TEST(!fib_test_validate_entry(fei,
9380 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9383 "%U via 10.10.10.2",
9384 format_fib_prefix, &pfx_10_10_10_16_s_28);
9385 FIB_TEST(!fib_test_validate_entry(fei,
9386 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9389 "%U via 10.10.10.2",
9390 format_fib_prefix, &pfx_10_10_10_21_s_32);
9391 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9392 FIB_TEST(!fib_test_validate_entry(fei,
9393 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9396 "%U via 10.10.10.2",
9397 format_fib_prefix, &pfx_10_10_10_22_s_32);
9398 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9399 FIB_TEST(!fib_test_validate_entry(fei,
9400 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9403 "%U via 10.10.10.2",
9404 format_fib_prefix, &pfx_10_10_10_255_s_32);
9405 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9406 FIB_TEST(!fib_test_validate_entry(fei,
9407 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9410 "%U via 10.10.10.2",
9411 format_fib_prefix, &pfx_10_10_10_0_s_24);
9413 * modify the /24. expect the new forwarding to be pushed down
9415 fib_table_entry_update_one_path(0,
9416 &pfx_10_10_10_0_s_24,
9418 FIB_ENTRY_FLAG_COVERED_INHERIT,
9421 tm->hw[0]->sw_if_index,
9425 FIB_ROUTE_PATH_FLAG_NONE);
9426 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9427 FIB_TEST(!fib_test_validate_entry(fei,
9428 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9431 "%U via 10.10.10.1",
9432 format_fib_prefix, &pfx_10_10_10_16_s_28);
9433 FIB_TEST(!fib_test_validate_entry(fei,
9434 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9437 "%U via 10.10.10.1",
9438 format_fib_prefix, &pfx_10_10_10_21_s_32);
9439 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9440 FIB_TEST(!fib_test_validate_entry(fei,
9441 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9444 "%U via 10.10.10.1",
9445 format_fib_prefix, &pfx_10_10_10_22_s_32);
9446 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9447 FIB_TEST(!fib_test_validate_entry(fei,
9448 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9451 "%U via 10.10.10.1",
9452 format_fib_prefix, &pfx_10_10_10_255_s_32);
9453 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9454 FIB_TEST(!fib_test_validate_entry(fei,
9455 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9458 "%U via 10.10.10.1",
9459 format_fib_prefix, &pfx_10_10_10_0_s_24);
9462 * add an entry less specific to /24. it should not own the /24's tree
9464 const fib_prefix_t pfx_10_10_0_0_s_16 = {
9466 .fp_proto = FIB_PROTOCOL_IP4,
9467 .fp_addr = nh_10_10_0_0,
9469 fib_table_entry_update_one_path(0,
9470 &pfx_10_10_0_0_s_16,
9472 FIB_ENTRY_FLAG_COVERED_INHERIT,
9475 tm->hw[0]->sw_if_index,
9479 FIB_ROUTE_PATH_FLAG_NONE);
9480 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9481 FIB_TEST(!fib_test_validate_entry(fei,
9482 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9485 "%U via 10.10.10.1",
9486 format_fib_prefix, &pfx_10_10_10_16_s_28);
9487 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_22_s_32);
9488 FIB_TEST(!fib_test_validate_entry(fei,
9489 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9492 "%U via 10.10.10.1",
9493 format_fib_prefix, &pfx_10_10_10_22_s_32);
9494 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_255_s_32);
9495 FIB_TEST(!fib_test_validate_entry(fei,
9496 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9499 "%U via 10.10.10.1",
9500 format_fib_prefix, &pfx_10_10_10_255_s_32);
9501 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9502 FIB_TEST(!fib_test_validate_entry(fei,
9503 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9506 "%U via 10.10.10.1",
9507 format_fib_prefix, &pfx_10_10_10_0_s_24);
9508 fei = fib_table_lookup_exact_match(0, &pfx_10_10_0_0_s_16);
9509 FIB_TEST(!fib_test_validate_entry(fei,
9510 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9513 "%U via 10.10.10.2",
9514 format_fib_prefix, &pfx_10_10_0_0_s_16);
9517 * Add/remove an interposer source to a new /32
9519 const fib_prefix_t pfx_11_11_11_11_s_32 = {
9521 .fp_proto = FIB_PROTOCOL_IP4,
9522 .fp_addr = nh_11_11_11_11,
9525 fib_table_entry_update_one_path(0,
9526 &pfx_11_11_11_11_s_32,
9528 FIB_ENTRY_FLAG_NONE,
9531 tm->hw[0]->sw_if_index,
9535 FIB_ROUTE_PATH_FLAG_NONE);
9537 dpo_id_t interposer = DPO_INVALID;
9538 fib_mpls_label_t *l99 = NULL, fml_99 = {
9541 vec_add1(l99, fml_99);
9543 mpls_label_dpo_create(l99,
9546 MPLS_LABEL_DPO_FLAG_NONE,
9547 punt_dpo_get(DPO_PROTO_MPLS),
9550 adj_index_t ai_10_10_10_3 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP4,
9553 tm->hw[0]->sw_if_index);
9554 fib_test_lb_bucket_t adj_o_10_10_10_3 = {
9557 .adj = ai_10_10_10_3,
9560 fib_test_lb_bucket_t l99_o_10_10_10_3 = {
9561 .type = FT_LB_LABEL_O_ADJ,
9563 .adj = ai_10_10_10_3,
9569 fei = fib_table_entry_special_dpo_add(0,
9570 &pfx_11_11_11_11_s_32,
9572 FIB_ENTRY_FLAG_INTERPOSE,
9574 FIB_TEST(!fib_test_validate_entry(fei,
9575 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9578 "%U via interposer adj",
9579 format_fib_prefix,&pfx_11_11_11_11_s_32);
9581 fib_table_entry_special_remove(0,
9582 &pfx_11_11_11_11_s_32,
9583 FIB_SOURCE_SPECIAL);
9584 FIB_TEST(!fib_test_validate_entry(fei,
9585 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9588 "%U via 10.10.10.1",
9589 format_fib_prefix, &pfx_11_11_11_11_s_32);
9592 * remove and re-add the second best API source while the interpose
9595 fei = fib_table_entry_special_dpo_add(0,
9596 &pfx_11_11_11_11_s_32,
9598 FIB_ENTRY_FLAG_INTERPOSE,
9600 FIB_TEST(!fib_test_validate_entry(fei,
9601 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9604 "%U via interposer adj",
9605 format_fib_prefix,&pfx_11_11_11_11_s_32);
9607 FIB_TEST(2 == pool_elts(mpls_label_dpo_pool),
9608 "MPLS label pool: %d",
9609 pool_elts(mpls_label_dpo_pool));
9611 fib_table_entry_delete(0, &pfx_11_11_11_11_s_32, FIB_SOURCE_API);
9614 * the interpose does not get stacked when there are not valid paths
9616 fib_test_lb_bucket_t bucket_drop = {
9619 .adj = DPO_PROTO_IP4,
9622 FIB_TEST(!fib_test_validate_entry(fei,
9623 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9627 format_fib_prefix,&pfx_11_11_11_11_s_32);
9629 fib_table_entry_update_one_path(0,
9630 &pfx_11_11_11_11_s_32,
9632 FIB_ENTRY_FLAG_NONE,
9635 tm->hw[0]->sw_if_index,
9639 FIB_ROUTE_PATH_FLAG_NONE);
9640 FIB_TEST(!fib_test_validate_entry(fei,
9641 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9644 "%U via interposer adj",
9645 format_fib_prefix,&pfx_11_11_11_11_s_32);
9646 fib_table_entry_delete(0, &pfx_11_11_11_11_s_32, FIB_SOURCE_API);
9649 * add a cover for the interposed entry, so that we test it selects
9650 * the covers forwarding.
9652 const fib_prefix_t pfx_11_11_11_0_s_24 = {
9654 .fp_proto = FIB_PROTOCOL_IP4,
9655 .fp_addr = nh_11_11_11_0,
9657 fib_table_entry_update_one_path(0,
9658 &pfx_11_11_11_0_s_24,
9660 FIB_ENTRY_FLAG_NONE,
9663 tm->hw[0]->sw_if_index,
9667 FIB_ROUTE_PATH_FLAG_NONE);
9668 FIB_TEST(!fib_test_validate_entry(fei,
9669 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9672 "%U via interposer adj",
9673 format_fib_prefix,&pfx_11_11_11_11_s_32);
9676 * multiple interpose sources on the same entry. Only the high
9677 * priority source gets to add the interpose.
9679 dpo_id_t interposer2 = DPO_INVALID;
9680 fib_mpls_label_t *l100 = NULL, fml_100 = {
9683 vec_add1(l100, fml_100);
9685 mpls_label_dpo_create(l100,
9688 MPLS_LABEL_DPO_FLAG_NONE,
9689 punt_dpo_get(DPO_PROTO_MPLS),
9692 fei = fib_table_entry_special_dpo_add(0,
9693 &pfx_11_11_11_11_s_32,
9694 FIB_SOURCE_CLASSIFY,
9695 FIB_ENTRY_FLAG_INTERPOSE,
9697 FIB_TEST(!fib_test_validate_entry(fei,
9698 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9701 "%U via interposer label 99",
9702 format_fib_prefix,&pfx_11_11_11_11_s_32);
9704 fib_test_lb_bucket_t l100_o_10_10_10_3 = {
9705 .type = FT_LB_LABEL_O_ADJ,
9707 .adj = ai_10_10_10_3,
9713 fib_table_entry_delete(0, &pfx_11_11_11_11_s_32, FIB_SOURCE_SPECIAL);
9715 FIB_TEST(!fib_test_validate_entry(fei,
9716 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9718 &l100_o_10_10_10_3),
9719 "%U via interposer label 99",
9720 format_fib_prefix,&pfx_11_11_11_11_s_32);
9722 fib_table_entry_delete(0, &pfx_11_11_11_0_s_24, FIB_SOURCE_API);
9723 FIB_TEST(!fib_test_validate_entry(fei,
9724 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9728 format_fib_prefix,&pfx_11_11_11_11_s_32);
9729 fib_table_entry_delete(0, &pfx_11_11_11_11_s_32, FIB_SOURCE_CLASSIFY);
9732 * update a source to/from interpose.
9734 /* fib_table_entry_update_one_path(0, */
9735 /* &pfx_11_11_11_0_s_24, */
9736 /* FIB_SOURCE_API, */
9737 /* FIB_ENTRY_FLAG_NONE, */
9738 /* DPO_PROTO_IP4, */
9739 /* &nh_10_10_10_3, */
9740 /* tm->hw[0]->sw_if_index, */
9744 /* FIB_ROUTE_PATH_FLAG_NONE); */
9745 /* fei = fib_table_entry_special_dpo_add(0, */
9746 /* &pfx_11_11_11_11_s_32, */
9747 /* FIB_SOURCE_API, */
9748 /* FIB_ENTRY_FLAG_INTERPOSE, */
9750 /* FIB_TEST(!fib_test_validate_entry(fei, */
9751 /* FIB_FORW_CHAIN_TYPE_UNICAST_IP4, */
9753 /* &l99_o_10_10_10_3), */
9754 /* "%U via interposer label 99", */
9755 /* format_fib_prefix,&pfx_11_11_11_11_s_32); */
9757 /* FIB_TEST(3 == pool_elts(mpls_label_dpo_pool), */
9758 /* "MPLS label pool: %d", */
9759 /* pool_elts(mpls_label_dpo_pool)); */
9760 /* FIB_TEST((2 == mpls_label_dpo_get(interposer.dpoi_index)->mld_locks), */
9761 /* "Interposer %d locks", */
9762 /* mpls_label_dpo_get(interposer.dpoi_index)->mld_locks); */
9764 /* fib_table_entry_update_one_path(0, */
9765 /* &pfx_11_11_11_11_s_32, */
9766 /* FIB_SOURCE_API, */
9767 /* FIB_ENTRY_FLAG_NONE, */
9768 /* DPO_PROTO_IP4, */
9769 /* &nh_10_10_10_2, */
9770 /* tm->hw[0]->sw_if_index, */
9774 /* FIB_ROUTE_PATH_FLAG_NONE); */
9775 /* FIB_TEST(!fib_test_validate_entry(fei, */
9776 /* FIB_FORW_CHAIN_TYPE_UNICAST_IP4, */
9778 /* &adj_o_10_10_10_2), */
9779 /* "%U via 10.10.10.2", */
9780 /* format_fib_prefix,&pfx_11_11_11_11_s_32); */
9782 /* FIB_TEST((1 == mpls_label_dpo_get(interposer.dpoi_index)->mld_locks), */
9783 /* "Interposer %d locks", */
9784 /* mpls_label_dpo_get(interposer.dpoi_index)->mld_locks); */
9785 /* FIB_TEST(2 == pool_elts(mpls_label_dpo_pool), */
9786 /* "MPLS label pool: %d", */
9787 /* pool_elts(mpls_label_dpo_pool)); */
9789 /* fei = fib_table_entry_special_dpo_add(0, */
9790 /* &pfx_11_11_11_11_s_32, */
9791 /* FIB_SOURCE_API, */
9792 /* FIB_ENTRY_FLAG_INTERPOSE, */
9794 /* FIB_TEST(!fib_test_validate_entry(fei, */
9795 /* FIB_FORW_CHAIN_TYPE_UNICAST_IP4, */
9797 /* &l99_o_10_10_10_3), */
9798 /* "%U via interposer label 99", */
9799 /* format_fib_prefix,&pfx_11_11_11_11_s_32); */
9801 /* fib_table_entry_delete(0, &pfx_11_11_11_11_s_32, FIB_SOURCE_API); */
9804 * Add/remove an interposer source from the top of the subtrie. The
9805 * interposer source is not inherited.
9807 fib_table_entry_update_one_path(0,
9808 &pfx_10_10_10_0_s_24,
9810 FIB_ENTRY_FLAG_COVERED_INHERIT,
9813 tm->hw[0]->sw_if_index,
9817 FIB_ROUTE_PATH_FLAG_NONE);
9818 fei = fib_table_entry_special_dpo_add(0,
9819 &pfx_10_10_10_0_s_24,
9821 FIB_ENTRY_FLAG_INTERPOSE,
9823 FIB_TEST(!fib_test_validate_entry(fei,
9824 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9827 "%U via interposer label",
9828 format_fib_prefix,&pfx_10_10_10_0_s_24);
9829 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9830 FIB_TEST(!fib_test_validate_entry(fei,
9831 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9835 format_fib_prefix, &pfx_10_10_10_21_s_32);
9837 fib_table_entry_special_remove(0,
9838 &pfx_10_10_10_0_s_24,
9839 FIB_SOURCE_SPECIAL);
9840 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_0_s_24);
9841 FIB_TEST(!fib_test_validate_entry(fei,
9842 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9845 "%U via 10.10.10.1",
9846 format_fib_prefix, &pfx_10_10_10_0_s_24);
9847 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9848 FIB_TEST(!fib_test_validate_entry(fei,
9849 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9852 "%U via via 10.10.10.1",
9853 format_fib_prefix, &pfx_10_10_10_21_s_32);
9856 * Add/remove an interposer source from the top of the subtrie. The
9857 * interposer source is inherited.
9859 fei = fib_table_entry_special_dpo_add(0,
9860 &pfx_10_10_10_0_s_24,
9862 (FIB_ENTRY_FLAG_COVERED_INHERIT |
9863 FIB_ENTRY_FLAG_INTERPOSE),
9865 FIB_TEST(!fib_test_validate_entry(fei,
9866 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9869 "%U via interposer label",
9870 format_fib_prefix,&pfx_10_10_10_0_s_24);
9872 /* interposer gets forwarding from the drop cli source */
9873 fei = fib_table_lookup_exact_match(0, &pfx_10_10_10_21_s_32);
9874 FIB_TEST(!fib_test_validate_entry(fei,
9875 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9879 format_fib_prefix,&pfx_10_10_10_21_s_32);
9881 fib_table_entry_update_one_path(0,
9882 &pfx_10_10_10_21_s_32,
9884 FIB_ENTRY_FLAG_NONE,
9887 tm->hw[0]->sw_if_index,
9891 FIB_ROUTE_PATH_FLAG_NONE);
9892 fib_table_entry_delete(0, &pfx_10_10_10_21_s_32, FIB_SOURCE_CLI);
9893 /* interposer gets forwarding from the API source */
9894 FIB_TEST(!fib_test_validate_entry(fei,
9895 FIB_FORW_CHAIN_TYPE_UNICAST_IP4,
9898 "%U via interposer label",
9899 format_fib_prefix,&pfx_10_10_10_21_s_32);
9904 fib_table_entry_delete(0, &pfx_10_10_10_22_s_32, FIB_SOURCE_CLI);
9905 fib_table_entry_delete(0, &pfx_10_10_10_21_s_32, FIB_SOURCE_API);
9906 fib_table_entry_delete(0, &pfx_10_10_10_16_s_28, FIB_SOURCE_CLI);
9907 fib_table_entry_delete(0, &pfx_10_10_10_255_s_32, FIB_SOURCE_CLI);
9908 fib_table_entry_delete(0, &pfx_10_10_10_0_s_24, FIB_SOURCE_API);
9909 fib_table_entry_delete(0, &pfx_10_10_0_0_s_16, FIB_SOURCE_API);
9910 fib_table_entry_delete(0, &pfx_10_10_10_0_s_24, FIB_SOURCE_SPECIAL);
9911 adj_unlock(ai_10_10_10_1);
9912 adj_unlock(ai_10_10_10_2);
9913 adj_unlock(ai_10_10_10_3);
9914 dpo_reset(&interposer);
9915 dpo_reset(&interposer2);
9916 FIB_TEST(0 == pool_elts(mpls_label_dpo_pool),
9917 "MPLS label pool empty: %d",
9918 pool_elts(mpls_label_dpo_pool));
9919 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
9920 FIB_TEST(N_PLS == fib_path_list_pool_size(),
9921 "number of path-lists: %d = %d",
9922 N_PLS, fib_path_list_pool_size());
9925 * test the v6 tree walk.
9926 * a /64 that covers everything. a /96 that covers one /128
9927 * a second /128 covered only by the /64.
9929 const fib_prefix_t pfx_2001_s_64 = {
9931 .fp_proto = FIB_PROTOCOL_IP6,
9935 [0] = clib_host_to_net_u64(0x2001000000000000),
9936 [1] = clib_host_to_net_u64(0x0000000000000000),
9941 const fib_prefix_t pfx_2001_1_s_96 = {
9943 .fp_proto = FIB_PROTOCOL_IP6,
9947 [0] = clib_host_to_net_u64(0x2001000000000000),
9948 [1] = clib_host_to_net_u64(0x1000000000000000),
9953 const fib_prefix_t pfx_2001_1_1_s_128 = {
9955 .fp_proto = FIB_PROTOCOL_IP6,
9959 [0] = clib_host_to_net_u64(0x2001000000000000),
9960 [1] = clib_host_to_net_u64(0x1000000000000001),
9965 const fib_prefix_t pfx_2001_0_1_s_128 = {
9967 .fp_proto = FIB_PROTOCOL_IP6,
9971 [0] = clib_host_to_net_u64(0x2001000000000000),
9972 [1] = clib_host_to_net_u64(0x0000000000000001),
9977 const ip46_address_t nh_3000_1 = {
9980 [0] = clib_host_to_net_u64(0x3000000000000000),
9981 [1] = clib_host_to_net_u64(0x0000000000000001),
9985 const ip46_address_t nh_3000_2 = {
9988 [0] = clib_host_to_net_u64(0x3000000000000000),
9989 [1] = clib_host_to_net_u64(0x0000000000000002),
9993 adj_index_t ai_3000_1 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
9996 tm->hw[0]->sw_if_index);
9997 adj_index_t ai_3000_2 = adj_nbr_add_or_lock(FIB_PROTOCOL_IP6,
10000 tm->hw[0]->sw_if_index);
10001 fib_test_lb_bucket_t adj_o_3000_1 = {
10007 fib_test_lb_bucket_t adj_o_3000_2 = {
10014 fib_table_entry_special_add(0,
10015 &pfx_2001_0_1_s_128,
10017 FIB_ENTRY_FLAG_DROP);
10018 fib_table_entry_special_add(0,
10019 &pfx_2001_1_1_s_128,
10021 FIB_ENTRY_FLAG_DROP);
10024 * /96 has inherited forwarding pushed down to its covered /128
10026 fib_table_entry_update_one_path(0,
10029 FIB_ENTRY_FLAG_COVERED_INHERIT,
10032 tm->hw[0]->sw_if_index,
10036 FIB_ROUTE_PATH_FLAG_NONE);
10037 fei = fib_table_lookup_exact_match(0, &pfx_2001_1_s_96);
10038 FIB_TEST(!fib_test_validate_entry(fei,
10039 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10043 format_fib_prefix, &pfx_2001_1_s_96);
10044 fei = fib_table_lookup_exact_match(0, &pfx_2001_1_1_s_128);
10045 FIB_TEST(!fib_test_validate_entry(fei,
10046 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10050 format_fib_prefix, &pfx_2001_1_1_s_128);
10051 fei = fib_table_lookup_exact_match(0, &pfx_2001_0_1_s_128);
10052 FIB_TEST(load_balance_is_drop(fib_entry_contribute_ip_forwarding(fei)),
10053 "%U resolves via drop",
10054 format_fib_prefix, &pfx_2001_0_1_s_128);
10057 * /64 has inherited forwarding pushed down to all, but the /96
10058 * and its sub-tree remain unaffected.
10060 fib_table_entry_update_one_path(0,
10063 FIB_ENTRY_FLAG_COVERED_INHERIT,
10066 tm->hw[0]->sw_if_index,
10070 FIB_ROUTE_PATH_FLAG_NONE);
10072 fei = fib_table_lookup_exact_match(0, &pfx_2001_s_64);
10073 FIB_TEST(!fib_test_validate_entry(fei,
10074 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10078 format_fib_prefix, &pfx_2001_s_64);
10079 fei = fib_table_lookup_exact_match(0, &pfx_2001_0_1_s_128);
10080 FIB_TEST(!fib_test_validate_entry(fei,
10081 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10085 format_fib_prefix, &pfx_2001_0_1_s_128);
10087 fei = fib_table_lookup_exact_match(0, &pfx_2001_1_s_96);
10088 FIB_TEST(!fib_test_validate_entry(fei,
10089 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10093 format_fib_prefix, &pfx_2001_1_s_96);
10094 fei = fib_table_lookup_exact_match(0, &pfx_2001_1_1_s_128);
10095 FIB_TEST(!fib_test_validate_entry(fei,
10096 FIB_FORW_CHAIN_TYPE_UNICAST_IP6,
10100 format_fib_prefix, &pfx_2001_1_1_s_128);
10105 fib_table_entry_delete(0, &pfx_2001_0_1_s_128, FIB_SOURCE_CLI);
10106 fib_table_entry_delete(0, &pfx_2001_1_1_s_128, FIB_SOURCE_CLI);
10107 fib_table_entry_delete(0, &pfx_2001_s_64, FIB_SOURCE_API);
10108 fib_table_entry_delete(0, &pfx_2001_1_s_96, FIB_SOURCE_API);
10109 adj_unlock(ai_3000_1);
10110 adj_unlock(ai_3000_2);
10113 * test no-one left behind
10115 FIB_TEST((n_feis == fib_entry_pool_size()), "Entries gone");
10116 FIB_TEST(0 == adj_nbr_db_size(), "All adjacencies removed");
10121 static clib_error_t *
10122 fib_test (vlib_main_t * vm,
10123 unformat_input_t * input,
10124 vlib_cli_command_t * cmd_arg)
10130 fib_test_mk_intf(4);
10132 if (unformat (input, "debug"))
10134 fib_test_do_debug = 1;
10137 if (unformat (input, "ip4"))
10139 res += fib_test_v4();
10141 else if (unformat (input, "ip6"))
10143 res += fib_test_v6();
10145 else if (unformat (input, "ip"))
10147 res += fib_test_v4();
10148 res += fib_test_v6();
10150 else if (unformat (input, "label"))
10152 res += fib_test_label();
10154 else if (unformat (input, "ae"))
10156 res += fib_test_ae();
10158 else if (unformat (input, "pref"))
10160 res += fib_test_pref();
10162 else if (unformat (input, "lfib"))
10164 res += lfib_test();
10166 else if (unformat (input, "walk"))
10168 res += fib_test_walk();
10170 else if (unformat (input, "bfd"))
10172 res += fib_test_bfd();
10174 else if (unformat (input, "inherit"))
10176 res += fib_test_inherit();
10180 res += fib_test_v4();
10181 res += fib_test_v6();
10182 res += fib_test_ae();
10183 res += fib_test_bfd();
10184 res += fib_test_pref();
10185 res += fib_test_label();
10186 res += fib_test_inherit();
10187 res += lfib_test();
10190 * fib-walk process must be disabled in order for the walk tests to work
10192 fib_walk_process_disable();
10193 res += fib_test_walk();
10194 fib_walk_process_enable();
10200 return clib_error_return(0, "FIB Unit Test Failed");
10208 VLIB_CLI_COMMAND (test_fib_command, static) = {
10209 .path = "test fib",
10210 .short_help = "fib unit tests - DO NOT RUN ON A LIVE SYSTEM",
10211 .function = fib_test,
10215 fib_test_init (vlib_main_t *vm)
10220 VLIB_INIT_FUNCTION (fib_test_init);