From 8f5fef2c78b95de1a636ce27111722b71702212a Mon Sep 17 00:00:00 2001 From: Neale Ranns Date: Mon, 21 Dec 2020 08:29:34 +0000 Subject: ip: Path MTU Type: feature Support setting the MTU for a peer on an interface. The minimum value of the path and interface MTU is used at forwarding time. the path MTU is specified for a given peer, by address and table-ID. In the forwarding plane the MTU is enfored either: 1 - if the peer is attached, then the MTU is set on the peer's adjacency 2 - if the peer is not attached, it is remote, then a DPO is added to the peer's FIB entry to perform the necessary fragmentation. Signed-off-by: Neale Ranns Change-Id: I8b9ea6a07868b50e97e2561f18d9335407dea7ae --- src/vnet/ip/ip_path_mtu.c | 883 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 883 insertions(+) create mode 100644 src/vnet/ip/ip_path_mtu.c (limited to 'src/vnet/ip/ip_path_mtu.c') diff --git a/src/vnet/ip/ip_path_mtu.c b/src/vnet/ip/ip_path_mtu.c new file mode 100644 index 00000000000..38adb44065b --- /dev/null +++ b/src/vnet/ip/ip_path_mtu.c @@ -0,0 +1,883 @@ +/* + *------------------------------------------------------------------ + * ip_path_mtu.c + * + * Copyright (c) 2021 Graphiant. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------ + */ + +#include +#include +#include +#include +#include +#include + +#include + +/** + * Path MTU + * + * A path is a peer. A peer is known by an IP address (in a table). + * Insert a DPO in the forwarding chain for the peer to perform the + * fragmentation. + * For attached peers, all traffic will use the peer's adjacency, there + * is already an MTU chekc in the adjacency (for the link's MTU) so as an + * optimisation, instead of using a DPO, we add a delegate to the adjacency + * to set the adjacency's MTU to the path MTU. + */ + +/** + * the logger + */ +static vlib_log_class_t ip_pmtu_logger; + +static adj_delegate_type_t ip_pmtu_adj_delegate_type; +static fib_source_t ip_pmtu_source; + +/** + * DPO pool + */ +ip_pmtu_dpo_t *ip_pmtu_dpo_pool; + +/** + * DPO type registered for these GBP FWD + */ +static dpo_type_t ip_pmtu_dpo_type; + +/** + * Fib node type for the tracker + */ +static fib_node_type_t ip_pmtu_fib_type; + +/** + * Path MTU tracker pool + */ +ip_pmtu_t *ip_pmtu_pool; + +/** + * Delegate added to adjacencies to track path MTU + */ +typedef struct ip_path_mtu_adj_delegate_t_ +{ + u16 pmtu; +} ip_path_mtu_adj_delegate_t; + +static ip_path_mtu_adj_delegate_t *ip_path_mtu_adj_delegate_pool; + +/* DB of all FIB PMTU settings */ +typedef struct ip_pmtu_key_t_ +{ + ip46_address_t nh; + u32 table_id; + fib_protocol_t fproto; +} __clib_packed ip_pmtu_key_t; + +static uword *ip_pmtu_db; + +#define IP_PMTU_TRKR_DBG(_ipt, _fmt, _args...) \ + { \ + vlib_log_debug (ip_pmtu_logger, "[%U]: " _fmt ": ", format_ip_pmtu, \ + _ipt - ip_pmtu_pool, ##_args); \ + } +#define IP_PMTU_DBG(_fmt, _args...) \ + { \ + vlib_log_debug (ip_pmtu_logger, _fmt ": ", ##_args); \ + } + +static u8 * +format_ip_pmtu_flags (u8 *s, va_list *ap) +{ + ip_pmtu_flags_t f = va_arg (*ap, ip_pmtu_flags_t); + + if (0) + ; +#define _(a, b, c) else if (f & IP_PMTU_FLAG_##a) s = format (s, "%s ", c); + foreach_ip_pmtu_flag +#undef _ + + return (s); +} + +u32 +ip_pmtu_get_table_id (const ip_pmtu_t *ipt) +{ + const fib_prefix_t *pfx; + u32 fib_index; + + pfx = fib_entry_get_prefix (ipt->ipt_fib_entry); + fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry); + + return (fib_table_get_table_id (fib_index, pfx->fp_proto)); +} + +void +ip_pmtu_get_ip (const ip_pmtu_t *ipt, ip_address_t *ip) +{ + const fib_prefix_t *pfx; + + pfx = fib_entry_get_prefix (ipt->ipt_fib_entry); + ip_address_from_46 (&pfx->fp_addr, pfx->fp_proto, ip); +} + +static u8 * +format_ip_pmtu (u8 *s, va_list *ap) +{ + ip_pmtu_t *ipt; + index_t ipti = va_arg (*ap, index_t); + const fib_prefix_t *pfx; + u32 fib_index; + + ipt = pool_elt_at_index (ip_pmtu_pool, ipti); + pfx = fib_entry_get_prefix (ipt->ipt_fib_entry); + fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry); + + s = + format (s, "[%d] [tbl:[%d:%d]] %U pmtu:[cfg:%d, oper:%d, parent:%d] [%U]", + ipti, ip_pmtu_get_table_id (ipt), fib_index, format_fib_prefix, + pfx, ipt->ipt_cfg_pmtu, ipt->ipt_oper_pmtu, ipt->ipt_parent_pmtu, + format_ip_pmtu_flags, ipt->ipt_flags); + + return (s); +} + +static u8 * +format_ip_path_mtu_adj_delegate (const adj_delegate_t *aed, u8 *s) +{ + ip_path_mtu_adj_delegate_t *ip_adj; + + ip_adj = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, aed->ad_index); + + s = format (s, "IP path-MTU: %d", ip_adj->pmtu); + + return (s); +} + +static void +ip_pmtu_adj_delegate_adj_created (adj_index_t ai) +{ + ip_path_mtu_adj_delegate_t *ipp_ad; + const ip_pmtu_t *ipt; + ip_adjacency_t *adj; + u32 table_id; + uword *p; + + adj = adj_get (ai); + + switch (adj->lookup_next_index) + { + case IP_LOOKUP_NEXT_DROP: + case IP_LOOKUP_NEXT_PUNT: + case IP_LOOKUP_NEXT_LOCAL: + case IP_LOOKUP_NEXT_GLEAN: + case IP_LOOKUP_NEXT_MCAST: + case IP_LOOKUP_NEXT_BCAST: + case IP_LOOKUP_NEXT_MCAST_MIDCHAIN: + case IP_LOOKUP_NEXT_ICMP_ERROR: + case IP_LOOKUP_N_NEXT: + return; + + case IP_LOOKUP_NEXT_ARP: + case IP_LOOKUP_NEXT_REWRITE: + case IP_LOOKUP_NEXT_MIDCHAIN: + break; + } + + table_id = fib_table_get_table_id_for_sw_if_index ( + adj->ia_nh_proto, adj->rewrite_header.sw_if_index); + + ip_pmtu_key_t key = { + .nh = adj->sub_type.nbr.next_hop, + .table_id = table_id, + .fproto = adj->ia_nh_proto, + }; + + p = hash_get_mem (ip_pmtu_db, &key); + + if (NULL == p) + return; + + ipt = pool_elt_at_index (ip_pmtu_pool, p[0]); + + pool_get (ip_path_mtu_adj_delegate_pool, ipp_ad); + ipp_ad->pmtu = ipt->ipt_cfg_pmtu; + + adj_delegate_add (adj, ip_pmtu_adj_delegate_type, + ipp_ad - ip_path_mtu_adj_delegate_pool); + + adj_nbr_set_mtu (ai, ipp_ad->pmtu); + + IP_PMTU_TRKR_DBG (ipt, "adj-added:", ai); +} + +static void +ip_pmtu_adj_delegate_adj_deleted (adj_delegate_t *ad) +{ + pool_put_index (ip_path_mtu_adj_delegate_pool, ad->ad_index); +} + +static void +ip_pmtu_adj_delegate_adj_modified (adj_delegate_t *ad) +{ + ip_path_mtu_adj_delegate_t *ipp_ad; + + ipp_ad = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, ad->ad_index); + + adj_nbr_set_mtu (ad->ad_adj_index, ipp_ad->pmtu); +} + +const adj_delegate_vft_t ip_path_adj_delegate_vft = { + .adv_format = format_ip_path_mtu_adj_delegate, + .adv_adj_deleted = ip_pmtu_adj_delegate_adj_deleted, + .adv_adj_modified = ip_pmtu_adj_delegate_adj_modified, + .adv_adj_created = ip_pmtu_adj_delegate_adj_created, +}; + +static bool +ip_path_mtu_value_invalid (u16 pmtu) +{ + return (pmtu == 0 || pmtu == 0xffff); +} + +static adj_walk_rc_t +ip_ptmu_adj_walk_remove (adj_index_t ai, void *ctx) +{ + adj_delegate_t *ad; + + ad = adj_delegate_get (adj_get (ai), ip_pmtu_adj_delegate_type); + + if (ad) + { + adj_nbr_set_mtu (ai, 0); + + pool_put_index (ip_path_mtu_adj_delegate_pool, ad->ad_index); + adj_delegate_remove (ai, ip_pmtu_adj_delegate_type); + } + return (ADJ_WALK_RC_CONTINUE); +} + +static adj_walk_rc_t +ip_ptmu_adj_walk_update (adj_index_t ai, void *ctx) +{ + ip_path_mtu_adj_delegate_t *ipp_ad; + adj_delegate_t *ad; + u16 *pmtup; + + pmtup = ctx; + ad = adj_delegate_get (adj_get (ai), ip_pmtu_adj_delegate_type); + + if (ad) + ipp_ad = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, ad->ad_index); + else + { + pool_get (ip_path_mtu_adj_delegate_pool, ipp_ad); + + adj_delegate_add (adj_get (ai), ip_pmtu_adj_delegate_type, + ipp_ad - ip_path_mtu_adj_delegate_pool); + } + + ipp_ad->pmtu = *pmtup; + + adj_nbr_set_mtu (ai, ipp_ad->pmtu); + + return (ADJ_WALK_RC_CONTINUE); +} + +static ip_pmtu_dpo_t * +ip_pmtu_dpo_alloc (void) +{ + ip_pmtu_dpo_t *ipm; + + pool_get_aligned_zero (ip_pmtu_dpo_pool, ipm, sizeof (ip_pmtu_dpo_t)); + + return (ipm); +} + +static ip_pmtu_dpo_t * +ip_pmtu_dpo_get_from_dpo (const dpo_id_t *dpo) +{ + ASSERT (ip_pmtu_dpo_type == dpo->dpoi_type); + + return (ip_pmtu_dpo_get (dpo->dpoi_index)); +} + +static index_t +ip_pmtu_dpo_get_index (ip_pmtu_dpo_t *ipm) +{ + return (ipm - ip_pmtu_dpo_pool); +} + +static void +ip_pmtu_dpo_lock (dpo_id_t *dpo) +{ + ip_pmtu_dpo_t *ipm; + + ipm = ip_pmtu_dpo_get_from_dpo (dpo); + ipm->ipm_locks++; +} + +static void +ip_pmtu_dpo_unlock (dpo_id_t *dpo) +{ + ip_pmtu_dpo_t *ipm; + + ipm = ip_pmtu_dpo_get_from_dpo (dpo); + ipm->ipm_locks--; + + if (0 == ipm->ipm_locks) + { + dpo_reset (&ipm->ipm_dpo); + pool_put (ip_pmtu_dpo_pool, ipm); + } +} + +static u32 +ip_pmtu_dpo_get_urpf (const dpo_id_t *dpo) +{ + ip_pmtu_dpo_t *ipm; + + ipm = ip_pmtu_dpo_get_from_dpo (dpo); + + return (dpo_get_urpf (&ipm->ipm_dpo)); +} + +void +ip_pmtu_dpo_add_or_lock (fib_protocol_t fproto, u16 pmtu, dpo_id_t *dpo) +{ + ip_pmtu_dpo_t *ipm; + dpo_id_t parent = DPO_INVALID; + + ipm = ip_pmtu_dpo_alloc (); + + ipm->ipm_proto = fib_proto_to_dpo (fproto); + ipm->ipm_pmtu = pmtu; + + dpo_copy (&parent, drop_dpo_get (ipm->ipm_proto)); + dpo_stack (ip_pmtu_dpo_type, ipm->ipm_proto, &ipm->ipm_dpo, &parent); + dpo_set (dpo, ip_pmtu_dpo_type, ipm->ipm_proto, ip_pmtu_dpo_get_index (ipm)); +} + +u8 * +format_ip_pmtu_dpo (u8 *s, va_list *ap) +{ + index_t index = va_arg (*ap, index_t); + u32 indent = va_arg (*ap, u32); + ip_pmtu_dpo_t *ipm = ip_pmtu_dpo_get (index); + + s = format (s, "ip-pmtu-dpo: %U, mtu:%d", format_dpo_proto, ipm->ipm_proto, + ipm->ipm_pmtu); + s = format (s, "\n%U", format_white_space, indent + 2); + s = format (s, "%U", format_dpo_id, &ipm->ipm_dpo, indent + 4); + + return (s); +} + +/** + * Interpose a path MTU DPO + */ +static void +ip_pmtu_dpo_interpose (const dpo_id_t *original, const dpo_id_t *parent, + dpo_id_t *clone) +{ + ip_pmtu_dpo_t *ipm, *ipm_clone; + + ipm_clone = ip_pmtu_dpo_alloc (); + ipm = ip_pmtu_dpo_get (original->dpoi_index); + + ipm_clone->ipm_proto = ipm->ipm_proto; + ipm_clone->ipm_pmtu = ipm->ipm_pmtu; + + dpo_stack (ip_pmtu_dpo_type, ipm_clone->ipm_proto, &ipm_clone->ipm_dpo, + parent); + dpo_set (clone, ip_pmtu_dpo_type, ipm_clone->ipm_proto, + ip_pmtu_dpo_get_index (ipm_clone)); +} + +static u16 +ip_pmtu_dpo_get_mtu (const dpo_id_t *dpo) +{ + ip_pmtu_dpo_t *ipd; + + ipd = pool_elt_at_index (ip_pmtu_dpo_pool, dpo->dpoi_index); + + return (ipd->ipm_pmtu); +} + +const static dpo_vft_t ip_pmtu_dpo_vft = { + .dv_lock = ip_pmtu_dpo_lock, + .dv_unlock = ip_pmtu_dpo_unlock, + .dv_format = format_ip_pmtu_dpo, + .dv_get_urpf = ip_pmtu_dpo_get_urpf, + .dv_mk_interpose = ip_pmtu_dpo_interpose, + .dv_get_mtu = ip_pmtu_dpo_get_mtu, +}; + +/** + * @brief The per-protocol VLIB graph nodes that are assigned to a glean + * object. + * + * this means that these graph nodes are ones from which a glean is the + * parent object in the DPO-graph. + */ +const static char *const ip_pmtu_dpo_ip4_nodes[] = { + "ip4-pmtu-dpo", + NULL, +}; + +const static char *const ip_pmtu_dpo_ip6_nodes[] = { + "ip6-pmtu-dpo", + NULL, +}; + +const static char *const *const ip_pmtu_dpo_nodes[DPO_PROTO_NUM] = { + [DPO_PROTO_IP4] = ip_pmtu_dpo_ip4_nodes, + [DPO_PROTO_IP6] = ip_pmtu_dpo_ip6_nodes, +}; + +static bool +ip_mtu_fib_entry_is_attached (fib_node_index_t fib_entry) +{ + const fib_prefix_t *pfx; + u32 cover, fib_index; + + fib_index = fib_entry_get_fib_index (fib_entry); + pfx = fib_entry_get_prefix (fib_entry); + + /* + * If the tracked prefix's cover is attached, then all packets that + * are forwarded to this neighbour will use the adjacency, this is a + * more efficient place to perform the MTU check and fragging + */ + cover = fib_table_get_less_specific (fib_index, pfx); + + return (FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags (cover) || + FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags (fib_entry)); +} + +static index_t +ip_pmtu_alloc (u32 fib_index, const fib_prefix_t *pfx, + const ip_pmtu_key_t *key, u16 pmtu) +{ + dpo_id_t ip_dpo = DPO_INVALID; + ip_pmtu_t *ipt; + fib_node_index_t cover; + const dpo_id_t *lb_dpo; + index_t ipti; + + pool_get (ip_pmtu_pool, ipt); + fib_node_init (&(ipt->ipt_node), ip_pmtu_fib_type); + + ipti = ipt - ip_pmtu_pool; + hash_set_mem_alloc (&ip_pmtu_db, key, ipti); + + ipt->ipt_cfg_pmtu = pmtu; + ipt->ipt_fib_entry = fib_entry_track (fib_index, pfx, ip_pmtu_fib_type, ipti, + &ipt->ipt_sibling); + + /* + * If the tracked prefix's cover is attached, then all packets that + * are forwarded to this neighbour will use the adjacency, this is a + * more efficient place to perform the MTU check and fragging + */ + cover = fib_table_get_less_specific (fib_index, pfx); + + if (ip_mtu_fib_entry_is_attached (ipt->ipt_fib_entry)) + { + u32 sw_if_index; + + ipt->ipt_flags |= IP_PMTU_FLAG_ATTACHED; + ipt->ipt_oper_pmtu = ipt->ipt_cfg_pmtu; + + sw_if_index = fib_entry_get_resolving_interface (cover); + + /* walk all adjs to add/update delegate */ + adj_nbr_walk_nh (sw_if_index, pfx->fp_proto, &pfx->fp_addr, + ip_ptmu_adj_walk_update, &ipt->ipt_oper_pmtu); + } + else + { + ipt->ipt_flags |= IP_PMTU_FLAG_REMOTE; + + lb_dpo = fib_entry_contribute_ip_forwarding (ipt->ipt_fib_entry); + + ipt->ipt_oper_pmtu = clib_min (dpo_get_mtu (lb_dpo), ipt->ipt_cfg_pmtu); + + /* + * interpose a policy DPO from the nh so that MTU is applied + */ + ip_pmtu_dpo_add_or_lock (pfx->fp_proto, ipt->ipt_oper_pmtu, &ip_dpo); + + fib_table_entry_special_dpo_add (fib_index, pfx, ip_pmtu_source, + FIB_ENTRY_FLAG_INTERPOSE, &ip_dpo); + dpo_reset (&ip_dpo); + } + + IP_PMTU_TRKR_DBG (ipt, "create"); + + return (ipti); +} + +static void +ip_pmtu_stack (ip_pmtu_t *ipt) +{ + bool was_attached, is_attached; + const fib_prefix_t *pfx; + u32 fib_index; + + pfx = fib_entry_get_prefix (ipt->ipt_fib_entry); + fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry); + + was_attached = !!(ipt->ipt_flags & IP_PMTU_FLAG_ATTACHED); + is_attached = ip_mtu_fib_entry_is_attached (ipt->ipt_fib_entry); + + if (was_attached && !is_attached) + { + /* transition from attached to remote - walk all adjs to remove delegate + */ + adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry), + pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_remove, + &ipt->ipt_oper_pmtu); + ipt->ipt_flags &= ~IP_PMTU_FLAG_ATTACHED; + } + if (!was_attached && is_attached) + { + /* transition from remote to attached - remove the DPO */ + fib_table_entry_special_remove (fib_index, pfx, ip_pmtu_source); + ipt->ipt_flags &= ~IP_PMTU_FLAG_REMOTE; + } + + if (is_attached) + { + /* walk all adjs to add/update delegate */ + ipt->ipt_oper_pmtu = ipt->ipt_cfg_pmtu; + adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry), + pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_update, + &ipt->ipt_oper_pmtu); + ipt->ipt_flags |= IP_PMTU_FLAG_ATTACHED; + } + else + { + const dpo_id_t *lb_dpo; + u16 dpo_mtu; + + fib_table_entry_special_remove (fib_index, pfx, ip_pmtu_source); + + ipt->ipt_flags |= IP_PMTU_FLAG_REMOTE; + lb_dpo = fib_entry_contribute_ip_forwarding (ipt->ipt_fib_entry); + dpo_mtu = dpo_get_mtu (lb_dpo); + + ipt->ipt_oper_pmtu = clib_min (dpo_mtu, ipt->ipt_cfg_pmtu); + + /* + * if the configured path-MTU is less that the egress/interface then + * interpose a policy DPO from the nh so that MTU is applied + */ + if (ipt->ipt_oper_pmtu < dpo_mtu) + { + dpo_id_t ip_dpo = DPO_INVALID; + + ip_pmtu_dpo_add_or_lock (pfx->fp_proto, ipt->ipt_oper_pmtu, &ip_dpo); + + fib_table_entry_special_dpo_update ( + fib_index, pfx, ip_pmtu_source, FIB_ENTRY_FLAG_INTERPOSE, &ip_dpo); + dpo_reset (&ip_dpo); + } + } + IP_PMTU_TRKR_DBG (ipt, "stack"); +} + +static void +ip_pmtu_update (index_t ipti, u16 pmtu) +{ + ip_pmtu_t *ipt; + + ipt = pool_elt_at_index (ip_pmtu_pool, ipti); + ipt->ipt_flags &= ~IP_PMTU_FLAG_STALE; + ipt->ipt_cfg_pmtu = pmtu; + + ip_pmtu_stack (ipt); +} + +static index_t +ip_pmtu_destroy (index_t ipti, const ip_pmtu_key_t *key) +{ + ip_pmtu_t *ipt; + const fib_prefix_t *pfx; + + ipt = pool_elt_at_index (ip_pmtu_pool, ipti); + pfx = fib_entry_get_prefix (ipt->ipt_fib_entry); + + IP_PMTU_TRKR_DBG (ipt, "destroy"); + + if (ipt->ipt_flags & IP_PMTU_FLAG_REMOTE) + fib_table_entry_special_remove ( + fib_entry_get_fib_index (ipt->ipt_fib_entry), pfx, ip_pmtu_source); + else + /* remove the delegate from all the adjacencies */ + adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry), + pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_remove, + NULL); + + /* + * Drop the fib entry we're tracking + */ + fib_entry_untrack (ipt->ipt_fib_entry, ipt->ipt_sibling); + + /* + * remove from DB and return to pool + */ + hash_unset_mem_free (&ip_pmtu_db, key); + pool_put (ip_pmtu_pool, ipt); + + return (ipti); +} + +int +ip_path_mtu_update (const ip_address_t *nh, u32 table_id, u16 pmtu) +{ + fib_prefix_t pfx; + u32 fib_index; + uword *p; + + ip_address_to_fib_prefix (nh, &pfx); + fib_index = fib_table_find (pfx.fp_proto, table_id); + + if (~0 == fib_index) + return (VNET_API_ERROR_NO_SUCH_TABLE); + + ip_pmtu_key_t key = { + .fproto = pfx.fp_proto, + .table_id = table_id, + .nh = pfx.fp_addr, + }; + + p = hash_get_mem (ip_pmtu_db, &key); + + if (!ip_path_mtu_value_invalid (pmtu)) + { + /* Add or update of path MTU */ + if (NULL == p) + ip_pmtu_alloc (fib_index, &pfx, &key, pmtu); + else + ip_pmtu_update (p[0], pmtu); + } + else + { + if (NULL != p) + ip_pmtu_destroy (p[0], &key); + } + + return (0); +} + +static walk_rc_t +ip_path_mtu_walk_mark (index_t ipti, void *ctx) +{ + ip_pmtu_t *ipt; + + ipt = ip_path_mtu_get (ipti); + + ipt->ipt_flags |= IP_PMTU_FLAG_STALE; + + return (WALK_CONTINUE); +} + +typedef struct ip_path_mtu_walk_sweep_ctx_t_ +{ + index_t *indicies; +} ip_path_mtu_walk_sweep_ctx_t; + +static walk_rc_t +ip_path_mtu_walk_sweep (index_t ipti, void *arg) +{ + ip_path_mtu_walk_sweep_ctx_t *ctx = arg; + ip_pmtu_t *ipt; + + ipt = ip_path_mtu_get (ipti); + + if (ipt->ipt_flags & IP_PMTU_FLAG_STALE) + { + vec_add1 (ctx->indicies, ipti); + } + + return (WALK_CONTINUE); +} + +int +ip_path_mtu_replace_begin (void) +{ + IP_PMTU_DBG ("replace-begin"); + + ip_path_mtu_walk (ip_path_mtu_walk_mark, NULL); + + return (0); +} + +int +ip_path_mtu_replace_end (void) +{ + index_t *ipti; + + IP_PMTU_DBG ("replace-end"); + + /* + * not safe to walk the pool whilst deleting, so create + * temporary storage of stale entries + */ + ip_path_mtu_walk_sweep_ctx_t ctx = { + .indicies = NULL, + }; + + ip_path_mtu_walk (ip_path_mtu_walk_sweep, &ctx); + + vec_foreach (ipti, ctx.indicies) + { + ip_pmtu_t *ipt; + ip_address_t ip; + + ipt = ip_path_mtu_get (*ipti); + ip_pmtu_get_ip (ipt, &ip); + ip_path_mtu_update (&ip, ip_pmtu_get_table_id (ipt), 0); + } + + vec_free (ctx.indicies); + + return (0); +} + +void +ip_path_mtu_walk (ip_path_mtu_walk_t fn, void *ctx) +{ + index_t ipmi; + + pool_foreach_index (ipmi, ip_pmtu_pool) + { + if (WALK_STOP == fn (ipmi, ctx)) + break; + } +} + +static fib_node_t * +ip_pmtu_get_node (fib_node_index_t index) +{ + ip_pmtu_t *ipt; + + ipt = pool_elt_at_index (ip_pmtu_pool, index); + + return (&(ipt->ipt_node)); +} + +static ip_pmtu_t * +ip_pmtu_get_from_node (fib_node_t *node) +{ + return ( + (ip_pmtu_t *) (((char *) node) - STRUCT_OFFSET_OF (ip_pmtu_t, ipt_node))); +} + +static void +ip_pmtu_last_lock_gone (fib_node_t *node) +{ + /* + * the lifetime of the entry is managed by the API. + */ + ASSERT (0); +} + +/* + * A back walk has reached this BIER entry + */ +static fib_node_back_walk_rc_t +ip_pmtu_back_walk_notify (fib_node_t *node, fib_node_back_walk_ctx_t *ctx) +{ + /* + * re-populate the ECMP tables with new choices + */ + ip_pmtu_t *ipr = ip_pmtu_get_from_node (node); + + ip_pmtu_stack (ipr); + + /* + * no need to propagate further up the graph, since there's nothing there + */ + return (FIB_NODE_BACK_WALK_CONTINUE); +} + +static const fib_node_vft_t ip_ptmu_fib_node_vft = { + .fnv_get = ip_pmtu_get_node, + .fnv_last_lock = ip_pmtu_last_lock_gone, + .fnv_back_walk = ip_pmtu_back_walk_notify, +}; + +static clib_error_t * +ip_path_module_init (vlib_main_t *vm) +{ + ip_pmtu_adj_delegate_type = + adj_delegate_register_new_type (&ip_path_adj_delegate_vft); + ip_pmtu_source = fib_source_allocate ("path-mtu", FIB_SOURCE_PRIORITY_HI, + FIB_SOURCE_BH_SIMPLE); + ip_pmtu_fib_type = fib_node_register_new_type (&ip_ptmu_fib_node_vft); + + ip_pmtu_db = hash_create_mem (0, sizeof (ip_pmtu_key_t), sizeof (index_t)); + ip_pmtu_logger = vlib_log_register_class ("ip", "pmtu"); + ip_pmtu_dpo_type = + dpo_register_new_type (&ip_pmtu_dpo_vft, ip_pmtu_dpo_nodes); + + return (NULL); +} + +VLIB_INIT_FUNCTION (ip_path_module_init); + +static clib_error_t * +show_ip_pmtu_command (vlib_main_t *vm, unformat_input_t *input, + vlib_cli_command_t *cmd) +{ + index_t ipti; + + if (unformat (input, "%d", &ipti)) + { + /* + * show one in detail + */ + if (!pool_is_free_index (ip_pmtu_pool, ipti)) + vlib_cli_output (vm, "%U", format_ip_pmtu, ipti); + else + vlib_cli_output (vm, "entry %d invalid", ipti); + } + else + { + /* + * show all + */ + pool_foreach_index (ipti, ip_pmtu_pool) + { + vlib_cli_output (vm, "%U", format_ip_pmtu, ipti); + } + } + + return (NULL); +} + +VLIB_CLI_COMMAND (show_fib_entry, static) = { + .path = "show ip pmtu", + .function = show_ip_pmtu_command, + .short_help = "show ip path MTU", +}; + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ -- cgit 1.2.3-korg