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 (qpim_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 (qpim_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
, qpim_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_IFINDEX
:
661 case NEXTHOP_TYPE_IPV4_IFINDEX
:
662 case NEXTHOP_TYPE_IPV6
:
663 case NEXTHOP_TYPE_BLACKHOLE
:
665 case NEXTHOP_TYPE_IPV6_IFINDEX
:
666 ifp1
= if_lookup_by_index(nexthop
->ifindex
,
668 nbr
= pim_neighbor_find_if(ifp1
);
669 /* Overwrite with Nbr address as NH addr */
671 nexthop
->gate
.ipv4
= nbr
->source_addr
;
673 // Mark nexthop address to 0 until PIM
675 nexthop
->gate
.ipv4
.s_addr
=
682 ifp
= if_lookup_by_index(nexthop
->ifindex
, pim
->vrf_id
);
684 if (PIM_DEBUG_PIM_NHT
) {
685 char buf
[NEXTHOP_STRLEN
];
687 "%s: could not find interface for ifindex %d(%s) (addr %s)",
691 nexthop2str(nexthop
, buf
,
694 nexthop_free(nexthop
);
698 if (PIM_DEBUG_PIM_NHT
) {
699 char p_str
[PREFIX2STR_BUFFER
];
701 prefix2str(&nhr
.prefix
, p_str
, sizeof(p_str
));
703 "%s: NHT addr %s(%s) %d-nhop via %s(%s) type %d distance:%u metric:%u ",
704 __PRETTY_FUNCTION__
, p_str
,
705 pim
->vrf
->name
, i
+ 1,
706 inet_ntoa(nexthop
->gate
.ipv4
),
707 ifp
->name
, nexthop
->type
, nhr
.distance
,
712 if (PIM_DEBUG_PIM_NHT
) {
713 char buf
[NEXTHOP_STRLEN
];
716 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, addr %s)",
717 __PRETTY_FUNCTION__
, ifp
->name
,
720 nexthop2str(nexthop
, buf
,
723 nexthop_free(nexthop
);
728 nhlist_tail
->next
= nexthop
;
729 nhlist_tail
= nexthop
;
731 nhlist_tail
= nexthop
;
732 nhlist_head
= nexthop
;
734 // Only keep track of nexthops which are PIM enabled.
737 /* Reset existing pnc->nexthop before assigning new list */
738 nexthops_free(pnc
->nexthop
);
739 pnc
->nexthop
= nhlist_head
;
740 if (pnc
->nexthop_num
) {
741 pnc
->flags
|= PIM_NEXTHOP_VALID
;
742 pnc
->distance
= nhr
.distance
;
743 pnc
->metric
= nhr
.metric
;
746 pnc
->flags
&= ~PIM_NEXTHOP_VALID
;
747 pnc
->nexthop_num
= nhr
.nexthop_num
;
748 nexthops_free(pnc
->nexthop
);
752 if (PIM_DEBUG_PIM_NHT
) {
753 char buf
[PREFIX2STR_BUFFER
];
754 prefix2str(&nhr
.prefix
, buf
, sizeof(buf
));
756 "%s: NHT Update for %s(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
757 __PRETTY_FUNCTION__
, buf
, pim
->vrf
->name
,
758 nhr
.nexthop_num
, pnc
->nexthop_num
, vrf_id
,
759 pnc
->upstream_hash
->count
, listcount(pnc
->rp_list
));
762 pim_rpf_set_refresh_time(pim
);
764 if (listcount(pnc
->rp_list
))
765 pim_update_rp_nh(pim
, pnc
);
766 if (pnc
->upstream_hash
->count
)
767 pim_update_upstream_nh(pim
, pnc
);
772 int pim_ecmp_nexthop_lookup(struct pim_instance
*pim
,
773 struct pim_nexthop
*nexthop
, struct in_addr addr
,
774 struct prefix
*src
, struct prefix
*grp
,
777 struct pim_zlookup_nexthop nexthop_tab
[MULTIPATH_NUM
];
778 struct pim_neighbor
*nbr
= NULL
;
780 struct interface
*ifp
;
784 uint32_t hash_val
= 0, mod_val
= 0;
786 if (PIM_DEBUG_PIM_NHT
) {
787 char addr_str
[INET_ADDRSTRLEN
];
788 pim_inet4_dump("<addr?>", addr
, addr_str
, sizeof(addr_str
));
789 zlog_debug("%s: Looking up: %s(%s), last lookup time: %lld",
790 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
,
791 nexthop
->last_lookup_time
);
794 memset(nexthop_tab
, 0,
795 sizeof(struct pim_zlookup_nexthop
) * MULTIPATH_NUM
);
796 num_ifindex
= zclient_lookup_nexthop(pim
, nexthop_tab
, MULTIPATH_NUM
,
797 addr
, PIM_NEXTHOP_LOOKUP_MAX
);
798 if (num_ifindex
< 1) {
799 if (PIM_DEBUG_PIM_NHT
) {
800 char addr_str
[INET_ADDRSTRLEN
];
801 pim_inet4_dump("<addr?>", addr
, addr_str
,
804 "%s: could not find nexthop ifindex for address %s(%s)",
805 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
);
810 // If PIM ECMP enable then choose ECMP path.
811 if (qpim_ecmp_enable
) {
812 hash_val
= pim_compute_ecmp_hash(src
, grp
);
813 mod_val
= hash_val
% num_ifindex
;
814 if (PIM_DEBUG_PIM_NHT_DETAIL
)
815 zlog_debug("%s: hash_val %u mod_val %u",
816 __PRETTY_FUNCTION__
, hash_val
, mod_val
);
819 while (!found
&& (i
< num_ifindex
)) {
820 first_ifindex
= nexthop_tab
[i
].ifindex
;
822 ifp
= if_lookup_by_index(first_ifindex
, pim
->vrf_id
);
824 if (PIM_DEBUG_PIM_NHT
) {
825 char addr_str
[INET_ADDRSTRLEN
];
826 pim_inet4_dump("<addr?>", addr
, addr_str
,
829 "%s %s: could not find interface for ifindex %d (address %s(%s))",
830 __FILE__
, __PRETTY_FUNCTION__
,
831 first_ifindex
, addr_str
,
841 if (PIM_DEBUG_PIM_NHT
) {
842 char addr_str
[INET_ADDRSTRLEN
];
843 pim_inet4_dump("<addr?>", addr
, addr_str
,
846 "%s: multicast not enabled on input interface %s(%s) (ifindex=%d, RPF for source %s)",
847 __PRETTY_FUNCTION__
, ifp
->name
,
848 pim
->vrf
->name
, first_ifindex
,
856 if (neighbor_needed
&& !pim_if_connected_to_source(ifp
, addr
)) {
857 nbr
= pim_neighbor_find(
858 ifp
, nexthop_tab
[i
].nexthop_addr
.u
.prefix4
);
859 if (PIM_DEBUG_PIM_NHT_DETAIL
)
860 zlog_debug("ifp name: %s(%s), pim nbr: %p",
861 ifp
->name
, pim
->vrf
->name
, nbr
);
862 if (!nbr
&& !if_is_loopback(ifp
)) {
866 if (PIM_DEBUG_PIM_NHT
) {
867 char addr_str
[INET_ADDRSTRLEN
];
868 pim_inet4_dump("<addr?>", addr
,
872 "%s: NBR not found on input interface %s(%s) (RPF for source %s)",
873 __PRETTY_FUNCTION__
, ifp
->name
,
874 pim
->vrf
->name
, addr_str
);
881 if (PIM_DEBUG_PIM_NHT
) {
882 char nexthop_str
[PREFIX_STRLEN
];
883 char addr_str
[INET_ADDRSTRLEN
];
884 pim_addr_dump("<nexthop?>",
885 &nexthop_tab
[i
].nexthop_addr
,
886 nexthop_str
, sizeof(nexthop_str
));
887 pim_inet4_dump("<addr?>", addr
, addr_str
,
890 "%s: found nhop %s for addr %s interface %s(%s) metric %d dist %d",
891 __PRETTY_FUNCTION__
, nexthop_str
,
892 addr_str
, ifp
->name
, pim
->vrf
->name
,
893 nexthop_tab
[i
].route_metric
,
894 nexthop_tab
[i
].protocol_distance
);
896 /* update nextop data */
897 nexthop
->interface
= ifp
;
898 nexthop
->mrib_nexthop_addr
=
899 nexthop_tab
[i
].nexthop_addr
;
900 nexthop
->mrib_metric_preference
=
901 nexthop_tab
[i
].protocol_distance
;
902 nexthop
->mrib_route_metric
=
903 nexthop_tab
[i
].route_metric
;
904 nexthop
->last_lookup
= addr
;
905 nexthop
->last_lookup_time
= pim_time_monotonic_usec();
918 int pim_ecmp_fib_lookup_if_vif_index(struct pim_instance
*pim
,
919 struct in_addr addr
, struct prefix
*src
,
922 struct pim_zlookup_nexthop nexthop_tab
[MULTIPATH_NUM
];
925 ifindex_t first_ifindex
;
926 uint32_t hash_val
= 0, mod_val
= 0;
928 memset(nexthop_tab
, 0,
929 sizeof(struct pim_zlookup_nexthop
) * MULTIPATH_NUM
);
930 num_ifindex
= zclient_lookup_nexthop(pim
, nexthop_tab
, MULTIPATH_NUM
,
931 addr
, PIM_NEXTHOP_LOOKUP_MAX
);
932 if (num_ifindex
< 1) {
933 if (PIM_DEBUG_PIM_NHT
) {
934 char addr_str
[INET_ADDRSTRLEN
];
935 pim_inet4_dump("<addr?>", addr
, addr_str
,
938 "%s: could not find nexthop ifindex for address %s(%s)",
939 __PRETTY_FUNCTION__
, addr_str
, pim
->vrf
->name
);
944 // If PIM ECMP enable then choose ECMP path.
945 if (qpim_ecmp_enable
) {
946 hash_val
= pim_compute_ecmp_hash(src
, grp
);
947 mod_val
= hash_val
% num_ifindex
;
948 if (PIM_DEBUG_PIM_NHT_DETAIL
)
949 zlog_debug("%s: hash_val %u mod_val %u",
950 __PRETTY_FUNCTION__
, hash_val
, mod_val
);
953 first_ifindex
= nexthop_tab
[mod_val
].ifindex
;
955 if (PIM_DEBUG_PIM_NHT
) {
956 char addr_str
[INET_ADDRSTRLEN
];
957 pim_inet4_dump("<ifaddr?>", addr
, addr_str
, sizeof(addr_str
));
959 "%s: found nexthop ifindex=%d (interface %s(%s)) for address %s",
960 __PRETTY_FUNCTION__
, first_ifindex
,
961 ifindex2ifname(first_ifindex
, pim
->vrf_id
),
962 pim
->vrf
->name
, addr_str
);
965 vif_index
= pim_if_find_vifindex_by_ifindex(pim
, first_ifindex
);
968 if (PIM_DEBUG_PIM_NHT
) {
969 char addr_str
[INET_ADDRSTRLEN
];
970 pim_inet4_dump("<addr?>", addr
, addr_str
,
973 "%s: low vif_index=%d(%s) < 1 nexthop for address %s",
974 __PRETTY_FUNCTION__
, vif_index
, pim
->vrf
->name
,