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
22 #include "zebra/rib.h"
39 #include "pim_iface.h"
41 #include "pim_zlookup.h"
42 #include "pim_upstream.h"
43 #include "pim_ifchannel.h"
44 #include "pim_neighbor.h"
46 #include "pim_zebra.h"
48 #include "pim_macro.h"
51 #include "pim_register.h"
53 #include "pim_jp_agg.h"
57 static void join_timer_stop(struct pim_upstream
*up
);
59 pim_upstream_update_assert_tracking_desired(struct pim_upstream
*up
);
62 * A (*,G) or a (*,*) is going away
63 * remove the parent pointer from
64 * those pointing at us
66 static void pim_upstream_remove_children(struct pim_instance
*pim
,
67 struct pim_upstream
*up
)
69 struct pim_upstream
*child
;
74 while (!list_isempty(up
->sources
)) {
75 child
= listnode_head(up
->sources
);
76 listnode_delete(up
->sources
, child
);
77 if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(child
->flags
)) {
78 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(child
->flags
);
79 child
= pim_upstream_del(pim
, child
,
85 list_delete(up
->sources
);
90 * A (*,G) or a (*,*) is being created
91 * Find the children that would point
94 static void pim_upstream_find_new_children(struct pim_instance
*pim
,
95 struct pim_upstream
*up
)
97 struct pim_upstream
*child
;
98 struct listnode
*ch_node
;
100 if ((up
->sg
.src
.s_addr
!= INADDR_ANY
)
101 && (up
->sg
.grp
.s_addr
!= INADDR_ANY
))
104 if ((up
->sg
.src
.s_addr
== INADDR_ANY
)
105 && (up
->sg
.grp
.s_addr
== INADDR_ANY
))
108 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, ch_node
, child
)) {
109 if ((up
->sg
.grp
.s_addr
!= INADDR_ANY
)
110 && (child
->sg
.grp
.s_addr
== up
->sg
.grp
.s_addr
)
113 listnode_add_sort(up
->sources
, child
);
119 * If we have a (*,*) || (S,*) there is no parent
120 * If we have a (S,G), find the (*,G)
121 * If we have a (*,G), find the (*,*)
123 static struct pim_upstream
*pim_upstream_find_parent(struct pim_instance
*pim
,
124 struct pim_upstream
*child
)
126 struct prefix_sg any
= child
->sg
;
127 struct pim_upstream
*up
= NULL
;
130 if ((child
->sg
.src
.s_addr
!= INADDR_ANY
)
131 && (child
->sg
.grp
.s_addr
!= INADDR_ANY
)) {
132 any
.src
.s_addr
= INADDR_ANY
;
133 up
= pim_upstream_find(pim
, &any
);
136 listnode_add(up
->sources
, child
);
144 void pim_upstream_free(struct pim_upstream
*up
)
146 XFREE(MTYPE_PIM_UPSTREAM
, up
);
150 static void upstream_channel_oil_detach(struct pim_upstream
*up
)
152 if (up
->channel_oil
) {
153 /* Detaching from channel_oil, channel_oil may exist post del,
154 but upstream would not keep reference of it
156 pim_channel_oil_del(up
->channel_oil
);
157 up
->channel_oil
= NULL
;
161 struct pim_upstream
*pim_upstream_del(struct pim_instance
*pim
,
162 struct pim_upstream
*up
, const char *name
)
164 bool notify_msdp
= false;
169 "%s(%s): Delete %s ref count: %d , flags: %d c_oil ref count %d (Pre decrement)",
170 __PRETTY_FUNCTION__
, name
, up
->sg_str
, up
->ref_count
,
171 up
->flags
, up
->channel_oil
->oil_ref_count
);
175 if (up
->ref_count
>= 1)
178 THREAD_OFF(up
->t_ka_timer
);
179 THREAD_OFF(up
->t_rs_timer
);
180 THREAD_OFF(up
->t_msdp_reg_timer
);
182 if (up
->join_state
== PIM_UPSTREAM_JOINED
) {
183 pim_jp_agg_single_upstream_send(&up
->rpf
, up
, 0);
185 if (up
->sg
.src
.s_addr
== INADDR_ANY
) {
186 /* if a (*, G) entry in the joined state is being
188 * need to notify MSDP */
194 pim_jp_agg_upstream_verification(up
, false);
195 up
->rpf
.source_nexthop
.interface
= NULL
;
197 if (up
->sg
.src
.s_addr
!= INADDR_ANY
) {
198 wheel_remove_item(pim
->upstream_sg_wheel
, up
);
202 pim_upstream_remove_children(pim
, up
);
204 list_delete(up
->sources
);
206 pim_mroute_del(up
->channel_oil
, __PRETTY_FUNCTION__
);
207 upstream_channel_oil_detach(up
);
209 list_delete(up
->ifchannels
);
210 up
->ifchannels
= NULL
;
213 notice that listnode_delete() can't be moved
214 into pim_upstream_free() because the later is
215 called by list_delete_all_node()
217 if (up
->parent
&& up
->parent
->sources
)
218 listnode_delete(up
->parent
->sources
, up
);
221 listnode_delete(pim
->upstream_list
, up
);
222 hash_release(pim
->upstream_hash
, up
);
225 pim_msdp_up_del(&up
->sg
);
228 /* Deregister addr with Zebra NHT */
229 nht_p
.family
= AF_INET
;
230 nht_p
.prefixlen
= IPV4_MAX_BITLEN
;
231 nht_p
.u
.prefix4
= up
->upstream_addr
;
232 if (PIM_DEBUG_TRACE
) {
233 char buf
[PREFIX2STR_BUFFER
];
234 prefix2str(&nht_p
, buf
, sizeof(buf
));
235 zlog_debug("%s: Deregister upstream %s addr %s with Zebra NHT",
236 __PRETTY_FUNCTION__
, up
->sg_str
, buf
);
238 pim_delete_tracked_nexthop(pim
, &nht_p
, up
, NULL
);
240 pim_upstream_free(up
);
245 void pim_upstream_send_join(struct pim_upstream
*up
)
247 if (PIM_DEBUG_TRACE
) {
248 char rpf_str
[PREFIX_STRLEN
];
249 pim_addr_dump("<rpf?>", &up
->rpf
.rpf_addr
, rpf_str
,
251 zlog_debug("%s: RPF'%s=%s(%s) for Interface %s",
252 __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
,
253 pim_upstream_state2str(up
->join_state
),
254 up
->rpf
.source_nexthop
.interface
->name
);
255 if (pim_rpf_addr_is_inaddr_any(&up
->rpf
)) {
256 zlog_debug("%s: can't send join upstream: RPF'%s=%s",
257 __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
);
262 /* send Join(S,G) to the current upstream neighbor */
263 pim_jp_agg_single_upstream_send(&up
->rpf
, up
, 1 /* join */);
266 static int on_join_timer(struct thread
*t
)
268 struct pim_upstream
*up
;
273 * In the case of a HFR we will not ahve anyone to send this to.
275 if (PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
))
279 * Don't send the join if the outgoing interface is a loopback
280 * But since this might change leave the join timer running
282 if (up
->rpf
.source_nexthop
283 .interface
&& !if_is_loopback(up
->rpf
.source_nexthop
.interface
))
284 pim_upstream_send_join(up
);
286 join_timer_start(up
);
291 static void join_timer_stop(struct pim_upstream
*up
)
293 struct pim_neighbor
*nbr
;
295 THREAD_OFF(up
->t_join_timer
);
297 nbr
= pim_neighbor_find(up
->rpf
.source_nexthop
.interface
,
298 up
->rpf
.rpf_addr
.u
.prefix4
);
301 pim_jp_agg_remove_group(nbr
->upstream_jp_agg
, up
);
303 pim_jp_agg_upstream_verification(up
, false);
306 void join_timer_start(struct pim_upstream
*up
)
308 struct pim_neighbor
*nbr
= NULL
;
310 if (up
->rpf
.source_nexthop
.interface
) {
311 nbr
= pim_neighbor_find(up
->rpf
.source_nexthop
.interface
,
312 up
->rpf
.rpf_addr
.u
.prefix4
);
314 if (PIM_DEBUG_PIM_EVENTS
) {
316 "%s: starting %d sec timer for upstream (S,G)=%s",
317 __PRETTY_FUNCTION__
, qpim_t_periodic
,
323 pim_jp_agg_add_group(nbr
->upstream_jp_agg
, up
, 1);
325 THREAD_OFF(up
->t_join_timer
);
326 thread_add_timer(master
, on_join_timer
, up
, qpim_t_periodic
,
329 pim_jp_agg_upstream_verification(up
, true);
333 * This is only called when we are switching the upstream
334 * J/P from one neighbor to another
336 * As such we need to remove from the old list and
337 * add to the new list.
339 void pim_upstream_join_timer_restart(struct pim_upstream
*up
,
342 // THREAD_OFF(up->t_join_timer);
343 join_timer_start(up
);
346 static void pim_upstream_join_timer_restart_msec(struct pim_upstream
*up
,
349 if (PIM_DEBUG_PIM_EVENTS
) {
350 zlog_debug("%s: restarting %d msec timer for upstream (S,G)=%s",
351 __PRETTY_FUNCTION__
, interval_msec
, up
->sg_str
);
354 THREAD_OFF(up
->t_join_timer
);
355 thread_add_timer_msec(master
, on_join_timer
, up
, interval_msec
,
359 void pim_upstream_join_suppress(struct pim_upstream
*up
,
360 struct in_addr rpf_addr
, int holdtime
)
362 long t_joinsuppress_msec
;
363 long join_timer_remain_msec
;
365 t_joinsuppress_msec
=
366 MIN(pim_if_t_suppressed_msec(up
->rpf
.source_nexthop
.interface
),
369 join_timer_remain_msec
= pim_time_timer_remain_msec(up
->t_join_timer
);
371 if (PIM_DEBUG_TRACE
) {
372 char rpf_str
[INET_ADDRSTRLEN
];
373 pim_inet4_dump("<rpf?>", rpf_addr
, rpf_str
, sizeof(rpf_str
));
375 "%s %s: detected Join%s to RPF'(S,G)=%s: join_timer=%ld msec t_joinsuppress=%ld msec",
376 __FILE__
, __PRETTY_FUNCTION__
, up
->sg_str
, rpf_str
,
377 join_timer_remain_msec
, t_joinsuppress_msec
);
380 if (join_timer_remain_msec
< t_joinsuppress_msec
) {
381 if (PIM_DEBUG_TRACE
) {
383 "%s %s: suppressing Join(S,G)=%s for %ld msec",
384 __FILE__
, __PRETTY_FUNCTION__
, up
->sg_str
,
385 t_joinsuppress_msec
);
388 pim_upstream_join_timer_restart_msec(up
, t_joinsuppress_msec
);
392 void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label
,
393 struct pim_upstream
*up
)
395 long join_timer_remain_msec
;
398 join_timer_remain_msec
= pim_time_timer_remain_msec(up
->t_join_timer
);
400 pim_if_t_override_msec(up
->rpf
.source_nexthop
.interface
);
402 if (PIM_DEBUG_TRACE
) {
403 char rpf_str
[INET_ADDRSTRLEN
];
404 pim_inet4_dump("<rpf?>", up
->rpf
.rpf_addr
.u
.prefix4
, rpf_str
,
407 "%s: to RPF'%s=%s: join_timer=%ld msec t_override=%d msec",
408 debug_label
, up
->sg_str
, rpf_str
,
409 join_timer_remain_msec
, t_override_msec
);
412 if (join_timer_remain_msec
> t_override_msec
) {
413 if (PIM_DEBUG_TRACE
) {
415 "%s: decreasing (S,G)=%s join timer to t_override=%d msec",
416 debug_label
, up
->sg_str
, t_override_msec
);
419 pim_upstream_join_timer_restart_msec(up
, t_override_msec
);
423 static void forward_on(struct pim_upstream
*up
)
425 struct listnode
*chnode
;
426 struct listnode
*chnextnode
;
427 struct pim_ifchannel
*ch
= NULL
;
429 /* scan (S,G) state */
430 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
431 if (pim_macro_chisin_oiflist(ch
))
432 pim_forward_start(ch
);
434 } /* scan iface channel list */
437 static void forward_off(struct pim_upstream
*up
)
439 struct listnode
*chnode
;
440 struct listnode
*chnextnode
;
441 struct pim_ifchannel
*ch
;
443 /* scan per-interface (S,G) state */
444 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
446 pim_forward_stop(ch
);
448 } /* scan iface channel list */
451 static int pim_upstream_could_register(struct pim_upstream
*up
)
453 struct pim_interface
*pim_ifp
= NULL
;
455 if (up
->rpf
.source_nexthop
.interface
)
456 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
459 zlog_debug("%s: up %s RPF is not present",
460 __PRETTY_FUNCTION__
, up
->sg_str
);
463 if (pim_ifp
&& PIM_I_am_DR(pim_ifp
)
464 && pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
471 /* Source registration is supressed for SSM groups. When the SSM range changes
472 * we re-revaluate register setup for existing upstream entries */
473 void pim_upstream_register_reevaluate(struct pim_instance
*pim
)
475 struct listnode
*upnode
;
476 struct pim_upstream
*up
;
478 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, upnode
, up
)) {
479 /* If FHR is set CouldRegister is True. Also check if the flow
480 * is actually active; if it is not kat setup will trigger
482 * registration whenever the flow becomes active. */
483 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
) || !up
->t_ka_timer
)
486 if (pim_is_grp_ssm(up
->sg
.grp
)) {
487 /* clear the register state for SSM groups */
488 if (up
->reg_state
!= PIM_REG_NOINFO
) {
489 if (PIM_DEBUG_PIM_EVENTS
)
491 "Clear register for %s as G is now SSM",
493 /* remove regiface from the OIL if it is there*/
494 pim_channel_del_oif(up
->channel_oil
,
496 PIM_OIF_FLAG_PROTO_PIM
);
497 up
->reg_state
= PIM_REG_NOINFO
;
500 /* register ASM sources with the RP */
501 if (up
->reg_state
== PIM_REG_NOINFO
) {
502 if (PIM_DEBUG_PIM_EVENTS
)
504 "Register %s as G is now ASM",
506 pim_channel_add_oif(up
->channel_oil
,
508 PIM_OIF_FLAG_PROTO_PIM
);
509 up
->reg_state
= PIM_REG_JOIN
;
515 void pim_upstream_switch(struct pim_upstream
*up
,
516 enum pim_upstream_state new_state
)
518 enum pim_upstream_state old_state
= up
->join_state
;
520 if (PIM_DEBUG_PIM_EVENTS
) {
521 zlog_debug("%s: PIM_UPSTREAM_%s: (S,G) old: %s new: %s",
522 __PRETTY_FUNCTION__
, up
->sg_str
,
523 pim_upstream_state2str(up
->join_state
),
524 pim_upstream_state2str(new_state
));
527 up
->join_state
= new_state
;
528 if (old_state
!= new_state
)
529 up
->state_transition
= pim_time_monotonic_sec();
531 pim_upstream_update_assert_tracking_desired(up
);
533 if (new_state
== PIM_UPSTREAM_JOINED
) {
534 if (old_state
!= PIM_UPSTREAM_JOINED
) {
535 int old_fhr
= PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
);
537 pim_msdp_up_join_state_changed(up
);
538 if (pim_upstream_could_register(up
)) {
539 PIM_UPSTREAM_FLAG_SET_FHR(up
->flags
);
541 && PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(
543 pim_upstream_keep_alive_timer_start(
544 up
, qpim_keep_alive_time
);
545 pim_register_join(up
);
548 pim_upstream_send_join(up
);
549 join_timer_start(up
);
557 if (old_state
== PIM_UPSTREAM_JOINED
)
558 pim_msdp_up_join_state_changed(up
);
560 /* IHR, Trigger SGRpt on *,G IIF to prune S,G from RPT towards
562 If I am RP for G then send S,G prune to its IIF. */
563 if (pim_upstream_is_sg_rpt(up
) && up
->parent
564 && !I_am_RP(up
->channel_oil
->pim
, up
->sg
.grp
)) {
565 if (PIM_DEBUG_PIM_TRACE_DETAIL
)
567 "%s: *,G IIF %s S,G IIF %s ",
569 up
->parent
->rpf
.source_nexthop
571 up
->rpf
.source_nexthop
.interface
->name
);
572 pim_jp_agg_single_upstream_send(&up
->parent
->rpf
,
576 pim_jp_agg_single_upstream_send(&up
->rpf
, up
,
582 int pim_upstream_compare(void *arg1
, void *arg2
)
584 const struct pim_upstream
*up1
= (const struct pim_upstream
*)arg1
;
585 const struct pim_upstream
*up2
= (const struct pim_upstream
*)arg2
;
587 if (ntohl(up1
->sg
.grp
.s_addr
) < ntohl(up2
->sg
.grp
.s_addr
))
590 if (ntohl(up1
->sg
.grp
.s_addr
) > ntohl(up2
->sg
.grp
.s_addr
))
593 if (ntohl(up1
->sg
.src
.s_addr
) < ntohl(up2
->sg
.src
.s_addr
))
596 if (ntohl(up1
->sg
.src
.s_addr
) > ntohl(up2
->sg
.src
.s_addr
))
602 static struct pim_upstream
*
603 pim_upstream_new(struct prefix_sg
*sg
, struct interface
*incoming
, int flags
)
605 enum pim_rpf_result rpf_result
;
606 struct pim_interface
*pim_ifp
;
607 struct pim_instance
*pim
;
608 struct pim_upstream
*up
;
610 up
= XCALLOC(MTYPE_PIM_UPSTREAM
, sizeof(*up
));
612 zlog_err("%s: PIM XCALLOC(%zu) failure", __PRETTY_FUNCTION__
,
617 pim_ifp
= incoming
->info
;
620 pim_str_sg_set(sg
, up
->sg_str
);
621 up
= hash_get(pim
->upstream_hash
, up
, hash_alloc_intern
);
622 if (!pim_rp_set_upstream_addr(pim
, &up
->upstream_addr
, sg
->src
,
625 zlog_debug("%s: Received a (*,G) with no RP configured",
626 __PRETTY_FUNCTION__
);
628 hash_release(pim
->upstream_hash
, up
);
629 XFREE(MTYPE_PIM_UPSTREAM
, up
);
633 up
->parent
= pim_upstream_find_parent(pim
, up
);
634 if (up
->sg
.src
.s_addr
== INADDR_ANY
) {
635 up
->sources
= list_new();
636 up
->sources
->cmp
= pim_upstream_compare
;
640 pim_upstream_find_new_children(pim
, up
);
643 up
->t_join_timer
= NULL
;
644 up
->t_ka_timer
= NULL
;
645 up
->t_rs_timer
= NULL
;
646 up
->t_msdp_reg_timer
= NULL
;
647 up
->join_state
= PIM_UPSTREAM_NOTJOINED
;
648 up
->reg_state
= PIM_REG_NOINFO
;
649 up
->state_transition
= pim_time_monotonic_sec();
650 up
->channel_oil
= NULL
;
651 up
->sptbit
= PIM_UPSTREAM_SPTBIT_FALSE
;
653 up
->rpf
.source_nexthop
.interface
= NULL
;
654 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.family
= AF_INET
;
655 up
->rpf
.source_nexthop
.mrib_nexthop_addr
.u
.prefix4
.s_addr
=
657 up
->rpf
.source_nexthop
.mrib_metric_preference
=
658 qpim_infinite_assert_metric
.metric_preference
;
659 up
->rpf
.source_nexthop
.mrib_route_metric
=
660 qpim_infinite_assert_metric
.route_metric
;
661 up
->rpf
.rpf_addr
.family
= AF_INET
;
662 up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
= PIM_NET_INADDR_ANY
;
664 up
->ifchannels
= list_new();
665 up
->ifchannels
->cmp
= (int (*)(void *, void *))pim_ifchannel_compare
;
667 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
668 wheel_add_item(pim
->upstream_sg_wheel
, up
);
670 rpf_result
= pim_rpf_update(up
, NULL
, 1);
671 if (rpf_result
== PIM_RPF_FAILURE
) {
676 "%s: Attempting to create upstream(%s), Unable to RPF for source",
677 __PRETTY_FUNCTION__
, up
->sg_str
);
679 nht_p
.family
= AF_INET
;
680 nht_p
.prefixlen
= IPV4_MAX_BITLEN
;
681 nht_p
.u
.prefix4
= up
->upstream_addr
;
682 pim_delete_tracked_nexthop(pim_ifp
->pim
, &nht_p
, up
, NULL
);
685 listnode_delete(up
->parent
->sources
, up
);
689 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
690 wheel_remove_item(pim
->upstream_sg_wheel
, up
);
692 pim_upstream_remove_children(pim
, up
);
694 list_delete(up
->sources
);
696 hash_release(pim
->upstream_hash
, up
);
697 XFREE(MTYPE_PIM_UPSTREAM
, up
);
701 if (up
->rpf
.source_nexthop
.interface
) {
702 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
704 up
->channel_oil
= pim_channel_oil_add(
705 pim
, &up
->sg
, pim_ifp
->mroute_vif_index
);
707 listnode_add_sort(pim
->upstream_list
, up
);
709 if (PIM_DEBUG_TRACE
) {
711 "%s: Created Upstream %s upstream_addr %s ref count %d increment",
712 __PRETTY_FUNCTION__
, up
->sg_str
,
713 inet_ntoa(up
->upstream_addr
), up
->ref_count
);
719 struct pim_upstream
*pim_upstream_find(struct pim_instance
*pim
,
720 struct prefix_sg
*sg
)
722 struct pim_upstream lookup
;
723 struct pim_upstream
*up
= NULL
;
726 up
= hash_lookup(pim
->upstream_hash
, &lookup
);
730 struct pim_upstream
*pim_upstream_find_or_add(struct prefix_sg
*sg
,
731 struct interface
*incoming
,
732 int flags
, const char *name
)
734 struct pim_upstream
*up
;
735 struct pim_interface
*pim_ifp
;
737 pim_ifp
= incoming
->info
;
739 up
= pim_upstream_find(pim_ifp
->pim
, sg
);
742 if (!(up
->flags
& flags
)) {
747 "%s(%s): upstream %s ref count %d increment",
748 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
752 up
= pim_upstream_add(sg
, incoming
, flags
, name
);
757 void pim_upstream_ref(struct pim_upstream
*up
, int flags
, const char *name
)
762 zlog_debug("%s(%s): upstream %s ref count %d increment",
763 __PRETTY_FUNCTION__
, name
, up
->sg_str
,
767 struct pim_upstream
*pim_upstream_add(struct prefix_sg
*sg
,
768 struct interface
*incoming
, int flags
,
771 struct pim_upstream
*up
= NULL
;
772 struct pim_interface
*pim_ifp
;
775 pim_ifp
= incoming
->info
;
776 up
= pim_upstream_find(pim_ifp
->pim
, sg
);
778 pim_upstream_ref(up
, flags
, name
);
781 up
= pim_upstream_new(sg
, incoming
, flags
);
784 if (PIM_DEBUG_TRACE
) {
786 char buf
[PREFIX2STR_BUFFER
];
787 prefix2str(&up
->rpf
.rpf_addr
, buf
, sizeof(buf
));
788 zlog_debug("%s(%s): %s, iif %s (%s) found: %d: ref_count: %d",
789 __PRETTY_FUNCTION__
, name
,
790 up
->sg_str
, buf
, up
->rpf
.source_nexthop
.interface
?
791 up
->rpf
.source_nexthop
.interface
->name
: "NIL" ,
792 found
, up
->ref_count
);
794 zlog_debug("%s(%s): (%s) failure to create",
795 __PRETTY_FUNCTION__
, name
,
796 pim_str_sg_dump(sg
));
803 * Passed in up must be the upstream for ch. starch is NULL if no
806 int pim_upstream_evaluate_join_desired_interface(struct pim_upstream
*up
,
807 struct pim_ifchannel
*ch
,
808 struct pim_ifchannel
*starch
)
811 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
814 if (!pim_macro_ch_lost_assert(ch
)
815 && pim_macro_chisin_joins_or_include(ch
))
823 if (PIM_IF_FLAG_TEST_S_G_RPT(starch
->upstream
->flags
))
826 if (!pim_macro_ch_lost_assert(starch
)
827 && pim_macro_chisin_joins_or_include(starch
))
835 Evaluate JoinDesired(S,G):
837 JoinDesired(S,G) is true if there is a downstream (S,G) interface I
840 inherited_olist(S,G) =
841 joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
843 JoinDesired(S,G) may be affected by changes in the following:
845 pim_ifp->primary_address
847 ch->ifassert_winner_metric
849 ch->local_ifmembership
851 ch->upstream->rpf.source_nexthop.mrib_metric_preference
852 ch->upstream->rpf.source_nexthop.mrib_route_metric
853 ch->upstream->rpf.source_nexthop.interface
855 See also pim_upstream_update_join_desired() below.
857 int pim_upstream_evaluate_join_desired(struct pim_instance
*pim
,
858 struct pim_upstream
*up
)
860 struct interface
*ifp
;
861 struct listnode
*node
;
862 struct pim_ifchannel
*ch
, *starch
;
863 struct pim_upstream
*starup
= up
->parent
;
866 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(pim
->vrf_id
), node
, ifp
)) {
870 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
873 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
880 ret
+= pim_upstream_evaluate_join_desired_interface(up
, ch
,
882 } /* scan iface channel list */
884 return ret
; /* false */
888 See also pim_upstream_evaluate_join_desired() above.
890 void pim_upstream_update_join_desired(struct pim_instance
*pim
,
891 struct pim_upstream
*up
)
893 int was_join_desired
; /* boolean */
894 int is_join_desired
; /* boolean */
896 was_join_desired
= PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up
->flags
);
898 is_join_desired
= pim_upstream_evaluate_join_desired(pim
, up
);
900 PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(up
->flags
);
902 PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(up
->flags
);
904 /* switched from false to true */
905 if (is_join_desired
&& !was_join_desired
) {
906 pim_upstream_switch(up
, PIM_UPSTREAM_JOINED
);
910 /* switched from true to false */
911 if (!is_join_desired
&& was_join_desired
) {
912 pim_upstream_switch(up
, PIM_UPSTREAM_NOTJOINED
);
918 RFC 4601 4.5.7. Sending (S,G) Join/Prune Messages
919 Transitions from Joined State
920 RPF'(S,G) GenID changes
922 The upstream (S,G) state machine remains in Joined state. If the
923 Join Timer is set to expire in more than t_override seconds, reset
924 it so that it expires after t_override seconds.
926 void pim_upstream_rpf_genid_changed(struct pim_instance
*pim
,
927 struct in_addr neigh_addr
)
929 struct listnode
*up_node
;
930 struct listnode
*up_nextnode
;
931 struct pim_upstream
*up
;
934 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
936 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
938 if (PIM_DEBUG_TRACE
) {
939 char neigh_str
[INET_ADDRSTRLEN
];
940 char rpf_addr_str
[PREFIX_STRLEN
];
941 pim_inet4_dump("<neigh?>", neigh_addr
, neigh_str
,
943 pim_addr_dump("<rpf?>", &up
->rpf
.rpf_addr
, rpf_addr_str
,
944 sizeof(rpf_addr_str
));
946 "%s: matching neigh=%s against upstream (S,G)=%s joined=%d rpf_addr=%s",
947 __PRETTY_FUNCTION__
, neigh_str
, up
->sg_str
,
948 up
->join_state
== PIM_UPSTREAM_JOINED
,
952 /* consider only (S,G) upstream in Joined state */
953 if (up
->join_state
!= PIM_UPSTREAM_JOINED
)
956 /* match RPF'(S,G)=neigh_addr */
957 if (up
->rpf
.rpf_addr
.u
.prefix4
.s_addr
!= neigh_addr
.s_addr
)
960 pim_upstream_join_timer_decrease_to_t_override(
961 "RPF'(S,G) GenID change", up
);
966 void pim_upstream_rpf_interface_changed(struct pim_upstream
*up
,
967 struct interface
*old_rpf_ifp
)
969 struct listnode
*chnode
;
970 struct listnode
*chnextnode
;
971 struct pim_ifchannel
*ch
;
973 /* search all ifchannels */
974 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
975 if (ch
->ifassert_state
== PIM_IFASSERT_I_AM_LOSER
) {
977 /* RPF_interface(S) was NOT I */
978 (old_rpf_ifp
== ch
->interface
) &&
979 /* RPF_interface(S) stopped being I */
980 (ch
->upstream
->rpf
.source_nexthop
981 .interface
!= ch
->interface
)) {
982 assert_action_a5(ch
);
984 } /* PIM_IFASSERT_I_AM_LOSER */
986 pim_ifchannel_update_assert_tracking_desired(ch
);
990 void pim_upstream_update_could_assert(struct pim_upstream
*up
)
992 struct listnode
*chnode
;
993 struct listnode
*chnextnode
;
994 struct pim_ifchannel
*ch
;
996 /* scan per-interface (S,G) state */
997 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
998 pim_ifchannel_update_could_assert(ch
);
999 } /* scan iface channel list */
1002 void pim_upstream_update_my_assert_metric(struct pim_upstream
*up
)
1004 struct listnode
*chnode
;
1005 struct listnode
*chnextnode
;
1006 struct pim_ifchannel
*ch
;
1008 /* scan per-interface (S,G) state */
1009 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1010 pim_ifchannel_update_my_assert_metric(ch
);
1012 } /* scan iface channel list */
1015 static void pim_upstream_update_assert_tracking_desired(struct pim_upstream
*up
)
1017 struct listnode
*chnode
;
1018 struct listnode
*chnextnode
;
1019 struct pim_interface
*pim_ifp
;
1020 struct pim_ifchannel
*ch
;
1022 /* scan per-interface (S,G) state */
1023 for (ALL_LIST_ELEMENTS(up
->ifchannels
, chnode
, chnextnode
, ch
)) {
1026 pim_ifp
= ch
->interface
->info
;
1030 pim_ifchannel_update_assert_tracking_desired(ch
);
1032 } /* scan iface channel list */
1035 /* When kat is stopped CouldRegister goes to false so we need to
1036 * transition the (S, G) on FHR to NI state and remove reg tunnel
1038 static void pim_upstream_fhr_kat_expiry(struct pim_instance
*pim
,
1039 struct pim_upstream
*up
)
1041 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up
->flags
))
1044 if (PIM_DEBUG_TRACE
)
1045 zlog_debug("kat expired on %s; clear fhr reg state",
1048 /* stop reg-stop timer */
1049 THREAD_OFF(up
->t_rs_timer
);
1050 /* remove regiface from the OIL if it is there*/
1051 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1052 PIM_OIF_FLAG_PROTO_PIM
);
1053 /* clear the register state */
1054 up
->reg_state
= PIM_REG_NOINFO
;
1055 PIM_UPSTREAM_FLAG_UNSET_FHR(up
->flags
);
1058 /* When kat is started CouldRegister can go to true. And if it does we
1059 * need to transition the (S, G) on FHR to JOINED state and add reg tunnel
1061 static void pim_upstream_fhr_kat_start(struct pim_upstream
*up
)
1063 if (pim_upstream_could_register(up
)) {
1064 if (PIM_DEBUG_TRACE
)
1066 "kat started on %s; set fhr reg state to joined",
1069 PIM_UPSTREAM_FLAG_SET_FHR(up
->flags
);
1070 if (up
->reg_state
== PIM_REG_NOINFO
)
1071 pim_register_join(up
);
1076 * On an RP, the PMBR value must be cleared when the
1077 * Keepalive Timer expires
1078 * KAT expiry indicates that flow is inactive. If the flow was created or
1079 * maintained by activity now is the time to deref it.
1081 static int pim_upstream_keep_alive_timer(struct thread
*t
)
1083 struct pim_upstream
*up
;
1087 if (I_am_RP(pimg
, up
->sg
.grp
)) {
1088 pim_br_clear_pmbr(&up
->sg
);
1090 * We need to do more here :)
1091 * But this is the start.
1095 /* source is no longer active - pull the SA from MSDP's cache */
1096 pim_msdp_sa_local_del(&up
->sg
);
1098 /* if entry was created because of activity we need to deref it */
1099 if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1100 pim_upstream_fhr_kat_expiry(pimg
, up
);
1101 if (PIM_DEBUG_TRACE
)
1102 zlog_debug("kat expired on %s; remove stream reference",
1104 PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(up
->flags
);
1105 pim_upstream_del(pimg
, up
, __PRETTY_FUNCTION__
);
1106 } else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
)) {
1107 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(up
->flags
);
1108 pim_upstream_del(pimg
, up
, __PRETTY_FUNCTION__
);
1114 void pim_upstream_keep_alive_timer_start(struct pim_upstream
*up
, uint32_t time
)
1116 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1117 if (PIM_DEBUG_TRACE
)
1118 zlog_debug("kat start on %s with no stream reference",
1121 THREAD_OFF(up
->t_ka_timer
);
1122 thread_add_timer(master
, pim_upstream_keep_alive_timer
, up
, time
,
1125 /* any time keepalive is started against a SG we will have to
1126 * re-evaluate our active source database */
1127 pim_msdp_sa_local_update(up
);
1130 /* MSDP on RP needs to know if a source is registerable to this RP */
1131 static int pim_upstream_msdp_reg_timer(struct thread
*t
)
1133 struct pim_upstream
*up
;
1137 /* source is no longer active - pull the SA from MSDP's cache */
1138 pim_msdp_sa_local_del(&up
->sg
);
1141 void pim_upstream_msdp_reg_timer_start(struct pim_upstream
*up
)
1143 THREAD_OFF(up
->t_msdp_reg_timer
);
1144 thread_add_timer(master
, pim_upstream_msdp_reg_timer
, up
,
1145 PIM_MSDP_REG_RXED_PERIOD
, &up
->t_msdp_reg_timer
);
1147 pim_msdp_sa_local_update(up
);
1151 * 4.2.1 Last-Hop Switchover to the SPT
1153 * In Sparse-Mode PIM, last-hop routers join the shared tree towards the
1154 * RP. Once traffic from sources to joined groups arrives at a last-hop
1155 * router, it has the option of switching to receive the traffic on a
1156 * shortest path tree (SPT).
1158 * The decision for a router to switch to the SPT is controlled as
1162 * CheckSwitchToSpt(S,G) {
1163 * if ( ( pim_include(*,G) (-) pim_exclude(S,G)
1164 * (+) pim_include(S,G) != NULL )
1165 * AND SwitchToSptDesired(S,G) ) {
1166 * # Note: Restarting the KAT will result in the SPT switch
1167 * set KeepaliveTimer(S,G) to Keepalive_Period
1171 * SwitchToSptDesired(S,G) is a policy function that is implementation
1172 * defined. An "infinite threshold" policy can be implemented by making
1173 * SwitchToSptDesired(S,G) return false all the time. A "switch on
1174 * first packet" policy can be implemented by making
1175 * SwitchToSptDesired(S,G) return true once a single packet has been
1176 * received for the source and group.
1178 int pim_upstream_switch_to_spt_desired(struct prefix_sg
*sg
)
1180 if (I_am_RP(pimg
, sg
->grp
))
1186 int pim_upstream_is_sg_rpt(struct pim_upstream
*up
)
1188 struct listnode
*chnode
;
1189 struct pim_ifchannel
*ch
;
1191 for (ALL_LIST_ELEMENTS_RO(up
->ifchannels
, chnode
, ch
)) {
1192 if (PIM_IF_FLAG_TEST_S_G_RPT(ch
->flags
))
1199 * After receiving a packet set SPTbit:
1201 * Update_SPTbit(S,G,iif) {
1202 * if ( iif == RPF_interface(S)
1203 * AND JoinDesired(S,G) == TRUE
1204 * AND ( DirectlyConnected(S) == TRUE
1205 * OR RPF_interface(S) != RPF_interface(RP(G))
1206 * OR inherited_olist(S,G,rpt) == NULL
1207 * OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1208 * ( RPF'(S,G) != NULL ) )
1209 * OR ( I_Am_Assert_Loser(S,G,iif) ) {
1210 * Set SPTbit(S,G) to TRUE
1214 void pim_upstream_set_sptbit(struct pim_upstream
*up
,
1215 struct interface
*incoming
)
1217 struct pim_upstream
*starup
= up
->parent
;
1219 // iif == RPF_interfvace(S)
1220 if (up
->rpf
.source_nexthop
.interface
!= incoming
) {
1221 if (PIM_DEBUG_TRACE
)
1223 "%s: Incoming Interface: %s is different than RPF_interface(S) %s",
1224 __PRETTY_FUNCTION__
, incoming
->name
,
1225 up
->rpf
.source_nexthop
.interface
->name
);
1229 // AND JoinDesired(S,G) == TRUE
1232 // DirectlyConnected(S) == TRUE
1233 if (pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1235 if (PIM_DEBUG_TRACE
)
1236 zlog_debug("%s: %s is directly connected to the source",
1237 __PRETTY_FUNCTION__
, up
->sg_str
);
1238 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1242 // OR RPF_interface(S) != RPF_interface(RP(G))
1244 || up
->rpf
.source_nexthop
1245 .interface
!= starup
->rpf
.source_nexthop
.interface
) {
1246 if (PIM_DEBUG_TRACE
)
1248 "%s: %s RPF_interface(S) != RPF_interface(RP(G))",
1249 __PRETTY_FUNCTION__
, up
->sg_str
);
1250 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1254 // OR inherited_olist(S,G,rpt) == NULL
1255 if (pim_upstream_is_sg_rpt(up
)
1256 && pim_upstream_empty_inherited_olist(up
)) {
1257 if (PIM_DEBUG_TRACE
)
1258 zlog_debug("%s: %s OR inherited_olist(S,G,rpt) == NULL",
1259 __PRETTY_FUNCTION__
, up
->sg_str
);
1260 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1264 // OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1265 // ( RPF'(S,G) != NULL ) )
1266 if (up
->parent
&& pim_rpf_is_same(&up
->rpf
, &up
->parent
->rpf
)) {
1267 if (PIM_DEBUG_TRACE
)
1268 zlog_debug("%s: %s RPF'(S,G) is the same as RPF'(*,G)",
1269 __PRETTY_FUNCTION__
, up
->sg_str
);
1270 up
->sptbit
= PIM_UPSTREAM_SPTBIT_TRUE
;
1277 const char *pim_upstream_state2str(enum pim_upstream_state join_state
)
1279 switch (join_state
) {
1280 case PIM_UPSTREAM_NOTJOINED
:
1283 case PIM_UPSTREAM_JOINED
:
1290 const char *pim_reg_state2str(enum pim_reg_state reg_state
, char *state_str
)
1292 switch (reg_state
) {
1293 case PIM_REG_NOINFO
:
1294 strcpy(state_str
, "RegNoInfo");
1297 strcpy(state_str
, "RegJoined");
1299 case PIM_REG_JOIN_PENDING
:
1300 strcpy(state_str
, "RegJoinPend");
1303 strcpy(state_str
, "RegPrune");
1306 strcpy(state_str
, "RegUnknown");
1311 static int pim_upstream_register_stop_timer(struct thread
*t
)
1313 struct pim_interface
*pim_ifp
;
1314 struct pim_upstream
*up
;
1315 struct pim_rpf
*rpg
;
1319 if (PIM_DEBUG_TRACE
) {
1320 char state_str
[PIM_REG_STATE_STR_LEN
];
1321 zlog_debug("%s: (S,G)=%s upstream register stop timer %s",
1322 __PRETTY_FUNCTION__
, up
->sg_str
,
1323 pim_reg_state2str(up
->reg_state
, state_str
));
1326 switch (up
->reg_state
) {
1327 case PIM_REG_JOIN_PENDING
:
1328 up
->reg_state
= PIM_REG_JOIN
;
1329 pim_channel_add_oif(up
->channel_oil
, pimg
->regiface
,
1330 PIM_OIF_FLAG_PROTO_PIM
);
1335 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
1337 if (PIM_DEBUG_TRACE
)
1339 "%s: Interface: %s is not configured for pim",
1340 __PRETTY_FUNCTION__
,
1341 up
->rpf
.source_nexthop
.interface
->name
);
1344 up
->reg_state
= PIM_REG_JOIN_PENDING
;
1345 pim_upstream_start_register_stop_timer(up
, 1);
1347 if (((up
->channel_oil
->cc
.lastused
/ 100)
1348 > PIM_KEEPALIVE_PERIOD
)
1349 && (I_am_RP(pim_ifp
->pim
, up
->sg
.grp
))) {
1350 if (PIM_DEBUG_TRACE
)
1352 "%s: Stop sending the register, because I am the RP and we haven't seen a packet in a while",
1353 __PRETTY_FUNCTION__
);
1356 rpg
= RP(pim_ifp
->pim
, up
->sg
.grp
);
1357 memset(&ip_hdr
, 0, sizeof(struct ip
));
1358 ip_hdr
.ip_p
= PIM_IP_PROTO_PIM
;
1361 ip_hdr
.ip_src
= up
->sg
.src
;
1362 ip_hdr
.ip_dst
= up
->sg
.grp
;
1363 ip_hdr
.ip_len
= htons(20);
1364 // checksum is broken
1365 pim_register_send((uint8_t *)&ip_hdr
, sizeof(struct ip
),
1366 pim_ifp
->primary_address
, rpg
, 1, up
);
1375 void pim_upstream_start_register_stop_timer(struct pim_upstream
*up
,
1380 THREAD_TIMER_OFF(up
->t_rs_timer
);
1382 if (!null_register
) {
1383 uint32_t lower
= (0.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1384 uint32_t upper
= (1.5 * PIM_REGISTER_SUPPRESSION_PERIOD
);
1385 time
= lower
+ (random() % (upper
- lower
+ 1))
1386 - PIM_REGISTER_PROBE_PERIOD
;
1388 time
= PIM_REGISTER_PROBE_PERIOD
;
1390 if (PIM_DEBUG_TRACE
) {
1392 "%s: (S,G)=%s Starting upstream register stop timer %d",
1393 __PRETTY_FUNCTION__
, up
->sg_str
, time
);
1395 thread_add_timer(master
, pim_upstream_register_stop_timer
, up
, time
,
1399 int pim_upstream_inherited_olist_decide(struct pim_instance
*pim
,
1400 struct pim_upstream
*up
)
1402 struct interface
*ifp
;
1403 struct pim_interface
*pim_ifp
= NULL
;
1404 struct pim_ifchannel
*ch
, *starch
;
1405 struct listnode
*node
;
1406 struct pim_upstream
*starup
= up
->parent
;
1407 int output_intf
= 0;
1409 if (up
->rpf
.source_nexthop
.interface
)
1410 pim_ifp
= up
->rpf
.source_nexthop
.interface
->info
;
1412 if (PIM_DEBUG_TRACE
)
1413 zlog_debug("%s: up %s RPF is not present",
1414 __PRETTY_FUNCTION__
, up
->sg_str
);
1416 if (pim_ifp
&& !up
->channel_oil
)
1417 up
->channel_oil
= pim_channel_oil_add(
1418 pim
, &up
->sg
, pim_ifp
->mroute_vif_index
);
1420 for (ALL_LIST_ELEMENTS_RO(vrf_iflist(pim
->vrf_id
), node
, ifp
)) {
1424 ch
= pim_ifchannel_find(ifp
, &up
->sg
);
1427 starch
= pim_ifchannel_find(ifp
, &starup
->sg
);
1434 if (pim_upstream_evaluate_join_desired_interface(up
, ch
,
1436 int flag
= PIM_OIF_FLAG_PROTO_PIM
;
1439 flag
= PIM_OIF_FLAG_PROTO_STAR
;
1441 pim_channel_add_oif(up
->channel_oil
, ifp
, flag
);
1450 * For a given upstream, determine the inherited_olist
1453 * inherited_olist(S,G,rpt) =
1454 * ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
1455 * (+) ( pim_include(*,G) (-) pim_exclude(S,G))
1456 * (-) ( lost_assert(*,G) (+) lost_assert(S,G,rpt) )
1458 * inherited_olist(S,G) =
1459 * inherited_olist(S,G,rpt) (+)
1460 * joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
1462 * return 1 if there are any output interfaces
1463 * return 0 if there are not any output interfaces
1465 int pim_upstream_inherited_olist(struct pim_instance
*pim
,
1466 struct pim_upstream
*up
)
1468 int output_intf
= pim_upstream_inherited_olist_decide(pim
, up
);
1471 * If we have output_intf switch state to Join and work like normal
1472 * If we don't have an output_intf that means we are probably a
1473 * switch on a stick so turn on forwarding to just accept the
1474 * incoming packets so we don't bother the other stuff!
1477 pim_upstream_switch(up
, PIM_UPSTREAM_JOINED
);
1484 int pim_upstream_empty_inherited_olist(struct pim_upstream
*up
)
1486 return pim_channel_oil_empty(up
->channel_oil
);
1490 * When we have a new neighbor,
1491 * find upstreams that don't have their rpf_addr
1492 * set and see if the new neighbor allows
1493 * the join to be sent
1495 void pim_upstream_find_new_rpf(struct pim_instance
*pim
)
1497 struct listnode
*up_node
;
1498 struct listnode
*up_nextnode
;
1499 struct pim_upstream
*up
;
1502 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1504 for (ALL_LIST_ELEMENTS(pim
->upstream_list
, up_node
, up_nextnode
, up
)) {
1505 if (pim_rpf_addr_is_inaddr_any(&up
->rpf
)) {
1506 if (PIM_DEBUG_TRACE
)
1508 "Upstream %s without a path to send join, checking",
1510 pim_rpf_update(up
, NULL
, 1);
1515 static unsigned int pim_upstream_hash_key(void *arg
)
1517 struct pim_upstream
*up
= (struct pim_upstream
*)arg
;
1519 return jhash_2words(up
->sg
.src
.s_addr
, up
->sg
.grp
.s_addr
, 0);
1522 void pim_upstream_terminate(struct pim_instance
*pim
)
1524 if (pim
->upstream_list
)
1525 list_delete(pim
->upstream_list
);
1526 pim
->upstream_list
= NULL
;
1528 if (pim
->upstream_hash
)
1529 hash_free(pim
->upstream_hash
);
1530 pim
->upstream_hash
= NULL
;
1533 static int pim_upstream_equal(const void *arg1
, const void *arg2
)
1535 const struct pim_upstream
*up1
= (const struct pim_upstream
*)arg1
;
1536 const struct pim_upstream
*up2
= (const struct pim_upstream
*)arg2
;
1538 if ((up1
->sg
.grp
.s_addr
== up2
->sg
.grp
.s_addr
)
1539 && (up1
->sg
.src
.s_addr
== up2
->sg
.src
.s_addr
))
1545 /* rfc4601:section-4.2:"Data Packet Forwarding Rules" defines
1546 * the cases where kat has to be restarted on rxing traffic -
1548 * if( DirectlyConnected(S) == TRUE AND iif == RPF_interface(S) ) {
1549 * set KeepaliveTimer(S,G) to Keepalive_Period
1550 * # Note: a register state transition or UpstreamJPState(S,G)
1551 * # transition may happen as a result of restarting
1552 * # KeepaliveTimer, and must be dealt with here.
1554 * if( iif == RPF_interface(S) AND UpstreamJPState(S,G) == Joined AND
1555 * inherited_olist(S,G) != NULL ) {
1556 * set KeepaliveTimer(S,G) to Keepalive_Period
1559 static bool pim_upstream_kat_start_ok(struct pim_upstream
*up
)
1561 /* "iif == RPF_interface(S)" check has to be done by the kernel or hw
1562 * so we will skip that here */
1563 if (pim_if_connected_to_source(up
->rpf
.source_nexthop
.interface
,
1568 if ((up
->join_state
== PIM_UPSTREAM_JOINED
)
1569 && !pim_upstream_empty_inherited_olist(up
)) {
1570 /* XXX: I have added this RP check just for 3.2 and it's a
1572 * what rfc-4601 says. Till now we were only running KAT on FHR
1574 * there is some angst around making the change to run it all
1576 * maintain the (S, G) state. This is tracked via CM-13601 and
1578 * removed to handle spt turn-arounds correctly in a 3-tier clos
1580 if (I_am_RP(pimg
, up
->sg
.grp
))
1588 * Code to check and see if we've received packets on a S,G mroute
1589 * and if so to set the SPT bit appropriately
1591 static void pim_upstream_sg_running(void *arg
)
1593 struct pim_upstream
*up
= (struct pim_upstream
*)arg
;
1595 // No packet can have arrived here if this is the case
1596 if (!up
->channel_oil
|| !up
->channel_oil
->installed
) {
1597 if (PIM_DEBUG_TRACE
)
1598 zlog_debug("%s: %s is not installed in mroute",
1599 __PRETTY_FUNCTION__
, up
->sg_str
);
1604 * This is a bit of a hack
1605 * We've noted that we should rescan but
1606 * we've missed the window for doing so in
1607 * pim_zebra.c for some reason. I am
1608 * only doing this at this point in time
1609 * to get us up and working for the moment
1611 if (up
->channel_oil
->oil_inherited_rescan
) {
1612 if (PIM_DEBUG_TRACE
)
1614 "%s: Handling unscanned inherited_olist for %s",
1615 __PRETTY_FUNCTION__
, up
->sg_str
);
1616 pim_upstream_inherited_olist_decide(pimg
, up
);
1617 up
->channel_oil
->oil_inherited_rescan
= 0;
1619 pim_mroute_update_counters(up
->channel_oil
);
1621 // Have we seen packets?
1622 if ((up
->channel_oil
->cc
.oldpktcnt
>= up
->channel_oil
->cc
.pktcnt
)
1623 && (up
->channel_oil
->cc
.lastused
/ 100 > 30)) {
1624 if (PIM_DEBUG_TRACE
) {
1626 "%s: %s old packet count is equal or lastused is greater than 30, (%ld,%ld,%lld)",
1627 __PRETTY_FUNCTION__
, up
->sg_str
,
1628 up
->channel_oil
->cc
.oldpktcnt
,
1629 up
->channel_oil
->cc
.pktcnt
,
1630 up
->channel_oil
->cc
.lastused
/ 100);
1635 if (pim_upstream_kat_start_ok(up
)) {
1636 /* Add a source reference to the stream if
1637 * one doesn't already exist */
1638 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up
->flags
)) {
1639 if (PIM_DEBUG_TRACE
)
1641 "source reference created on kat restart %s",
1644 pim_upstream_ref(up
, PIM_UPSTREAM_FLAG_MASK_SRC_STREAM
,
1645 __PRETTY_FUNCTION__
);
1646 PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up
->flags
);
1647 pim_upstream_fhr_kat_start(up
);
1649 pim_upstream_keep_alive_timer_start(up
, qpim_keep_alive_time
);
1650 } else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up
->flags
))
1651 pim_upstream_keep_alive_timer_start(up
, qpim_keep_alive_time
);
1653 if (up
->sptbit
!= PIM_UPSTREAM_SPTBIT_TRUE
) {
1654 pim_upstream_set_sptbit(up
, up
->rpf
.source_nexthop
.interface
);
1659 void pim_upstream_add_lhr_star_pimreg(struct pim_instance
*pim
)
1661 struct pim_upstream
*up
;
1662 struct listnode
*node
;
1664 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1665 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1668 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1671 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1672 PIM_OIF_FLAG_PROTO_IGMP
);
1676 void pim_upstream_spt_prefix_list_update(struct pim_instance
*pim
,
1677 struct prefix_list
*pl
)
1679 const char *pname
= prefix_list_name(pl
);
1681 if (pim
->spt
.plist
&& strcmp(pim
->spt
.plist
, pname
) == 0) {
1682 pim_upstream_remove_lhr_star_pimreg(pim
, pname
);
1687 * nlist -> The new prefix list
1689 * Per Group Application of pimreg to the OIL
1690 * If the prefix list tells us DENY then
1691 * we need to Switchover to SPT immediate
1692 * so add the pimreg.
1693 * If the prefix list tells us to ACCEPT than
1694 * we need to Never do the SPT so remove
1698 void pim_upstream_remove_lhr_star_pimreg(struct pim_instance
*pim
,
1701 struct pim_upstream
*up
;
1702 struct listnode
*node
;
1703 struct prefix_list
*np
;
1705 enum prefix_list_type apply_new
;
1707 np
= prefix_list_lookup(AFI_IP
, nlist
);
1710 g
.prefixlen
= IPV4_MAX_PREFIXLEN
;
1712 for (ALL_LIST_ELEMENTS_RO(pim
->upstream_list
, node
, up
)) {
1713 if (up
->sg
.src
.s_addr
!= INADDR_ANY
)
1716 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up
->flags
))
1720 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1721 PIM_OIF_FLAG_PROTO_IGMP
);
1724 g
.u
.prefix4
= up
->sg
.grp
;
1725 apply_new
= prefix_list_apply(np
, &g
);
1726 if (apply_new
== PREFIX_DENY
)
1727 pim_channel_add_oif(up
->channel_oil
, pim
->regiface
,
1728 PIM_OIF_FLAG_PROTO_IGMP
);
1730 pim_channel_del_oif(up
->channel_oil
, pim
->regiface
,
1731 PIM_OIF_FLAG_PROTO_IGMP
);
1735 void pim_upstream_init(struct pim_instance
*pim
)
1737 pim
->upstream_sg_wheel
=
1738 wheel_init(master
, 31000, 100, pim_upstream_hash_key
,
1739 pim_upstream_sg_running
);
1740 pim
->upstream_hash
= hash_create_size(8192, pim_upstream_hash_key
,
1741 pim_upstream_equal
, NULL
);
1743 pim
->upstream_list
= list_new();
1744 pim
->upstream_list
->del
= (void (*)(void *))pim_upstream_free
;
1745 pim
->upstream_list
->cmp
= pim_upstream_compare
;