2 *------------------------------------------------------------------
5 * Copyright (c) 2021 Graphiant.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
20 #include <vnet/ip/ip_path_mtu.h>
21 #include <vnet/ip/ip_frag.h>
22 #include <vnet/adj/adj_delegate.h>
23 #include <vnet/adj/adj_nbr.h>
24 #include <vnet/fib/fib_table.h>
25 #include <vnet/fib/fib_entry_track.h>
27 #include <vnet/dpo/drop_dpo.h>
32 * A path is a peer. A peer is known by an IP address (in a table).
33 * Insert a DPO in the forwarding chain for the peer to perform the
35 * For attached peers, all traffic will use the peer's adjacency, there
36 * is already an MTU chekc in the adjacency (for the link's MTU) so as an
37 * optimisation, instead of using a DPO, we add a delegate to the adjacency
38 * to set the adjacency's MTU to the path MTU.
44 static vlib_log_class_t ip_pmtu_logger;
46 static adj_delegate_type_t ip_pmtu_adj_delegate_type;
47 static fib_source_t ip_pmtu_source;
52 ip_pmtu_dpo_t *ip_pmtu_dpo_pool;
55 * DPO type registered for these GBP FWD
57 static dpo_type_t ip_pmtu_dpo_type;
60 * Fib node type for the tracker
62 static fib_node_type_t ip_pmtu_fib_type;
65 * Path MTU tracker pool
67 ip_pmtu_t *ip_pmtu_pool;
70 * Delegate added to adjacencies to track path MTU
72 typedef struct ip_path_mtu_adj_delegate_t_
75 } ip_path_mtu_adj_delegate_t;
77 static ip_path_mtu_adj_delegate_t *ip_path_mtu_adj_delegate_pool;
79 /* DB of all FIB PMTU settings */
80 typedef struct ip_pmtu_key_t_
84 fib_protocol_t fproto;
85 } __clib_packed ip_pmtu_key_t;
87 static uword *ip_pmtu_db;
89 #define IP_PMTU_TRKR_DBG(_ipt, _fmt, _args...) \
91 vlib_log_debug (ip_pmtu_logger, "[%U]: " _fmt ": ", format_ip_pmtu, \
92 _ipt - ip_pmtu_pool, ##_args); \
94 #define IP_PMTU_DBG(_fmt, _args...) \
96 vlib_log_debug (ip_pmtu_logger, _fmt ": ", ##_args); \
100 format_ip_pmtu_flags (u8 *s, va_list *ap)
102 ip_pmtu_flags_t f = va_arg (*ap, ip_pmtu_flags_t);
106 #define _(a, b, c) else if (f & IP_PMTU_FLAG_##a) s = format (s, "%s ", c);
114 ip_pmtu_get_table_id (const ip_pmtu_t *ipt)
116 const fib_prefix_t *pfx;
119 pfx = fib_entry_get_prefix (ipt->ipt_fib_entry);
120 fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry);
122 return (fib_table_get_table_id (fib_index, pfx->fp_proto));
126 ip_pmtu_get_ip (const ip_pmtu_t *ipt, ip_address_t *ip)
128 const fib_prefix_t *pfx;
130 pfx = fib_entry_get_prefix (ipt->ipt_fib_entry);
131 ip_address_from_46 (&pfx->fp_addr, pfx->fp_proto, ip);
135 format_ip_pmtu (u8 *s, va_list *ap)
138 index_t ipti = va_arg (*ap, index_t);
139 const fib_prefix_t *pfx;
142 ipt = pool_elt_at_index (ip_pmtu_pool, ipti);
143 pfx = fib_entry_get_prefix (ipt->ipt_fib_entry);
144 fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry);
147 format (s, "[%d] [tbl:[%d:%d]] %U pmtu:[cfg:%d, oper:%d, parent:%d] [%U]",
148 ipti, ip_pmtu_get_table_id (ipt), fib_index, format_fib_prefix,
149 pfx, ipt->ipt_cfg_pmtu, ipt->ipt_oper_pmtu, ipt->ipt_parent_pmtu,
150 format_ip_pmtu_flags, ipt->ipt_flags);
156 format_ip_path_mtu_adj_delegate (const adj_delegate_t *aed, u8 *s)
158 ip_path_mtu_adj_delegate_t *ip_adj;
160 ip_adj = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, aed->ad_index);
162 s = format (s, "IP path-MTU: %d", ip_adj->pmtu);
168 ip_pmtu_adj_delegate_adj_created (adj_index_t ai)
170 ip_path_mtu_adj_delegate_t *ipp_ad;
171 const ip_pmtu_t *ipt;
178 switch (adj->lookup_next_index)
180 case IP_LOOKUP_NEXT_DROP:
181 case IP_LOOKUP_NEXT_PUNT:
182 case IP_LOOKUP_NEXT_LOCAL:
183 case IP_LOOKUP_NEXT_GLEAN:
184 case IP_LOOKUP_NEXT_MCAST:
185 case IP_LOOKUP_NEXT_BCAST:
186 case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
187 case IP_LOOKUP_NEXT_ICMP_ERROR:
188 case IP_LOOKUP_N_NEXT:
191 case IP_LOOKUP_NEXT_ARP:
192 case IP_LOOKUP_NEXT_REWRITE:
193 case IP_LOOKUP_NEXT_MIDCHAIN:
197 table_id = fib_table_get_table_id_for_sw_if_index (
198 adj->ia_nh_proto, adj->rewrite_header.sw_if_index);
200 ip_pmtu_key_t key = {
201 .nh = adj->sub_type.nbr.next_hop,
202 .table_id = table_id,
203 .fproto = adj->ia_nh_proto,
206 p = hash_get_mem (ip_pmtu_db, &key);
211 ipt = pool_elt_at_index (ip_pmtu_pool, p[0]);
213 pool_get (ip_path_mtu_adj_delegate_pool, ipp_ad);
214 ipp_ad->pmtu = ipt->ipt_cfg_pmtu;
216 adj_delegate_add (adj, ip_pmtu_adj_delegate_type,
217 ipp_ad - ip_path_mtu_adj_delegate_pool);
219 adj_nbr_set_mtu (ai, ipp_ad->pmtu);
221 IP_PMTU_TRKR_DBG (ipt, "adj-added:", ai);
225 ip_pmtu_adj_delegate_adj_deleted (adj_delegate_t *ad)
227 pool_put_index (ip_path_mtu_adj_delegate_pool, ad->ad_index);
231 ip_pmtu_adj_delegate_adj_modified (adj_delegate_t *ad)
233 ip_path_mtu_adj_delegate_t *ipp_ad;
235 ipp_ad = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, ad->ad_index);
237 adj_nbr_set_mtu (ad->ad_adj_index, ipp_ad->pmtu);
240 const adj_delegate_vft_t ip_path_adj_delegate_vft = {
241 .adv_format = format_ip_path_mtu_adj_delegate,
242 .adv_adj_deleted = ip_pmtu_adj_delegate_adj_deleted,
243 .adv_adj_modified = ip_pmtu_adj_delegate_adj_modified,
244 .adv_adj_created = ip_pmtu_adj_delegate_adj_created,
248 ip_path_mtu_value_invalid (u16 pmtu)
250 return (pmtu == 0 || pmtu == 0xffff);
254 ip_ptmu_adj_walk_remove (adj_index_t ai, void *ctx)
258 ad = adj_delegate_get (adj_get (ai), ip_pmtu_adj_delegate_type);
262 adj_nbr_set_mtu (ai, 0);
264 pool_put_index (ip_path_mtu_adj_delegate_pool, ad->ad_index);
265 adj_delegate_remove (ai, ip_pmtu_adj_delegate_type);
267 return (ADJ_WALK_RC_CONTINUE);
271 ip_ptmu_adj_walk_update (adj_index_t ai, void *ctx)
273 ip_path_mtu_adj_delegate_t *ipp_ad;
278 ad = adj_delegate_get (adj_get (ai), ip_pmtu_adj_delegate_type);
281 ipp_ad = pool_elt_at_index (ip_path_mtu_adj_delegate_pool, ad->ad_index);
284 pool_get (ip_path_mtu_adj_delegate_pool, ipp_ad);
286 adj_delegate_add (adj_get (ai), ip_pmtu_adj_delegate_type,
287 ipp_ad - ip_path_mtu_adj_delegate_pool);
290 ipp_ad->pmtu = *pmtup;
292 adj_nbr_set_mtu (ai, ipp_ad->pmtu);
294 return (ADJ_WALK_RC_CONTINUE);
297 static ip_pmtu_dpo_t *
298 ip_pmtu_dpo_alloc (void)
300 vlib_main_t *vm = vlib_get_main ();
301 u8 need_barrier_sync = pool_get_will_expand (ip_pmtu_dpo_pool);
305 if (need_barrier_sync)
306 vlib_worker_thread_barrier_sync (vm);
308 pool_get_aligned_zero (ip_pmtu_dpo_pool, ipm, sizeof (ip_pmtu_dpo_t));
310 if (need_barrier_sync)
311 vlib_worker_thread_barrier_release (vm);
316 static ip_pmtu_dpo_t *
317 ip_pmtu_dpo_get_from_dpo (const dpo_id_t *dpo)
319 ASSERT (ip_pmtu_dpo_type == dpo->dpoi_type);
321 return (ip_pmtu_dpo_get (dpo->dpoi_index));
325 ip_pmtu_dpo_get_index (ip_pmtu_dpo_t *ipm)
327 return (ipm - ip_pmtu_dpo_pool);
331 ip_pmtu_dpo_lock (dpo_id_t *dpo)
335 ipm = ip_pmtu_dpo_get_from_dpo (dpo);
340 ip_pmtu_dpo_unlock (dpo_id_t *dpo)
344 ipm = ip_pmtu_dpo_get_from_dpo (dpo);
347 if (0 == ipm->ipm_locks)
349 dpo_reset (&ipm->ipm_dpo);
350 pool_put (ip_pmtu_dpo_pool, ipm);
355 ip_pmtu_dpo_get_urpf (const dpo_id_t *dpo)
359 ipm = ip_pmtu_dpo_get_from_dpo (dpo);
361 return (dpo_get_urpf (&ipm->ipm_dpo));
365 ip_pmtu_dpo_add_or_lock (u16 pmtu, const dpo_id_t *parent, dpo_id_t *dpo)
369 ipm = ip_pmtu_dpo_alloc ();
371 ipm->ipm_proto = parent->dpoi_proto;
372 ipm->ipm_pmtu = pmtu;
374 dpo_stack (ip_pmtu_dpo_type, ipm->ipm_proto, &ipm->ipm_dpo, parent);
375 dpo_set (dpo, ip_pmtu_dpo_type, ipm->ipm_proto, ip_pmtu_dpo_get_index (ipm));
379 format_ip_pmtu_dpo (u8 *s, va_list *ap)
381 index_t index = va_arg (*ap, index_t);
382 u32 indent = va_arg (*ap, u32);
383 ip_pmtu_dpo_t *ipm = ip_pmtu_dpo_get (index);
385 s = format (s, "ip-pmtu-dpo: %U, mtu:%d", format_dpo_proto, ipm->ipm_proto,
387 s = format (s, "\n%U", format_white_space, indent + 2);
388 s = format (s, "%U", format_dpo_id, &ipm->ipm_dpo, indent + 4);
394 * Interpose a path MTU DPO
397 ip_pmtu_dpo_interpose (const dpo_id_t *original, const dpo_id_t *parent,
400 ip_pmtu_dpo_t *ipm, *ipm_clone;
402 ipm_clone = ip_pmtu_dpo_alloc ();
403 ipm = ip_pmtu_dpo_get (original->dpoi_index);
405 ipm_clone->ipm_proto = ipm->ipm_proto;
406 ipm_clone->ipm_pmtu = ipm->ipm_pmtu;
408 dpo_stack (ip_pmtu_dpo_type, ipm_clone->ipm_proto, &ipm_clone->ipm_dpo,
410 dpo_set (clone, ip_pmtu_dpo_type, ipm_clone->ipm_proto,
411 ip_pmtu_dpo_get_index (ipm_clone));
415 ip_pmtu_dpo_get_mtu (const dpo_id_t *dpo)
419 ipd = pool_elt_at_index (ip_pmtu_dpo_pool, dpo->dpoi_index);
421 return (ipd->ipm_pmtu);
424 const static dpo_vft_t ip_pmtu_dpo_vft = {
425 .dv_lock = ip_pmtu_dpo_lock,
426 .dv_unlock = ip_pmtu_dpo_unlock,
427 .dv_format = format_ip_pmtu_dpo,
428 .dv_get_urpf = ip_pmtu_dpo_get_urpf,
429 .dv_mk_interpose = ip_pmtu_dpo_interpose,
430 .dv_get_mtu = ip_pmtu_dpo_get_mtu,
434 * @brief The per-protocol VLIB graph nodes that are assigned to a glean
437 * this means that these graph nodes are ones from which a glean is the
438 * parent object in the DPO-graph.
440 const static char *const ip_pmtu_dpo_ip4_nodes[] = {
445 const static char *const ip_pmtu_dpo_ip6_nodes[] = {
450 const static char *const *const ip_pmtu_dpo_nodes[DPO_PROTO_NUM] = {
451 [DPO_PROTO_IP4] = ip_pmtu_dpo_ip4_nodes,
452 [DPO_PROTO_IP6] = ip_pmtu_dpo_ip6_nodes,
456 ip_mtu_fib_entry_is_attached (fib_node_index_t fib_entry)
458 const fib_prefix_t *pfx;
459 u32 cover, fib_index;
461 fib_index = fib_entry_get_fib_index (fib_entry);
462 pfx = fib_entry_get_prefix (fib_entry);
465 * If the tracked prefix's cover is attached, then all packets that
466 * are forwarded to this neighbour will use the adjacency, this is a
467 * more efficient place to perform the MTU check and fragging
469 cover = fib_table_get_less_specific (fib_index, pfx);
471 return (FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags (cover) ||
472 FIB_ENTRY_FLAG_ATTACHED & fib_entry_get_flags (fib_entry));
476 ip_pmtu_alloc (u32 fib_index, const fib_prefix_t *pfx,
477 const ip_pmtu_key_t *key, u16 pmtu)
479 dpo_id_t ip_dpo = DPO_INVALID;
481 fib_node_index_t cover;
482 const dpo_id_t *lb_dpo;
485 pool_get (ip_pmtu_pool, ipt);
486 fib_node_init (&(ipt->ipt_node), ip_pmtu_fib_type);
488 ipti = ipt - ip_pmtu_pool;
489 hash_set_mem_alloc (&ip_pmtu_db, key, ipti);
491 ipt->ipt_cfg_pmtu = pmtu;
492 ipt->ipt_fib_entry = fib_entry_track (fib_index, pfx, ip_pmtu_fib_type, ipti,
496 * If the tracked prefix's cover is attached, then all packets that
497 * are forwarded to this neighbour will use the adjacency, this is a
498 * more efficient place to perform the MTU check and fragging
500 cover = fib_table_get_less_specific (fib_index, pfx);
502 if (ip_mtu_fib_entry_is_attached (ipt->ipt_fib_entry))
506 ipt->ipt_flags |= IP_PMTU_FLAG_ATTACHED;
507 ipt->ipt_oper_pmtu = ipt->ipt_cfg_pmtu;
509 sw_if_index = fib_entry_get_resolving_interface (cover);
511 /* walk all adjs to add/update delegate */
512 adj_nbr_walk_nh (sw_if_index, pfx->fp_proto, &pfx->fp_addr,
513 ip_ptmu_adj_walk_update, &ipt->ipt_oper_pmtu);
517 ipt->ipt_flags |= IP_PMTU_FLAG_REMOTE;
519 lb_dpo = fib_entry_contribute_ip_forwarding (ipt->ipt_fib_entry);
521 ipt->ipt_oper_pmtu = clib_min (dpo_get_mtu (lb_dpo), ipt->ipt_cfg_pmtu);
524 * interpose a policy DPO from the nh so that MTU is applied
526 ip_pmtu_dpo_add_or_lock (ipt->ipt_oper_pmtu,
527 drop_dpo_get (fib_proto_to_dpo (pfx->fp_proto)),
530 fib_table_entry_special_dpo_add (fib_index, pfx, ip_pmtu_source,
531 FIB_ENTRY_FLAG_INTERPOSE, &ip_dpo);
535 IP_PMTU_TRKR_DBG (ipt, "create");
541 ip_pmtu_stack (ip_pmtu_t *ipt)
543 bool was_attached, is_attached;
544 const fib_prefix_t *pfx;
547 pfx = fib_entry_get_prefix (ipt->ipt_fib_entry);
548 fib_index = fib_entry_get_fib_index (ipt->ipt_fib_entry);
550 was_attached = !!(ipt->ipt_flags & IP_PMTU_FLAG_ATTACHED);
551 is_attached = ip_mtu_fib_entry_is_attached (ipt->ipt_fib_entry);
553 if (was_attached && !is_attached)
555 /* transition from attached to remote - walk all adjs to remove delegate
557 adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry),
558 pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_remove,
559 &ipt->ipt_oper_pmtu);
560 ipt->ipt_flags &= ~IP_PMTU_FLAG_ATTACHED;
562 if (!was_attached && is_attached)
564 /* transition from remote to attached - remove the DPO */
565 fib_table_entry_special_remove (fib_index, pfx, ip_pmtu_source);
566 ipt->ipt_flags &= ~IP_PMTU_FLAG_REMOTE;
571 /* walk all adjs to add/update delegate */
572 ipt->ipt_oper_pmtu = ipt->ipt_cfg_pmtu;
573 adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry),
574 pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_update,
575 &ipt->ipt_oper_pmtu);
576 ipt->ipt_flags |= IP_PMTU_FLAG_ATTACHED;
580 const dpo_id_t *lb_dpo;
583 fib_table_entry_special_remove (fib_index, pfx, ip_pmtu_source);
585 ipt->ipt_flags |= IP_PMTU_FLAG_REMOTE;
586 lb_dpo = fib_entry_contribute_ip_forwarding (ipt->ipt_fib_entry);
587 dpo_mtu = dpo_get_mtu (lb_dpo);
589 ipt->ipt_oper_pmtu = clib_min (dpo_mtu, ipt->ipt_cfg_pmtu);
592 * if the configured path-MTU is less that the egress/interface then
593 * interpose a policy DPO from the nh so that MTU is applied
595 if (ipt->ipt_oper_pmtu < dpo_mtu)
597 dpo_id_t ip_dpo = DPO_INVALID;
599 ip_pmtu_dpo_add_or_lock (
601 drop_dpo_get (fib_proto_to_dpo (pfx->fp_proto)), &ip_dpo);
603 fib_table_entry_special_dpo_update (
604 fib_index, pfx, ip_pmtu_source, FIB_ENTRY_FLAG_INTERPOSE, &ip_dpo);
608 IP_PMTU_TRKR_DBG (ipt, "stack");
612 ip_pmtu_update (index_t ipti, u16 pmtu)
616 ipt = pool_elt_at_index (ip_pmtu_pool, ipti);
617 ipt->ipt_flags &= ~IP_PMTU_FLAG_STALE;
618 ipt->ipt_cfg_pmtu = pmtu;
624 ip_pmtu_destroy (index_t ipti, const ip_pmtu_key_t *key)
627 const fib_prefix_t *pfx;
629 ipt = pool_elt_at_index (ip_pmtu_pool, ipti);
630 pfx = fib_entry_get_prefix (ipt->ipt_fib_entry);
632 IP_PMTU_TRKR_DBG (ipt, "destroy");
634 if (ipt->ipt_flags & IP_PMTU_FLAG_REMOTE)
635 fib_table_entry_special_remove (
636 fib_entry_get_fib_index (ipt->ipt_fib_entry), pfx, ip_pmtu_source);
638 /* remove the delegate from all the adjacencies */
639 adj_nbr_walk_nh (fib_entry_get_resolving_interface (ipt->ipt_fib_entry),
640 pfx->fp_proto, &pfx->fp_addr, ip_ptmu_adj_walk_remove,
644 * Drop the fib entry we're tracking
646 fib_entry_untrack (ipt->ipt_fib_entry, ipt->ipt_sibling);
649 * remove from DB and return to pool
651 hash_unset_mem_free (&ip_pmtu_db, key);
652 pool_put (ip_pmtu_pool, ipt);
658 ip_path_mtu_update (const ip_address_t *nh, u32 table_id, u16 pmtu)
664 ip_address_to_fib_prefix (nh, &pfx);
665 fib_index = fib_table_find (pfx.fp_proto, table_id);
668 return (VNET_API_ERROR_NO_SUCH_TABLE);
670 ip_pmtu_key_t key = {
671 .fproto = pfx.fp_proto,
672 .table_id = table_id,
676 p = hash_get_mem (ip_pmtu_db, &key);
678 if (!ip_path_mtu_value_invalid (pmtu))
680 /* Add or update of path MTU */
682 ip_pmtu_alloc (fib_index, &pfx, &key, pmtu);
684 ip_pmtu_update (p[0], pmtu);
689 ip_pmtu_destroy (p[0], &key);
696 ip_path_mtu_walk_mark (index_t ipti, void *ctx)
700 ipt = ip_path_mtu_get (ipti);
702 ipt->ipt_flags |= IP_PMTU_FLAG_STALE;
704 return (WALK_CONTINUE);
707 typedef struct ip_path_mtu_walk_sweep_ctx_t_
710 } ip_path_mtu_walk_sweep_ctx_t;
713 ip_path_mtu_walk_sweep (index_t ipti, void *arg)
715 ip_path_mtu_walk_sweep_ctx_t *ctx = arg;
718 ipt = ip_path_mtu_get (ipti);
720 if (ipt->ipt_flags & IP_PMTU_FLAG_STALE)
722 vec_add1 (ctx->indicies, ipti);
725 return (WALK_CONTINUE);
729 ip_path_mtu_replace_begin (void)
731 IP_PMTU_DBG ("replace-begin");
733 ip_path_mtu_walk (ip_path_mtu_walk_mark, NULL);
739 ip_path_mtu_replace_end (void)
743 IP_PMTU_DBG ("replace-end");
746 * not safe to walk the pool whilst deleting, so create
747 * temporary storage of stale entries
749 ip_path_mtu_walk_sweep_ctx_t ctx = {
753 ip_path_mtu_walk (ip_path_mtu_walk_sweep, &ctx);
755 vec_foreach (ipti, ctx.indicies)
760 ipt = ip_path_mtu_get (*ipti);
761 ip_pmtu_get_ip (ipt, &ip);
762 ip_path_mtu_update (&ip, ip_pmtu_get_table_id (ipt), 0);
765 vec_free (ctx.indicies);
771 ip_path_mtu_walk (ip_path_mtu_walk_t fn, void *ctx)
775 pool_foreach_index (ipmi, ip_pmtu_pool)
777 if (WALK_STOP == fn (ipmi, ctx))
783 ip_pmtu_get_node (fib_node_index_t index)
787 ipt = pool_elt_at_index (ip_pmtu_pool, index);
789 return (&(ipt->ipt_node));
793 ip_pmtu_get_from_node (fib_node_t *node)
796 (ip_pmtu_t *) (((char *) node) - STRUCT_OFFSET_OF (ip_pmtu_t, ipt_node)));
800 ip_pmtu_last_lock_gone (fib_node_t *node)
803 * the lifetime of the entry is managed by the API.
809 * A back walk has reached this BIER entry
811 static fib_node_back_walk_rc_t
812 ip_pmtu_back_walk_notify (fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
815 * re-populate the ECMP tables with new choices
817 ip_pmtu_t *ipr = ip_pmtu_get_from_node (node);
822 * no need to propagate further up the graph, since there's nothing there
824 return (FIB_NODE_BACK_WALK_CONTINUE);
827 static const fib_node_vft_t ip_ptmu_fib_node_vft = {
828 .fnv_get = ip_pmtu_get_node,
829 .fnv_last_lock = ip_pmtu_last_lock_gone,
830 .fnv_back_walk = ip_pmtu_back_walk_notify,
833 static clib_error_t *
834 ip_path_module_init (vlib_main_t *vm)
836 ip_pmtu_adj_delegate_type =
837 adj_delegate_register_new_type (&ip_path_adj_delegate_vft);
838 ip_pmtu_source = fib_source_allocate ("path-mtu", FIB_SOURCE_PRIORITY_HI,
839 FIB_SOURCE_BH_SIMPLE);
841 fib_node_register_new_type ("ip-pmtu", &ip_ptmu_fib_node_vft);
843 ip_pmtu_db = hash_create_mem (0, sizeof (ip_pmtu_key_t), sizeof (index_t));
844 ip_pmtu_logger = vlib_log_register_class ("ip", "pmtu");
846 dpo_register_new_type (&ip_pmtu_dpo_vft, ip_pmtu_dpo_nodes);
851 VLIB_INIT_FUNCTION (ip_path_module_init);
853 static clib_error_t *
854 show_ip_pmtu_command (vlib_main_t *vm, unformat_input_t *input,
855 vlib_cli_command_t *cmd)
859 if (unformat (input, "%d", &ipti))
864 if (!pool_is_free_index (ip_pmtu_pool, ipti))
865 vlib_cli_output (vm, "%U", format_ip_pmtu, ipti);
867 vlib_cli_output (vm, "entry %d invalid", ipti);
874 pool_foreach_index (ipti, ip_pmtu_pool)
876 vlib_cli_output (vm, "%U", format_ip_pmtu, ipti);
883 VLIB_CLI_COMMAND (show_fib_entry, static) = {
884 .path = "show ip pmtu",
885 .function = show_ip_pmtu_command,
886 .short_help = "show ip path MTU",
890 * fd.io coding-style-patch-verification: ON
893 * eval: (c-set-style "gnu")