3 * Copyright (C) 2008 Everton da Silva Marques
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
37 #include "pim_iface.h"
39 #include "pim_zlookup.h"
40 #include "pim_upstream.h"
41 #include "pim_ifchannel.h"
42 #include "pim_neighbor.h"
44 #include "pim_zebra.h"
46 #include "pim_macro.h"
49 #include "pim_register.h"
51 #include "pim_jp_agg.h"
54 #include "pim_vxlan.h"
56 static void join_timer_stop(struct pim_upstream
*up
);
58 pim_upstream_update_assert_tracking_desired(struct pim_upstream
*up
);
61 * A (*,G) or a (*,*) is going away
62 * remove the parent pointer from
63 * those pointing at us
65 static void pim_upstream_remove_children(struct pim_instance
*pim
,
66 struct pim_upstream
*up
)
68 struct pim_upstream
*child
;
73 while (!list_isempty(up
->sources
)) {
74 child
= listnode_head(up
->sources
);
75 listnode_delete(up
->sources
, child
);
76 if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(child
->flags
)) {
77 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(child
->flags
);
78 child
= pim_upstream_del(pim
, child
,
84 list_delete(&up
->sources
);
88 * A (*,G) or a (*,*) is being created
89 * Find the children that would point
92 static void pim_upstream_find_new_children(struct pim_instance
*pim
,
93 struct pim_upstream
*up
)
95 struct pim_upstream
*child
;
96 struct listnode
*ch_node
;
98 if ((up
->sg
.src
.s_addr
!= INADDR_ANY
)
99 && (up
->sg
.grp
.s_addr
!= INADDR_ANY
))
102 if ((up
->sg
.src
.s_addr
== INADDR_ANY
)
103 && (up
->sg
.grp
.s_addr
== INADDR_ANY
))
106 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, ch_node
, child
)) {
107 if ((up
->sg
.grp
.s_addr
!= INADDR_ANY
)
108 && (child
->sg
.grp
.s_addr
== up
->sg
.grp
.s_addr
)
111 listnode_add_sort(up
->sources
, child
);
117 * If we have a (*,*) || (S,*) there is no parent
118 * If we have a (S,G), find the (*,G)
119 * If we have a (*,G), find the (*,*)
121 static struct pim_upstream
*pim_upstream_find_parent(struct pim_instance
*pim
,
122 struct pim_upstream
*child
)
124 struct prefix_sg any
= child
->sg
;
125 struct pim_upstream
*up
= NULL
;
128 if ((child
->sg
.src
.s_addr
!= INADDR_ANY
)
129 && (child
->sg
.grp
.s_addr
!= INADDR_ANY
)) {
130 any
.src
.s_addr
= INADDR_ANY
;
131 up
= pim_upstream_find(pim
, &any
);
134 listnode_add(up
->sources
, child
);
142 static void upstream_channel_oil_detach(struct pim_upstream
*up
)
144 if (up
->channel_oil
) {
145 /* Detaching from channel_oil, channel_oil may exist post del,
146 but upstream would not keep reference of it
148 up
->channel_oil
->up
= NULL
;
149 pim_channel_oil_del(up
->channel_oil
, __PRETTY_FUNCTION__
);
150 up
->channel_oil
= NULL
;
154 struct pim_upstream
*pim_upstream_del(struct pim_instance
*pim
,
155 struct pim_upstream
*up
, const char *name
)
157 struct listnode
*node
, *nnode
;
158 struct pim_ifchannel
*ch
;
159 bool notify_msdp
= false;
164 "%s(%s): Delete %s[%s] ref count: %d , flags: %d c_oil ref count %d (Pre decrement)",
165 __PRETTY_FUNCTION__
, name
, up
->sg_str
, pim
->vrf
->name
,
166 up
->ref_count
, up
->flags
,
167 up
->channel_oil
->oil_ref_count
);
169 assert(up
->ref_count
> 0);
173 if (up
->ref_count
>= 1)
176 THREAD_OFF(up
->t_ka_timer
);
177 THREAD_OFF(up
->t_rs_timer
);
178 THREAD_OFF(up
->t_msdp_reg_timer
);
180 if (up
->join_state
== PIM_UPSTREAM_JOINED
) {
181 pim_jp_agg_single_upstream_send(&up
->rpf
, up
, 0);
183 if (up
->sg
.src
.s_addr
== INADDR_ANY
) {
184 /* if a (*, G) entry in the joined state is being
186 * need to notify MSDP */
192 pim_jp_agg_upstream_verification(up
, false);
193 up
->rpf
.source_nexthop
.interface
= NULL
;
195 if (up
->sg
.src
.s_addr
!= INADDR_ANY
) {
196 if (pim
->upstream_sg_wheel
)
197 wheel_remove_item(pim
->upstream_sg_wheel
, up
);
201 pim_mroute_del(up
->channel_oil
, __PRETTY_FUNCTION__
);
202 upstream_channel_oil_detach(up
);
204 for (ALL_LIST_ELEMENTS(up
->ifchannels
, node
, nnode
, ch
))
205 pim_ifchannel_delete(ch
);
206 list_delete(&up
->ifchannels
);
208 pim_upstream_remove_children(pim
, up
);
210 list_delete(&up
->sources
);
212 if (up
->parent
&& up
->parent
->sources
)
213 listnode_delete(up
->parent
->sources
, up
);
216 listnode_delete(pim
->upstream_list
, up
);
217 hash_release(pim
->upstream_hash
, up
);
220 pim_msdp_up_del(pim
, &up
->sg
);
223 /* When RP gets deleted, pim_rp_del() deregister addr with Zebra NHT
224 * and assign up->upstream_addr as INADDR_ANY.
225 * So before de-registering the upstream address, check if is not equal
226 * to INADDR_ANY. This is done in order to avoid de-registering for
227 * 255.255.255.255 which is maintained for some reason..
229 if (up
->upstream_addr
.s_addr
!= INADDR_ANY
) {
230 /* Deregister addr with Zebra NHT */
231 nht_p
.family
= AF_INET
;
232 nht_p
.prefixlen
= IPV4_MAX_BITLEN
;
233 nht_p
.u
.prefix4
= up
->upstream_addr
;
234 if (PIM_DEBUG_TRACE
) {
235 char buf
[PREFIX2STR_BUFFER
];
236 prefix2str(&nht_p
, buf
, sizeof(buf
));
237 zlog_debug("%s: Deregister upstream %s addr %s with Zebra NHT",
238 __PRETTY_FUNCTION__
, up
->sg_str
, buf
);
240 pim_delete_tracked_nexthop(pim
, &nht_p
, up
, NULL
, false);
243 XFREE(MTYPE_PIM_UPSTREAM
, up
);
248 void pim_upstream_send_join(struct pim_upstream
*up
)
250 if (!up
->rpf
.source_nexthop
.interface
) {
252 zlog_debug("%s: up %s RPF is not present",
253 __PRETTY_FUNCTION__
, up
->sg_str
);
257 if (PIM_DEBUG_TRACE
) {
258 char rpf_str
[PREFIX_STRLEN
];
259 pim_addr_dump("<rpf?>", &up
->rpf
.rpf_addr
, rpf_str
,
261 zlog_debug("%s: RPF'%s=%s(%s) for Interface %s",
262 __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
,
263 pim_upstream_state2str(up
->join_state
),
264 up
->rpf
.source_nexthop
.interface
->name
);
265 if (pim_rpf_addr_is_inaddr_any(&up
->rpf
)) {
266 zlog_debug("%s: can't send join upstream: RPF'%s=%s",
267 __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
);
272 /* send Join(S,G) to the current upstream neighbor */
273 pim_jp_agg_single_upstream_send(&up
->rpf
, up
, 1 /* join */);
276 static int on_join_timer(struct thread
*t
)
278 struct pim_upstream
*up
;
282 if (!up
->rpf
.source_nexthop
.interface
) {
284 zlog_debug("%s: up %s RPF is not present",
285 __PRETTY_FUNCTION__
, up
->sg_str
);
290 * In the case of a HFR we will not ahve anyone to send this to.
292 if (PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
))
296 * Don't send the join if the outgoing interface is a loopback
297 * But since this might change leave the join timer running
299 if (up
->rpf
.source_nexthop
300 .interface
&& !if_is_loopback(up
->rpf
.source_nexthop
.interface
))
301 pim_upstream_send_join(up
);
303 join_timer_start(up
);
308 static void join_timer_stop(struct pim_upstream
*up
)
310 struct pim_neighbor
*nbr
= NULL
;
312 THREAD_OFF(up
->t_join_timer
);
314 if (up
->rpf
.source_nexthop
.interface
)
315 nbr
= pim_neighbor_find(up
->rpf
.source_nexthop
.interface
,
316 up
->rpf
.rpf_addr
.u
.prefix4
);
319 pim_jp_agg_remove_group(nbr
->upstream_jp_agg
, up
);
321 pim_jp_agg_upstream_verification(up
, false);
324 void join_timer_start(struct pim_upstream
*up
)
326 struct pim_neighbor
*nbr
= NULL
;
328 if (up
->rpf
.source_nexthop
.interface
) {
329 nbr
= pim_neighbor_find(up
->rpf
.source_nexthop
.interface
,
330 up
->rpf
.rpf_addr
.u
.prefix4
);
332 if (PIM_DEBUG_PIM_EVENTS
) {
334 "%s: starting %d sec timer for upstream (S,G)=%s",
335 __PRETTY_FUNCTION__
, router
->t_periodic
,
341 pim_jp_agg_add_group(nbr
->upstream_jp_agg
, up
, 1);
343 THREAD_OFF(up
->t_join_timer
);
344 thread_add_timer(router
->master
, on_join_timer
, up
,
345 router
->t_periodic
, &up
->t_join_timer
);
347 pim_jp_agg_upstream_verification(up
, true);
351 * This is only called when we are switching the upstream
352 * J/P from one neighbor to another
354 * As such we need to remove from the old list and
355 * add to the new list.
357 void pim_upstream_join_timer_restart(struct pim_upstream
*up
,
360 // THREAD_OFF(up->t_join_timer);
361 join_timer_start(up
);
364 static void pim_upstream_join_timer_restart_msec(struct pim_upstream
*up
,
367 if (PIM_DEBUG_PIM_EVENTS
) {
368 zlog_debug("%s: restarting %d msec timer for upstream (S,G)=%s",
369 __PRETTY_FUNCTION__
, interval_msec
, up
->sg_str
);
372 THREAD_OFF(up
->t_join_timer
);
373 thread_add_timer_msec(router
->master
, on_join_timer
, up
, interval_msec
,
377 void pim_upstream_join_suppress(struct pim_upstream
*up
,
378 struct in_addr rpf_addr
, int holdtime
)
380 long t_joinsuppress_msec
;
381 long join_timer_remain_msec
;
383 if (!up
->rpf
.source_nexthop
.interface
) {
385 zlog_debug("%s: up %s RPF is not present",
386 __PRETTY_FUNCTION__
, up
->sg_str
);
390 t_joinsuppress_msec
=
391 MIN(pim_if_t_suppressed_msec(up
->rpf
.source_nexthop
.interface
),
394 join_timer_remain_msec
= pim_time_timer_remain_msec(up
->t_join_timer
);
396 if (PIM_DEBUG_TRACE
) {
397 char rpf_str
[INET_ADDRSTRLEN
];
398 pim_inet4_dump("<rpf?>", rpf_addr
, rpf_str
, sizeof(rpf_str
));
400 "%s %s: detected Join%s to RPF'(S,G)=%s: join_timer=%ld msec t_joinsuppress=%ld msec",
401 __FILE__
, __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
,
402 join_timer_remain_msec
, t_joinsuppress_msec
);
405 if (join_timer_remain_msec
< t_joinsuppress_msec
) {
406 if (PIM_DEBUG_TRACE
) {
408 "%s %s: suppressing Join(S,G)=%s for %ld msec",
409 __FILE__
, __PRETTY_FUNCTION__
, up
->sg_str
,
410 t_joinsuppress_msec
);
413 pim_upstream_join_timer_restart_msec(up
, t_joinsuppress_msec
);
417 void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label
,
418 struct pim_upstream
*up
)
420 long join_timer_remain_msec
;
423 if (!up
->rpf
.source_nexthop
.interface
) {
425 zlog_debug("%s: up %s RPF is not present",
426 __PRETTY_FUNCTION__
, up
->sg_str
);
430 join_timer_remain_msec
= pim_time_timer_remain_msec(up
->t_join_timer
);
432 pim_if_t_override_msec(up
->rpf
.source_nexthop
.interface
);
434 if (PIM_DEBUG_TRACE
) {
435 char rpf_str
[INET_ADDRSTRLEN
];
436 pim_inet4_dump("<rpf?>", up
->rpf
.rpf_addr
.u
.prefix4
, rpf_str
,
439 "%s: to RPF'%s=%s: join_timer=%ld msec t_override=%d msec",
440 debug_label
, up
->sg_str
, rpf_str
,
441 join_timer_remain_msec
, t_override_msec
);
444 if (join_timer_remain_msec
> t_override_msec
) {
445 if (PIM_DEBUG_TRACE
) {
447 "%s: decreasing (S,G)=%s join timer to t_override=%d msec",
448 debug_label
, up
->sg_str
, t_override_msec
);
451 pim_upstream_join_timer_restart_msec(up
, t_override_msec
);
455 static void forward_on(struct pim_upstream
*up
)
457 struct listnode
*chnode
;
458 struct listnode
*chnextnode
;
459 struct pim_ifchannel
*ch
= NULL
;
461 /* scan (S,G) state */
462 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
463 if (pim_macro_chisin_oiflist(ch
))
464 pim_forward_start(ch
);
466 } /* scan iface channel list */
469 static void forward_off(struct pim_upstream
*up
)
471 struct listnode
*chnode
;
472 struct listnode
*chnextnode
;
473 struct pim_ifchannel
*ch
;
475 /* scan per-interface (S,G) state */
476 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
478 pim_forward_stop(ch
, false);
480 } /* scan iface channel list */
483 static int pim_upstream_could_register(struct pim_upstream
*up
)
485 struct pim_interface
*pim_ifp
= NULL
;
487 /* FORCE_PIMREG is a generic flag to let an app like VxLAN-AA register
488 * a source on an upstream entry even if the source is not directly
489 * connected on the IIF.
491 if (PIM_UPSTREAM_FLAG_TEST_FORCE_PIMREG(up
->flags
))
494 if (up
->rpf
.source_nexthop
.interface
)
495 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
498 zlog_debug("%s: up %s RPF is not present",
499 __PRETTY_FUNCTION__
, up
->sg_str
);
502 if (pim_ifp
&& PIM_I_am_DR(pim_ifp
)
503 && pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
510 /* Source registration is suppressed for SSM groups. When the SSM range changes
511 * we re-revaluate register setup for existing upstream entries */
512 void pim_upstream_register_reevaluate(struct pim_instance
*pim
)
514 struct listnode
*upnode
;
515 struct pim_upstream
*up
;
517 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, upnode
, up
)) {
518 /* If FHR is set CouldRegister is True. Also check if the flow
519 * is actually active; if it is not kat setup will trigger
521 * registration whenever the flow becomes active. */
522 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
) || !up
->t_ka_timer
)
525 if (pim_is_grp_ssm(pim
, up
->sg
.grp
)) {
526 /* clear the register state for SSM groups */
527 if (up
->reg_state
!= PIM_REG_NOINFO
) {
528 if (PIM_DEBUG_PIM_EVENTS
)
530 "Clear register for %s as G is now SSM",
532 /* remove regiface from the OIL if it is there*/
533 pim_channel_del_oif(up
->channel_oil
,
535 PIM_OIF_FLAG_PROTO_PIM
);
536 up
->reg_state
= PIM_REG_NOINFO
;
539 /* register ASM sources with the RP */
540 if (up
->reg_state
== PIM_REG_NOINFO
) {
541 if (PIM_DEBUG_PIM_EVENTS
)
543 "Register %s as G is now ASM",
545 pim_channel_add_oif(up
->channel_oil
,
547 PIM_OIF_FLAG_PROTO_PIM
);
548 up
->reg_state
= PIM_REG_JOIN
;
554 void pim_upstream_switch(struct pim_instance
*pim
, struct pim_upstream
*up
,
555 enum pim_upstream_state new_state
)
557 enum pim_upstream_state old_state
= up
->join_state
;
559 if (up
->upstream_addr
.s_addr
== INADDR_ANY
) {
560 if (PIM_DEBUG_PIM_EVENTS
)
561 zlog_debug("%s: RPF not configured for %s",
562 __PRETTY_FUNCTION__
, up
->sg_str
);
566 if (!up
->rpf
.source_nexthop
.interface
) {
567 if (PIM_DEBUG_PIM_EVENTS
)
568 zlog_debug("%s: RP not reachable for %s",
569 __PRETTY_FUNCTION__
, up
->sg_str
);
573 if (PIM_DEBUG_PIM_EVENTS
) {
574 zlog_debug("%s: PIM_UPSTREAM_%s: (S,G) old: %s new: %s",
575 __PRETTY_FUNCTION__
, up
->sg_str
,
576 pim_upstream_state2str(up
->join_state
),
577 pim_upstream_state2str(new_state
));
580 up
->join_state
= new_state
;
581 if (old_state
!= new_state
)
582 up
->state_transition
= pim_time_monotonic_sec();
584 pim_upstream_update_assert_tracking_desired(up
);
586 if (new_state
== PIM_UPSTREAM_JOINED
) {
587 pim_upstream_inherited_olist_decide(pim
, up
);
588 if (old_state
!= PIM_UPSTREAM_JOINED
) {
589 int old_fhr
= PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
);
591 pim_msdp_up_join_state_changed(pim
, up
);
592 if (pim_upstream_could_register(up
)) {
593 PIM_UPSTREAM_FLAG_SET_FHR(up
->flags
);
595 && PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(
597 pim_upstream_keep_alive_timer_start(
598 up
, pim
->keep_alive_time
);
599 pim_register_join(up
);
602 pim_upstream_send_join(up
);
603 join_timer_start(up
);
609 if (old_state
== PIM_UPSTREAM_JOINED
)
610 pim_msdp_up_join_state_changed(pim
, up
);
612 /* IHR, Trigger SGRpt on *,G IIF to prune S,G from RPT towards
614 If I am RP for G then send S,G prune to its IIF. */
615 if (pim_upstream_is_sg_rpt(up
) && up
->parent
616 && !I_am_RP(pim
, up
->sg
.grp
)) {
617 if (PIM_DEBUG_PIM_TRACE_DETAIL
)
619 "%s: *,G IIF %s S,G IIF %s ",
621 up
->parent
->rpf
.source_nexthop
.interface
?
622 up
->parent
->rpf
.source_nexthop
.interface
->name
624 up
->rpf
.source_nexthop
.interface
?
625 up
->rpf
.source_nexthop
.interface
->name
:
627 pim_jp_agg_single_upstream_send(&up
->parent
->rpf
,
631 pim_jp_agg_single_upstream_send(&up
->rpf
, up
,
637 int pim_upstream_compare(void *arg1
, void *arg2
)
639 const struct pim_upstream
*up1
= (const struct pim_upstream
*)arg1
;
640 const struct pim_upstream
*up2
= (const struct pim_upstream
*)arg2
;
642 if (ntohl(up1
->sg
.grp
.s_addr
) < ntohl(up2
->sg
.grp
.s_addr
))
645 if (ntohl(up1
->sg
.grp
.s_addr
) > ntohl(up2
->sg
.grp
.s_addr
))
648 if (ntohl(up1
->sg
.src
.s_addr
) < ntohl(up2
->sg
.src
.s_addr
))
651 if (ntohl(up1
->sg
.src
.s_addr
) > ntohl(up2
->sg
.src
.s_addr
))
657 void pim_upstream_fill_static_iif(struct pim_upstream
*up
,
658 struct interface
*incoming
)
660 up
->rpf
.source_nexthop
.interface
= incoming
;
662 /* reset other parameters to matched a connected incoming interface */
663 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.family
= AF_INET
;
664 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.u
.prefix4
.s_addr
=
666 up
->rpf
.source_nexthop
.mrib_metric_preference
=
667 ZEBRA_CONNECT_DISTANCE_DEFAULT
;
668 up
->rpf
.source_nexthop
.mrib_route_metric
= 0;
669 up
->rpf
.rpf_addr
.family
= AF_INET
;
670 up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
= PIM_NET_INADDR_ANY
;
674 static struct pim_upstream
*pim_upstream_new(struct pim_instance
*pim
,
675 struct prefix_sg
*sg
,
676 struct interface
*incoming
,
678 struct pim_ifchannel
*ch
)
680 enum pim_rpf_result rpf_result
;
681 struct pim_interface
*pim_ifp
;
682 struct pim_upstream
*up
;
684 up
= XCALLOC(MTYPE_PIM_UPSTREAM
, sizeof(*up
));
687 pim_str_sg_set(sg
, up
->sg_str
);
691 up
= hash_get(pim
->upstream_hash
, up
, hash_alloc_intern
);
692 /* Set up->upstream_addr as INADDR_ANY, if RP is not
693 * configured and retain the upstream data structure
695 if (!pim_rp_set_upstream_addr(pim
, &up
->upstream_addr
, sg
->src
,
698 zlog_debug("%s: Received a (*,G) with no RP configured",
699 __PRETTY_FUNCTION__
);
702 up
->parent
= pim_upstream_find_parent(pim
, up
);
703 if (up
->sg
.src
.s_addr
== INADDR_ANY
) {
704 up
->sources
= list_new();
705 up
->sources
->cmp
= pim_upstream_compare
;
709 pim_upstream_find_new_children(pim
, up
);
712 up
->t_join_timer
= NULL
;
713 up
->t_ka_timer
= NULL
;
714 up
->t_rs_timer
= NULL
;
715 up
->t_msdp_reg_timer
= NULL
;
716 up
->join_state
= PIM_UPSTREAM_NOTJOINED
;
717 up
->reg_state
= PIM_REG_NOINFO
;
718 up
->state_transition
= pim_time_monotonic_sec();
720 pim_channel_oil_add(pim
, &up
->sg
, MAXVIFS
, __PRETTY_FUNCTION__
);
721 up
->sptbit
= PIM_UPSTREAM_SPTBIT_FALSE
;
723 up
->rpf
.source_nexthop
.interface
= NULL
;
724 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.family
= AF_INET
;
725 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.u
.prefix4
.s_addr
=
727 up
->rpf
.source_nexthop
.mrib_metric_preference
=
728 router
->infinite_assert_metric
.metric_preference
;
729 up
->rpf
.source_nexthop
.mrib_route_metric
=
730 router
->infinite_assert_metric
.route_metric
;
731 up
->rpf
.rpf_addr
.family
= AF_INET
;
732 up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
= PIM_NET_INADDR_ANY
;
734 up
->ifchannels
= list_new();
735 up
->ifchannels
->cmp
= (int (*)(void *, void *))pim_ifchannel_compare
;
737 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
738 wheel_add_item(pim
->upstream_sg_wheel
, up
);
740 if (PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(up
->flags
)
741 || PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up
->flags
)) {
742 pim_upstream_fill_static_iif(up
, incoming
);
743 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
745 pim_channel_oil_change_iif(pim
, up
->channel_oil
,
746 pim_ifp
->mroute_vif_index
,
747 __PRETTY_FUNCTION__
);
749 if (PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up
->flags
))
750 pim_upstream_keep_alive_timer_start(
751 up
, pim
->keep_alive_time
);
752 } else if (up
->upstream_addr
.s_addr
!= INADDR_ANY
) {
753 rpf_result
= pim_rpf_update(pim
, up
, NULL
);
754 if (rpf_result
== PIM_RPF_FAILURE
) {
757 "%s: Attempting to create upstream(%s), Unable to RPF for source",
758 __PRETTY_FUNCTION__
, up
->sg_str
);
761 if (up
->rpf
.source_nexthop
.interface
) {
762 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
764 pim_channel_oil_change_iif(
765 pim
, up
->channel_oil
,
766 pim_ifp
->mroute_vif_index
,
767 __PRETTY_FUNCTION__
);
771 listnode_add_sort(pim
->upstream_list
, up
);
773 if (PIM_DEBUG_TRACE
) {
775 "%s: Created Upstream %s upstream_addr %s ref count %d increment",
776 __PRETTY_FUNCTION__
, up
->sg_str
,
777 inet_ntoa(up
->upstream_addr
), up
->ref_count
);
783 struct pim_upstream
*pim_upstream_find(struct pim_instance
*pim
,
784 struct prefix_sg
*sg
)
786 struct pim_upstream lookup
;
787 struct pim_upstream
*up
= NULL
;
790 up
= hash_lookup(pim
->upstream_hash
, &lookup
);
794 struct pim_upstream
*pim_upstream_find_or_add(struct prefix_sg
*sg
,
795 struct interface
*incoming
,
796 int flags
, const char *name
)
798 struct pim_upstream
*up
;
799 struct pim_interface
*pim_ifp
;
801 pim_ifp
= incoming
->info
;
803 up
= pim_upstream_find(pim_ifp
->pim
, sg
);
806 if (!(up
->flags
& flags
)) {
811 "%s(%s): upstream %s ref count %d increment",
812 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
816 up
= pim_upstream_add(pim_ifp
->pim
, sg
, incoming
, flags
, name
,
822 void pim_upstream_ref(struct pim_upstream
*up
, int flags
, const char *name
)
827 zlog_debug("%s(%s): upstream %s ref count %d increment",
828 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
832 struct pim_upstream
*pim_upstream_add(struct pim_instance
*pim
,
833 struct prefix_sg
*sg
,
834 struct interface
*incoming
, int flags
,
836 struct pim_ifchannel
*ch
)
838 struct pim_upstream
*up
= NULL
;
841 up
= pim_upstream_find(pim
, sg
);
843 pim_upstream_ref(up
, flags
, name
);
846 up
= pim_upstream_new(pim
, sg
, incoming
, flags
, ch
);
849 if (PIM_DEBUG_TRACE
) {
851 char buf
[PREFIX2STR_BUFFER
];
852 prefix2str(&up
->rpf
.rpf_addr
, buf
, sizeof(buf
));
853 zlog_debug("%s(%s): %s, iif %s (%s) found: %d: ref_count: %d",
854 __PRETTY_FUNCTION__
, name
,
855 up
->sg_str
, buf
, up
->rpf
.source_nexthop
.interface
?
856 up
->rpf
.source_nexthop
.interface
->name
: "Unknown" ,
857 found
, up
->ref_count
);
859 zlog_debug("%s(%s): (%s) failure to create",
860 __PRETTY_FUNCTION__
, name
,
861 pim_str_sg_dump(sg
));
868 * Passed in up must be the upstream for ch. starch is NULL if no
871 int pim_upstream_evaluate_join_desired_interface(struct pim_upstream
*up
,
872 struct pim_ifchannel
*ch
,
873 struct pim_ifchannel
*starch
)
876 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
879 if (!pim_macro_ch_lost_assert(ch
)
880 && pim_macro_chisin_joins_or_include(ch
))
888 if (PIM_IF_FLAG_TEST_S_G_RPT(starch
->upstream
->flags
))
891 if (!pim_macro_ch_lost_assert(starch
)
892 && pim_macro_chisin_joins_or_include(starch
))
900 Evaluate JoinDesired(S,G):
902 JoinDesired(S,G) is true if there is a downstream (S,G) interface I
905 inherited_olist(S,G) =
906 joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
908 JoinDesired(S,G) may be affected by changes in the following:
910 pim_ifp->primary_address
912 ch->ifassert_winner_metric
914 ch->local_ifmembership
916 ch->upstream->rpf.source_nexthop.mrib_metric_preference
917 ch->upstream->rpf.source_nexthop.mrib_route_metric
918 ch->upstream->rpf.source_nexthop.interface
920 See also pim_upstream_update_join_desired() below.
922 int pim_upstream_evaluate_join_desired(struct pim_instance
*pim
,
923 struct pim_upstream
*up
)
925 struct interface
*ifp
;
926 struct pim_ifchannel
*ch
, *starch
;
927 struct pim_upstream
*starup
= up
->parent
;
930 FOR_ALL_INTERFACES (pim
->vrf
, ifp
) {
934 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
937 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
944 ret
+= pim_upstream_evaluate_join_desired_interface(up
, ch
,
946 } /* scan iface channel list */
948 return ret
; /* false */
952 See also pim_upstream_evaluate_join_desired() above.
954 void pim_upstream_update_join_desired(struct pim_instance
*pim
,
955 struct pim_upstream
*up
)
957 int was_join_desired
; /* boolean */
958 int is_join_desired
; /* boolean */
960 was_join_desired
= PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up
->flags
);
962 is_join_desired
= pim_upstream_evaluate_join_desired(pim
, up
);
964 PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(up
->flags
);
966 PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(up
->flags
);
968 /* switched from false to true */
969 if (is_join_desired
&& (up
->join_state
== PIM_UPSTREAM_NOTJOINED
)) {
970 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_JOINED
);
974 /* switched from true to false */
975 if (!is_join_desired
&& was_join_desired
) {
976 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_NOTJOINED
);
982 RFC 4601 4.5.7. Sending (S,G) Join/Prune Messages
983 Transitions from Joined State
984 RPF'(S,G) GenID changes
986 The upstream (S,G) state machine remains in Joined state. If the
987 Join Timer is set to expire in more than t_override seconds, reset
988 it so that it expires after t_override seconds.
990 void pim_upstream_rpf_genid_changed(struct pim_instance
*pim
,
991 struct in_addr neigh_addr
)
993 struct listnode
*up_node
;
994 struct listnode
*up_nextnode
;
995 struct pim_upstream
*up
;
998 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1000 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
1002 if (PIM_DEBUG_TRACE
) {
1003 char neigh_str
[INET_ADDRSTRLEN
];
1004 char rpf_addr_str
[PREFIX_STRLEN
];
1005 pim_inet4_dump("<neigh?>", neigh_addr
, neigh_str
,
1007 pim_addr_dump("<rpf?>", &up
->rpf
.rpf_addr
, rpf_addr_str
,
1008 sizeof(rpf_addr_str
));
1010 "%s: matching neigh=%s against upstream (S,G)=%s[%s] joined=%d rpf_addr=%s",
1011 __PRETTY_FUNCTION__
, neigh_str
, up
->sg_str
,
1013 up
->join_state
== PIM_UPSTREAM_JOINED
,
1017 /* consider only (S,G) upstream in Joined state */
1018 if (up
->join_state
!= PIM_UPSTREAM_JOINED
)
1021 /* match RPF'(S,G)=neigh_addr */
1022 if (up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
!= neigh_addr
.s_addr
)
1025 pim_upstream_join_timer_decrease_to_t_override(
1026 "RPF'(S,G) GenID change", up
);
1031 void pim_upstream_rpf_interface_changed(struct pim_upstream
*up
,
1032 struct interface
*old_rpf_ifp
)
1034 struct listnode
*chnode
;
1035 struct listnode
*chnextnode
;
1036 struct pim_ifchannel
*ch
;
1038 /* search all ifchannels */
1039 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1040 if (ch
->ifassert_state
== PIM_IFASSERT_I_AM_LOSER
) {
1042 /* RPF_interface(S) was NOT I */
1043 (old_rpf_ifp
== ch
->interface
) &&
1044 /* RPF_interface(S) stopped being I */
1045 (ch
->upstream
->rpf
.source_nexthop
1047 (ch
->upstream
->rpf
.source_nexthop
1048 .interface
!= ch
->interface
)) {
1049 assert_action_a5(ch
);
1051 } /* PIM_IFASSERT_I_AM_LOSER */
1053 pim_ifchannel_update_assert_tracking_desired(ch
);
1057 void pim_upstream_update_could_assert(struct pim_upstream
*up
)
1059 struct listnode
*chnode
;
1060 struct listnode
*chnextnode
;
1061 struct pim_ifchannel
*ch
;
1063 /* scan per-interface (S,G) state */
1064 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1065 pim_ifchannel_update_could_assert(ch
);
1066 } /* scan iface channel list */
1069 void pim_upstream_update_my_assert_metric(struct pim_upstream
*up
)
1071 struct listnode
*chnode
;
1072 struct listnode
*chnextnode
;
1073 struct pim_ifchannel
*ch
;
1075 /* scan per-interface (S,G) state */
1076 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1077 pim_ifchannel_update_my_assert_metric(ch
);
1079 } /* scan iface channel list */
1082 static void pim_upstream_update_assert_tracking_desired(struct pim_upstream
*up
)
1084 struct listnode
*chnode
;
1085 struct listnode
*chnextnode
;
1086 struct pim_interface
*pim_ifp
;
1087 struct pim_ifchannel
*ch
;
1089 /* scan per-interface (S,G) state */
1090 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1093 pim_ifp
= ch
->interface
->info
;
1097 pim_ifchannel_update_assert_tracking_desired(ch
);
1099 } /* scan iface channel list */
1102 /* When kat is stopped CouldRegister goes to false so we need to
1103 * transition the (S, G) on FHR to NI state and remove reg tunnel
1105 static void pim_upstream_fhr_kat_expiry(struct pim_instance
*pim
,
1106 struct pim_upstream
*up
)
1108 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
))
1111 if (PIM_DEBUG_TRACE
)
1112 zlog_debug("kat expired on %s; clear fhr reg state",
1115 /* stop reg-stop timer */
1116 THREAD_OFF(up
->t_rs_timer
);
1117 /* remove regiface from the OIL if it is there*/
1118 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1119 PIM_OIF_FLAG_PROTO_PIM
);
1120 /* clear the register state */
1121 up
->reg_state
= PIM_REG_NOINFO
;
1122 PIM_UPSTREAM_FLAG_UNSET_FHR(up
->flags
);
1125 /* When kat is started CouldRegister can go to true. And if it does we
1126 * need to transition the (S, G) on FHR to JOINED state and add reg tunnel
1128 static void pim_upstream_fhr_kat_start(struct pim_upstream
*up
)
1130 if (pim_upstream_could_register(up
)) {
1131 if (PIM_DEBUG_TRACE
)
1133 "kat started on %s; set fhr reg state to joined",
1136 PIM_UPSTREAM_FLAG_SET_FHR(up
->flags
);
1137 if (up
->reg_state
== PIM_REG_NOINFO
)
1138 pim_register_join(up
);
1143 * On an RP, the PMBR value must be cleared when the
1144 * Keepalive Timer expires
1145 * KAT expiry indicates that flow is inactive. If the flow was created or
1146 * maintained by activity now is the time to deref it.
1148 struct pim_upstream
*pim_upstream_keep_alive_timer_proc(
1149 struct pim_upstream
*up
)
1151 struct pim_instance
*pim
;
1153 pim
= up
->channel_oil
->pim
;
1155 if (PIM_UPSTREAM_FLAG_TEST_DISABLE_KAT_EXPIRY(up
->flags
)) {
1156 /* if the router is a PIM vxlan encapsulator we prevent expiry
1157 * of KAT as the mroute is pre-setup without any traffic
1159 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1163 if (I_am_RP(pim
, up
->sg
.grp
)) {
1164 pim_br_clear_pmbr(&up
->sg
);
1166 * We need to do more here :)
1167 * But this is the start.
1171 /* source is no longer active - pull the SA from MSDP's cache */
1172 pim_msdp_sa_local_del(pim
, &up
->sg
);
1174 /* if entry was created because of activity we need to deref it */
1175 if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1176 pim_upstream_fhr_kat_expiry(pim
, up
);
1177 if (PIM_DEBUG_TRACE
)
1179 "kat expired on %s[%s]; remove stream reference",
1180 up
->sg_str
, pim
->vrf
->name
);
1181 PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(up
->flags
);
1183 /* Return if upstream entry got deleted.*/
1184 if (!pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
))
1187 if (PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up
->flags
)) {
1188 PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(up
->flags
);
1190 if (!pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
))
1194 /* upstream reference would have been added to track the local
1195 * membership if it is LHR. We have to clear it when KAT expires.
1196 * Otherwise would result in stale entry with uncleared ref count.
1198 if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
)) {
1199 struct pim_upstream
*parent
= up
->parent
;
1201 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(up
->flags
);
1202 up
= pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
);
1205 pim_jp_agg_single_upstream_send(&parent
->rpf
, parent
,
1212 static int pim_upstream_keep_alive_timer(struct thread
*t
)
1214 struct pim_upstream
*up
;
1218 pim_upstream_keep_alive_timer_proc(up
);
1222 void pim_upstream_keep_alive_timer_start(struct pim_upstream
*up
, uint32_t time
)
1224 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1225 if (PIM_DEBUG_TRACE
)
1226 zlog_debug("kat start on %s with no stream reference",
1229 THREAD_OFF(up
->t_ka_timer
);
1230 thread_add_timer(router
->master
, pim_upstream_keep_alive_timer
, up
,
1231 time
, &up
->t_ka_timer
);
1233 /* any time keepalive is started against a SG we will have to
1234 * re-evaluate our active source database */
1235 pim_msdp_sa_local_update(up
);
1238 /* MSDP on RP needs to know if a source is registerable to this RP */
1239 static int pim_upstream_msdp_reg_timer(struct thread
*t
)
1241 struct pim_upstream
*up
= THREAD_ARG(t
);
1242 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1244 /* source is no longer active - pull the SA from MSDP's cache */
1245 pim_msdp_sa_local_del(pim
, &up
->sg
);
1248 void pim_upstream_msdp_reg_timer_start(struct pim_upstream
*up
)
1250 THREAD_OFF(up
->t_msdp_reg_timer
);
1251 thread_add_timer(router
->master
, pim_upstream_msdp_reg_timer
, up
,
1252 PIM_MSDP_REG_RXED_PERIOD
, &up
->t_msdp_reg_timer
);
1254 pim_msdp_sa_local_update(up
);
1258 * 4.2.1 Last-Hop Switchover to the SPT
1260 * In Sparse-Mode PIM, last-hop routers join the shared tree towards the
1261 * RP. Once traffic from sources to joined groups arrives at a last-hop
1262 * router, it has the option of switching to receive the traffic on a
1263 * shortest path tree (SPT).
1265 * The decision for a router to switch to the SPT is controlled as
1269 * CheckSwitchToSpt(S,G) {
1270 * if ( ( pim_include(*,G) (-) pim_exclude(S,G)
1271 * (+) pim_include(S,G) != NULL )
1272 * AND SwitchToSptDesired(S,G) ) {
1273 * # Note: Restarting the KAT will result in the SPT switch
1274 * set KeepaliveTimer(S,G) to Keepalive_Period
1278 * SwitchToSptDesired(S,G) is a policy function that is implementation
1279 * defined. An "infinite threshold" policy can be implemented by making
1280 * SwitchToSptDesired(S,G) return false all the time. A "switch on
1281 * first packet" policy can be implemented by making
1282 * SwitchToSptDesired(S,G) return true once a single packet has been
1283 * received for the source and group.
1285 int pim_upstream_switch_to_spt_desired(struct pim_instance
*pim
,
1286 struct prefix_sg
*sg
)
1288 if (I_am_RP(pim
, sg
->grp
))
1294 int pim_upstream_is_sg_rpt(struct pim_upstream
*up
)
1296 struct listnode
*chnode
;
1297 struct pim_ifchannel
*ch
;
1299 for (ALL_LIST_ELEMENTS_RO(up
->ifchannels
, chnode
, ch
)) {
1300 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
1307 * After receiving a packet set SPTbit:
1309 * Update_SPTbit(S,G,iif) {
1310 * if ( iif == RPF_interface(S)
1311 * AND JoinDesired(S,G) == true
1312 * AND ( DirectlyConnected(S) == true
1313 * OR RPF_interface(S) != RPF_interface(RP(G))
1314 * OR inherited_olist(S,G,rpt) == NULL
1315 * OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1316 * ( RPF'(S,G) != NULL ) )
1317 * OR ( I_Am_Assert_Loser(S,G,iif) ) {
1318 * Set SPTbit(S,G) to true
1322 void pim_upstream_set_sptbit(struct pim_upstream
*up
,
1323 struct interface
*incoming
)
1325 struct pim_upstream
*starup
= up
->parent
;
1327 // iif == RPF_interfvace(S)
1328 if (up
->rpf
.source_nexthop
.interface
!= incoming
) {
1329 if (PIM_DEBUG_TRACE
)
1331 "%s: Incoming Interface: %s is different than RPF_interface(S) %s",
1332 __PRETTY_FUNCTION__
, incoming
->name
,
1333 up
->rpf
.source_nexthop
.interface
->name
);
1337 // AND JoinDesired(S,G) == true
1338 if (!pim_upstream_evaluate_join_desired(up
->channel_oil
->pim
, up
)) {
1339 if (PIM_DEBUG_TRACE
)
1340 zlog_debug("%s: %s Join is not Desired",
1341 __PRETTY_FUNCTION__
, up
->sg_str
);
1345 // DirectlyConnected(S) == true
1346 if (pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1348 if (PIM_DEBUG_TRACE
)
1349 zlog_debug("%s: %s is directly connected to the source",
1350 __PRETTY_FUNCTION__
, up
->sg_str
);
1351 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1355 // OR RPF_interface(S) != RPF_interface(RP(G))
1357 || up
->rpf
.source_nexthop
1358 .interface
!= starup
->rpf
.source_nexthop
.interface
) {
1359 struct pim_upstream
*starup
= up
->parent
;
1361 if (PIM_DEBUG_TRACE
)
1363 "%s: %s RPF_interface(S) != RPF_interface(RP(G))",
1364 __PRETTY_FUNCTION__
, up
->sg_str
);
1365 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1367 pim_jp_agg_single_upstream_send(&starup
->rpf
, starup
, true);
1371 // OR inherited_olist(S,G,rpt) == NULL
1372 if (pim_upstream_is_sg_rpt(up
)
1373 && pim_upstream_empty_inherited_olist(up
)) {
1374 if (PIM_DEBUG_TRACE
)
1375 zlog_debug("%s: %s OR inherited_olist(S,G,rpt) == NULL",
1376 __PRETTY_FUNCTION__
, up
->sg_str
);
1377 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1381 // OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1382 // ( RPF'(S,G) != NULL ) )
1383 if (up
->parent
&& pim_rpf_is_same(&up
->rpf
, &up
->parent
->rpf
)) {
1384 if (PIM_DEBUG_TRACE
)
1385 zlog_debug("%s: %s RPF'(S,G) is the same as RPF'(*,G)",
1386 __PRETTY_FUNCTION__
, up
->sg_str
);
1387 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1394 const char *pim_upstream_state2str(enum pim_upstream_state join_state
)
1396 switch (join_state
) {
1397 case PIM_UPSTREAM_NOTJOINED
:
1400 case PIM_UPSTREAM_JOINED
:
1407 const char *pim_reg_state2str(enum pim_reg_state reg_state
, char *state_str
,
1408 size_t state_str_len
)
1410 switch (reg_state
) {
1411 case PIM_REG_NOINFO
:
1412 strlcpy(state_str
, "RegNoInfo", state_str_len
);
1415 strlcpy(state_str
, "RegJoined", state_str_len
);
1417 case PIM_REG_JOIN_PENDING
:
1418 strlcpy(state_str
, "RegJoinPend", state_str_len
);
1421 strlcpy(state_str
, "RegPrune", state_str_len
);
1424 strlcpy(state_str
, "RegUnknown", state_str_len
);
1429 static int pim_upstream_register_stop_timer(struct thread
*t
)
1431 struct pim_interface
*pim_ifp
;
1432 struct pim_instance
*pim
;
1433 struct pim_upstream
*up
;
1435 pim
= up
->channel_oil
->pim
;
1437 if (PIM_DEBUG_TRACE
) {
1438 char state_str
[PIM_REG_STATE_STR_LEN
];
1439 zlog_debug("%s: (S,G)=%s[%s] upstream register stop timer %s",
1440 __PRETTY_FUNCTION__
, up
->sg_str
, pim
->vrf
->name
,
1441 pim_reg_state2str(up
->reg_state
, state_str
, sizeof(state_str
)));
1444 switch (up
->reg_state
) {
1445 case PIM_REG_JOIN_PENDING
:
1446 up
->reg_state
= PIM_REG_JOIN
;
1447 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1448 PIM_OIF_FLAG_PROTO_PIM
);
1449 pim_vxlan_update_sg_reg_state(pim
, up
, true /*reg_join*/);
1454 if (!up
->rpf
.source_nexthop
.interface
) {
1455 if (PIM_DEBUG_TRACE
)
1456 zlog_debug("%s: up %s RPF is not present",
1457 __PRETTY_FUNCTION__
, up
->sg_str
);
1461 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
1463 if (PIM_DEBUG_TRACE
)
1465 "%s: Interface: %s is not configured for pim",
1466 __PRETTY_FUNCTION__
,
1467 up
->rpf
.source_nexthop
.interface
->name
);
1470 up
->reg_state
= PIM_REG_JOIN_PENDING
;
1471 pim_upstream_start_register_stop_timer(up
, 1);
1473 if (((up
->channel_oil
->cc
.lastused
/ 100)
1474 > pim
->keep_alive_time
)
1475 && (I_am_RP(pim_ifp
->pim
, up
->sg
.grp
))) {
1476 if (PIM_DEBUG_TRACE
)
1478 "%s: Stop sending the register, because I am the RP and we haven't seen a packet in a while",
1479 __PRETTY_FUNCTION__
);
1482 pim_null_register_send(up
);
1491 void pim_upstream_start_register_stop_timer(struct pim_upstream
*up
,
1496 THREAD_TIMER_OFF(up
->t_rs_timer
);
1498 if (!null_register
) {
1499 uint32_t lower
= (0.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1500 uint32_t upper
= (1.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1501 time
= lower
+ (random() % (upper
- lower
+ 1))
1502 - PIM_REGISTER_PROBE_PERIOD
;
1504 time
= PIM_REGISTER_PROBE_PERIOD
;
1506 if (PIM_DEBUG_TRACE
) {
1508 "%s: (S,G)=%s Starting upstream register stop timer %d",
1509 __PRETTY_FUNCTION__
, up
->sg_str
, time
);
1511 thread_add_timer(router
->master
, pim_upstream_register_stop_timer
, up
,
1512 time
, &up
->t_rs_timer
);
1515 int pim_upstream_inherited_olist_decide(struct pim_instance
*pim
,
1516 struct pim_upstream
*up
)
1518 struct interface
*ifp
;
1519 struct pim_ifchannel
*ch
, *starch
;
1520 struct pim_upstream
*starup
= up
->parent
;
1521 int output_intf
= 0;
1523 if (!up
->rpf
.source_nexthop
.interface
)
1524 if (PIM_DEBUG_TRACE
)
1525 zlog_debug("%s: up %s RPF is not present",
1526 __PRETTY_FUNCTION__
, up
->sg_str
);
1528 FOR_ALL_INTERFACES (pim
->vrf
, ifp
) {
1532 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
1535 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
1542 if (pim_upstream_evaluate_join_desired_interface(up
, ch
,
1544 int flag
= PIM_OIF_FLAG_PROTO_PIM
;
1547 flag
= PIM_OIF_FLAG_PROTO_STAR
;
1549 pim_channel_add_oif(up
->channel_oil
, ifp
, flag
);
1558 * For a given upstream, determine the inherited_olist
1561 * inherited_olist(S,G,rpt) =
1562 * ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
1563 * (+) ( pim_include(*,G) (-) pim_exclude(S,G))
1564 * (-) ( lost_assert(*,G) (+) lost_assert(S,G,rpt) )
1566 * inherited_olist(S,G) =
1567 * inherited_olist(S,G,rpt) (+)
1568 * joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
1570 * return 1 if there are any output interfaces
1571 * return 0 if there are not any output interfaces
1573 int pim_upstream_inherited_olist(struct pim_instance
*pim
,
1574 struct pim_upstream
*up
)
1576 int output_intf
= pim_upstream_inherited_olist_decide(pim
, up
);
1579 * If we have output_intf switch state to Join and work like normal
1580 * If we don't have an output_intf that means we are probably a
1581 * switch on a stick so turn on forwarding to just accept the
1582 * incoming packets so we don't bother the other stuff!
1585 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_JOINED
);
1592 int pim_upstream_empty_inherited_olist(struct pim_upstream
*up
)
1594 return pim_channel_oil_empty(up
->channel_oil
);
1598 * When we have a new neighbor,
1599 * find upstreams that don't have their rpf_addr
1600 * set and see if the new neighbor allows
1601 * the join to be sent
1603 void pim_upstream_find_new_rpf(struct pim_instance
*pim
)
1605 struct listnode
*up_node
;
1606 struct listnode
*up_nextnode
;
1607 struct pim_upstream
*up
;
1610 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1612 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
1613 if (up
->upstream_addr
.s_addr
== INADDR_ANY
) {
1614 if (PIM_DEBUG_TRACE
)
1616 "%s: RP not configured for Upstream %s",
1617 __PRETTY_FUNCTION__
, up
->sg_str
);
1621 if (pim_rpf_addr_is_inaddr_any(&up
->rpf
)) {
1622 if (PIM_DEBUG_TRACE
)
1624 "%s: Upstream %s without a path to send join, checking",
1625 __PRETTY_FUNCTION__
, up
->sg_str
);
1626 pim_rpf_update(pim
, up
, NULL
);
1631 unsigned int pim_upstream_hash_key(const void *arg
)
1633 const struct pim_upstream
*up
= arg
;
1635 return jhash_2words(up
->sg
.src
.s_addr
, up
->sg
.grp
.s_addr
, 0);
1638 void pim_upstream_terminate(struct pim_instance
*pim
)
1640 struct pim_upstream
*up
;
1642 if (pim
->upstream_list
) {
1643 while (pim
->upstream_list
->count
) {
1644 up
= listnode_head(pim
->upstream_list
);
1645 pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
);
1648 list_delete(&pim
->upstream_list
);
1651 if (pim
->upstream_hash
)
1652 hash_free(pim
->upstream_hash
);
1653 pim
->upstream_hash
= NULL
;
1655 if (pim
->upstream_sg_wheel
)
1656 wheel_delete(pim
->upstream_sg_wheel
);
1657 pim
->upstream_sg_wheel
= NULL
;
1660 bool pim_upstream_equal(const void *arg1
, const void *arg2
)
1662 const struct pim_upstream
*up1
= (const struct pim_upstream
*)arg1
;
1663 const struct pim_upstream
*up2
= (const struct pim_upstream
*)arg2
;
1665 if ((up1
->sg
.grp
.s_addr
== up2
->sg
.grp
.s_addr
)
1666 && (up1
->sg
.src
.s_addr
== up2
->sg
.src
.s_addr
))
1672 /* rfc4601:section-4.2:"Data Packet Forwarding Rules" defines
1673 * the cases where kat has to be restarted on rxing traffic -
1675 * if( DirectlyConnected(S) == true AND iif == RPF_interface(S) ) {
1676 * set KeepaliveTimer(S,G) to Keepalive_Period
1677 * # Note: a register state transition or UpstreamJPState(S,G)
1678 * # transition may happen as a result of restarting
1679 * # KeepaliveTimer, and must be dealt with here.
1681 * if( iif == RPF_interface(S) AND UpstreamJPState(S,G) == Joined AND
1682 * inherited_olist(S,G) != NULL ) {
1683 * set KeepaliveTimer(S,G) to Keepalive_Period
1686 static bool pim_upstream_kat_start_ok(struct pim_upstream
*up
)
1688 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1690 /* "iif == RPF_interface(S)" check has to be done by the kernel or hw
1691 * so we will skip that here */
1692 if (up
->rpf
.source_nexthop
.interface
&&
1693 pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1698 if ((up
->join_state
== PIM_UPSTREAM_JOINED
)
1699 && !pim_upstream_empty_inherited_olist(up
)) {
1700 /* XXX: I have added this RP check just for 3.2 and it's a
1702 * what rfc-4601 says. Till now we were only running KAT on FHR
1704 * there is some angst around making the change to run it all
1706 * maintain the (S, G) state. This is tracked via CM-13601 and
1708 * removed to handle spt turn-arounds correctly in a 3-tier clos
1710 if (I_am_RP(pim
, up
->sg
.grp
))
1718 * Code to check and see if we've received packets on a S,G mroute
1719 * and if so to set the SPT bit appropriately
1721 static void pim_upstream_sg_running(void *arg
)
1723 struct pim_upstream
*up
= (struct pim_upstream
*)arg
;
1724 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1726 // No packet can have arrived here if this is the case
1727 if (!up
->channel_oil
->installed
) {
1728 if (PIM_DEBUG_TRACE
)
1729 zlog_debug("%s: %s%s is not installed in mroute",
1730 __PRETTY_FUNCTION__
, up
->sg_str
,
1736 * This is a bit of a hack
1737 * We've noted that we should rescan but
1738 * we've missed the window for doing so in
1739 * pim_zebra.c for some reason. I am
1740 * only doing this at this point in time
1741 * to get us up and working for the moment
1743 if (up
->channel_oil
->oil_inherited_rescan
) {
1744 if (PIM_DEBUG_TRACE
)
1746 "%s: Handling unscanned inherited_olist for %s[%s]",
1747 __PRETTY_FUNCTION__
, up
->sg_str
,
1749 pim_upstream_inherited_olist_decide(pim
, up
);
1750 up
->channel_oil
->oil_inherited_rescan
= 0;
1752 pim_mroute_update_counters(up
->channel_oil
);
1754 // Have we seen packets?
1755 if ((up
->channel_oil
->cc
.oldpktcnt
>= up
->channel_oil
->cc
.pktcnt
)
1756 && (up
->channel_oil
->cc
.lastused
/ 100 > 30)) {
1757 if (PIM_DEBUG_TRACE
) {
1759 "%s[%s]: %s old packet count is equal or lastused is greater than 30, (%ld,%ld,%lld)",
1760 __PRETTY_FUNCTION__
, up
->sg_str
, pim
->vrf
->name
,
1761 up
->channel_oil
->cc
.oldpktcnt
,
1762 up
->channel_oil
->cc
.pktcnt
,
1763 up
->channel_oil
->cc
.lastused
/ 100);
1768 if (pim_upstream_kat_start_ok(up
)) {
1769 /* Add a source reference to the stream if
1770 * one doesn't already exist */
1771 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1772 if (PIM_DEBUG_TRACE
)
1774 "source reference created on kat restart %s[%s]",
1775 up
->sg_str
, pim
->vrf
->name
);
1777 pim_upstream_ref(up
, PIM_UPSTREAM_FLAG_MASK_SRC_STREAM
,
1778 __PRETTY_FUNCTION__
);
1779 PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up
->flags
);
1780 pim_upstream_fhr_kat_start(up
);
1782 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1783 } else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
))
1784 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1786 if ((up
->sptbit
!= PIM_UPSTREAM_SPTBIT_TRUE
) &&
1787 (up
->rpf
.source_nexthop
.interface
)) {
1788 pim_upstream_set_sptbit(up
, up
->rpf
.source_nexthop
.interface
);
1793 void pim_upstream_add_lhr_star_pimreg(struct pim_instance
*pim
)
1795 struct pim_upstream
*up
;
1796 struct listnode
*node
;
1798 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1799 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1802 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1805 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1806 PIM_OIF_FLAG_PROTO_IGMP
);
1810 void pim_upstream_spt_prefix_list_update(struct pim_instance
*pim
,
1811 struct prefix_list
*pl
)
1813 const char *pname
= prefix_list_name(pl
);
1815 if (pim
->spt
.plist
&& strcmp(pim
->spt
.plist
, pname
) == 0) {
1816 pim_upstream_remove_lhr_star_pimreg(pim
, pname
);
1821 * nlist -> The new prefix list
1823 * Per Group Application of pimreg to the OIL
1824 * If the prefix list tells us DENY then
1825 * we need to Switchover to SPT immediate
1826 * so add the pimreg.
1827 * If the prefix list tells us to ACCEPT than
1828 * we need to Never do the SPT so remove
1832 void pim_upstream_remove_lhr_star_pimreg(struct pim_instance
*pim
,
1835 struct pim_upstream
*up
;
1836 struct listnode
*node
;
1837 struct prefix_list
*np
;
1839 enum prefix_list_type apply_new
;
1841 np
= prefix_list_lookup(AFI_IP
, nlist
);
1844 g
.prefixlen
= IPV4_MAX_PREFIXLEN
;
1846 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1847 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1850 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1854 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1855 PIM_OIF_FLAG_PROTO_IGMP
);
1858 g
.u
.prefix4
= up
->sg
.grp
;
1859 apply_new
= prefix_list_apply(np
, &g
);
1860 if (apply_new
== PREFIX_DENY
)
1861 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1862 PIM_OIF_FLAG_PROTO_IGMP
);
1864 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1865 PIM_OIF_FLAG_PROTO_IGMP
);
1869 void pim_upstream_init(struct pim_instance
*pim
)
1873 snprintf(name
, 64, "PIM %s Timer Wheel",
1875 pim
->upstream_sg_wheel
=
1876 wheel_init(router
->master
, 31000, 100, pim_upstream_hash_key
,
1877 pim_upstream_sg_running
, name
);
1879 snprintf(name
, 64, "PIM %s Upstream Hash",
1881 pim
->upstream_hash
= hash_create_size(8192, pim_upstream_hash_key
,
1882 pim_upstream_equal
, name
);
1884 pim
->upstream_list
= list_new();
1885 pim
->upstream_list
->cmp
= pim_upstream_compare
;