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();
719 up
->channel_oil
= NULL
;
720 up
->sptbit
= PIM_UPSTREAM_SPTBIT_FALSE
;
722 up
->rpf
.source_nexthop
.interface
= NULL
;
723 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.family
= AF_INET
;
724 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.u
.prefix4
.s_addr
=
726 up
->rpf
.source_nexthop
.mrib_metric_preference
=
727 router
->infinite_assert_metric
.metric_preference
;
728 up
->rpf
.source_nexthop
.mrib_route_metric
=
729 router
->infinite_assert_metric
.route_metric
;
730 up
->rpf
.rpf_addr
.family
= AF_INET
;
731 up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
= PIM_NET_INADDR_ANY
;
733 up
->ifchannels
= list_new();
734 up
->ifchannels
->cmp
= (int (*)(void *, void *))pim_ifchannel_compare
;
736 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
737 wheel_add_item(pim
->upstream_sg_wheel
, up
);
739 if (PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(up
->flags
)) {
740 pim_upstream_fill_static_iif(up
, incoming
);
741 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
743 up
->channel_oil
= pim_channel_oil_add(pim
, &up
->sg
,
744 pim_ifp
->mroute_vif_index
,
745 __PRETTY_FUNCTION__
);
746 } else if (up
->upstream_addr
.s_addr
== INADDR_ANY
) {
747 /* Create a dummmy channel oil with incoming ineterface MAXVIFS,
748 * since RP is not configured
750 up
->channel_oil
= pim_channel_oil_add(pim
, &up
->sg
, MAXVIFS
,
751 __PRETTY_FUNCTION__
);
754 rpf_result
= pim_rpf_update(pim
, up
, NULL
);
755 if (rpf_result
== PIM_RPF_FAILURE
) {
758 "%s: Attempting to create upstream(%s), Unable to RPF for source",
759 __PRETTY_FUNCTION__
, up
->sg_str
);
760 /* Create a dummmy channel oil with incoming ineterface
761 * MAXVIFS, since RP is not reachable
763 up
->channel_oil
= pim_channel_oil_add(
764 pim
, &up
->sg
, MAXVIFS
, __PRETTY_FUNCTION__
);
767 if (up
->rpf
.source_nexthop
.interface
) {
768 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
770 up
->channel_oil
= pim_channel_oil_add(
771 pim
, &up
->sg
, pim_ifp
->mroute_vif_index
,
772 __PRETTY_FUNCTION__
);
775 * Yeah this should not happen
776 * but let's be sure that we are not
777 * doing something stupid, all paths
778 * through upstream creation will
779 * create a channel oil
781 up
->channel_oil
= pim_channel_oil_add(
782 pim
, &up
->sg
, MAXVIFS
,
783 __PRETTY_FUNCTION__
);
788 listnode_add_sort(pim
->upstream_list
, up
);
790 if (PIM_DEBUG_TRACE
) {
792 "%s: Created Upstream %s upstream_addr %s ref count %d increment",
793 __PRETTY_FUNCTION__
, up
->sg_str
,
794 inet_ntoa(up
->upstream_addr
), up
->ref_count
);
800 struct pim_upstream
*pim_upstream_find(struct pim_instance
*pim
,
801 struct prefix_sg
*sg
)
803 struct pim_upstream lookup
;
804 struct pim_upstream
*up
= NULL
;
807 up
= hash_lookup(pim
->upstream_hash
, &lookup
);
811 struct pim_upstream
*pim_upstream_find_or_add(struct prefix_sg
*sg
,
812 struct interface
*incoming
,
813 int flags
, const char *name
)
815 struct pim_upstream
*up
;
816 struct pim_interface
*pim_ifp
;
818 pim_ifp
= incoming
->info
;
820 up
= pim_upstream_find(pim_ifp
->pim
, sg
);
823 if (!(up
->flags
& flags
)) {
828 "%s(%s): upstream %s ref count %d increment",
829 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
833 up
= pim_upstream_add(pim_ifp
->pim
, sg
, incoming
, flags
, name
,
839 void pim_upstream_ref(struct pim_upstream
*up
, int flags
, const char *name
)
844 zlog_debug("%s(%s): upstream %s ref count %d increment",
845 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
849 struct pim_upstream
*pim_upstream_add(struct pim_instance
*pim
,
850 struct prefix_sg
*sg
,
851 struct interface
*incoming
, int flags
,
853 struct pim_ifchannel
*ch
)
855 struct pim_upstream
*up
= NULL
;
858 up
= pim_upstream_find(pim
, sg
);
860 pim_upstream_ref(up
, flags
, name
);
863 up
= pim_upstream_new(pim
, sg
, incoming
, flags
, ch
);
866 if (PIM_DEBUG_TRACE
) {
868 char buf
[PREFIX2STR_BUFFER
];
869 prefix2str(&up
->rpf
.rpf_addr
, buf
, sizeof(buf
));
870 zlog_debug("%s(%s): %s, iif %s (%s) found: %d: ref_count: %d",
871 __PRETTY_FUNCTION__
, name
,
872 up
->sg_str
, buf
, up
->rpf
.source_nexthop
.interface
?
873 up
->rpf
.source_nexthop
.interface
->name
: "Unknown" ,
874 found
, up
->ref_count
);
876 zlog_debug("%s(%s): (%s) failure to create",
877 __PRETTY_FUNCTION__
, name
,
878 pim_str_sg_dump(sg
));
885 * Passed in up must be the upstream for ch. starch is NULL if no
888 int pim_upstream_evaluate_join_desired_interface(struct pim_upstream
*up
,
889 struct pim_ifchannel
*ch
,
890 struct pim_ifchannel
*starch
)
893 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
896 if (!pim_macro_ch_lost_assert(ch
)
897 && pim_macro_chisin_joins_or_include(ch
))
905 if (PIM_IF_FLAG_TEST_S_G_RPT(starch
->upstream
->flags
))
908 if (!pim_macro_ch_lost_assert(starch
)
909 && pim_macro_chisin_joins_or_include(starch
))
917 Evaluate JoinDesired(S,G):
919 JoinDesired(S,G) is true if there is a downstream (S,G) interface I
922 inherited_olist(S,G) =
923 joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
925 JoinDesired(S,G) may be affected by changes in the following:
927 pim_ifp->primary_address
929 ch->ifassert_winner_metric
931 ch->local_ifmembership
933 ch->upstream->rpf.source_nexthop.mrib_metric_preference
934 ch->upstream->rpf.source_nexthop.mrib_route_metric
935 ch->upstream->rpf.source_nexthop.interface
937 See also pim_upstream_update_join_desired() below.
939 int pim_upstream_evaluate_join_desired(struct pim_instance
*pim
,
940 struct pim_upstream
*up
)
942 struct interface
*ifp
;
943 struct pim_ifchannel
*ch
, *starch
;
944 struct pim_upstream
*starup
= up
->parent
;
947 FOR_ALL_INTERFACES (pim
->vrf
, ifp
) {
951 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
954 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
961 ret
+= pim_upstream_evaluate_join_desired_interface(up
, ch
,
963 } /* scan iface channel list */
965 return ret
; /* false */
969 See also pim_upstream_evaluate_join_desired() above.
971 void pim_upstream_update_join_desired(struct pim_instance
*pim
,
972 struct pim_upstream
*up
)
974 int was_join_desired
; /* boolean */
975 int is_join_desired
; /* boolean */
977 was_join_desired
= PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up
->flags
);
979 is_join_desired
= pim_upstream_evaluate_join_desired(pim
, up
);
981 PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(up
->flags
);
983 PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(up
->flags
);
985 /* switched from false to true */
986 if (is_join_desired
&& (up
->join_state
== PIM_UPSTREAM_NOTJOINED
)) {
987 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_JOINED
);
991 /* switched from true to false */
992 if (!is_join_desired
&& was_join_desired
) {
993 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_NOTJOINED
);
999 RFC 4601 4.5.7. Sending (S,G) Join/Prune Messages
1000 Transitions from Joined State
1001 RPF'(S,G) GenID changes
1003 The upstream (S,G) state machine remains in Joined state. If the
1004 Join Timer is set to expire in more than t_override seconds, reset
1005 it so that it expires after t_override seconds.
1007 void pim_upstream_rpf_genid_changed(struct pim_instance
*pim
,
1008 struct in_addr neigh_addr
)
1010 struct listnode
*up_node
;
1011 struct listnode
*up_nextnode
;
1012 struct pim_upstream
*up
;
1015 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1017 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
1019 if (PIM_DEBUG_TRACE
) {
1020 char neigh_str
[INET_ADDRSTRLEN
];
1021 char rpf_addr_str
[PREFIX_STRLEN
];
1022 pim_inet4_dump("<neigh?>", neigh_addr
, neigh_str
,
1024 pim_addr_dump("<rpf?>", &up
->rpf
.rpf_addr
, rpf_addr_str
,
1025 sizeof(rpf_addr_str
));
1027 "%s: matching neigh=%s against upstream (S,G)=%s[%s] joined=%d rpf_addr=%s",
1028 __PRETTY_FUNCTION__
, neigh_str
, up
->sg_str
,
1030 up
->join_state
== PIM_UPSTREAM_JOINED
,
1034 /* consider only (S,G) upstream in Joined state */
1035 if (up
->join_state
!= PIM_UPSTREAM_JOINED
)
1038 /* match RPF'(S,G)=neigh_addr */
1039 if (up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
!= neigh_addr
.s_addr
)
1042 pim_upstream_join_timer_decrease_to_t_override(
1043 "RPF'(S,G) GenID change", up
);
1048 void pim_upstream_rpf_interface_changed(struct pim_upstream
*up
,
1049 struct interface
*old_rpf_ifp
)
1051 struct listnode
*chnode
;
1052 struct listnode
*chnextnode
;
1053 struct pim_ifchannel
*ch
;
1055 /* search all ifchannels */
1056 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1057 if (ch
->ifassert_state
== PIM_IFASSERT_I_AM_LOSER
) {
1059 /* RPF_interface(S) was NOT I */
1060 (old_rpf_ifp
== ch
->interface
) &&
1061 /* RPF_interface(S) stopped being I */
1062 (ch
->upstream
->rpf
.source_nexthop
1064 (ch
->upstream
->rpf
.source_nexthop
1065 .interface
!= ch
->interface
)) {
1066 assert_action_a5(ch
);
1068 } /* PIM_IFASSERT_I_AM_LOSER */
1070 pim_ifchannel_update_assert_tracking_desired(ch
);
1074 void pim_upstream_update_could_assert(struct pim_upstream
*up
)
1076 struct listnode
*chnode
;
1077 struct listnode
*chnextnode
;
1078 struct pim_ifchannel
*ch
;
1080 /* scan per-interface (S,G) state */
1081 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1082 pim_ifchannel_update_could_assert(ch
);
1083 } /* scan iface channel list */
1086 void pim_upstream_update_my_assert_metric(struct pim_upstream
*up
)
1088 struct listnode
*chnode
;
1089 struct listnode
*chnextnode
;
1090 struct pim_ifchannel
*ch
;
1092 /* scan per-interface (S,G) state */
1093 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1094 pim_ifchannel_update_my_assert_metric(ch
);
1096 } /* scan iface channel list */
1099 static void pim_upstream_update_assert_tracking_desired(struct pim_upstream
*up
)
1101 struct listnode
*chnode
;
1102 struct listnode
*chnextnode
;
1103 struct pim_interface
*pim_ifp
;
1104 struct pim_ifchannel
*ch
;
1106 /* scan per-interface (S,G) state */
1107 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1110 pim_ifp
= ch
->interface
->info
;
1114 pim_ifchannel_update_assert_tracking_desired(ch
);
1116 } /* scan iface channel list */
1119 /* When kat is stopped CouldRegister goes to false so we need to
1120 * transition the (S, G) on FHR to NI state and remove reg tunnel
1122 static void pim_upstream_fhr_kat_expiry(struct pim_instance
*pim
,
1123 struct pim_upstream
*up
)
1125 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
))
1128 if (PIM_DEBUG_TRACE
)
1129 zlog_debug("kat expired on %s; clear fhr reg state",
1132 /* stop reg-stop timer */
1133 THREAD_OFF(up
->t_rs_timer
);
1134 /* remove regiface from the OIL if it is there*/
1135 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1136 PIM_OIF_FLAG_PROTO_PIM
);
1137 /* clear the register state */
1138 up
->reg_state
= PIM_REG_NOINFO
;
1139 PIM_UPSTREAM_FLAG_UNSET_FHR(up
->flags
);
1142 /* When kat is started CouldRegister can go to true. And if it does we
1143 * need to transition the (S, G) on FHR to JOINED state and add reg tunnel
1145 static void pim_upstream_fhr_kat_start(struct pim_upstream
*up
)
1147 if (pim_upstream_could_register(up
)) {
1148 if (PIM_DEBUG_TRACE
)
1150 "kat started on %s; set fhr reg state to joined",
1153 PIM_UPSTREAM_FLAG_SET_FHR(up
->flags
);
1154 if (up
->reg_state
== PIM_REG_NOINFO
)
1155 pim_register_join(up
);
1160 * On an RP, the PMBR value must be cleared when the
1161 * Keepalive Timer expires
1162 * KAT expiry indicates that flow is inactive. If the flow was created or
1163 * maintained by activity now is the time to deref it.
1165 struct pim_upstream
*pim_upstream_keep_alive_timer_proc(
1166 struct pim_upstream
*up
)
1168 struct pim_instance
*pim
;
1170 pim
= up
->channel_oil
->pim
;
1172 if (PIM_UPSTREAM_FLAG_TEST_DISABLE_KAT_EXPIRY(up
->flags
)) {
1173 /* if the router is a PIM vxlan encapsulator we prevent expiry
1174 * of KAT as the mroute is pre-setup without any traffic
1176 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1180 if (I_am_RP(pim
, up
->sg
.grp
)) {
1181 pim_br_clear_pmbr(&up
->sg
);
1183 * We need to do more here :)
1184 * But this is the start.
1188 /* source is no longer active - pull the SA from MSDP's cache */
1189 pim_msdp_sa_local_del(pim
, &up
->sg
);
1191 /* if entry was created because of activity we need to deref it */
1192 if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1193 pim_upstream_fhr_kat_expiry(pim
, up
);
1194 if (PIM_DEBUG_TRACE
)
1196 "kat expired on %s[%s]; remove stream reference",
1197 up
->sg_str
, pim
->vrf
->name
);
1198 PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(up
->flags
);
1200 /* Return if upstream entry got deleted.*/
1201 if (!pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
))
1204 /* upstream reference would have been added to track the local
1205 * membership if it is LHR. We have to clear it when KAT expires.
1206 * Otherwise would result in stale entry with uncleared ref count.
1208 if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
)) {
1209 struct pim_upstream
*parent
= up
->parent
;
1211 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(up
->flags
);
1212 up
= pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
);
1215 pim_jp_agg_single_upstream_send(&parent
->rpf
, parent
,
1222 static int pim_upstream_keep_alive_timer(struct thread
*t
)
1224 struct pim_upstream
*up
;
1228 pim_upstream_keep_alive_timer_proc(up
);
1232 void pim_upstream_keep_alive_timer_start(struct pim_upstream
*up
, uint32_t time
)
1234 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1235 if (PIM_DEBUG_TRACE
)
1236 zlog_debug("kat start on %s with no stream reference",
1239 THREAD_OFF(up
->t_ka_timer
);
1240 thread_add_timer(router
->master
, pim_upstream_keep_alive_timer
, up
,
1241 time
, &up
->t_ka_timer
);
1243 /* any time keepalive is started against a SG we will have to
1244 * re-evaluate our active source database */
1245 pim_msdp_sa_local_update(up
);
1248 /* MSDP on RP needs to know if a source is registerable to this RP */
1249 static int pim_upstream_msdp_reg_timer(struct thread
*t
)
1251 struct pim_upstream
*up
= THREAD_ARG(t
);
1252 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1254 /* source is no longer active - pull the SA from MSDP's cache */
1255 pim_msdp_sa_local_del(pim
, &up
->sg
);
1258 void pim_upstream_msdp_reg_timer_start(struct pim_upstream
*up
)
1260 THREAD_OFF(up
->t_msdp_reg_timer
);
1261 thread_add_timer(router
->master
, pim_upstream_msdp_reg_timer
, up
,
1262 PIM_MSDP_REG_RXED_PERIOD
, &up
->t_msdp_reg_timer
);
1264 pim_msdp_sa_local_update(up
);
1268 * 4.2.1 Last-Hop Switchover to the SPT
1270 * In Sparse-Mode PIM, last-hop routers join the shared tree towards the
1271 * RP. Once traffic from sources to joined groups arrives at a last-hop
1272 * router, it has the option of switching to receive the traffic on a
1273 * shortest path tree (SPT).
1275 * The decision for a router to switch to the SPT is controlled as
1279 * CheckSwitchToSpt(S,G) {
1280 * if ( ( pim_include(*,G) (-) pim_exclude(S,G)
1281 * (+) pim_include(S,G) != NULL )
1282 * AND SwitchToSptDesired(S,G) ) {
1283 * # Note: Restarting the KAT will result in the SPT switch
1284 * set KeepaliveTimer(S,G) to Keepalive_Period
1288 * SwitchToSptDesired(S,G) is a policy function that is implementation
1289 * defined. An "infinite threshold" policy can be implemented by making
1290 * SwitchToSptDesired(S,G) return false all the time. A "switch on
1291 * first packet" policy can be implemented by making
1292 * SwitchToSptDesired(S,G) return true once a single packet has been
1293 * received for the source and group.
1295 int pim_upstream_switch_to_spt_desired(struct pim_instance
*pim
,
1296 struct prefix_sg
*sg
)
1298 if (I_am_RP(pim
, sg
->grp
))
1304 int pim_upstream_is_sg_rpt(struct pim_upstream
*up
)
1306 struct listnode
*chnode
;
1307 struct pim_ifchannel
*ch
;
1309 for (ALL_LIST_ELEMENTS_RO(up
->ifchannels
, chnode
, ch
)) {
1310 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
1317 * After receiving a packet set SPTbit:
1319 * Update_SPTbit(S,G,iif) {
1320 * if ( iif == RPF_interface(S)
1321 * AND JoinDesired(S,G) == TRUE
1322 * AND ( DirectlyConnected(S) == TRUE
1323 * OR RPF_interface(S) != RPF_interface(RP(G))
1324 * OR inherited_olist(S,G,rpt) == NULL
1325 * OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1326 * ( RPF'(S,G) != NULL ) )
1327 * OR ( I_Am_Assert_Loser(S,G,iif) ) {
1328 * Set SPTbit(S,G) to TRUE
1332 void pim_upstream_set_sptbit(struct pim_upstream
*up
,
1333 struct interface
*incoming
)
1335 struct pim_upstream
*starup
= up
->parent
;
1337 // iif == RPF_interfvace(S)
1338 if (up
->rpf
.source_nexthop
.interface
!= incoming
) {
1339 if (PIM_DEBUG_TRACE
)
1341 "%s: Incoming Interface: %s is different than RPF_interface(S) %s",
1342 __PRETTY_FUNCTION__
, incoming
->name
,
1343 up
->rpf
.source_nexthop
.interface
->name
);
1347 // AND JoinDesired(S,G) == TRUE
1348 if (!pim_upstream_evaluate_join_desired(up
->channel_oil
->pim
, up
)) {
1349 if (PIM_DEBUG_TRACE
)
1350 zlog_debug("%s: %s Join is not Desired",
1351 __PRETTY_FUNCTION__
, up
->sg_str
);
1355 // DirectlyConnected(S) == TRUE
1356 if (pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1358 if (PIM_DEBUG_TRACE
)
1359 zlog_debug("%s: %s is directly connected to the source",
1360 __PRETTY_FUNCTION__
, up
->sg_str
);
1361 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1365 // OR RPF_interface(S) != RPF_interface(RP(G))
1367 || up
->rpf
.source_nexthop
1368 .interface
!= starup
->rpf
.source_nexthop
.interface
) {
1369 struct pim_upstream
*starup
= up
->parent
;
1371 if (PIM_DEBUG_TRACE
)
1373 "%s: %s RPF_interface(S) != RPF_interface(RP(G))",
1374 __PRETTY_FUNCTION__
, up
->sg_str
);
1375 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1377 pim_jp_agg_single_upstream_send(&starup
->rpf
, starup
, true);
1381 // OR inherited_olist(S,G,rpt) == NULL
1382 if (pim_upstream_is_sg_rpt(up
)
1383 && pim_upstream_empty_inherited_olist(up
)) {
1384 if (PIM_DEBUG_TRACE
)
1385 zlog_debug("%s: %s OR inherited_olist(S,G,rpt) == NULL",
1386 __PRETTY_FUNCTION__
, up
->sg_str
);
1387 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1391 // OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1392 // ( RPF'(S,G) != NULL ) )
1393 if (up
->parent
&& pim_rpf_is_same(&up
->rpf
, &up
->parent
->rpf
)) {
1394 if (PIM_DEBUG_TRACE
)
1395 zlog_debug("%s: %s RPF'(S,G) is the same as RPF'(*,G)",
1396 __PRETTY_FUNCTION__
, up
->sg_str
);
1397 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1404 const char *pim_upstream_state2str(enum pim_upstream_state join_state
)
1406 switch (join_state
) {
1407 case PIM_UPSTREAM_NOTJOINED
:
1410 case PIM_UPSTREAM_JOINED
:
1417 const char *pim_reg_state2str(enum pim_reg_state reg_state
, char *state_str
,
1418 size_t state_str_len
)
1420 switch (reg_state
) {
1421 case PIM_REG_NOINFO
:
1422 strlcpy(state_str
, "RegNoInfo", state_str_len
);
1425 strlcpy(state_str
, "RegJoined", state_str_len
);
1427 case PIM_REG_JOIN_PENDING
:
1428 strlcpy(state_str
, "RegJoinPend", state_str_len
);
1431 strlcpy(state_str
, "RegPrune", state_str_len
);
1434 strlcpy(state_str
, "RegUnknown", state_str_len
);
1439 static int pim_upstream_register_stop_timer(struct thread
*t
)
1441 struct pim_interface
*pim_ifp
;
1442 struct pim_instance
*pim
;
1443 struct pim_upstream
*up
;
1445 pim
= up
->channel_oil
->pim
;
1447 if (PIM_DEBUG_TRACE
) {
1448 char state_str
[PIM_REG_STATE_STR_LEN
];
1449 zlog_debug("%s: (S,G)=%s[%s] upstream register stop timer %s",
1450 __PRETTY_FUNCTION__
, up
->sg_str
, pim
->vrf
->name
,
1451 pim_reg_state2str(up
->reg_state
, state_str
, sizeof(state_str
)));
1454 switch (up
->reg_state
) {
1455 case PIM_REG_JOIN_PENDING
:
1456 up
->reg_state
= PIM_REG_JOIN
;
1457 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1458 PIM_OIF_FLAG_PROTO_PIM
);
1459 pim_vxlan_update_sg_reg_state(pim
, up
, TRUE
/*reg_join*/);
1464 if (!up
->rpf
.source_nexthop
.interface
) {
1465 if (PIM_DEBUG_TRACE
)
1466 zlog_debug("%s: up %s RPF is not present",
1467 __PRETTY_FUNCTION__
, up
->sg_str
);
1471 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
1473 if (PIM_DEBUG_TRACE
)
1475 "%s: Interface: %s is not configured for pim",
1476 __PRETTY_FUNCTION__
,
1477 up
->rpf
.source_nexthop
.interface
->name
);
1480 up
->reg_state
= PIM_REG_JOIN_PENDING
;
1481 pim_upstream_start_register_stop_timer(up
, 1);
1483 if (((up
->channel_oil
->cc
.lastused
/ 100)
1484 > pim
->keep_alive_time
)
1485 && (I_am_RP(pim_ifp
->pim
, up
->sg
.grp
))) {
1486 if (PIM_DEBUG_TRACE
)
1488 "%s: Stop sending the register, because I am the RP and we haven't seen a packet in a while",
1489 __PRETTY_FUNCTION__
);
1492 pim_null_register_send(up
);
1501 void pim_upstream_start_register_stop_timer(struct pim_upstream
*up
,
1506 THREAD_TIMER_OFF(up
->t_rs_timer
);
1508 if (!null_register
) {
1509 uint32_t lower
= (0.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1510 uint32_t upper
= (1.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1511 time
= lower
+ (random() % (upper
- lower
+ 1))
1512 - PIM_REGISTER_PROBE_PERIOD
;
1514 time
= PIM_REGISTER_PROBE_PERIOD
;
1516 if (PIM_DEBUG_TRACE
) {
1518 "%s: (S,G)=%s Starting upstream register stop timer %d",
1519 __PRETTY_FUNCTION__
, up
->sg_str
, time
);
1521 thread_add_timer(router
->master
, pim_upstream_register_stop_timer
, up
,
1522 time
, &up
->t_rs_timer
);
1525 int pim_upstream_inherited_olist_decide(struct pim_instance
*pim
,
1526 struct pim_upstream
*up
)
1528 struct interface
*ifp
;
1529 struct pim_interface
*pim_ifp
= NULL
;
1530 struct pim_ifchannel
*ch
, *starch
;
1531 struct pim_upstream
*starup
= up
->parent
;
1532 int output_intf
= 0;
1534 if (up
->rpf
.source_nexthop
.interface
)
1535 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
1537 if (PIM_DEBUG_TRACE
)
1538 zlog_debug("%s: up %s RPF is not present",
1539 __PRETTY_FUNCTION__
, up
->sg_str
);
1541 if (pim_ifp
&& !up
->channel_oil
)
1542 up
->channel_oil
= pim_channel_oil_add(pim
, &up
->sg
,
1543 pim_ifp
->mroute_vif_index
,
1544 __PRETTY_FUNCTION__
);
1546 FOR_ALL_INTERFACES (pim
->vrf
, ifp
) {
1550 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
1553 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
1560 if (pim_upstream_evaluate_join_desired_interface(up
, ch
,
1562 int flag
= PIM_OIF_FLAG_PROTO_PIM
;
1565 flag
= PIM_OIF_FLAG_PROTO_STAR
;
1567 pim_channel_add_oif(up
->channel_oil
, ifp
, flag
);
1576 * For a given upstream, determine the inherited_olist
1579 * inherited_olist(S,G,rpt) =
1580 * ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
1581 * (+) ( pim_include(*,G) (-) pim_exclude(S,G))
1582 * (-) ( lost_assert(*,G) (+) lost_assert(S,G,rpt) )
1584 * inherited_olist(S,G) =
1585 * inherited_olist(S,G,rpt) (+)
1586 * joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
1588 * return 1 if there are any output interfaces
1589 * return 0 if there are not any output interfaces
1591 int pim_upstream_inherited_olist(struct pim_instance
*pim
,
1592 struct pim_upstream
*up
)
1594 int output_intf
= pim_upstream_inherited_olist_decide(pim
, up
);
1597 * If we have output_intf switch state to Join and work like normal
1598 * If we don't have an output_intf that means we are probably a
1599 * switch on a stick so turn on forwarding to just accept the
1600 * incoming packets so we don't bother the other stuff!
1603 pim_upstream_switch(pim
, up
, PIM_UPSTREAM_JOINED
);
1610 int pim_upstream_empty_inherited_olist(struct pim_upstream
*up
)
1612 return pim_channel_oil_empty(up
->channel_oil
);
1616 * When we have a new neighbor,
1617 * find upstreams that don't have their rpf_addr
1618 * set and see if the new neighbor allows
1619 * the join to be sent
1621 void pim_upstream_find_new_rpf(struct pim_instance
*pim
)
1623 struct listnode
*up_node
;
1624 struct listnode
*up_nextnode
;
1625 struct pim_upstream
*up
;
1628 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1630 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
1631 if (up
->upstream_addr
.s_addr
== INADDR_ANY
) {
1632 if (PIM_DEBUG_TRACE
)
1634 "%s: RP not configured for Upstream %s",
1635 __PRETTY_FUNCTION__
, up
->sg_str
);
1639 if (pim_rpf_addr_is_inaddr_any(&up
->rpf
)) {
1640 if (PIM_DEBUG_TRACE
)
1642 "%s: Upstream %s without a path to send join, checking",
1643 __PRETTY_FUNCTION__
, up
->sg_str
);
1644 pim_rpf_update(pim
, up
, NULL
);
1649 unsigned int pim_upstream_hash_key(const void *arg
)
1651 const struct pim_upstream
*up
= arg
;
1653 return jhash_2words(up
->sg
.src
.s_addr
, up
->sg
.grp
.s_addr
, 0);
1656 void pim_upstream_terminate(struct pim_instance
*pim
)
1658 struct pim_upstream
*up
;
1660 if (pim
->upstream_list
) {
1661 while (pim
->upstream_list
->count
) {
1662 up
= listnode_head(pim
->upstream_list
);
1663 pim_upstream_del(pim
, up
, __PRETTY_FUNCTION__
);
1666 list_delete(&pim
->upstream_list
);
1669 if (pim
->upstream_hash
)
1670 hash_free(pim
->upstream_hash
);
1671 pim
->upstream_hash
= NULL
;
1673 if (pim
->upstream_sg_wheel
)
1674 wheel_delete(pim
->upstream_sg_wheel
);
1675 pim
->upstream_sg_wheel
= NULL
;
1678 bool pim_upstream_equal(const void *arg1
, const void *arg2
)
1680 const struct pim_upstream
*up1
= (const struct pim_upstream
*)arg1
;
1681 const struct pim_upstream
*up2
= (const struct pim_upstream
*)arg2
;
1683 if ((up1
->sg
.grp
.s_addr
== up2
->sg
.grp
.s_addr
)
1684 && (up1
->sg
.src
.s_addr
== up2
->sg
.src
.s_addr
))
1690 /* rfc4601:section-4.2:"Data Packet Forwarding Rules" defines
1691 * the cases where kat has to be restarted on rxing traffic -
1693 * if( DirectlyConnected(S) == TRUE AND iif == RPF_interface(S) ) {
1694 * set KeepaliveTimer(S,G) to Keepalive_Period
1695 * # Note: a register state transition or UpstreamJPState(S,G)
1696 * # transition may happen as a result of restarting
1697 * # KeepaliveTimer, and must be dealt with here.
1699 * if( iif == RPF_interface(S) AND UpstreamJPState(S,G) == Joined AND
1700 * inherited_olist(S,G) != NULL ) {
1701 * set KeepaliveTimer(S,G) to Keepalive_Period
1704 static bool pim_upstream_kat_start_ok(struct pim_upstream
*up
)
1706 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1708 /* "iif == RPF_interface(S)" check has to be done by the kernel or hw
1709 * so we will skip that here */
1710 if (up
->rpf
.source_nexthop
.interface
&&
1711 pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1716 if ((up
->join_state
== PIM_UPSTREAM_JOINED
)
1717 && !pim_upstream_empty_inherited_olist(up
)) {
1718 /* XXX: I have added this RP check just for 3.2 and it's a
1720 * what rfc-4601 says. Till now we were only running KAT on FHR
1722 * there is some angst around making the change to run it all
1724 * maintain the (S, G) state. This is tracked via CM-13601 and
1726 * removed to handle spt turn-arounds correctly in a 3-tier clos
1728 if (I_am_RP(pim
, up
->sg
.grp
))
1736 * Code to check and see if we've received packets on a S,G mroute
1737 * and if so to set the SPT bit appropriately
1739 static void pim_upstream_sg_running(void *arg
)
1741 struct pim_upstream
*up
= (struct pim_upstream
*)arg
;
1742 struct pim_instance
*pim
= up
->channel_oil
->pim
;
1744 // No packet can have arrived here if this is the case
1745 if (!up
->channel_oil
->installed
) {
1746 if (PIM_DEBUG_TRACE
)
1747 zlog_debug("%s: %s%s is not installed in mroute",
1748 __PRETTY_FUNCTION__
, up
->sg_str
,
1754 * This is a bit of a hack
1755 * We've noted that we should rescan but
1756 * we've missed the window for doing so in
1757 * pim_zebra.c for some reason. I am
1758 * only doing this at this point in time
1759 * to get us up and working for the moment
1761 if (up
->channel_oil
->oil_inherited_rescan
) {
1762 if (PIM_DEBUG_TRACE
)
1764 "%s: Handling unscanned inherited_olist for %s[%s]",
1765 __PRETTY_FUNCTION__
, up
->sg_str
,
1767 pim_upstream_inherited_olist_decide(pim
, up
);
1768 up
->channel_oil
->oil_inherited_rescan
= 0;
1770 pim_mroute_update_counters(up
->channel_oil
);
1772 // Have we seen packets?
1773 if ((up
->channel_oil
->cc
.oldpktcnt
>= up
->channel_oil
->cc
.pktcnt
)
1774 && (up
->channel_oil
->cc
.lastused
/ 100 > 30)) {
1775 if (PIM_DEBUG_TRACE
) {
1777 "%s[%s]: %s old packet count is equal or lastused is greater than 30, (%ld,%ld,%lld)",
1778 __PRETTY_FUNCTION__
, up
->sg_str
, pim
->vrf
->name
,
1779 up
->channel_oil
->cc
.oldpktcnt
,
1780 up
->channel_oil
->cc
.pktcnt
,
1781 up
->channel_oil
->cc
.lastused
/ 100);
1786 if (pim_upstream_kat_start_ok(up
)) {
1787 /* Add a source reference to the stream if
1788 * one doesn't already exist */
1789 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1790 if (PIM_DEBUG_TRACE
)
1792 "source reference created on kat restart %s[%s]",
1793 up
->sg_str
, pim
->vrf
->name
);
1795 pim_upstream_ref(up
, PIM_UPSTREAM_FLAG_MASK_SRC_STREAM
,
1796 __PRETTY_FUNCTION__
);
1797 PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up
->flags
);
1798 pim_upstream_fhr_kat_start(up
);
1800 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1801 } else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
))
1802 pim_upstream_keep_alive_timer_start(up
, pim
->keep_alive_time
);
1804 if ((up
->sptbit
!= PIM_UPSTREAM_SPTBIT_TRUE
) &&
1805 (up
->rpf
.source_nexthop
.interface
)) {
1806 pim_upstream_set_sptbit(up
, up
->rpf
.source_nexthop
.interface
);
1811 void pim_upstream_add_lhr_star_pimreg(struct pim_instance
*pim
)
1813 struct pim_upstream
*up
;
1814 struct listnode
*node
;
1816 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1817 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1820 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1823 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1824 PIM_OIF_FLAG_PROTO_IGMP
);
1828 void pim_upstream_spt_prefix_list_update(struct pim_instance
*pim
,
1829 struct prefix_list
*pl
)
1831 const char *pname
= prefix_list_name(pl
);
1833 if (pim
->spt
.plist
&& strcmp(pim
->spt
.plist
, pname
) == 0) {
1834 pim_upstream_remove_lhr_star_pimreg(pim
, pname
);
1839 * nlist -> The new prefix list
1841 * Per Group Application of pimreg to the OIL
1842 * If the prefix list tells us DENY then
1843 * we need to Switchover to SPT immediate
1844 * so add the pimreg.
1845 * If the prefix list tells us to ACCEPT than
1846 * we need to Never do the SPT so remove
1850 void pim_upstream_remove_lhr_star_pimreg(struct pim_instance
*pim
,
1853 struct pim_upstream
*up
;
1854 struct listnode
*node
;
1855 struct prefix_list
*np
;
1857 enum prefix_list_type apply_new
;
1859 np
= prefix_list_lookup(AFI_IP
, nlist
);
1862 g
.prefixlen
= IPV4_MAX_PREFIXLEN
;
1864 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1865 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1868 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1872 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1873 PIM_OIF_FLAG_PROTO_IGMP
);
1876 g
.u
.prefix4
= up
->sg
.grp
;
1877 apply_new
= prefix_list_apply(np
, &g
);
1878 if (apply_new
== PREFIX_DENY
)
1879 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1880 PIM_OIF_FLAG_PROTO_IGMP
);
1882 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1883 PIM_OIF_FLAG_PROTO_IGMP
);
1887 void pim_upstream_init(struct pim_instance
*pim
)
1891 snprintf(name
, 64, "PIM %s Timer Wheel",
1893 pim
->upstream_sg_wheel
=
1894 wheel_init(router
->master
, 31000, 100, pim_upstream_hash_key
,
1895 pim_upstream_sg_running
, name
);
1897 snprintf(name
, 64, "PIM %s Upstream Hash",
1899 pim
->upstream_hash
= hash_create_size(8192, pim_upstream_hash_key
,
1900 pim_upstream_equal
, name
);
1902 pim
->upstream_list
= list_new();
1903 pim
->upstream_list
->cmp
= pim_upstream_compare
;