3 * Copyright (C) 2017 Cumulus Networks, Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "pimd/pim_nht.h"
34 #include "pim_ifchannel.h"
35 #include "pim_mroute.h"
36 #include "pim_zebra.h"
37 #include "pim_upstream.h"
39 #include "pim_jp_agg.h"
40 #include "pim_zebra.h"
41 #include "pim_zlookup.h"
44 * pim_sendmsg_zebra_rnh -- Format and send a nexthop register/Unregister
47 void pim_sendmsg_zebra_rnh(struct pim_instance
*pim
, struct zclient
*zclient
,
48 struct pim_nexthop_cache
*pnc
, int command
)
53 p
= &(pnc
->rpf
.rpf_addr
);
54 ret
= zclient_send_rnh(zclient
, command
, p
, false, pim
->vrf_id
);
56 zlog_warn("sendmsg_nexthop: zclient_send_message() failed");
58 if (PIM_DEBUG_PIM_NHT
) {
59 char buf
[PREFIX2STR_BUFFER
];
60 prefix2str(p
, buf
, sizeof(buf
));
62 "%s: NHT %sregistered addr %s(%s) with Zebra ret:%d ",
64 (command
== ZEBRA_NEXTHOP_REGISTER
) ? " " : "de", buf
,
71 struct pim_nexthop_cache
*pim_nexthop_cache_find(struct pim_instance
*pim
,
74 struct pim_nexthop_cache
*pnc
= NULL
;
75 struct pim_nexthop_cache lookup
;
77 lookup
.rpf
.rpf_addr
.family
= rpf
->rpf_addr
.family
;
78 lookup
.rpf
.rpf_addr
.prefixlen
= rpf
->rpf_addr
.prefixlen
;
79 lookup
.rpf
.rpf_addr
.u
.prefix4
.s_addr
= rpf
->rpf_addr
.u
.prefix4
.s_addr
;
81 pnc
= hash_lookup(pim
->rpf_hash
, &lookup
);
86 static struct pim_nexthop_cache
*pim_nexthop_cache_add(struct pim_instance
*pim
,
87 struct pim_rpf
*rpf_addr
)
89 struct pim_nexthop_cache
*pnc
;
93 pnc
= XCALLOC(MTYPE_PIM_NEXTHOP_CACHE
,
94 sizeof(struct pim_nexthop_cache
));
96 zlog_err("%s: NHT PIM XCALLOC failure ", __PRETTY_FUNCTION__
);
99 pnc
->rpf
.rpf_addr
.family
= rpf_addr
->rpf_addr
.family
;
100 pnc
->rpf
.rpf_addr
.prefixlen
= rpf_addr
->rpf_addr
.prefixlen
;
101 pnc
->rpf
.rpf_addr
.u
.prefix4
.s_addr
=
102 rpf_addr
->rpf_addr
.u
.prefix4
.s_addr
;
104 pnc
= hash_get(pim
->rpf_hash
, pnc
, hash_alloc_intern
);
106 pnc
->rp_list
= list_new();
107 pnc
->rp_list
->cmp
= pim_rp_list_cmp
;
109 snprintf(hash_name
, 64, "PNC %s(%s) Upstream Hash",
110 prefix2str(&pnc
->rpf
.rpf_addr
, buf1
, 64), pim
->vrf
->name
);
111 pnc
->upstream_hash
= hash_create_size(8192, pim_upstream_hash_key
,
112 pim_upstream_equal
, hash_name
);
118 * pim_find_or_track_nexthop
120 * This API is used to Register an address with Zebra
125 int pim_find_or_track_nexthop(struct pim_instance
*pim
, struct prefix
*addr
,
126 struct pim_upstream
*up
, struct rp_info
*rp
,
127 struct pim_nexthop_cache
*out_pnc
)
129 struct pim_nexthop_cache
*pnc
= NULL
;
131 struct listnode
*ch_node
= NULL
;
132 struct zclient
*zclient
= NULL
;
134 zclient
= pim_zebra_zclient_get();
135 memset(&rpf
, 0, sizeof(struct pim_rpf
));
136 rpf
.rpf_addr
.family
= addr
->family
;
137 rpf
.rpf_addr
.prefixlen
= addr
->prefixlen
;
138 rpf
.rpf_addr
.u
.prefix4
= addr
->u
.prefix4
;
140 pnc
= pim_nexthop_cache_find(pim
, &rpf
);
142 pnc
= pim_nexthop_cache_add(pim
, &rpf
);
144 char rpf_str
[PREFIX_STRLEN
];
145 pim_addr_dump("<nht-pnc?>", addr
, rpf_str
,
147 zlog_warn("%s: pnc node allocation failed. addr %s ",
148 __PRETTY_FUNCTION__
, rpf_str
);
151 pim_sendmsg_zebra_rnh(pim
, zclient
, pnc
,
152 ZEBRA_NEXTHOP_REGISTER
);
153 if (PIM_DEBUG_PIM_NHT
) {
154 char buf
[PREFIX2STR_BUFFER
];
155 prefix2str(addr
, buf
, sizeof(buf
));
157 "%s: NHT cache and zebra notification added for %s(%s)",
158 __PRETTY_FUNCTION__
, buf
, pim
->vrf
->name
);
163 ch_node
= listnode_lookup(pnc
->rp_list
, rp
);
165 listnode_add_sort(pnc
->rp_list
, rp
);
169 hash_get(pnc
->upstream_hash
, up
, hash_alloc_intern
);
171 if (pnc
&& CHECK_FLAG(pnc
->flags
, PIM_NEXTHOP_VALID
)) {
172 memcpy(out_pnc
, pnc
, sizeof(struct pim_nexthop_cache
));
179 void pim_delete_tracked_nexthop(struct pim_instance
*pim
, struct prefix
*addr
,
180 struct pim_upstream
*up
, struct rp_info
*rp
)
182 struct pim_nexthop_cache
*pnc
= NULL
;
183 struct pim_nexthop_cache lookup
;
184 struct zclient
*zclient
= NULL
;
186 zclient
= pim_zebra_zclient_get();
188 /* Remove from RPF hash if it is the last entry */
189 lookup
.rpf
.rpf_addr
= *addr
;
190 pnc
= hash_lookup(pim
->rpf_hash
, &lookup
);
193 listnode_delete(pnc
->rp_list
, rp
);
195 hash_release(pnc
->upstream_hash
, up
);
197 if (PIM_DEBUG_PIM_NHT
) {
198 char buf
[PREFIX_STRLEN
];
199 prefix2str(addr
, buf
, sizeof buf
);
201 "%s: NHT %s(%s) rp_list count:%d upstream count:%ld",
202 __PRETTY_FUNCTION__
, buf
, pim
->vrf
->name
,
203 pnc
->rp_list
->count
, pnc
->upstream_hash
->count
);
206 if (pnc
->rp_list
->count
== 0
207 && pnc
->upstream_hash
->count
== 0) {
208 pim_sendmsg_zebra_rnh(pim
, zclient
, pnc
,
209 ZEBRA_NEXTHOP_UNREGISTER
);
211 list_delete_and_null(&pnc
->rp_list
);
212 hash_free(pnc
->upstream_hash
);
214 hash_release(pim
->rpf_hash
, pnc
);
216 nexthops_free(pnc
->nexthop
);
217 XFREE(MTYPE_PIM_NEXTHOP_CACHE
, pnc
);
222 /* Update RP nexthop info based on Nexthop update received from Zebra.*/
223 static void pim_update_rp_nh(struct pim_instance
*pim
,
224 struct pim_nexthop_cache
*pnc
)
226 struct listnode
*node
= NULL
;
227 struct rp_info
*rp_info
= NULL
;
229 /*Traverse RP list and update each RP Nexthop info */
230 for (ALL_LIST_ELEMENTS_RO(pnc
->rp_list
, node
, rp_info
)) {
231 if (rp_info
->rp
.rpf_addr
.u
.prefix4
.s_addr
== INADDR_NONE
)
234 // Compute PIM RPF using cached nexthop
235 pim_ecmp_nexthop_search(pim
, pnc
, &rp_info
->rp
.source_nexthop
,
236 &rp_info
->rp
.rpf_addr
, &rp_info
->group
,
241 /* This API is used to traverse nexthop cache of RPF addr
242 of upstream entry whose IPv4 nexthop address is in
243 unresolved state and due to event like pim neighbor
244 UP event if it can be resolved.
246 void pim_resolve_upstream_nh(struct pim_instance
*pim
, struct prefix
*nht_p
)
248 struct nexthop
*nh_node
= NULL
;
249 struct pim_nexthop_cache pnc
;
250 struct pim_neighbor
*nbr
= NULL
;
252 memset(&pnc
, 0, sizeof(struct pim_nexthop_cache
));
253 if (!pim_find_or_track_nexthop(pim
, nht_p
, NULL
, NULL
, &pnc
))
256 for (nh_node
= pnc
.nexthop
; nh_node
; nh_node
= nh_node
->next
) {
257 if (nh_node
->gate
.ipv4
.s_addr
!= 0)
260 struct interface
*ifp1
=
261 if_lookup_by_index(nh_node
->ifindex
, pim
->vrf_id
);
262 nbr
= pim_neighbor_find_if(ifp1
);
266 nh_node
->gate
.ipv4
= nbr
->source_addr
;
267 if (PIM_DEBUG_PIM_NHT
) {
268 char str
[PREFIX_STRLEN
];
269 char str1
[INET_ADDRSTRLEN
];
270 pim_inet4_dump("<nht_nbr?>", nbr
->source_addr
, str1
,
272 pim_addr_dump("<nht_addr?>", nht_p
, str
, sizeof(str
));
274 "%s: addr %s new nexthop addr %s interface %s",
275 __PRETTY_FUNCTION__
, str
, str1
, ifp1
->name
);
280 /* Update Upstream nexthop info based on Nexthop update received from Zebra.*/
281 static int pim_update_upstream_nh_helper(struct hash_backet
*backet
, void *arg
)
283 struct pim_instance
*pim
= (struct pim_instance
*)arg
;
284 struct pim_upstream
*up
= (struct pim_upstream
*)backet
->data
;
287 enum pim_rpf_result rpf_result
;
290 old
.source_nexthop
.interface
= up
->rpf
.source_nexthop
.interface
;
291 rpf_result
= pim_rpf_update(pim
, up
, &old
, 0);
292 if (rpf_result
== PIM_RPF_FAILURE
) {
293 pim_mroute_del(up
->channel_oil
, __PRETTY_FUNCTION__
);
294 return HASHWALK_CONTINUE
;
297 /* update kernel multicast forwarding cache (MFC) */
298 if (up
->channel_oil
) {
299 ifindex_t ifindex
= up
->rpf
.source_nexthop
.interface
->ifindex
;
301 vif_index
= pim_if_find_vifindex_by_ifindex(pim
, ifindex
);
302 /* Pass Current selected NH vif index to mroute download
305 pim_scan_individual_oil(up
->channel_oil
, vif_index
);
307 if (PIM_DEBUG_PIM_NHT
)
309 "%s: NHT upstream %s channel_oil IIF %s vif_index is not valid",
310 __PRETTY_FUNCTION__
, up
->sg_str
,
311 up
->rpf
.source_nexthop
.interface
->name
);
315 if (rpf_result
== PIM_RPF_CHANGED
) {
316 struct pim_neighbor
*nbr
;
318 nbr
= pim_neighbor_find(old
.source_nexthop
.interface
,
319 old
.rpf_addr
.u
.prefix4
);
321 pim_jp_agg_remove_group(nbr
->upstream_jp_agg
, up
);
324 * We have detected a case where we might need to rescan
325 * the inherited o_list so do it.
327 if (up
->channel_oil
&& up
->channel_oil
->oil_inherited_rescan
) {
328 pim_upstream_inherited_olist_decide(pim
, up
);
329 up
->channel_oil
->oil_inherited_rescan
= 0;
332 if (up
->join_state
== PIM_UPSTREAM_JOINED
) {
334 * If we come up real fast we can be here
335 * where the mroute has not been installed
338 if (up
->channel_oil
&& !up
->channel_oil
->installed
)
339 pim_mroute_add(up
->channel_oil
,
340 __PRETTY_FUNCTION__
);
343 * RFC 4601: 4.5.7. Sending (S,G) Join/Prune Messages
345 * Transitions from Joined State
347 * RPF'(S,G) changes not due to an Assert
349 * The upstream (S,G) state machine remains in Joined
350 * state. Send Join(S,G) to the new upstream
351 * neighbor, which is the new value of RPF'(S,G).
352 * Send Prune(S,G) to the old upstream neighbor, which
353 * is the old value of RPF'(S,G). Set the Join
354 * Timer (JT) to expire after t_periodic seconds.
356 pim_jp_agg_switch_interface(&old
, &up
->rpf
, up
);
358 pim_upstream_join_timer_restart(up
, &old
);
359 } /* up->join_state == PIM_UPSTREAM_JOINED */
362 * FIXME can join_desired actually be changed by
363 * pim_rpf_update() returning PIM_RPF_CHANGED ?
365 pim_upstream_update_join_desired(pim
, up
);
367 } /* PIM_RPF_CHANGED */
369 if (PIM_DEBUG_PIM_NHT
) {
370 zlog_debug("%s: NHT upstream %s(%s) old ifp %s new ifp %s",
371 __PRETTY_FUNCTION__
, up
->sg_str
, pim
->vrf
->name
,
372 old
.source_nexthop
.interface
->name
,
373 up
->rpf
.source_nexthop
.interface
->name
);
376 return HASHWALK_CONTINUE
;
379 static int pim_update_upstream_nh(struct pim_instance
*pim
,
380 struct pim_nexthop_cache
*pnc
)
382 struct listnode
*node
;
383 struct interface
*ifp
;
385 hash_walk(pnc
->upstream_hash
, pim_update_upstream_nh_helper
, pim
);
387 FOR_ALL_INTERFACES (pim
->vrf
, ifp
)
389 struct pim_interface
*pim_ifp
= ifp
->info
;
390 struct pim_iface_upstream_switch
*us
;
392 for (ALL_LIST_ELEMENTS_RO(pim_ifp
->upstream_switch_list
,
395 rpf
.source_nexthop
.interface
= ifp
;
396 rpf
.rpf_addr
.u
.prefix4
= us
->address
;
397 pim_joinprune_send(&rpf
, us
->us
);
398 pim_jp_agg_clear_group(us
->us
);
405 uint32_t pim_compute_ecmp_hash(struct prefix
*src
, struct prefix
*grp
)
408 uint32_t s
= 0, g
= 0;
413 switch (src
->family
) {
415 s
= src
->u
.prefix4
.s_addr
;
418 g
= grp
->u
.prefix4
.s_addr
;
424 hash_val
= jhash_2words(g
, s
, 101);
428 int pim_ecmp_nexthop_search(struct pim_instance
*pim
,
429 struct pim_nexthop_cache
*pnc
,
430 struct pim_nexthop
*nexthop
, struct prefix
*src
,
431 struct prefix
*grp
, int neighbor_needed
)
433 struct pim_neighbor
*nbr
= NULL
;
434 struct nexthop
*nh_node
= NULL
;
435 ifindex_t first_ifindex
;
436 struct interface
*ifp
= NULL
;
437 uint32_t hash_val
= 0, mod_val
= 0;
438 uint8_t nh_iter
= 0, found
= 0;
440 if (!pnc
|| !pnc
->nexthop_num
|| !nexthop
)
443 // Current Nexthop is VALID, check to stay on the current path.
444 if (nexthop
->interface
&& nexthop
->interface
->info
445 && nexthop
->mrib_nexthop_addr
.u
.prefix4
.s_addr
446 != PIM_NET_INADDR_ANY
) {
447 /* User configured knob to explicitly switch
448 to new path is disabled or current path
449 metric is less than nexthop update.
452 if (pim
->ecmp_rebalance_enable
== 0) {
453 uint8_t curr_route_valid
= 0;
454 // Check if current nexthop is present in new updated
456 // If the current nexthop is not valid, candidate to
457 // choose new Nexthop.
458 for (nh_node
= pnc
->nexthop
; nh_node
;
459 nh_node
= nh_node
->next
) {
460 curr_route_valid
= (nexthop
->interface
->ifindex
461 == nh_node
->ifindex
);
462 if (curr_route_valid
)
467 && !pim_if_connected_to_source(nexthop
->interface
,
469 nbr
= pim_neighbor_find(
471 nexthop
->mrib_nexthop_addr
.u
.prefix4
);
473 && !if_is_loopback(nexthop
->interface
)) {
474 if (PIM_DEBUG_PIM_NHT
)
476 "%s: current nexthop does not have nbr ",
477 __PRETTY_FUNCTION__
);
479 if (PIM_DEBUG_PIM_NHT
) {
480 char src_str
[INET_ADDRSTRLEN
];
481 pim_inet4_dump("<addr?>",
485 char grp_str
[INET_ADDRSTRLEN
];
486 pim_inet4_dump("<addr?>",
491 "%s: (%s,%s)(%s) current nexthop %s is valid, skipping new path selection",
495 nexthop
->interface
->name
);
502 if (pim
->ecmp_enable
) {
503 // PIM ECMP flag is enable then choose ECMP path.
504 hash_val
= pim_compute_ecmp_hash(src
, grp
);
505 mod_val
= hash_val
% pnc
->nexthop_num
;
508 for (nh_node
= pnc
->nexthop
; nh_node
&& (found
== 0);
509 nh_node
= nh_node
->next
) {
510 first_ifindex
= nh_node
->ifindex
;
511 ifp
= if_lookup_by_index(first_ifindex
, pim
->vrf_id
);
513 if (PIM_DEBUG_PIM_NHT
) {
514 char addr_str
[INET_ADDRSTRLEN
];
515 pim_inet4_dump("<addr?>", src
->u
.prefix4
,
516 addr_str
, sizeof(addr_str
));
518 "%s %s: could not find interface for ifindex %d (address %s(%s))",
519 __FILE__
, __PRETTY_FUNCTION__
,
520 first_ifindex
, addr_str
,
523 if (nh_iter
== mod_val
)
524 mod_val
++; // Select nexthpath
529 if (PIM_DEBUG_PIM_NHT
) {
530 char addr_str
[INET_ADDRSTRLEN
];
531 pim_inet4_dump("<addr?>", src
->u
.prefix4
,
532 addr_str
, sizeof(addr_str
));
534 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %s)",
535 __PRETTY_FUNCTION__
, ifp
->name
,
536 pim
->vrf
->name
, first_ifindex
,
539 if (nh_iter
== mod_val
)
540 mod_val
++; // Select nexthpath
546 && !pim_if_connected_to_source(ifp
, src
->u
.prefix4
)) {
547 nbr
= pim_neighbor_find(ifp
, nh_node
->gate
.ipv4
);
548 if (!nbr
&& !if_is_loopback(ifp
)) {
549 if (PIM_DEBUG_PIM_NHT
)
551 "%s: pim nbr not found on input interface %s(%s)",
552 __PRETTY_FUNCTION__
, ifp
->name
,
554 if (nh_iter
== mod_val
)
555 mod_val
++; // Select nexthpath
561 if (nh_iter
== mod_val
) {
562 nexthop
->interface
= ifp
;
563 nexthop
->mrib_nexthop_addr
.family
= AF_INET
;
564 nexthop
->mrib_nexthop_addr
.prefixlen
= IPV4_MAX_BITLEN
;
565 nexthop
->mrib_nexthop_addr
.u
.prefix4
=
567 nexthop
->mrib_metric_preference
= pnc
->distance
;
568 nexthop
->mrib_route_metric
= pnc
->metric
;
569 nexthop
->last_lookup
= src
->u
.prefix4
;
570 nexthop
->last_lookup_time
= pim_time_monotonic_usec();
573 if (PIM_DEBUG_PIM_NHT
) {
574 char buf
[INET_ADDRSTRLEN
];
575 char buf2
[INET_ADDRSTRLEN
];
576 char buf3
[INET_ADDRSTRLEN
];
577 pim_inet4_dump("<src?>", src
->u
.prefix4
, buf2
,
579 pim_inet4_dump("<grp?>", grp
->u
.prefix4
, buf3
,
583 nexthop
->mrib_nexthop_addr
.u
.prefix4
,
586 "%s: (%s,%s)(%s) selected nhop interface %s addr %s mod_val %u iter %d ecmp %d",
587 __PRETTY_FUNCTION__
, buf2
, buf3
,
588 pim
->vrf
->name
, ifp
->name
, buf
, mod_val
,
589 nh_iter
, pim
->ecmp_enable
);
601 /* This API is used to parse Registered address nexthop update coming from Zebra
603 int pim_parse_nexthop_update(int command
, struct zclient
*zclient
,
604 zebra_size_t length
, vrf_id_t vrf_id
)
606 struct nexthop
*nexthop
;
607 struct nexthop
*nhlist_head
= NULL
;
608 struct nexthop
*nhlist_tail
= NULL
;
611 struct pim_nexthop_cache
*pnc
= NULL
;
612 struct pim_neighbor
*nbr
= NULL
;
613 struct interface
*ifp
= NULL
;
614 struct interface
*ifp1
= NULL
;
615 struct vrf
*vrf
= vrf_lookup_by_id(vrf_id
);
616 struct pim_instance
*pim
;
617 struct zapi_route nhr
;
623 if (!zapi_nexthop_update_decode(zclient
->ibuf
, &nhr
)) {
624 if (PIM_DEBUG_PIM_NHT
)
626 "%s: Decode of nexthop update from zebra failed",
627 __PRETTY_FUNCTION__
);
631 if (command
== ZEBRA_NEXTHOP_UPDATE
) {
632 prefix_copy(&rpf
.rpf_addr
, &nhr
.prefix
);
633 pnc
= pim_nexthop_cache_find(pim
, &rpf
);
635 if (PIM_DEBUG_PIM_NHT
) {
636 char buf
[PREFIX2STR_BUFFER
];
637 prefix2str(&rpf
.rpf_addr
, buf
, sizeof(buf
));
639 "%s: Skipping NHT update, addr %s is not in local cached DB.",
640 __PRETTY_FUNCTION__
, buf
);
646 * We do not currently handle ZEBRA_IMPORT_CHECK_UPDATE
651 pnc
->last_update
= pim_time_monotonic_usec();
653 if (nhr
.nexthop_num
) {
654 pnc
->nexthop_num
= 0; // Only increment for pim enabled rpf.
656 for (i
= 0; i
< nhr
.nexthop_num
; i
++) {
657 nexthop
= nexthop_from_zapi_nexthop(&nhr
.nexthops
[i
]);
658 switch (nexthop
->type
) {
659 case NEXTHOP_TYPE_IPV4
:
660 case NEXTHOP_TYPE_IPV4_IFINDEX
:
661 case NEXTHOP_TYPE_IPV6
:
662 case NEXTHOP_TYPE_BLACKHOLE
:
664 case NEXTHOP_TYPE_IFINDEX
:
666 * Connected route (i.e. no nexthop), use
667 * RPF address from nexthop cache (i.e.
668 * destination) as PIM nexthop.
670 nexthop
->type
= NEXTHOP_TYPE_IPV4_IFINDEX
;
672 pnc
->rpf
.rpf_addr
.u
.prefix4
;
674 case NEXTHOP_TYPE_IPV6_IFINDEX
:
675 ifp1
= if_lookup_by_index(nexthop
->ifindex
,
677 nbr
= pim_neighbor_find_if(ifp1
);
678 /* Overwrite with Nbr address as NH addr */
680 nexthop
->gate
.ipv4
= nbr
->source_addr
;
682 // Mark nexthop address to 0 until PIM
684 nexthop
->gate
.ipv4
.s_addr
=
691 ifp
= if_lookup_by_index(nexthop
->ifindex
, pim
->vrf_id
);
693 if (PIM_DEBUG_PIM_NHT
) {
694 char buf
[NEXTHOP_STRLEN
];
696 "%s: could not find interface for ifindex %d(%s) (addr %s)",
700 nexthop2str(nexthop
, buf
,
703 nexthop_free(nexthop
);
707 if (PIM_DEBUG_PIM_NHT
) {
708 char p_str
[PREFIX2STR_BUFFER
];
710 prefix2str(&nhr
.prefix
, p_str
, sizeof(p_str
));
712 "%s: NHT addr %s(%s) %d-nhop via %s(%s) type %d distance:%u metric:%u ",
713 __PRETTY_FUNCTION__
, p_str
,
714 pim
->vrf
->name
, i
+ 1,
715 inet_ntoa(nexthop
->gate
.ipv4
),
716 ifp
->name
, nexthop
->type
, nhr
.distance
,
721 if (PIM_DEBUG_PIM_NHT
) {
722 char buf
[NEXTHOP_STRLEN
];
725 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, addr %s)",
726 __PRETTY_FUNCTION__
, ifp
->name
,
729 nexthop2str(nexthop
, buf
,
732 nexthop_free(nexthop
);
737 nhlist_tail
->next
= nexthop
;
738 nhlist_tail
= nexthop
;
740 nhlist_tail
= nexthop
;
741 nhlist_head
= nexthop
;
743 // Only keep track of nexthops which are PIM enabled.
746 /* Reset existing pnc->nexthop before assigning new list */
747 nexthops_free(pnc
->nexthop
);
748 pnc
->nexthop
= nhlist_head
;
749 if (pnc
->nexthop_num
) {
750 pnc
->flags
|= PIM_NEXTHOP_VALID
;
751 pnc
->distance
= nhr
.distance
;
752 pnc
->metric
= nhr
.metric
;
755 pnc
->flags
&= ~PIM_NEXTHOP_VALID
;
756 pnc
->nexthop_num
= nhr
.nexthop_num
;
757 nexthops_free(pnc
->nexthop
);
761 if (PIM_DEBUG_PIM_NHT
) {
762 char buf
[PREFIX2STR_BUFFER
];
763 prefix2str(&nhr
.prefix
, buf
, sizeof(buf
));
765 "%s: NHT Update for %s(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
766 __PRETTY_FUNCTION__
, buf
, pim
->vrf
->name
,
767 nhr
.nexthop_num
, pnc
->nexthop_num
, vrf_id
,
768 pnc
->upstream_hash
->count
, listcount(pnc
->rp_list
));
771 pim_rpf_set_refresh_time(pim
);
773 if (listcount(pnc
->rp_list
))
774 pim_update_rp_nh(pim
, pnc
);
775 if (pnc
->upstream_hash
->count
)
776 pim_update_upstream_nh(pim
, pnc
);
781 int pim_ecmp_nexthop_lookup(struct pim_instance
*pim
,
782 struct pim_nexthop
*nexthop
, struct in_addr addr
,
783 struct prefix
*src
, struct prefix
*grp
,
786 struct pim_zlookup_nexthop nexthop_tab
[MULTIPATH_NUM
];
787 struct pim_neighbor
*nbr
= NULL
;
789 struct interface
*ifp
;
793 uint32_t hash_val
= 0, mod_val
= 0;
795 if (PIM_DEBUG_PIM_NHT
) {
796 char addr_str
[INET_ADDRSTRLEN
];
797 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
798 zlog_debug("%s: Looking up: %s(%s), last lookup time: %lld",
799 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
,
800 nexthop
->last_lookup_time
);
803 memset(nexthop_tab
, 0,
804 sizeof(struct pim_zlookup_nexthop
) * MULTIPATH_NUM
);
805 num_ifindex
= zclient_lookup_nexthop(pim
, nexthop_tab
, MULTIPATH_NUM
,
806 addr
, PIM_NEXTHOP_LOOKUP_MAX
);
807 if (num_ifindex
< 1) {
808 if (PIM_DEBUG_PIM_NHT
) {
809 char addr_str
[INET_ADDRSTRLEN
];
810 pim_inet4_dump("<addr?>", addr
, addr_str
,
813 "%s: could not find nexthop ifindex for address %s(%s)",
814 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
);
819 // If PIM ECMP enable then choose ECMP path.
820 if (pim
->ecmp_enable
) {
821 hash_val
= pim_compute_ecmp_hash(src
, grp
);
822 mod_val
= hash_val
% num_ifindex
;
823 if (PIM_DEBUG_PIM_NHT_DETAIL
)
824 zlog_debug("%s: hash_val %u mod_val %u",
825 __PRETTY_FUNCTION__
, hash_val
, mod_val
);
828 while (!found
&& (i
< num_ifindex
)) {
829 first_ifindex
= nexthop_tab
[i
].ifindex
;
831 ifp
= if_lookup_by_index(first_ifindex
, pim
->vrf_id
);
833 if (PIM_DEBUG_PIM_NHT
) {
834 char addr_str
[INET_ADDRSTRLEN
];
835 pim_inet4_dump("<addr?>", addr
, addr_str
,
838 "%s %s: could not find interface for ifindex %d (address %s(%s))",
839 __FILE__
, __PRETTY_FUNCTION__
,
840 first_ifindex
, addr_str
,
850 if (PIM_DEBUG_PIM_NHT
) {
851 char addr_str
[INET_ADDRSTRLEN
];
852 pim_inet4_dump("<addr?>", addr
, addr_str
,
855 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %s)",
856 __PRETTY_FUNCTION__
, ifp
->name
,
857 pim
->vrf
->name
, first_ifindex
,
865 if (neighbor_needed
&& !pim_if_connected_to_source(ifp
, addr
)) {
866 nbr
= pim_neighbor_find(
867 ifp
, nexthop_tab
[i
].nexthop_addr
.u
.prefix4
);
868 if (PIM_DEBUG_PIM_NHT_DETAIL
)
869 zlog_debug("ifp name: %s(%s), pim nbr: %p",
870 ifp
->name
, pim
->vrf
->name
, nbr
);
871 if (!nbr
&& !if_is_loopback(ifp
)) {
875 if (PIM_DEBUG_PIM_NHT
) {
876 char addr_str
[INET_ADDRSTRLEN
];
877 pim_inet4_dump("<addr?>", addr
,
881 "%s: NBR not found on input interface %s(%s) (RPF for source %s)",
882 __PRETTY_FUNCTION__
, ifp
->name
,
883 pim
->vrf
->name
, addr_str
);
890 if (PIM_DEBUG_PIM_NHT
) {
891 char nexthop_str
[PREFIX_STRLEN
];
892 char addr_str
[INET_ADDRSTRLEN
];
893 pim_addr_dump("<nexthop?>",
894 &nexthop_tab
[i
].nexthop_addr
,
895 nexthop_str
, sizeof(nexthop_str
));
896 pim_inet4_dump("<addr?>", addr
, addr_str
,
899 "%s: found nhop %s for addr %s interface %s(%s) metric %d dist %d",
900 __PRETTY_FUNCTION__
, nexthop_str
,
901 addr_str
, ifp
->name
, pim
->vrf
->name
,
902 nexthop_tab
[i
].route_metric
,
903 nexthop_tab
[i
].protocol_distance
);
905 /* update nexthop data */
906 nexthop
->interface
= ifp
;
907 nexthop
->mrib_nexthop_addr
=
908 nexthop_tab
[i
].nexthop_addr
;
909 nexthop
->mrib_metric_preference
=
910 nexthop_tab
[i
].protocol_distance
;
911 nexthop
->mrib_route_metric
=
912 nexthop_tab
[i
].route_metric
;
913 nexthop
->last_lookup
= addr
;
914 nexthop
->last_lookup_time
= pim_time_monotonic_usec();
927 int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance
*pim
,
928 struct in_addr addr
, struct prefix
*src
,
931 struct pim_zlookup_nexthop nexthop_tab
[MULTIPATH_NUM
];
934 ifindex_t first_ifindex
;
935 uint32_t hash_val
= 0, mod_val
= 0;
937 memset(nexthop_tab
, 0,
938 sizeof(struct pim_zlookup_nexthop
) * MULTIPATH_NUM
);
939 num_ifindex
= zclient_lookup_nexthop(pim
, nexthop_tab
, MULTIPATH_NUM
,
940 addr
, PIM_NEXTHOP_LOOKUP_MAX
);
941 if (num_ifindex
< 1) {
942 if (PIM_DEBUG_PIM_NHT
) {
943 char addr_str
[INET_ADDRSTRLEN
];
944 pim_inet4_dump("<addr?>", addr
, addr_str
,
947 "%s: could not find nexthop ifindex for address %s(%s)",
948 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
);
953 // If PIM ECMP enable then choose ECMP path.
954 if (pim
->ecmp_enable
) {
955 hash_val
= pim_compute_ecmp_hash(src
, grp
);
956 mod_val
= hash_val
% num_ifindex
;
957 if (PIM_DEBUG_PIM_NHT_DETAIL
)
958 zlog_debug("%s: hash_val %u mod_val %u",
959 __PRETTY_FUNCTION__
, hash_val
, mod_val
);
962 first_ifindex
= nexthop_tab
[mod_val
].ifindex
;
964 if (PIM_DEBUG_PIM_NHT
) {
965 char addr_str
[INET_ADDRSTRLEN
];
966 pim_inet4_dump("<ifaddr?>", addr
, addr_str
, sizeof(addr_str
));
968 "%s: found nexthop ifindex=%d (interface %s(%s)) for address %s",
969 __PRETTY_FUNCTION__
, first_ifindex
,
970 ifindex2ifname(first_ifindex
, pim
->vrf_id
),
971 pim
->vrf
->name
, addr_str
);
974 vif_index
= pim_if_find_vifindex_by_ifindex(pim
, first_ifindex
);
977 if (PIM_DEBUG_PIM_NHT
) {
978 char addr_str
[INET_ADDRSTRLEN
];
979 pim_inet4_dump("<addr?>", addr
, addr_str
,
982 "%s: low vif_index=%d(%s) < 1 nexthop for address %s",
983 __PRETTY_FUNCTION__
, vif_index
, pim
->vrf
->name
,