X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Ffib%2Ffib_path.c;h=2a4e6ab551f0095ab1f34ea9a734fa92929e7476;hb=e2fe09742;hp=e974e31e9594684811fc5dd6fb763cf90dd78456;hpb=e821ab100aea2fb3f740a98650eb750ff5911c49;p=vpp.git diff --git a/src/vnet/fib/fib_path.c b/src/vnet/fib/fib_path.c index e974e31e959..2a4e6ab551f 100644 --- a/src/vnet/fib/fib_path.c +++ b/src/vnet/fib/fib_path.c @@ -24,7 +24,9 @@ #include #include #include -#include +#include +#include +#include #include #include @@ -37,6 +39,7 @@ #include #include #include +#include #include #include #include @@ -103,17 +106,8 @@ typedef enum fib_path_type_t_ { * via a DVR. */ FIB_PATH_TYPE_DVR, - /** - * Marker. Add new types before this one, then update it. - */ - FIB_PATH_TYPE_LAST = FIB_PATH_TYPE_BIER_FMASK, } __attribute__ ((packed)) fib_path_type_t; -/** - * The maximum number of path_types - */ -#define FIB_PATH_TYPE_MAX (FIB_PATH_TYPE_LAST + 1) - #define FIB_PATH_TYPES { \ [FIB_PATH_TYPE_ATTACHED_NEXT_HOP] = "attached-nexthop", \ [FIB_PATH_TYPE_ATTACHED] = "attached", \ @@ -130,11 +124,6 @@ typedef enum fib_path_type_t_ { [FIB_PATH_TYPE_DVR] = "dvr", \ } -#define FOR_EACH_FIB_PATH_TYPE(_item) \ - for (_item = FIB_PATH_TYPE_FIRST; \ - _item <= FIB_PATH_TYPE_LAST; \ - _item++) - /** * Enurmeration of path operational (i.e. derived) attributes */ @@ -256,6 +245,10 @@ typedef struct fib_path_t_ { u32 fp_interface; } attached_next_hop; struct { + /** + * The Connected local address + */ + fib_prefix_t fp_connected; /** * The interface */ @@ -350,6 +343,12 @@ typedef struct fib_path_t_ { */ u32 fp_udp_encap_id; } udp_encap; + struct { + /** + * The UDP Encap object this path resolves through + */ + u32 fp_classify_table_id; + } classify; struct { /** * The interface @@ -409,22 +408,22 @@ static const char *fib_path_cfg_attribute_names[] = FIB_PATH_CFG_ATTRIBUTES; */ static fib_path_t *fib_path_pool; +/** + * the logger + */ +vlib_log_class_t fib_path_logger; + /* * Debug macro */ -#ifdef FIB_DEBUG -#define FIB_PATH_DBG(_p, _fmt, _args...) \ -{ \ - u8 *_tmp = NULL; \ - _tmp = fib_path_format(fib_path_get_index(_p), _tmp); \ - clib_warning("path:[%d:%U]:" _fmt, \ - fib_path_get_index(_p), format_fib_path, _p, 0,\ - ##_args); \ - vec_free(_tmp); \ +#define FIB_PATH_DBG(_p, _fmt, _args...) \ +{ \ + vlib_log_debug (fib_path_logger, \ + "[%U]: " _fmt, \ + format_fib_path, fib_path_get_index(_p), 0, \ + FIB_PATH_FORMAT_FLAGS_ONE_LINE, \ + ##_args); \ } -#else -#define FIB_PATH_DBG(_p, _fmt, _args...) -#endif static fib_path_t * fib_path_get (fib_node_index_t index) @@ -456,10 +455,21 @@ format_fib_path (u8 * s, va_list * args) { fib_node_index_t path_index = va_arg (*args, fib_node_index_t); u32 indent = va_arg (*args, u32); + fib_format_path_flags_t flags = va_arg (*args, fib_format_path_flags_t); vnet_main_t * vnm = vnet_get_main(); fib_path_oper_attribute_t oattr; fib_path_cfg_attribute_t cattr; fib_path_t *path; + const char *eol; + + if (flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE) + { + eol = ""; + } + else + { + eol = "\n"; + } path = fib_path_get(path_index); @@ -486,7 +496,8 @@ format_fib_path (u8 * s, va_list * args) } } } - s = format(s, "\n%U", format_white_space, indent+2); + if (!(flags & FIB_PATH_FORMAT_FLAGS_ONE_LINE)) + s = format(s, "\n%U", format_white_space, indent+2); switch (path->fp_type) { @@ -514,11 +525,11 @@ format_fib_path (u8 * s, va_list * args) } if (!dpo_id_is_valid(&path->fp_dpo)) { - s = format(s, "\n%Uunresolved", format_white_space, indent+2); + s = format(s, "%s%Uunresolved", eol, format_white_space, indent+2); } else { - s = format(s, "\n%U%U", + s = format(s, "%s%U%U", eol, format_white_space, indent, format_dpo_id, &path->fp_dpo, 13); @@ -593,10 +604,14 @@ format_fib_path (u8 * s, va_list * args) vnm, path->dvr.fp_interface)); break; + case FIB_PATH_TYPE_DEAG: + s = format (s, " %sfib-index:%d", + (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID ? "m" : ""), + path->deag.fp_tbl_id); + break; case FIB_PATH_TYPE_RECEIVE: case FIB_PATH_TYPE_INTF_RX: case FIB_PATH_TYPE_SPECIAL: - case FIB_PATH_TYPE_DEAG: case FIB_PATH_TYPE_EXCLUSIVE: if (dpo_id_is_valid(&path->fp_dpo)) { @@ -608,17 +623,6 @@ format_fib_path (u8 * s, va_list * args) return (s); } -u8 * -fib_path_format (fib_node_index_t pi, u8 *s) -{ - fib_path_t *path; - - path = fib_path_get(pi); - ASSERT(NULL != path); - - return (format (s, "%U", format_fib_path, path)); -} - /* * fib_path_last_lock_gone * @@ -631,10 +635,18 @@ fib_path_last_lock_gone (fib_node_t *node) ASSERT(0); } -static const adj_index_t +static fib_path_t* fib_path_attached_next_hop_get_adj (fib_path_t *path, - vnet_link_t link) + vnet_link_t link, + dpo_id_t *dpo) { + fib_node_index_t fib_path_index; + fib_protocol_t nh_proto; + adj_index_t ai; + + fib_path_index = fib_path_get_index(path); + nh_proto = dpo_proto_to_fib(path->fp_nh_proto); + if (vnet_sw_interface_is_p2p(vnet_get_main(), path->attached_next_hop.fp_interface)) { @@ -644,33 +656,34 @@ fib_path_attached_next_hop_get_adj (fib_path_t *path, * the subnet address (the attached route) links to the * auto-adj (see below), we want that adj here too. */ - return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), - link, - &zero_addr, - path->attached_next_hop.fp_interface)); + ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr, + path->attached_next_hop.fp_interface); } else { - return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), - link, - &path->attached_next_hop.fp_nh, - path->attached_next_hop.fp_interface)); + ai = adj_nbr_add_or_lock(nh_proto, link, + &path->attached_next_hop.fp_nh, + path->attached_next_hop.fp_interface); } + + dpo_set(dpo, DPO_ADJACENCY, vnet_link_to_dpo_proto(link), ai); + adj_unlock(ai); + + return (fib_path_get(fib_path_index)); } static void fib_path_attached_next_hop_set (fib_path_t *path) { /* - * resolve directly via the adjacnecy discribed by the + * resolve directly via the adjacency discribed by the * interface and next-hop */ - dpo_set(&path->fp_dpo, - DPO_ADJACENCY, - path->fp_nh_proto, - fib_path_attached_next_hop_get_adj( - path, - dpo_proto_to_link(path->fp_nh_proto))); + path = fib_path_attached_next_hop_get_adj(path, + dpo_proto_to_link(path->fp_nh_proto), + &path->fp_dpo); + + ASSERT(dpo_is_adj(&path->fp_dpo)); /* * become a child of the adjacency so we receive updates @@ -680,18 +693,23 @@ fib_path_attached_next_hop_set (fib_path_t *path) FIB_NODE_TYPE_PATH, fib_path_get_index(path)); - if (!vnet_sw_interface_is_admin_up(vnet_get_main(), - path->attached_next_hop.fp_interface) || + if (!vnet_sw_interface_is_up(vnet_get_main(), + path->attached_next_hop.fp_interface) || !adj_is_up(path->fp_dpo.dpoi_index)) { path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED; } } -static const adj_index_t +static void fib_path_attached_get_adj (fib_path_t *path, - vnet_link_t link) + vnet_link_t link, + dpo_id_t *dpo) { + fib_protocol_t nh_proto; + + nh_proto = dpo_proto_to_fib(path->fp_nh_proto); + if (vnet_sw_interface_is_p2p(vnet_get_main(), path->attached.fp_interface)) { @@ -699,17 +717,28 @@ fib_path_attached_get_adj (fib_path_t *path, * point-2-point interfaces do not require a glean, since * there is nothing to ARP. Install a rewrite/nbr adj instead */ - return (adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), - link, - &zero_addr, - path->attached.fp_interface)); + adj_index_t ai; + + ai = adj_nbr_add_or_lock(nh_proto, link, &zero_addr, + path->attached.fp_interface); + + dpo_set(dpo, DPO_ADJACENCY, vnet_link_to_dpo_proto(link), ai); + adj_unlock(ai); + } + else if (vnet_sw_interface_is_nbma(vnet_get_main(), + path->attached.fp_interface)) + { + dpo_copy(dpo, drop_dpo_get(path->fp_nh_proto)); } else { - return (adj_glean_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), - link, - path->attached.fp_interface, - NULL)); + adj_index_t ai; + + ai = adj_glean_add_or_lock(nh_proto, link, + path->attached.fp_interface, + &path->attached.fp_connected); + dpo_set(dpo, DPO_ADJACENCY_GLEAN, vnet_link_to_dpo_proto(link), ai); + adj_unlock(ai); } } @@ -874,14 +903,14 @@ fib_path_unresolve (fib_path_t *path) case FIB_PATH_TYPE_RECURSIVE: if (FIB_NODE_INDEX_INVALID != path->fp_via_fib) { - fib_prefix_t pfx; - - fib_entry_get_prefix(path->fp_via_fib, &pfx); fib_entry_child_remove(path->fp_via_fib, path->fp_sibling); - fib_table_entry_special_remove(path->recursive.fp_tbl_id, - &pfx, + fib_table_entry_special_remove(path->recursive.fp_tbl_id, + fib_entry_get_prefix(path->fp_via_fib), FIB_SOURCE_RR); + fib_table_unlock(path->recursive.fp_tbl_id, + dpo_proto_to_fib(path->fp_nh_proto), + FIB_SOURCE_RR); path->fp_via_fib = FIB_NODE_INDEX_INVALID; } break; @@ -896,17 +925,13 @@ fib_path_unresolve (fib_path_t *path) bier_table_ecmp_unlock(path->fp_via_bier_tbl); break; case FIB_PATH_TYPE_ATTACHED_NEXT_HOP: - adj_child_remove(path->fp_dpo.dpoi_index, - path->fp_sibling); - adj_unlock(path->fp_dpo.dpoi_index); - break; case FIB_PATH_TYPE_ATTACHED: - adj_child_remove(path->fp_dpo.dpoi_index, - path->fp_sibling); - adj_unlock(path->fp_dpo.dpoi_index); + if (dpo_is_adj(&path->fp_dpo)) + adj_child_remove(path->fp_dpo.dpoi_index, + path->fp_sibling); break; case FIB_PATH_TYPE_UDP_ENCAP: - udp_encap_unlock_w_index(path->fp_dpo.dpoi_index); + udp_encap_unlock(path->fp_dpo.dpoi_index); break; case FIB_PATH_TYPE_EXCLUSIVE: dpo_reset(&path->exclusive.fp_ex_dpo); @@ -966,6 +991,9 @@ fib_path_back_walk_notify (fib_node_t *node, path = fib_path_from_fib_node(node); + FIB_PATH_DBG(path, "bw:%U", + format_fib_node_bw_reason, ctx->fnbw_reason); + switch (path->fp_type) { case FIB_PATH_TYPE_RECURSIVE: @@ -1072,25 +1100,22 @@ FIXME comment * restack the DPO to pick up the correct DPO sub-type */ uword if_is_up; - adj_index_t ai; - if_is_up = vnet_sw_interface_is_admin_up( + if_is_up = vnet_sw_interface_is_up( vnet_get_main(), path->attached_next_hop.fp_interface); - ai = fib_path_attached_next_hop_get_adj( - path, - dpo_proto_to_link(path->fp_nh_proto)); + path = fib_path_attached_next_hop_get_adj( + path, + dpo_proto_to_link(path->fp_nh_proto), + &path->fp_dpo); path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED; - if (if_is_up && adj_is_up(ai)) + if (if_is_up && adj_is_up(path->fp_dpo.dpoi_index)) { path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RESOLVED; } - dpo_set(&path->fp_dpo, DPO_ADJACENCY, path->fp_nh_proto, ai); - adj_unlock(ai); - if (!if_is_up) { /* @@ -1217,6 +1242,8 @@ fib_path_route_flags_to_cfg_flags (const fib_route_path_t *rpath) { fib_path_cfg_flags_t cfg_flags = FIB_PATH_CFG_FLAG_NONE; + if (rpath->frp_flags & FIB_ROUTE_PATH_POP_PW_CW) + cfg_flags |= FIB_PATH_CFG_FLAG_POP_PW_CW; if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_HOST) cfg_flags |= FIB_PATH_CFG_FLAG_RESOLVE_HOST; if (rpath->frp_flags & FIB_ROUTE_PATH_RESOLVE_VIA_ATTACHED) @@ -1235,6 +1262,12 @@ fib_path_route_flags_to_cfg_flags (const fib_route_path_t *rpath) cfg_flags |= FIB_PATH_CFG_FLAG_DROP; if (rpath->frp_flags & FIB_ROUTE_PATH_SOURCE_LOOKUP) cfg_flags |= FIB_PATH_CFG_FLAG_DEAG_SRC; + if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_UNREACH) + cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_UNREACH; + if (rpath->frp_flags & FIB_ROUTE_PATH_ICMP_PROHIBIT) + cfg_flags |= FIB_PATH_CFG_FLAG_ICMP_PROHIBIT; + if (rpath->frp_flags & FIB_ROUTE_PATH_GLEAN) + cfg_flags |= FIB_PATH_CFG_FLAG_GLEAN; return (cfg_flags); } @@ -1252,7 +1285,7 @@ fib_path_create (fib_node_index_t pl_index, fib_path_t *path; pool_get(fib_path_pool, path); - memset(path, 0, sizeof(*path)); + clib_memset(path, 0, sizeof(*path)); fib_node_init(&path->fp_node, FIB_NODE_TYPE_PATH); @@ -1323,6 +1356,27 @@ fib_path_create (fib_node_index_t pl_index, path->fp_type = FIB_PATH_TYPE_DVR; path->dvr.fp_interface = rpath->frp_sw_if_index; } + else if (rpath->frp_flags & FIB_ROUTE_PATH_EXCLUSIVE) + { + path->fp_type = FIB_PATH_TYPE_EXCLUSIVE; + dpo_copy(&path->exclusive.fp_ex_dpo, &rpath->dpo); + } + else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) || + (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH)) + { + path->fp_type = FIB_PATH_TYPE_SPECIAL; + } + else if ((path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY)) + { + path->fp_type = FIB_PATH_TYPE_SPECIAL; + path->classify.fp_classify_table_id = rpath->frp_classify_table_id; + } + else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_GLEAN) + { + path->fp_type = FIB_PATH_TYPE_ATTACHED; + path->attached.fp_interface = rpath->frp_sw_if_index; + path->attached.fp_connected = rpath->frp_connected; + } else if (~0 != rpath->frp_sw_if_index) { if (ip46_address_is_zero(&rpath->frp_addr)) @@ -1388,7 +1442,7 @@ fib_path_create_special (fib_node_index_t pl_index, fib_path_t *path; pool_get(fib_path_pool, path); - memset(path, 0, sizeof(*path)); + clib_memset(path, 0, sizeof(*path)); fib_node_init(&path->fp_node, FIB_NODE_TYPE_PATH); @@ -1436,7 +1490,7 @@ fib_path_copy (fib_node_index_t path_index, orig_path = fib_path_get(path_index); ASSERT(NULL != orig_path); - memcpy(path, orig_path, sizeof(*path)); + clib_memcpy(path, orig_path, sizeof(*path)); FIB_PATH_DBG(path, "create-copy:%d", path_index); @@ -1447,7 +1501,7 @@ fib_path_copy (fib_node_index_t path_index, path->fp_oper_flags = FIB_PATH_OPER_FLAG_NONE; path->fp_pl_index = path_list_index; path->fp_via_fib = FIB_NODE_INDEX_INVALID; - memset(&path->fp_dpo, 0, sizeof(path->fp_dpo)); + clib_memset(&path->fp_dpo, 0, sizeof(path->fp_dpo)); dpo_reset(&path->fp_dpo); return (fib_path_get_index(path)); @@ -1538,8 +1592,8 @@ fib_path_cmp_i (const fib_path_t *path1, path2->attached.fp_interface); break; case FIB_PATH_TYPE_RECURSIVE: - res = ip46_address_cmp(&path1->recursive.fp_nh, - &path2->recursive.fp_nh); + res = ip46_address_cmp(&path1->recursive.fp_nh.fp_ip, + &path2->recursive.fp_nh.fp_ip); if (0 == res) { @@ -1574,9 +1628,11 @@ fib_path_cmp_i (const fib_path_t *path1, case FIB_PATH_TYPE_DVR: res = (path1->dvr.fp_interface - path2->dvr.fp_interface); break; + case FIB_PATH_TYPE_EXCLUSIVE: + res = dpo_cmp(&path1->exclusive.fp_ex_dpo, &path2->exclusive.fp_ex_dpo); + break; case FIB_PATH_TYPE_SPECIAL: case FIB_PATH_TYPE_RECEIVE: - case FIB_PATH_TYPE_EXCLUSIVE: res = 0; break; } @@ -1711,9 +1767,20 @@ fib_path_cmp_w_route_path (fib_node_index_t path_index, case FIB_PATH_TYPE_DVR: res = (path->dvr.fp_interface - rpath->frp_sw_if_index); break; - case FIB_PATH_TYPE_SPECIAL: - case FIB_PATH_TYPE_RECEIVE: case FIB_PATH_TYPE_EXCLUSIVE: + res = dpo_cmp(&path->exclusive.fp_ex_dpo, &rpath->dpo); + break; + case FIB_PATH_TYPE_RECEIVE: + if (rpath->frp_flags & FIB_ROUTE_PATH_LOCAL) + { + res = 0; + } + else + { + res = 1; + } + break; + case FIB_PATH_TYPE_SPECIAL: res = 0; break; } @@ -1789,7 +1856,7 @@ fib_path_recursive_loop_detect (fib_node_index_t path_index, { /* * no loop here yet. keep forward walking the graph. - */ + */ if (fib_entry_recursive_loop_detect(path->fp_via_fib, entry_indicies)) { FIB_PATH_DBG(path, "recursive loop formed"); @@ -1805,6 +1872,19 @@ fib_path_recursive_loop_detect (fib_node_index_t path_index, } case FIB_PATH_TYPE_ATTACHED_NEXT_HOP: case FIB_PATH_TYPE_ATTACHED: + if (dpo_is_adj(&path->fp_dpo) && + adj_recursive_loop_detect(path->fp_dpo.dpoi_index, + entry_indicies)) + { + FIB_PATH_DBG(path, "recursive loop formed"); + path->fp_oper_flags |= FIB_PATH_OPER_FLAG_RECURSIVE_LOOP; + } + else + { + FIB_PATH_DBG(path, "recursive loop cleared"); + path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RECURSIVE_LOOP; + } + break; case FIB_PATH_TYPE_SPECIAL: case FIB_PATH_TYPE_DEAG: case FIB_PATH_TYPE_DVR: @@ -1853,28 +1933,40 @@ fib_path_resolve (fib_node_index_t path_index) fib_path_attached_next_hop_set(path); break; case FIB_PATH_TYPE_ATTACHED: + { + dpo_id_t tmp = DPO_INVALID; + /* * path->attached.fp_interface */ - if (!vnet_sw_interface_is_admin_up(vnet_get_main(), - path->attached.fp_interface)) + if (!vnet_sw_interface_is_up(vnet_get_main(), + path->attached.fp_interface)) { path->fp_oper_flags &= ~FIB_PATH_OPER_FLAG_RESOLVED; } - dpo_set(&path->fp_dpo, - DPO_ADJACENCY, - path->fp_nh_proto, - fib_path_attached_get_adj(path, - dpo_proto_to_link(path->fp_nh_proto))); + fib_path_attached_get_adj(path, + dpo_proto_to_link(path->fp_nh_proto), + &tmp); + + /* + * re-fetch after possible mem realloc + */ + path = fib_path_get(path_index); + dpo_copy(&path->fp_dpo, &tmp); /* * become a child of the adjacency so we receive updates * when the interface state changes */ - path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index, - FIB_NODE_TYPE_PATH, - fib_path_get_index(path)); + if (dpo_is_adj(&path->fp_dpo)) + { + path->fp_sibling = adj_child_add(path->fp_dpo.dpoi_index, + FIB_NODE_TYPE_PATH, + fib_path_get_index(path)); + } + dpo_reset(&tmp); break; + } case FIB_PATH_TYPE_RECURSIVE: { /* @@ -1900,6 +1992,9 @@ fib_path_resolve (fib_node_index_t path_index) fib_prefix_from_ip46_addr(&path->recursive.fp_nh.fp_ip, &pfx); } + fib_table_lock(path->recursive.fp_tbl_id, + dpo_proto_to_fib(path->fp_nh_proto), + FIB_SOURCE_RR); fei = fib_table_entry_special_add(path->recursive.fp_tbl_id, &pfx, FIB_SOURCE_RR, @@ -1962,11 +2057,33 @@ fib_path_resolve (fib_node_index_t path_index) break; } case FIB_PATH_TYPE_SPECIAL: - /* - * Resolve via the drop - */ - dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto)); - break; + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) + { + ip_null_dpo_add_and_lock (path->fp_nh_proto, + IP_NULL_ACTION_SEND_ICMP_PROHIBIT, + &path->fp_dpo); + } + else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH) + { + ip_null_dpo_add_and_lock (path->fp_nh_proto, + IP_NULL_ACTION_SEND_ICMP_UNREACH, + &path->fp_dpo); + } + else if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_CLASSIFY) + { + dpo_set (&path->fp_dpo, DPO_CLASSIFY, + path->fp_nh_proto, + classify_dpo_create (path->fp_nh_proto, + path->classify.fp_classify_table_id)); + } + else + { + /* + * Resolve via the drop + */ + dpo_copy(&path->fp_dpo, drop_dpo_get(path->fp_nh_proto)); + } + break; case FIB_PATH_TYPE_DEAG: { if (DPO_PROTO_BIER == path->fp_nh_proto) @@ -2000,7 +2117,7 @@ fib_path_resolve (fib_node_index_t path_index) break; } case FIB_PATH_TYPE_DVR: - dvr_dpo_add_or_lock(path->attached.fp_interface, + dvr_dpo_add_or_lock(path->dvr.fp_interface, path->fp_nh_proto, &path->fp_dpo); break; @@ -2072,7 +2189,7 @@ fib_path_get_resolving_interface (fib_node_index_t path_index) case FIB_PATH_TYPE_BIER_IMP: break; } - return (~0); + return (dpo_get_urpf(&path->fp_dpo)); } index_t @@ -2114,7 +2231,6 @@ fib_path_get_adj (fib_node_index_t path_index) path = fib_path_get(path_index); - ASSERT(dpo_is_adj(&path->fp_dpo)); if (dpo_is_adj(&path->fp_dpo)) { return (path->fp_dpo.dpoi_index); @@ -2285,6 +2401,16 @@ fib_path_stack_mpls_disp (fib_node_index_t path_index, case FIB_PATH_TYPE_DVR: break; } + + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_POP_PW_CW) + { + dpo_id_t tmp = DPO_INVALID; + + dpo_copy(&tmp, dpo); + + pw_cw_dpo_create(&tmp, dpo); + dpo_reset(&tmp); + } } void @@ -2299,8 +2425,6 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, ASSERT(path); ASSERT(FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct); - FIB_PATH_DBG(path, "contribute"); - /* * The DPO stored in the path was created when the path was resolved. * This then represents the path's 'native' protocol; IP. @@ -2325,21 +2449,11 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, case FIB_FORW_CHAIN_TYPE_NSH: case FIB_FORW_CHAIN_TYPE_MCAST_IP4: case FIB_FORW_CHAIN_TYPE_MCAST_IP6: - { - adj_index_t ai; - - /* - * get a appropriate link type adj. - */ - ai = fib_path_attached_next_hop_get_adj( - path, - fib_forw_chain_type_to_link_type(fct)); - dpo_set(dpo, DPO_ADJACENCY, - fib_forw_chain_type_to_dpo_proto(fct), ai); - adj_unlock(ai); - + path = fib_path_attached_next_hop_get_adj( + path, + fib_forw_chain_type_to_link_type(fct), + dpo); break; - } case FIB_FORW_CHAIN_TYPE_BIER: break; } @@ -2417,10 +2531,10 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, case FIB_FORW_CHAIN_TYPE_MPLS_EOS: case FIB_FORW_CHAIN_TYPE_UNICAST_IP4: case FIB_FORW_CHAIN_TYPE_UNICAST_IP6: - dpo_copy(dpo, &path->fp_dpo); - break; case FIB_FORW_CHAIN_TYPE_MCAST_IP4: case FIB_FORW_CHAIN_TYPE_MCAST_IP6: + dpo_copy(dpo, &path->fp_dpo); + break; case FIB_FORW_CHAIN_TYPE_BIER: break; case FIB_FORW_CHAIN_TYPE_ETHERNET: @@ -2442,20 +2556,10 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, case FIB_FORW_CHAIN_TYPE_ETHERNET: case FIB_FORW_CHAIN_TYPE_NSH: case FIB_FORW_CHAIN_TYPE_BIER: - { - adj_index_t ai; - - /* - * get a appropriate link type adj. - */ - ai = fib_path_attached_get_adj( - path, - fib_forw_chain_type_to_link_type(fct)); - dpo_set(dpo, DPO_ADJACENCY, - fib_forw_chain_type_to_dpo_proto(fct), ai); - adj_unlock(ai); - break; - } + fib_path_attached_get_adj(path, + fib_forw_chain_type_to_link_type(fct), + dpo); + break; case FIB_FORW_CHAIN_TYPE_MCAST_IP4: case FIB_FORW_CHAIN_TYPE_MCAST_IP6: { @@ -2464,9 +2568,24 @@ fib_path_contribute_forwarding (fib_node_index_t path_index, /* * Create the adj needed for sending IP multicast traffic */ - ai = adj_mcast_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), - fib_forw_chain_type_to_link_type(fct), - path->attached.fp_interface); + if (vnet_sw_interface_is_p2p(vnet_get_main(), + path->attached.fp_interface)) + { + /* + * point-2-point interfaces do not require a glean, since + * there is nothing to ARP. Install a rewrite/nbr adj instead + */ + ai = adj_nbr_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), + fib_forw_chain_type_to_link_type(fct), + &zero_addr, + path->attached.fp_interface); + } + else + { + ai = adj_mcast_add_or_lock(dpo_proto_to_fib(path->fp_nh_proto), + fib_forw_chain_type_to_link_type(fct), + path->attached.fp_interface); + } dpo_set(dpo, DPO_ADJACENCY, fib_forw_chain_type_to_dpo_proto(fct), ai); @@ -2509,15 +2628,20 @@ fib_path_append_nh_for_multipath_hash (fib_node_index_t path_index, ASSERT(path); + vec_add2(hash_key, mnh, 1); + + mnh->path_weight = path->fp_weight; + mnh->path_index = path_index; + if (fib_path_is_resolved(path_index)) { - vec_add2(hash_key, mnh, 1); - - mnh->path_weight = path->fp_weight; - mnh->path_index = path_index; - fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo); + fib_path_contribute_forwarding(path_index, fct, &mnh->path_dpo); + } + else + { + dpo_copy(&mnh->path_dpo, + drop_dpo_get(fib_forw_chain_type_to_dpo_proto(fct))); } - return (hash_key); } @@ -2578,58 +2702,84 @@ fib_path_is_looped (fib_node_index_t path_index) fib_path_list_walk_rc_t fib_path_encode (fib_node_index_t path_list_index, - fib_node_index_t path_index, - void *ctx) + fib_node_index_t path_index, + const fib_path_ext_t *path_ext, + void *args) { - fib_route_path_encode_t **api_rpaths = ctx; - fib_route_path_encode_t *api_rpath; + fib_path_encode_ctx_t *ctx = args; + fib_route_path_t *rpath; fib_path_t *path; path = fib_path_get(path_index); if (!path) return (FIB_PATH_LIST_WALK_CONTINUE); - vec_add2(*api_rpaths, api_rpath, 1); - api_rpath->rpath.frp_weight = path->fp_weight; - api_rpath->rpath.frp_preference = path->fp_preference; - api_rpath->rpath.frp_proto = path->fp_nh_proto; - api_rpath->rpath.frp_sw_if_index = ~0; - api_rpath->dpo = path->fp_dpo; + + vec_add2(ctx->rpaths, rpath, 1); + rpath->frp_weight = path->fp_weight; + rpath->frp_preference = path->fp_preference; + rpath->frp_proto = path->fp_nh_proto; + rpath->frp_sw_if_index = ~0; + rpath->frp_fib_index = 0; switch (path->fp_type) - { + { case FIB_PATH_TYPE_RECEIVE: - api_rpath->rpath.frp_addr = path->receive.fp_addr; - api_rpath->rpath.frp_sw_if_index = path->receive.fp_interface; + rpath->frp_addr = path->receive.fp_addr; + rpath->frp_sw_if_index = path->receive.fp_interface; + rpath->frp_flags |= FIB_ROUTE_PATH_LOCAL; break; case FIB_PATH_TYPE_ATTACHED: - api_rpath->rpath.frp_sw_if_index = path->attached.fp_interface; + rpath->frp_sw_if_index = path->attached.fp_interface; break; case FIB_PATH_TYPE_ATTACHED_NEXT_HOP: - api_rpath->rpath.frp_sw_if_index = path->attached_next_hop.fp_interface; - api_rpath->rpath.frp_addr = path->attached_next_hop.fp_nh; + rpath->frp_sw_if_index = path->attached_next_hop.fp_interface; + rpath->frp_addr = path->attached_next_hop.fp_nh; break; case FIB_PATH_TYPE_BIER_FMASK: - api_rpath->rpath.frp_bier_fmask = path->bier_fmask.fp_bier_fmask; + rpath->frp_bier_fmask = path->bier_fmask.fp_bier_fmask; break; case FIB_PATH_TYPE_SPECIAL: break; case FIB_PATH_TYPE_DEAG: - api_rpath->rpath.frp_fib_index = path->deag.fp_tbl_id; + rpath->frp_fib_index = path->deag.fp_tbl_id; + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_RPF_ID) + { + rpath->frp_flags |= FIB_ROUTE_PATH_RPF_ID; + } break; case FIB_PATH_TYPE_RECURSIVE: - api_rpath->rpath.frp_addr = path->recursive.fp_nh.fp_ip; + rpath->frp_addr = path->recursive.fp_nh.fp_ip; + rpath->frp_fib_index = path->recursive.fp_tbl_id; break; case FIB_PATH_TYPE_DVR: - api_rpath->rpath.frp_sw_if_index = path->dvr.fp_interface; - api_rpath->rpath.frp_flags |= FIB_ROUTE_PATH_DVR; + rpath->frp_sw_if_index = path->dvr.fp_interface; + rpath->frp_flags |= FIB_ROUTE_PATH_DVR; break; case FIB_PATH_TYPE_UDP_ENCAP: - api_rpath->rpath.frp_udp_encap_id = path->udp_encap.fp_udp_encap_id; - api_rpath->rpath.frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP; + rpath->frp_udp_encap_id = path->udp_encap.fp_udp_encap_id; + rpath->frp_flags |= FIB_ROUTE_PATH_UDP_ENCAP; break; + case FIB_PATH_TYPE_INTF_RX: + rpath->frp_sw_if_index = path->receive.fp_interface; + rpath->frp_flags |= FIB_ROUTE_PATH_INTF_RX; + break; + case FIB_PATH_TYPE_EXCLUSIVE: + rpath->frp_flags |= FIB_ROUTE_PATH_EXCLUSIVE; default: break; - } + } + + if (path_ext && path_ext->fpe_type == FIB_PATH_EXT_MPLS) + { + rpath->frp_label_stack = path_ext->fpe_path.frp_label_stack; + } + + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_DROP) + rpath->frp_flags |= FIB_ROUTE_PATH_DROP; + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_UNREACH) + rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_UNREACH; + if (path->fp_cfg_flags & FIB_PATH_CFG_FLAG_ICMP_PROHIBIT) + rpath->frp_flags |= FIB_ROUTE_PATH_ICMP_PROHIBIT; return (FIB_PATH_LIST_WALK_CONTINUE); } @@ -2648,6 +2798,7 @@ void fib_path_module_init (void) { fib_node_register_type (FIB_NODE_TYPE_PATH, &fib_path_vft); + fib_path_logger = vlib_log_register_class ("fib", "path"); } static clib_error_t * @@ -2666,10 +2817,11 @@ show_fib_path_command (vlib_main_t * vm, if (!pool_is_free_index(fib_path_pool, pi)) { path = fib_path_get(pi); - u8 *s = format(NULL, "%U", format_fib_path, pi, 1); - s = format(s, "children:"); + u8 *s = format(NULL, "%U", format_fib_path, pi, 1, + FIB_PATH_FORMAT_FLAGS_NONE); + s = format(s, "\n children:"); s = fib_node_children_format(path->fp_node.fn_children, s); - vlib_cli_output (vm, "%s", s); + vlib_cli_output (vm, "%v", s); vec_free(s); } else @@ -2682,7 +2834,8 @@ show_fib_path_command (vlib_main_t * vm, vlib_cli_output (vm, "FIB Paths"); pool_foreach_index (pi, fib_path_pool, ({ - vlib_cli_output (vm, "%U", format_fib_path, pi, 0); + vlib_cli_output (vm, "%U", format_fib_path, pi, 0, + FIB_PATH_FORMAT_FLAGS_NONE); })); }