]> git.proxmox.com Git - mirror_frr.git/blob - pimd/pim_upstream.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #4724 from satheeshkarra/pim_fixes
[mirror_frr.git] / pimd / pim_upstream.c
1 /*
2 * PIM for Quagga
3 * Copyright (C) 2008 Everton da Silva Marques
4 *
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.
9 *
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.
14 *
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
18 */
19
20 #include <zebra.h>
21
22 #include "log.h"
23 #include "zclient.h"
24 #include "memory.h"
25 #include "thread.h"
26 #include "linklist.h"
27 #include "vty.h"
28 #include "plist.h"
29 #include "hash.h"
30 #include "jhash.h"
31 #include "wheel.h"
32
33 #include "pimd.h"
34 #include "pim_pim.h"
35 #include "pim_str.h"
36 #include "pim_time.h"
37 #include "pim_iface.h"
38 #include "pim_join.h"
39 #include "pim_zlookup.h"
40 #include "pim_upstream.h"
41 #include "pim_ifchannel.h"
42 #include "pim_neighbor.h"
43 #include "pim_rpf.h"
44 #include "pim_zebra.h"
45 #include "pim_oil.h"
46 #include "pim_macro.h"
47 #include "pim_rp.h"
48 #include "pim_br.h"
49 #include "pim_register.h"
50 #include "pim_msdp.h"
51 #include "pim_jp_agg.h"
52 #include "pim_nht.h"
53 #include "pim_ssm.h"
54 #include "pim_vxlan.h"
55
56 static void join_timer_stop(struct pim_upstream *up);
57 static void
58 pim_upstream_update_assert_tracking_desired(struct pim_upstream *up);
59
60 /*
61 * A (*,G) or a (*,*) is going away
62 * remove the parent pointer from
63 * those pointing at us
64 */
65 static void pim_upstream_remove_children(struct pim_instance *pim,
66 struct pim_upstream *up)
67 {
68 struct pim_upstream *child;
69
70 if (!up->sources)
71 return;
72
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,
79 __PRETTY_FUNCTION__);
80 }
81 if (child)
82 child->parent = NULL;
83 }
84 list_delete(&up->sources);
85 }
86
87 /*
88 * A (*,G) or a (*,*) is being created
89 * Find the children that would point
90 * at us.
91 */
92 static void pim_upstream_find_new_children(struct pim_instance *pim,
93 struct pim_upstream *up)
94 {
95 struct pim_upstream *child;
96 struct listnode *ch_node;
97
98 if ((up->sg.src.s_addr != INADDR_ANY)
99 && (up->sg.grp.s_addr != INADDR_ANY))
100 return;
101
102 if ((up->sg.src.s_addr == INADDR_ANY)
103 && (up->sg.grp.s_addr == INADDR_ANY))
104 return;
105
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)
109 && (child != up)) {
110 child->parent = up;
111 listnode_add_sort(up->sources, child);
112 }
113 }
114 }
115
116 /*
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 (*,*)
120 */
121 static struct pim_upstream *pim_upstream_find_parent(struct pim_instance *pim,
122 struct pim_upstream *child)
123 {
124 struct prefix_sg any = child->sg;
125 struct pim_upstream *up = NULL;
126
127 // (S,G)
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);
132
133 if (up)
134 listnode_add(up->sources, child);
135
136 return up;
137 }
138
139 return NULL;
140 }
141
142 static void upstream_channel_oil_detach(struct pim_upstream *up)
143 {
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
147 */
148 up->channel_oil->up = NULL;
149 pim_channel_oil_del(up->channel_oil, __PRETTY_FUNCTION__);
150 up->channel_oil = NULL;
151 }
152 }
153
154 struct pim_upstream *pim_upstream_del(struct pim_instance *pim,
155 struct pim_upstream *up, const char *name)
156 {
157 struct listnode *node, *nnode;
158 struct pim_ifchannel *ch;
159 bool notify_msdp = false;
160 struct prefix nht_p;
161
162 if (PIM_DEBUG_TRACE)
163 zlog_debug(
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);
168
169 assert(up->ref_count > 0);
170
171 --up->ref_count;
172
173 if (up->ref_count >= 1)
174 return up;
175
176 THREAD_OFF(up->t_ka_timer);
177 THREAD_OFF(up->t_rs_timer);
178 THREAD_OFF(up->t_msdp_reg_timer);
179
180 if (up->join_state == PIM_UPSTREAM_JOINED) {
181 pim_jp_agg_single_upstream_send(&up->rpf, up, 0);
182
183 if (up->sg.src.s_addr == INADDR_ANY) {
184 /* if a (*, G) entry in the joined state is being
185 * deleted we
186 * need to notify MSDP */
187 notify_msdp = true;
188 }
189 }
190
191 join_timer_stop(up);
192 pim_jp_agg_upstream_verification(up, false);
193 up->rpf.source_nexthop.interface = NULL;
194
195 if (up->sg.src.s_addr != INADDR_ANY) {
196 if (pim->upstream_sg_wheel)
197 wheel_remove_item(pim->upstream_sg_wheel, up);
198 notify_msdp = true;
199 }
200
201 pim_mroute_del(up->channel_oil, __PRETTY_FUNCTION__);
202 upstream_channel_oil_detach(up);
203
204 for (ALL_LIST_ELEMENTS(up->ifchannels, node, nnode, ch))
205 pim_ifchannel_delete(ch);
206 list_delete(&up->ifchannels);
207
208 pim_upstream_remove_children(pim, up);
209 if (up->sources)
210 list_delete(&up->sources);
211
212 if (up->parent && up->parent->sources)
213 listnode_delete(up->parent->sources, up);
214 up->parent = NULL;
215
216 listnode_delete(pim->upstream_list, up);
217 hash_release(pim->upstream_hash, up);
218
219 if (notify_msdp) {
220 pim_msdp_up_del(pim, &up->sg);
221 }
222
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..
228 */
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);
239 }
240 pim_delete_tracked_nexthop(pim, &nht_p, up, NULL, false);
241 }
242
243 XFREE(MTYPE_PIM_UPSTREAM, up);
244
245 return NULL;
246 }
247
248 void pim_upstream_send_join(struct pim_upstream *up)
249 {
250 if (!up->rpf.source_nexthop.interface) {
251 if (PIM_DEBUG_TRACE)
252 zlog_debug("%s: up %s RPF is not present",
253 __PRETTY_FUNCTION__, up->sg_str);
254 return;
255 }
256
257 if (PIM_DEBUG_TRACE) {
258 char rpf_str[PREFIX_STRLEN];
259 pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_str,
260 sizeof(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);
268 /* warning only */
269 }
270 }
271
272 /* send Join(S,G) to the current upstream neighbor */
273 pim_jp_agg_single_upstream_send(&up->rpf, up, 1 /* join */);
274 }
275
276 static int on_join_timer(struct thread *t)
277 {
278 struct pim_upstream *up;
279
280 up = THREAD_ARG(t);
281
282 if (!up->rpf.source_nexthop.interface) {
283 if (PIM_DEBUG_TRACE)
284 zlog_debug("%s: up %s RPF is not present",
285 __PRETTY_FUNCTION__, up->sg_str);
286 return 0;
287 }
288
289 /*
290 * In the case of a HFR we will not ahve anyone to send this to.
291 */
292 if (PIM_UPSTREAM_FLAG_TEST_FHR(up->flags))
293 return 0;
294
295 /*
296 * Don't send the join if the outgoing interface is a loopback
297 * But since this might change leave the join timer running
298 */
299 if (up->rpf.source_nexthop
300 .interface && !if_is_loopback(up->rpf.source_nexthop.interface))
301 pim_upstream_send_join(up);
302
303 join_timer_start(up);
304
305 return 0;
306 }
307
308 static void join_timer_stop(struct pim_upstream *up)
309 {
310 struct pim_neighbor *nbr = NULL;
311
312 THREAD_OFF(up->t_join_timer);
313
314 if (up->rpf.source_nexthop.interface)
315 nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
316 up->rpf.rpf_addr.u.prefix4);
317
318 if (nbr)
319 pim_jp_agg_remove_group(nbr->upstream_jp_agg, up);
320
321 pim_jp_agg_upstream_verification(up, false);
322 }
323
324 void join_timer_start(struct pim_upstream *up)
325 {
326 struct pim_neighbor *nbr = NULL;
327
328 if (up->rpf.source_nexthop.interface) {
329 nbr = pim_neighbor_find(up->rpf.source_nexthop.interface,
330 up->rpf.rpf_addr.u.prefix4);
331
332 if (PIM_DEBUG_PIM_EVENTS) {
333 zlog_debug(
334 "%s: starting %d sec timer for upstream (S,G)=%s",
335 __PRETTY_FUNCTION__, router->t_periodic,
336 up->sg_str);
337 }
338 }
339
340 if (nbr)
341 pim_jp_agg_add_group(nbr->upstream_jp_agg, up, 1);
342 else {
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);
346 }
347 pim_jp_agg_upstream_verification(up, true);
348 }
349
350 /*
351 * This is only called when we are switching the upstream
352 * J/P from one neighbor to another
353 *
354 * As such we need to remove from the old list and
355 * add to the new list.
356 */
357 void pim_upstream_join_timer_restart(struct pim_upstream *up,
358 struct pim_rpf *old)
359 {
360 // THREAD_OFF(up->t_join_timer);
361 join_timer_start(up);
362 }
363
364 static void pim_upstream_join_timer_restart_msec(struct pim_upstream *up,
365 int interval_msec)
366 {
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);
370 }
371
372 THREAD_OFF(up->t_join_timer);
373 thread_add_timer_msec(router->master, on_join_timer, up, interval_msec,
374 &up->t_join_timer);
375 }
376
377 void pim_upstream_join_suppress(struct pim_upstream *up,
378 struct in_addr rpf_addr, int holdtime)
379 {
380 long t_joinsuppress_msec;
381 long join_timer_remain_msec;
382
383 if (!up->rpf.source_nexthop.interface) {
384 if (PIM_DEBUG_TRACE)
385 zlog_debug("%s: up %s RPF is not present",
386 __PRETTY_FUNCTION__, up->sg_str);
387 return;
388 }
389
390 t_joinsuppress_msec =
391 MIN(pim_if_t_suppressed_msec(up->rpf.source_nexthop.interface),
392 1000 * holdtime);
393
394 join_timer_remain_msec = pim_time_timer_remain_msec(up->t_join_timer);
395
396 if (PIM_DEBUG_TRACE) {
397 char rpf_str[INET_ADDRSTRLEN];
398 pim_inet4_dump("<rpf?>", rpf_addr, rpf_str, sizeof(rpf_str));
399 zlog_debug(
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);
403 }
404
405 if (join_timer_remain_msec < t_joinsuppress_msec) {
406 if (PIM_DEBUG_TRACE) {
407 zlog_debug(
408 "%s %s: suppressing Join(S,G)=%s for %ld msec",
409 __FILE__, __PRETTY_FUNCTION__, up->sg_str,
410 t_joinsuppress_msec);
411 }
412
413 pim_upstream_join_timer_restart_msec(up, t_joinsuppress_msec);
414 }
415 }
416
417 void pim_upstream_join_timer_decrease_to_t_override(const char *debug_label,
418 struct pim_upstream *up)
419 {
420 long join_timer_remain_msec;
421 int t_override_msec;
422
423 if (!up->rpf.source_nexthop.interface) {
424 if (PIM_DEBUG_TRACE)
425 zlog_debug("%s: up %s RPF is not present",
426 __PRETTY_FUNCTION__, up->sg_str);
427 return;
428 }
429
430 join_timer_remain_msec = pim_time_timer_remain_msec(up->t_join_timer);
431 t_override_msec =
432 pim_if_t_override_msec(up->rpf.source_nexthop.interface);
433
434 if (PIM_DEBUG_TRACE) {
435 char rpf_str[INET_ADDRSTRLEN];
436 pim_inet4_dump("<rpf?>", up->rpf.rpf_addr.u.prefix4, rpf_str,
437 sizeof(rpf_str));
438 zlog_debug(
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);
442 }
443
444 if (join_timer_remain_msec > t_override_msec) {
445 if (PIM_DEBUG_TRACE) {
446 zlog_debug(
447 "%s: decreasing (S,G)=%s join timer to t_override=%d msec",
448 debug_label, up->sg_str, t_override_msec);
449 }
450
451 pim_upstream_join_timer_restart_msec(up, t_override_msec);
452 }
453 }
454
455 static void forward_on(struct pim_upstream *up)
456 {
457 struct listnode *chnode;
458 struct listnode *chnextnode;
459 struct pim_ifchannel *ch = NULL;
460
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);
465
466 } /* scan iface channel list */
467 }
468
469 static void forward_off(struct pim_upstream *up)
470 {
471 struct listnode *chnode;
472 struct listnode *chnextnode;
473 struct pim_ifchannel *ch;
474
475 /* scan per-interface (S,G) state */
476 for (ALL_LIST_ELEMENTS(up->ifchannels, chnode, chnextnode, ch)) {
477
478 pim_forward_stop(ch, false);
479
480 } /* scan iface channel list */
481 }
482
483 static int pim_upstream_could_register(struct pim_upstream *up)
484 {
485 struct pim_interface *pim_ifp = NULL;
486
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.
490 */
491 if (PIM_UPSTREAM_FLAG_TEST_FORCE_PIMREG(up->flags))
492 return 1;
493
494 if (up->rpf.source_nexthop.interface)
495 pim_ifp = up->rpf.source_nexthop.interface->info;
496 else {
497 if (PIM_DEBUG_TRACE)
498 zlog_debug("%s: up %s RPF is not present",
499 __PRETTY_FUNCTION__, up->sg_str);
500 }
501
502 if (pim_ifp && PIM_I_am_DR(pim_ifp)
503 && pim_if_connected_to_source(up->rpf.source_nexthop.interface,
504 up->sg.src))
505 return 1;
506
507 return 0;
508 }
509
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)
513 {
514 struct listnode *upnode;
515 struct pim_upstream *up;
516
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
520 * source
521 * registration whenever the flow becomes active. */
522 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up->flags) || !up->t_ka_timer)
523 continue;
524
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)
529 zlog_debug(
530 "Clear register for %s as G is now SSM",
531 up->sg_str);
532 /* remove regiface from the OIL if it is there*/
533 pim_channel_del_oif(up->channel_oil,
534 pim->regiface,
535 PIM_OIF_FLAG_PROTO_PIM);
536 up->reg_state = PIM_REG_NOINFO;
537 }
538 } else {
539 /* register ASM sources with the RP */
540 if (up->reg_state == PIM_REG_NOINFO) {
541 if (PIM_DEBUG_PIM_EVENTS)
542 zlog_debug(
543 "Register %s as G is now ASM",
544 up->sg_str);
545 pim_channel_add_oif(up->channel_oil,
546 pim->regiface,
547 PIM_OIF_FLAG_PROTO_PIM);
548 up->reg_state = PIM_REG_JOIN;
549 }
550 }
551 }
552 }
553
554 void pim_upstream_switch(struct pim_instance *pim, struct pim_upstream *up,
555 enum pim_upstream_state new_state)
556 {
557 enum pim_upstream_state old_state = up->join_state;
558
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);
563 return;
564 }
565
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);
570 return;
571 }
572
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));
578 }
579
580 up->join_state = new_state;
581 if (old_state != new_state)
582 up->state_transition = pim_time_monotonic_sec();
583
584 pim_upstream_update_assert_tracking_desired(up);
585
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);
590
591 pim_msdp_up_join_state_changed(pim, up);
592 if (pim_upstream_could_register(up)) {
593 PIM_UPSTREAM_FLAG_SET_FHR(up->flags);
594 if (!old_fhr
595 && PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(
596 up->flags)) {
597 pim_upstream_keep_alive_timer_start(
598 up, pim->keep_alive_time);
599 pim_register_join(up);
600 }
601 } else {
602 pim_upstream_send_join(up);
603 join_timer_start(up);
604 }
605 }
606 } else {
607
608 forward_off(up);
609 if (old_state == PIM_UPSTREAM_JOINED)
610 pim_msdp_up_join_state_changed(pim, up);
611
612 /* IHR, Trigger SGRpt on *,G IIF to prune S,G from RPT towards
613 RP.
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)
618 zlog_debug(
619 "%s: *,G IIF %s S,G IIF %s ",
620 __PRETTY_FUNCTION__,
621 up->parent->rpf.source_nexthop.interface ?
622 up->parent->rpf.source_nexthop.interface->name
623 : "Unknown",
624 up->rpf.source_nexthop.interface ?
625 up->rpf.source_nexthop.interface->name :
626 "Unknown");
627 pim_jp_agg_single_upstream_send(&up->parent->rpf,
628 up->parent,
629 1 /* (W,G) Join */);
630 } else
631 pim_jp_agg_single_upstream_send(&up->rpf, up,
632 0 /* prune */);
633 join_timer_stop(up);
634 }
635 }
636
637 int pim_upstream_compare(void *arg1, void *arg2)
638 {
639 const struct pim_upstream *up1 = (const struct pim_upstream *)arg1;
640 const struct pim_upstream *up2 = (const struct pim_upstream *)arg2;
641
642 if (ntohl(up1->sg.grp.s_addr) < ntohl(up2->sg.grp.s_addr))
643 return -1;
644
645 if (ntohl(up1->sg.grp.s_addr) > ntohl(up2->sg.grp.s_addr))
646 return 1;
647
648 if (ntohl(up1->sg.src.s_addr) < ntohl(up2->sg.src.s_addr))
649 return -1;
650
651 if (ntohl(up1->sg.src.s_addr) > ntohl(up2->sg.src.s_addr))
652 return 1;
653
654 return 0;
655 }
656
657 void pim_upstream_fill_static_iif(struct pim_upstream *up,
658 struct interface *incoming)
659 {
660 up->rpf.source_nexthop.interface = incoming;
661
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 =
665 PIM_NET_INADDR_ANY;
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;
671
672 }
673
674 static struct pim_upstream *pim_upstream_new(struct pim_instance *pim,
675 struct prefix_sg *sg,
676 struct interface *incoming,
677 int flags,
678 struct pim_ifchannel *ch)
679 {
680 enum pim_rpf_result rpf_result;
681 struct pim_interface *pim_ifp;
682 struct pim_upstream *up;
683
684 up = XCALLOC(MTYPE_PIM_UPSTREAM, sizeof(*up));
685
686 up->sg = *sg;
687 pim_str_sg_set(sg, up->sg_str);
688 if (ch)
689 ch->upstream = up;
690
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
694 */
695 if (!pim_rp_set_upstream_addr(pim, &up->upstream_addr, sg->src,
696 sg->grp)) {
697 if (PIM_DEBUG_TRACE)
698 zlog_debug("%s: Received a (*,G) with no RP configured",
699 __PRETTY_FUNCTION__);
700 }
701
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;
706 } else
707 up->sources = NULL;
708
709 pim_upstream_find_new_children(pim, up);
710 up->flags = flags;
711 up->ref_count = 1;
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 =
720 pim_channel_oil_add(pim, &up->sg, MAXVIFS, __PRETTY_FUNCTION__);
721 up->sptbit = PIM_UPSTREAM_SPTBIT_FALSE;
722
723 up->rpf.source_nexthop.interface = NULL;
724 up->rpf.source_nexthop.mrib_nexthop_addr.family = AF_INET;
725 up->rpf.source_nexthop.mrib_nexthop_addr.u.prefix4.s_addr =
726 PIM_NET_INADDR_ANY;
727 up->rpf.source_nexthop.mrib_metric_preference =
728 router->infinite_assert_metric.metric_preference;
729 up->rpf.source_nexthop.mrib_route_metric =
730 router->infinite_assert_metric.route_metric;
731 up->rpf.rpf_addr.family = AF_INET;
732 up->rpf.rpf_addr.u.prefix4.s_addr = PIM_NET_INADDR_ANY;
733
734 up->ifchannels = list_new();
735 up->ifchannels->cmp = (int (*)(void *, void *))pim_ifchannel_compare;
736
737 if (up->sg.src.s_addr != INADDR_ANY)
738 wheel_add_item(pim->upstream_sg_wheel, up);
739
740 if (PIM_UPSTREAM_FLAG_TEST_STATIC_IIF(up->flags)
741 || PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up->flags)) {
742 pim_upstream_fill_static_iif(up, incoming);
743 pim_ifp = up->rpf.source_nexthop.interface->info;
744 assert(pim_ifp);
745 pim_channel_oil_change_iif(pim, up->channel_oil,
746 pim_ifp->mroute_vif_index,
747 __PRETTY_FUNCTION__);
748
749 if (PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up->flags))
750 pim_upstream_keep_alive_timer_start(
751 up, pim->keep_alive_time);
752 } else if (up->upstream_addr.s_addr != INADDR_ANY) {
753 rpf_result = pim_rpf_update(pim, up, NULL);
754 if (rpf_result == PIM_RPF_FAILURE) {
755 if (PIM_DEBUG_TRACE)
756 zlog_debug(
757 "%s: Attempting to create upstream(%s), Unable to RPF for source",
758 __PRETTY_FUNCTION__, up->sg_str);
759 }
760
761 if (up->rpf.source_nexthop.interface) {
762 pim_ifp = up->rpf.source_nexthop.interface->info;
763 if (pim_ifp)
764 pim_channel_oil_change_iif(
765 pim, up->channel_oil,
766 pim_ifp->mroute_vif_index,
767 __PRETTY_FUNCTION__);
768 }
769 }
770
771 listnode_add_sort(pim->upstream_list, up);
772
773 if (PIM_DEBUG_TRACE) {
774 zlog_debug(
775 "%s: Created Upstream %s upstream_addr %s ref count %d increment",
776 __PRETTY_FUNCTION__, up->sg_str,
777 inet_ntoa(up->upstream_addr), up->ref_count);
778 }
779
780 return up;
781 }
782
783 struct pim_upstream *pim_upstream_find(struct pim_instance *pim,
784 struct prefix_sg *sg)
785 {
786 struct pim_upstream lookup;
787 struct pim_upstream *up = NULL;
788
789 lookup.sg = *sg;
790 up = hash_lookup(pim->upstream_hash, &lookup);
791 return up;
792 }
793
794 struct pim_upstream *pim_upstream_find_or_add(struct prefix_sg *sg,
795 struct interface *incoming,
796 int flags, const char *name)
797 {
798 struct pim_upstream *up;
799 struct pim_interface *pim_ifp;
800
801 pim_ifp = incoming->info;
802
803 up = pim_upstream_find(pim_ifp->pim, sg);
804
805 if (up) {
806 if (!(up->flags & flags)) {
807 up->flags |= flags;
808 up->ref_count++;
809 if (PIM_DEBUG_TRACE)
810 zlog_debug(
811 "%s(%s): upstream %s ref count %d increment",
812 __PRETTY_FUNCTION__, name, up->sg_str,
813 up->ref_count);
814 }
815 } else
816 up = pim_upstream_add(pim_ifp->pim, sg, incoming, flags, name,
817 NULL);
818
819 return up;
820 }
821
822 void pim_upstream_ref(struct pim_upstream *up, int flags, const char *name)
823 {
824 up->flags |= flags;
825 ++up->ref_count;
826 if (PIM_DEBUG_TRACE)
827 zlog_debug("%s(%s): upstream %s ref count %d increment",
828 __PRETTY_FUNCTION__, name, up->sg_str,
829 up->ref_count);
830 }
831
832 struct pim_upstream *pim_upstream_add(struct pim_instance *pim,
833 struct prefix_sg *sg,
834 struct interface *incoming, int flags,
835 const char *name,
836 struct pim_ifchannel *ch)
837 {
838 struct pim_upstream *up = NULL;
839 int found = 0;
840
841 up = pim_upstream_find(pim, sg);
842 if (up) {
843 pim_upstream_ref(up, flags, name);
844 found = 1;
845 } else {
846 up = pim_upstream_new(pim, sg, incoming, flags, ch);
847 }
848
849 if (PIM_DEBUG_TRACE) {
850 if (up) {
851 char buf[PREFIX2STR_BUFFER];
852 prefix2str(&up->rpf.rpf_addr, buf, sizeof(buf));
853 zlog_debug("%s(%s): %s, iif %s (%s) found: %d: ref_count: %d",
854 __PRETTY_FUNCTION__, name,
855 up->sg_str, buf, up->rpf.source_nexthop.interface ?
856 up->rpf.source_nexthop.interface->name : "Unknown" ,
857 found, up->ref_count);
858 } else
859 zlog_debug("%s(%s): (%s) failure to create",
860 __PRETTY_FUNCTION__, name,
861 pim_str_sg_dump(sg));
862 }
863
864 return up;
865 }
866
867 /*
868 * Passed in up must be the upstream for ch. starch is NULL if no
869 * information
870 */
871 int pim_upstream_evaluate_join_desired_interface(struct pim_upstream *up,
872 struct pim_ifchannel *ch,
873 struct pim_ifchannel *starch)
874 {
875 if (ch) {
876 if (PIM_IF_FLAG_TEST_S_G_RPT(ch->flags))
877 return 0;
878
879 if (!pim_macro_ch_lost_assert(ch)
880 && pim_macro_chisin_joins_or_include(ch))
881 return 1;
882 }
883
884 /*
885 * joins (*,G)
886 */
887 if (starch) {
888 if (PIM_IF_FLAG_TEST_S_G_RPT(starch->upstream->flags))
889 return 0;
890
891 if (!pim_macro_ch_lost_assert(starch)
892 && pim_macro_chisin_joins_or_include(starch))
893 return 1;
894 }
895
896 return 0;
897 }
898
899 /*
900 Evaluate JoinDesired(S,G):
901
902 JoinDesired(S,G) is true if there is a downstream (S,G) interface I
903 in the set:
904
905 inherited_olist(S,G) =
906 joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
907
908 JoinDesired(S,G) may be affected by changes in the following:
909
910 pim_ifp->primary_address
911 pim_ifp->pim_dr_addr
912 ch->ifassert_winner_metric
913 ch->ifassert_winner
914 ch->local_ifmembership
915 ch->ifjoin_state
916 ch->upstream->rpf.source_nexthop.mrib_metric_preference
917 ch->upstream->rpf.source_nexthop.mrib_route_metric
918 ch->upstream->rpf.source_nexthop.interface
919
920 See also pim_upstream_update_join_desired() below.
921 */
922 int pim_upstream_evaluate_join_desired(struct pim_instance *pim,
923 struct pim_upstream *up)
924 {
925 struct interface *ifp;
926 struct pim_ifchannel *ch, *starch;
927 struct pim_upstream *starup = up->parent;
928 int ret = 0;
929
930 FOR_ALL_INTERFACES (pim->vrf, ifp) {
931 if (!ifp->info)
932 continue;
933
934 ch = pim_ifchannel_find(ifp, &up->sg);
935
936 if (starup)
937 starch = pim_ifchannel_find(ifp, &starup->sg);
938 else
939 starch = NULL;
940
941 if (!ch && !starch)
942 continue;
943
944 ret += pim_upstream_evaluate_join_desired_interface(up, ch,
945 starch);
946 } /* scan iface channel list */
947
948 return ret; /* false */
949 }
950
951 /*
952 See also pim_upstream_evaluate_join_desired() above.
953 */
954 void pim_upstream_update_join_desired(struct pim_instance *pim,
955 struct pim_upstream *up)
956 {
957 int was_join_desired; /* boolean */
958 int is_join_desired; /* boolean */
959
960 was_join_desired = PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up->flags);
961
962 is_join_desired = pim_upstream_evaluate_join_desired(pim, up);
963 if (is_join_desired)
964 PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(up->flags);
965 else
966 PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(up->flags);
967
968 /* switched from false to true */
969 if (is_join_desired && (up->join_state == PIM_UPSTREAM_NOTJOINED)) {
970 pim_upstream_switch(pim, up, PIM_UPSTREAM_JOINED);
971 return;
972 }
973
974 /* switched from true to false */
975 if (!is_join_desired && was_join_desired) {
976 pim_upstream_switch(pim, up, PIM_UPSTREAM_NOTJOINED);
977 return;
978 }
979 }
980
981 /*
982 RFC 4601 4.5.7. Sending (S,G) Join/Prune Messages
983 Transitions from Joined State
984 RPF'(S,G) GenID changes
985
986 The upstream (S,G) state machine remains in Joined state. If the
987 Join Timer is set to expire in more than t_override seconds, reset
988 it so that it expires after t_override seconds.
989 */
990 void pim_upstream_rpf_genid_changed(struct pim_instance *pim,
991 struct in_addr neigh_addr)
992 {
993 struct listnode *up_node;
994 struct listnode *up_nextnode;
995 struct pim_upstream *up;
996
997 /*
998 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
999 */
1000 for (ALL_LIST_ELEMENTS(pim->upstream_list, up_node, up_nextnode, up)) {
1001
1002 if (PIM_DEBUG_TRACE) {
1003 char neigh_str[INET_ADDRSTRLEN];
1004 char rpf_addr_str[PREFIX_STRLEN];
1005 pim_inet4_dump("<neigh?>", neigh_addr, neigh_str,
1006 sizeof(neigh_str));
1007 pim_addr_dump("<rpf?>", &up->rpf.rpf_addr, rpf_addr_str,
1008 sizeof(rpf_addr_str));
1009 zlog_debug(
1010 "%s: matching neigh=%s against upstream (S,G)=%s[%s] joined=%d rpf_addr=%s",
1011 __PRETTY_FUNCTION__, neigh_str, up->sg_str,
1012 pim->vrf->name,
1013 up->join_state == PIM_UPSTREAM_JOINED,
1014 rpf_addr_str);
1015 }
1016
1017 /* consider only (S,G) upstream in Joined state */
1018 if (up->join_state != PIM_UPSTREAM_JOINED)
1019 continue;
1020
1021 /* match RPF'(S,G)=neigh_addr */
1022 if (up->rpf.rpf_addr.u.prefix4.s_addr != neigh_addr.s_addr)
1023 continue;
1024
1025 pim_upstream_join_timer_decrease_to_t_override(
1026 "RPF'(S,G) GenID change", up);
1027 }
1028 }
1029
1030
1031 void pim_upstream_rpf_interface_changed(struct pim_upstream *up,
1032 struct interface *old_rpf_ifp)
1033 {
1034 struct listnode *chnode;
1035 struct listnode *chnextnode;
1036 struct pim_ifchannel *ch;
1037
1038 /* search all ifchannels */
1039 for (ALL_LIST_ELEMENTS(up->ifchannels, chnode, chnextnode, ch)) {
1040 if (ch->ifassert_state == PIM_IFASSERT_I_AM_LOSER) {
1041 if (
1042 /* RPF_interface(S) was NOT I */
1043 (old_rpf_ifp == ch->interface) &&
1044 /* RPF_interface(S) stopped being I */
1045 (ch->upstream->rpf.source_nexthop
1046 .interface) &&
1047 (ch->upstream->rpf.source_nexthop
1048 .interface != ch->interface)) {
1049 assert_action_a5(ch);
1050 }
1051 } /* PIM_IFASSERT_I_AM_LOSER */
1052
1053 pim_ifchannel_update_assert_tracking_desired(ch);
1054 }
1055 }
1056
1057 void pim_upstream_update_could_assert(struct pim_upstream *up)
1058 {
1059 struct listnode *chnode;
1060 struct listnode *chnextnode;
1061 struct pim_ifchannel *ch;
1062
1063 /* scan per-interface (S,G) state */
1064 for (ALL_LIST_ELEMENTS(up->ifchannels, chnode, chnextnode, ch)) {
1065 pim_ifchannel_update_could_assert(ch);
1066 } /* scan iface channel list */
1067 }
1068
1069 void pim_upstream_update_my_assert_metric(struct pim_upstream *up)
1070 {
1071 struct listnode *chnode;
1072 struct listnode *chnextnode;
1073 struct pim_ifchannel *ch;
1074
1075 /* scan per-interface (S,G) state */
1076 for (ALL_LIST_ELEMENTS(up->ifchannels, chnode, chnextnode, ch)) {
1077 pim_ifchannel_update_my_assert_metric(ch);
1078
1079 } /* scan iface channel list */
1080 }
1081
1082 static void pim_upstream_update_assert_tracking_desired(struct pim_upstream *up)
1083 {
1084 struct listnode *chnode;
1085 struct listnode *chnextnode;
1086 struct pim_interface *pim_ifp;
1087 struct pim_ifchannel *ch;
1088
1089 /* scan per-interface (S,G) state */
1090 for (ALL_LIST_ELEMENTS(up->ifchannels, chnode, chnextnode, ch)) {
1091 if (!ch->interface)
1092 continue;
1093 pim_ifp = ch->interface->info;
1094 if (!pim_ifp)
1095 continue;
1096
1097 pim_ifchannel_update_assert_tracking_desired(ch);
1098
1099 } /* scan iface channel list */
1100 }
1101
1102 /* When kat is stopped CouldRegister goes to false so we need to
1103 * transition the (S, G) on FHR to NI state and remove reg tunnel
1104 * from the OIL */
1105 static void pim_upstream_fhr_kat_expiry(struct pim_instance *pim,
1106 struct pim_upstream *up)
1107 {
1108 if (!PIM_UPSTREAM_FLAG_TEST_FHR(up->flags))
1109 return;
1110
1111 if (PIM_DEBUG_TRACE)
1112 zlog_debug("kat expired on %s; clear fhr reg state",
1113 up->sg_str);
1114
1115 /* stop reg-stop timer */
1116 THREAD_OFF(up->t_rs_timer);
1117 /* remove regiface from the OIL if it is there*/
1118 pim_channel_del_oif(up->channel_oil, pim->regiface,
1119 PIM_OIF_FLAG_PROTO_PIM);
1120 /* clear the register state */
1121 up->reg_state = PIM_REG_NOINFO;
1122 PIM_UPSTREAM_FLAG_UNSET_FHR(up->flags);
1123 }
1124
1125 /* When kat is started CouldRegister can go to true. And if it does we
1126 * need to transition the (S, G) on FHR to JOINED state and add reg tunnel
1127 * to the OIL */
1128 static void pim_upstream_fhr_kat_start(struct pim_upstream *up)
1129 {
1130 if (pim_upstream_could_register(up)) {
1131 if (PIM_DEBUG_TRACE)
1132 zlog_debug(
1133 "kat started on %s; set fhr reg state to joined",
1134 up->sg_str);
1135
1136 PIM_UPSTREAM_FLAG_SET_FHR(up->flags);
1137 if (up->reg_state == PIM_REG_NOINFO)
1138 pim_register_join(up);
1139 }
1140 }
1141
1142 /*
1143 * On an RP, the PMBR value must be cleared when the
1144 * Keepalive Timer expires
1145 * KAT expiry indicates that flow is inactive. If the flow was created or
1146 * maintained by activity now is the time to deref it.
1147 */
1148 struct pim_upstream *pim_upstream_keep_alive_timer_proc(
1149 struct pim_upstream *up)
1150 {
1151 struct pim_instance *pim;
1152
1153 pim = up->channel_oil->pim;
1154
1155 if (PIM_UPSTREAM_FLAG_TEST_DISABLE_KAT_EXPIRY(up->flags)) {
1156 /* if the router is a PIM vxlan encapsulator we prevent expiry
1157 * of KAT as the mroute is pre-setup without any traffic
1158 */
1159 pim_upstream_keep_alive_timer_start(up, pim->keep_alive_time);
1160 return up;
1161 }
1162
1163 if (I_am_RP(pim, up->sg.grp)) {
1164 pim_br_clear_pmbr(&up->sg);
1165 /*
1166 * We need to do more here :)
1167 * But this is the start.
1168 */
1169 }
1170
1171 /* source is no longer active - pull the SA from MSDP's cache */
1172 pim_msdp_sa_local_del(pim, &up->sg);
1173
1174 /* if entry was created because of activity we need to deref it */
1175 if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
1176 pim_upstream_fhr_kat_expiry(pim, up);
1177 if (PIM_DEBUG_TRACE)
1178 zlog_debug(
1179 "kat expired on %s[%s]; remove stream reference",
1180 up->sg_str, pim->vrf->name);
1181 PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(up->flags);
1182
1183 /* Return if upstream entry got deleted.*/
1184 if (!pim_upstream_del(pim, up, __PRETTY_FUNCTION__))
1185 return NULL;
1186 }
1187 if (PIM_UPSTREAM_FLAG_TEST_SRC_NOCACHE(up->flags)) {
1188 PIM_UPSTREAM_FLAG_UNSET_SRC_NOCACHE(up->flags);
1189
1190 if (!pim_upstream_del(pim, up, __PRETTY_FUNCTION__))
1191 return NULL;
1192 }
1193
1194 /* upstream reference would have been added to track the local
1195 * membership if it is LHR. We have to clear it when KAT expires.
1196 * Otherwise would result in stale entry with uncleared ref count.
1197 */
1198 if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up->flags)) {
1199 struct pim_upstream *parent = up->parent;
1200
1201 PIM_UPSTREAM_FLAG_UNSET_SRC_LHR(up->flags);
1202 up = pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
1203
1204 if (parent) {
1205 pim_jp_agg_single_upstream_send(&parent->rpf, parent,
1206 true);
1207 }
1208 }
1209
1210 return up;
1211 }
1212 static int pim_upstream_keep_alive_timer(struct thread *t)
1213 {
1214 struct pim_upstream *up;
1215
1216 up = THREAD_ARG(t);
1217
1218 pim_upstream_keep_alive_timer_proc(up);
1219 return 0;
1220 }
1221
1222 void pim_upstream_keep_alive_timer_start(struct pim_upstream *up, uint32_t time)
1223 {
1224 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
1225 if (PIM_DEBUG_TRACE)
1226 zlog_debug("kat start on %s with no stream reference",
1227 up->sg_str);
1228 }
1229 THREAD_OFF(up->t_ka_timer);
1230 thread_add_timer(router->master, pim_upstream_keep_alive_timer, up,
1231 time, &up->t_ka_timer);
1232
1233 /* any time keepalive is started against a SG we will have to
1234 * re-evaluate our active source database */
1235 pim_msdp_sa_local_update(up);
1236 }
1237
1238 /* MSDP on RP needs to know if a source is registerable to this RP */
1239 static int pim_upstream_msdp_reg_timer(struct thread *t)
1240 {
1241 struct pim_upstream *up = THREAD_ARG(t);
1242 struct pim_instance *pim = up->channel_oil->pim;
1243
1244 /* source is no longer active - pull the SA from MSDP's cache */
1245 pim_msdp_sa_local_del(pim, &up->sg);
1246 return 1;
1247 }
1248 void pim_upstream_msdp_reg_timer_start(struct pim_upstream *up)
1249 {
1250 THREAD_OFF(up->t_msdp_reg_timer);
1251 thread_add_timer(router->master, pim_upstream_msdp_reg_timer, up,
1252 PIM_MSDP_REG_RXED_PERIOD, &up->t_msdp_reg_timer);
1253
1254 pim_msdp_sa_local_update(up);
1255 }
1256
1257 /*
1258 * 4.2.1 Last-Hop Switchover to the SPT
1259 *
1260 * In Sparse-Mode PIM, last-hop routers join the shared tree towards the
1261 * RP. Once traffic from sources to joined groups arrives at a last-hop
1262 * router, it has the option of switching to receive the traffic on a
1263 * shortest path tree (SPT).
1264 *
1265 * The decision for a router to switch to the SPT is controlled as
1266 * follows:
1267 *
1268 * void
1269 * CheckSwitchToSpt(S,G) {
1270 * if ( ( pim_include(*,G) (-) pim_exclude(S,G)
1271 * (+) pim_include(S,G) != NULL )
1272 * AND SwitchToSptDesired(S,G) ) {
1273 * # Note: Restarting the KAT will result in the SPT switch
1274 * set KeepaliveTimer(S,G) to Keepalive_Period
1275 * }
1276 * }
1277 *
1278 * SwitchToSptDesired(S,G) is a policy function that is implementation
1279 * defined. An "infinite threshold" policy can be implemented by making
1280 * SwitchToSptDesired(S,G) return false all the time. A "switch on
1281 * first packet" policy can be implemented by making
1282 * SwitchToSptDesired(S,G) return true once a single packet has been
1283 * received for the source and group.
1284 */
1285 int pim_upstream_switch_to_spt_desired(struct pim_instance *pim,
1286 struct prefix_sg *sg)
1287 {
1288 if (I_am_RP(pim, sg->grp))
1289 return 1;
1290
1291 return 0;
1292 }
1293
1294 int pim_upstream_is_sg_rpt(struct pim_upstream *up)
1295 {
1296 struct listnode *chnode;
1297 struct pim_ifchannel *ch;
1298
1299 for (ALL_LIST_ELEMENTS_RO(up->ifchannels, chnode, ch)) {
1300 if (PIM_IF_FLAG_TEST_S_G_RPT(ch->flags))
1301 return 1;
1302 }
1303
1304 return 0;
1305 }
1306 /*
1307 * After receiving a packet set SPTbit:
1308 * void
1309 * Update_SPTbit(S,G,iif) {
1310 * if ( iif == RPF_interface(S)
1311 * AND JoinDesired(S,G) == true
1312 * AND ( DirectlyConnected(S) == true
1313 * OR RPF_interface(S) != RPF_interface(RP(G))
1314 * OR inherited_olist(S,G,rpt) == NULL
1315 * OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1316 * ( RPF'(S,G) != NULL ) )
1317 * OR ( I_Am_Assert_Loser(S,G,iif) ) {
1318 * Set SPTbit(S,G) to true
1319 * }
1320 * }
1321 */
1322 void pim_upstream_set_sptbit(struct pim_upstream *up,
1323 struct interface *incoming)
1324 {
1325 struct pim_upstream *starup = up->parent;
1326
1327 // iif == RPF_interfvace(S)
1328 if (up->rpf.source_nexthop.interface != incoming) {
1329 if (PIM_DEBUG_TRACE)
1330 zlog_debug(
1331 "%s: Incoming Interface: %s is different than RPF_interface(S) %s",
1332 __PRETTY_FUNCTION__, incoming->name,
1333 up->rpf.source_nexthop.interface->name);
1334 return;
1335 }
1336
1337 // AND JoinDesired(S,G) == true
1338 if (!pim_upstream_evaluate_join_desired(up->channel_oil->pim, up)) {
1339 if (PIM_DEBUG_TRACE)
1340 zlog_debug("%s: %s Join is not Desired",
1341 __PRETTY_FUNCTION__, up->sg_str);
1342 return;
1343 }
1344
1345 // DirectlyConnected(S) == true
1346 if (pim_if_connected_to_source(up->rpf.source_nexthop.interface,
1347 up->sg.src)) {
1348 if (PIM_DEBUG_TRACE)
1349 zlog_debug("%s: %s is directly connected to the source",
1350 __PRETTY_FUNCTION__, up->sg_str);
1351 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
1352 return;
1353 }
1354
1355 // OR RPF_interface(S) != RPF_interface(RP(G))
1356 if (!starup
1357 || up->rpf.source_nexthop
1358 .interface != starup->rpf.source_nexthop.interface) {
1359 struct pim_upstream *starup = up->parent;
1360
1361 if (PIM_DEBUG_TRACE)
1362 zlog_debug(
1363 "%s: %s RPF_interface(S) != RPF_interface(RP(G))",
1364 __PRETTY_FUNCTION__, up->sg_str);
1365 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
1366
1367 pim_jp_agg_single_upstream_send(&starup->rpf, starup, true);
1368 return;
1369 }
1370
1371 // OR inherited_olist(S,G,rpt) == NULL
1372 if (pim_upstream_is_sg_rpt(up)
1373 && pim_upstream_empty_inherited_olist(up)) {
1374 if (PIM_DEBUG_TRACE)
1375 zlog_debug("%s: %s OR inherited_olist(S,G,rpt) == NULL",
1376 __PRETTY_FUNCTION__, up->sg_str);
1377 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
1378 return;
1379 }
1380
1381 // OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
1382 // ( RPF'(S,G) != NULL ) )
1383 if (up->parent && pim_rpf_is_same(&up->rpf, &up->parent->rpf)) {
1384 if (PIM_DEBUG_TRACE)
1385 zlog_debug("%s: %s RPF'(S,G) is the same as RPF'(*,G)",
1386 __PRETTY_FUNCTION__, up->sg_str);
1387 up->sptbit = PIM_UPSTREAM_SPTBIT_TRUE;
1388 return;
1389 }
1390
1391 return;
1392 }
1393
1394 const char *pim_upstream_state2str(enum pim_upstream_state join_state)
1395 {
1396 switch (join_state) {
1397 case PIM_UPSTREAM_NOTJOINED:
1398 return "NotJoined";
1399 break;
1400 case PIM_UPSTREAM_JOINED:
1401 return "Joined";
1402 break;
1403 }
1404 return "Unknown";
1405 }
1406
1407 const char *pim_reg_state2str(enum pim_reg_state reg_state, char *state_str,
1408 size_t state_str_len)
1409 {
1410 switch (reg_state) {
1411 case PIM_REG_NOINFO:
1412 strlcpy(state_str, "RegNoInfo", state_str_len);
1413 break;
1414 case PIM_REG_JOIN:
1415 strlcpy(state_str, "RegJoined", state_str_len);
1416 break;
1417 case PIM_REG_JOIN_PENDING:
1418 strlcpy(state_str, "RegJoinPend", state_str_len);
1419 break;
1420 case PIM_REG_PRUNE:
1421 strlcpy(state_str, "RegPrune", state_str_len);
1422 break;
1423 default:
1424 strlcpy(state_str, "RegUnknown", state_str_len);
1425 }
1426 return state_str;
1427 }
1428
1429 static int pim_upstream_register_stop_timer(struct thread *t)
1430 {
1431 struct pim_interface *pim_ifp;
1432 struct pim_instance *pim;
1433 struct pim_upstream *up;
1434 up = THREAD_ARG(t);
1435 pim = up->channel_oil->pim;
1436
1437 if (PIM_DEBUG_TRACE) {
1438 char state_str[PIM_REG_STATE_STR_LEN];
1439 zlog_debug("%s: (S,G)=%s[%s] upstream register stop timer %s",
1440 __PRETTY_FUNCTION__, up->sg_str, pim->vrf->name,
1441 pim_reg_state2str(up->reg_state, state_str, sizeof(state_str)));
1442 }
1443
1444 switch (up->reg_state) {
1445 case PIM_REG_JOIN_PENDING:
1446 up->reg_state = PIM_REG_JOIN;
1447 pim_channel_add_oif(up->channel_oil, pim->regiface,
1448 PIM_OIF_FLAG_PROTO_PIM);
1449 pim_vxlan_update_sg_reg_state(pim, up, true /*reg_join*/);
1450 break;
1451 case PIM_REG_JOIN:
1452 break;
1453 case PIM_REG_PRUNE:
1454 if (!up->rpf.source_nexthop.interface) {
1455 if (PIM_DEBUG_TRACE)
1456 zlog_debug("%s: up %s RPF is not present",
1457 __PRETTY_FUNCTION__, up->sg_str);
1458 return 0;
1459 }
1460
1461 pim_ifp = up->rpf.source_nexthop.interface->info;
1462 if (!pim_ifp) {
1463 if (PIM_DEBUG_TRACE)
1464 zlog_debug(
1465 "%s: Interface: %s is not configured for pim",
1466 __PRETTY_FUNCTION__,
1467 up->rpf.source_nexthop.interface->name);
1468 return 0;
1469 }
1470 up->reg_state = PIM_REG_JOIN_PENDING;
1471 pim_upstream_start_register_stop_timer(up, 1);
1472
1473 if (((up->channel_oil->cc.lastused / 100)
1474 > pim->keep_alive_time)
1475 && (I_am_RP(pim_ifp->pim, up->sg.grp))) {
1476 if (PIM_DEBUG_TRACE)
1477 zlog_debug(
1478 "%s: Stop sending the register, because I am the RP and we haven't seen a packet in a while",
1479 __PRETTY_FUNCTION__);
1480 return 0;
1481 }
1482 pim_null_register_send(up);
1483 break;
1484 default:
1485 break;
1486 }
1487
1488 return 0;
1489 }
1490
1491 void pim_upstream_start_register_stop_timer(struct pim_upstream *up,
1492 int null_register)
1493 {
1494 uint32_t time;
1495
1496 THREAD_TIMER_OFF(up->t_rs_timer);
1497
1498 if (!null_register) {
1499 uint32_t lower = (0.5 * PIM_REGISTER_SUPPRESSION_PERIOD);
1500 uint32_t upper = (1.5 * PIM_REGISTER_SUPPRESSION_PERIOD);
1501 time = lower + (random() % (upper - lower + 1))
1502 - PIM_REGISTER_PROBE_PERIOD;
1503 } else
1504 time = PIM_REGISTER_PROBE_PERIOD;
1505
1506 if (PIM_DEBUG_TRACE) {
1507 zlog_debug(
1508 "%s: (S,G)=%s Starting upstream register stop timer %d",
1509 __PRETTY_FUNCTION__, up->sg_str, time);
1510 }
1511 thread_add_timer(router->master, pim_upstream_register_stop_timer, up,
1512 time, &up->t_rs_timer);
1513 }
1514
1515 int pim_upstream_inherited_olist_decide(struct pim_instance *pim,
1516 struct pim_upstream *up)
1517 {
1518 struct interface *ifp;
1519 struct pim_ifchannel *ch, *starch;
1520 struct pim_upstream *starup = up->parent;
1521 int output_intf = 0;
1522
1523 if (!up->rpf.source_nexthop.interface)
1524 if (PIM_DEBUG_TRACE)
1525 zlog_debug("%s: up %s RPF is not present",
1526 __PRETTY_FUNCTION__, up->sg_str);
1527
1528 FOR_ALL_INTERFACES (pim->vrf, ifp) {
1529 if (!ifp->info)
1530 continue;
1531
1532 ch = pim_ifchannel_find(ifp, &up->sg);
1533
1534 if (starup)
1535 starch = pim_ifchannel_find(ifp, &starup->sg);
1536 else
1537 starch = NULL;
1538
1539 if (!ch && !starch)
1540 continue;
1541
1542 if (pim_upstream_evaluate_join_desired_interface(up, ch,
1543 starch)) {
1544 int flag = PIM_OIF_FLAG_PROTO_PIM;
1545
1546 if (!ch)
1547 flag = PIM_OIF_FLAG_PROTO_STAR;
1548
1549 pim_channel_add_oif(up->channel_oil, ifp, flag);
1550 output_intf++;
1551 }
1552 }
1553
1554 return output_intf;
1555 }
1556
1557 /*
1558 * For a given upstream, determine the inherited_olist
1559 * and apply it.
1560 *
1561 * inherited_olist(S,G,rpt) =
1562 * ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
1563 * (+) ( pim_include(*,G) (-) pim_exclude(S,G))
1564 * (-) ( lost_assert(*,G) (+) lost_assert(S,G,rpt) )
1565 *
1566 * inherited_olist(S,G) =
1567 * inherited_olist(S,G,rpt) (+)
1568 * joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)
1569 *
1570 * return 1 if there are any output interfaces
1571 * return 0 if there are not any output interfaces
1572 */
1573 int pim_upstream_inherited_olist(struct pim_instance *pim,
1574 struct pim_upstream *up)
1575 {
1576 int output_intf = pim_upstream_inherited_olist_decide(pim, up);
1577
1578 /*
1579 * If we have output_intf switch state to Join and work like normal
1580 * If we don't have an output_intf that means we are probably a
1581 * switch on a stick so turn on forwarding to just accept the
1582 * incoming packets so we don't bother the other stuff!
1583 */
1584 if (output_intf)
1585 pim_upstream_switch(pim, up, PIM_UPSTREAM_JOINED);
1586 else
1587 forward_on(up);
1588
1589 return output_intf;
1590 }
1591
1592 int pim_upstream_empty_inherited_olist(struct pim_upstream *up)
1593 {
1594 return pim_channel_oil_empty(up->channel_oil);
1595 }
1596
1597 /*
1598 * When we have a new neighbor,
1599 * find upstreams that don't have their rpf_addr
1600 * set and see if the new neighbor allows
1601 * the join to be sent
1602 */
1603 void pim_upstream_find_new_rpf(struct pim_instance *pim)
1604 {
1605 struct listnode *up_node;
1606 struct listnode *up_nextnode;
1607 struct pim_upstream *up;
1608
1609 /*
1610 * Scan all (S,G) upstreams searching for RPF'(S,G)=neigh_addr
1611 */
1612 for (ALL_LIST_ELEMENTS(pim->upstream_list, up_node, up_nextnode, up)) {
1613 if (up->upstream_addr.s_addr == INADDR_ANY) {
1614 if (PIM_DEBUG_TRACE)
1615 zlog_debug(
1616 "%s: RP not configured for Upstream %s",
1617 __PRETTY_FUNCTION__, up->sg_str);
1618 continue;
1619 }
1620
1621 if (pim_rpf_addr_is_inaddr_any(&up->rpf)) {
1622 if (PIM_DEBUG_TRACE)
1623 zlog_debug(
1624 "%s: Upstream %s without a path to send join, checking",
1625 __PRETTY_FUNCTION__, up->sg_str);
1626 pim_rpf_update(pim, up, NULL);
1627 }
1628 }
1629 }
1630
1631 unsigned int pim_upstream_hash_key(const void *arg)
1632 {
1633 const struct pim_upstream *up = arg;
1634
1635 return jhash_2words(up->sg.src.s_addr, up->sg.grp.s_addr, 0);
1636 }
1637
1638 void pim_upstream_terminate(struct pim_instance *pim)
1639 {
1640 struct pim_upstream *up;
1641
1642 if (pim->upstream_list) {
1643 while (pim->upstream_list->count) {
1644 up = listnode_head(pim->upstream_list);
1645 pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
1646 }
1647
1648 list_delete(&pim->upstream_list);
1649 }
1650
1651 if (pim->upstream_hash)
1652 hash_free(pim->upstream_hash);
1653 pim->upstream_hash = NULL;
1654
1655 if (pim->upstream_sg_wheel)
1656 wheel_delete(pim->upstream_sg_wheel);
1657 pim->upstream_sg_wheel = NULL;
1658 }
1659
1660 bool pim_upstream_equal(const void *arg1, const void *arg2)
1661 {
1662 const struct pim_upstream *up1 = (const struct pim_upstream *)arg1;
1663 const struct pim_upstream *up2 = (const struct pim_upstream *)arg2;
1664
1665 if ((up1->sg.grp.s_addr == up2->sg.grp.s_addr)
1666 && (up1->sg.src.s_addr == up2->sg.src.s_addr))
1667 return true;
1668
1669 return false;
1670 }
1671
1672 /* rfc4601:section-4.2:"Data Packet Forwarding Rules" defines
1673 * the cases where kat has to be restarted on rxing traffic -
1674 *
1675 * if( DirectlyConnected(S) == true AND iif == RPF_interface(S) ) {
1676 * set KeepaliveTimer(S,G) to Keepalive_Period
1677 * # Note: a register state transition or UpstreamJPState(S,G)
1678 * # transition may happen as a result of restarting
1679 * # KeepaliveTimer, and must be dealt with here.
1680 * }
1681 * if( iif == RPF_interface(S) AND UpstreamJPState(S,G) == Joined AND
1682 * inherited_olist(S,G) != NULL ) {
1683 * set KeepaliveTimer(S,G) to Keepalive_Period
1684 * }
1685 */
1686 static bool pim_upstream_kat_start_ok(struct pim_upstream *up)
1687 {
1688 struct pim_instance *pim = up->channel_oil->pim;
1689
1690 /* "iif == RPF_interface(S)" check has to be done by the kernel or hw
1691 * so we will skip that here */
1692 if (up->rpf.source_nexthop.interface &&
1693 pim_if_connected_to_source(up->rpf.source_nexthop.interface,
1694 up->sg.src)) {
1695 return true;
1696 }
1697
1698 if ((up->join_state == PIM_UPSTREAM_JOINED)
1699 && !pim_upstream_empty_inherited_olist(up)) {
1700 /* XXX: I have added this RP check just for 3.2 and it's a
1701 * digression from
1702 * what rfc-4601 says. Till now we were only running KAT on FHR
1703 * and RP and
1704 * there is some angst around making the change to run it all
1705 * routers that
1706 * maintain the (S, G) state. This is tracked via CM-13601 and
1707 * MUST be
1708 * removed to handle spt turn-arounds correctly in a 3-tier clos
1709 */
1710 if (I_am_RP(pim, up->sg.grp))
1711 return true;
1712 }
1713
1714 return false;
1715 }
1716
1717 /*
1718 * Code to check and see if we've received packets on a S,G mroute
1719 * and if so to set the SPT bit appropriately
1720 */
1721 static void pim_upstream_sg_running(void *arg)
1722 {
1723 struct pim_upstream *up = (struct pim_upstream *)arg;
1724 struct pim_instance *pim = up->channel_oil->pim;
1725
1726 // No packet can have arrived here if this is the case
1727 if (!up->channel_oil->installed) {
1728 if (PIM_DEBUG_TRACE)
1729 zlog_debug("%s: %s%s is not installed in mroute",
1730 __PRETTY_FUNCTION__, up->sg_str,
1731 pim->vrf->name);
1732 return;
1733 }
1734
1735 /*
1736 * This is a bit of a hack
1737 * We've noted that we should rescan but
1738 * we've missed the window for doing so in
1739 * pim_zebra.c for some reason. I am
1740 * only doing this at this point in time
1741 * to get us up and working for the moment
1742 */
1743 if (up->channel_oil->oil_inherited_rescan) {
1744 if (PIM_DEBUG_TRACE)
1745 zlog_debug(
1746 "%s: Handling unscanned inherited_olist for %s[%s]",
1747 __PRETTY_FUNCTION__, up->sg_str,
1748 pim->vrf->name);
1749 pim_upstream_inherited_olist_decide(pim, up);
1750 up->channel_oil->oil_inherited_rescan = 0;
1751 }
1752 pim_mroute_update_counters(up->channel_oil);
1753
1754 // Have we seen packets?
1755 if ((up->channel_oil->cc.oldpktcnt >= up->channel_oil->cc.pktcnt)
1756 && (up->channel_oil->cc.lastused / 100 > 30)) {
1757 if (PIM_DEBUG_TRACE) {
1758 zlog_debug(
1759 "%s[%s]: %s old packet count is equal or lastused is greater than 30, (%ld,%ld,%lld)",
1760 __PRETTY_FUNCTION__, up->sg_str, pim->vrf->name,
1761 up->channel_oil->cc.oldpktcnt,
1762 up->channel_oil->cc.pktcnt,
1763 up->channel_oil->cc.lastused / 100);
1764 }
1765 return;
1766 }
1767
1768 if (pim_upstream_kat_start_ok(up)) {
1769 /* Add a source reference to the stream if
1770 * one doesn't already exist */
1771 if (!PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
1772 if (PIM_DEBUG_TRACE)
1773 zlog_debug(
1774 "source reference created on kat restart %s[%s]",
1775 up->sg_str, pim->vrf->name);
1776
1777 pim_upstream_ref(up, PIM_UPSTREAM_FLAG_MASK_SRC_STREAM,
1778 __PRETTY_FUNCTION__);
1779 PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
1780 pim_upstream_fhr_kat_start(up);
1781 }
1782 pim_upstream_keep_alive_timer_start(up, pim->keep_alive_time);
1783 } else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up->flags))
1784 pim_upstream_keep_alive_timer_start(up, pim->keep_alive_time);
1785
1786 if ((up->sptbit != PIM_UPSTREAM_SPTBIT_TRUE) &&
1787 (up->rpf.source_nexthop.interface)) {
1788 pim_upstream_set_sptbit(up, up->rpf.source_nexthop.interface);
1789 }
1790 return;
1791 }
1792
1793 void pim_upstream_add_lhr_star_pimreg(struct pim_instance *pim)
1794 {
1795 struct pim_upstream *up;
1796 struct listnode *node;
1797
1798 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, node, up)) {
1799 if (up->sg.src.s_addr != INADDR_ANY)
1800 continue;
1801
1802 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up->flags))
1803 continue;
1804
1805 pim_channel_add_oif(up->channel_oil, pim->regiface,
1806 PIM_OIF_FLAG_PROTO_IGMP);
1807 }
1808 }
1809
1810 void pim_upstream_spt_prefix_list_update(struct pim_instance *pim,
1811 struct prefix_list *pl)
1812 {
1813 const char *pname = prefix_list_name(pl);
1814
1815 if (pim->spt.plist && strcmp(pim->spt.plist, pname) == 0) {
1816 pim_upstream_remove_lhr_star_pimreg(pim, pname);
1817 }
1818 }
1819
1820 /*
1821 * nlist -> The new prefix list
1822 *
1823 * Per Group Application of pimreg to the OIL
1824 * If the prefix list tells us DENY then
1825 * we need to Switchover to SPT immediate
1826 * so add the pimreg.
1827 * If the prefix list tells us to ACCEPT than
1828 * we need to Never do the SPT so remove
1829 * the interface
1830 *
1831 */
1832 void pim_upstream_remove_lhr_star_pimreg(struct pim_instance *pim,
1833 const char *nlist)
1834 {
1835 struct pim_upstream *up;
1836 struct listnode *node;
1837 struct prefix_list *np;
1838 struct prefix g;
1839 enum prefix_list_type apply_new;
1840
1841 np = prefix_list_lookup(AFI_IP, nlist);
1842
1843 g.family = AF_INET;
1844 g.prefixlen = IPV4_MAX_PREFIXLEN;
1845
1846 for (ALL_LIST_ELEMENTS_RO(pim->upstream_list, node, up)) {
1847 if (up->sg.src.s_addr != INADDR_ANY)
1848 continue;
1849
1850 if (!PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(up->flags))
1851 continue;
1852
1853 if (!nlist) {
1854 pim_channel_del_oif(up->channel_oil, pim->regiface,
1855 PIM_OIF_FLAG_PROTO_IGMP);
1856 continue;
1857 }
1858 g.u.prefix4 = up->sg.grp;
1859 apply_new = prefix_list_apply(np, &g);
1860 if (apply_new == PREFIX_DENY)
1861 pim_channel_add_oif(up->channel_oil, pim->regiface,
1862 PIM_OIF_FLAG_PROTO_IGMP);
1863 else
1864 pim_channel_del_oif(up->channel_oil, pim->regiface,
1865 PIM_OIF_FLAG_PROTO_IGMP);
1866 }
1867 }
1868
1869 void pim_upstream_init(struct pim_instance *pim)
1870 {
1871 char name[64];
1872
1873 snprintf(name, 64, "PIM %s Timer Wheel",
1874 pim->vrf->name);
1875 pim->upstream_sg_wheel =
1876 wheel_init(router->master, 31000, 100, pim_upstream_hash_key,
1877 pim_upstream_sg_running, name);
1878
1879 snprintf(name, 64, "PIM %s Upstream Hash",
1880 pim->vrf->name);
1881 pim->upstream_hash = hash_create_size(8192, pim_upstream_hash_key,
1882 pim_upstream_equal, name);
1883
1884 pim->upstream_list = list_new();
1885 pim->upstream_list->cmp = pim_upstream_compare;
1886 }
FRRouting mirror