2 * bgp_updgrp_adv.c: BGP update group advertisement and adjacency
6 * @copyright Copyright (C) 2014 Cumulus Networks, Inc.
8 * @author Avneesh Sachdev <avneesh@sproute.net>
9 * @author Rajesh Varadarajan <rajesh@sproute.net>
10 * @author Pradosh Mohapatra <pradosh@sproute.net>
12 * This file is part of GNU Zebra.
14 * GNU Zebra is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2, or (at your option) any
19 * GNU Zebra is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
24 * You should have received a copy of the GNU General Public License along
25 * with this program; see the file COPYING; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
40 #include "bgpd/bgpd.h"
41 #include "bgpd/bgp_table.h"
42 #include "bgpd/bgp_debug.h"
43 #include "bgpd/bgp_route.h"
44 #include "bgpd/bgp_advertise.h"
45 #include "bgpd/bgp_attr.h"
46 #include "bgpd/bgp_aspath.h"
47 #include "bgpd/bgp_packet.h"
48 #include "bgpd/bgp_fsm.h"
49 #include "bgpd/bgp_mplsvpn.h"
50 #include "bgpd/bgp_updgrp.h"
51 #include "bgpd/bgp_advertise.h"
52 #include "bgpd/bgp_addpath.h"
58 static int bgp_adj_out_compare(const struct bgp_adj_out
*o1
,
59 const struct bgp_adj_out
*o2
)
61 if (o1
->subgroup
< o2
->subgroup
)
64 if (o1
->subgroup
> o2
->subgroup
)
69 RB_GENERATE(bgp_adj_out_rb
, bgp_adj_out
, adj_entry
, bgp_adj_out_compare
);
71 static inline struct bgp_adj_out
*adj_lookup(struct bgp_node
*rn
,
72 struct update_subgroup
*subgrp
,
73 uint32_t addpath_tx_id
)
75 struct bgp_adj_out
*adj
, lookup
;
84 peer
= SUBGRP_PEER(subgrp
);
85 afi
= SUBGRP_AFI(subgrp
);
86 safi
= SUBGRP_SAFI(subgrp
);
87 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
89 /* update-groups that do not support addpath will pass 0 for
90 * addpath_tx_id so do not both matching against it */
91 lookup
.subgroup
= subgrp
;
92 adj
= RB_FIND(bgp_adj_out_rb
, &rn
->adj_out
, &lookup
);
94 if (addpath_capable
) {
95 if (adj
->addpath_tx_id
== addpath_tx_id
)
103 static void adj_free(struct bgp_adj_out
*adj
)
105 TAILQ_REMOVE(&(adj
->subgroup
->adjq
), adj
, subgrp_adj_train
);
106 SUBGRP_DECR_STAT(adj
->subgroup
, adj_count
);
107 XFREE(MTYPE_BGP_ADJ_OUT
, adj
);
110 static void subgrp_withdraw_stale_addpath(struct updwalk_context
*ctx
,
111 struct update_subgroup
*subgrp
)
113 struct bgp_adj_out
*adj
, *adj_next
;
115 struct bgp_path_info
*pi
;
116 afi_t afi
= SUBGRP_AFI(subgrp
);
117 safi_t safi
= SUBGRP_SAFI(subgrp
);
118 struct peer
*peer
= SUBGRP_PEER(subgrp
);
120 /* Look through all of the paths we have advertised for this rn and send
121 * a withdraw for the ones that are no longer present */
122 RB_FOREACH_SAFE (adj
, bgp_adj_out_rb
, &ctx
->rn
->adj_out
, adj_next
) {
124 if (adj
->subgroup
== subgrp
) {
125 for (pi
= bgp_node_get_bgp_path_info(ctx
->rn
);
127 id
= bgp_addpath_id_for_peer(peer
, afi
, safi
,
130 if (id
== adj
->addpath_tx_id
) {
136 subgroup_process_announce_selected(
137 subgrp
, NULL
, ctx
->rn
,
144 static int group_announce_route_walkcb(struct update_group
*updgrp
, void *arg
)
146 struct updwalk_context
*ctx
= arg
;
147 struct update_subgroup
*subgrp
;
148 struct bgp_path_info
*pi
;
152 struct bgp_adj_out
*adj
, *adj_next
;
155 afi
= UPDGRP_AFI(updgrp
);
156 safi
= UPDGRP_SAFI(updgrp
);
157 peer
= UPDGRP_PEER(updgrp
);
158 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
160 if (BGP_DEBUG(update
, UPDATE_OUT
)) {
161 char buf_prefix
[PREFIX_STRLEN
];
162 prefix2str(&ctx
->rn
->p
, buf_prefix
, sizeof(buf_prefix
));
163 zlog_debug("%s: afi=%s, safi=%s, p=%s", __func__
, afi2str(afi
),
164 safi2str(safi
), buf_prefix
);
168 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
171 * Skip the subgroups that have coalesce timer running. We will
172 * walk the entire prefix table for those subgroups when the
173 * coalesce timer fires.
175 if (!subgrp
->t_coalesce
) {
176 /* An update-group that uses addpath */
177 if (addpath_capable
) {
178 subgrp_withdraw_stale_addpath(ctx
, subgrp
);
180 for (pi
= bgp_node_get_bgp_path_info(ctx
->rn
);
182 /* Skip the bestpath for now */
186 subgroup_process_announce_selected(
188 bgp_addpath_id_for_peer(
193 /* Process the bestpath last so the "show [ip]
194 * bgp neighbor x.x.x.x advertised"
195 * output shows the attributes from the bestpath
198 subgroup_process_announce_selected(
199 subgrp
, ctx
->pi
, ctx
->rn
,
200 bgp_addpath_id_for_peer(
202 &ctx
->pi
->tx_addpath
));
205 /* An update-group that does not use addpath */
208 subgroup_process_announce_selected(
209 subgrp
, ctx
->pi
, ctx
->rn
,
210 bgp_addpath_id_for_peer(
212 &ctx
->pi
->tx_addpath
));
214 /* Find the addpath_tx_id of the path we
217 RB_FOREACH_SAFE (adj
, bgp_adj_out_rb
,
220 if (adj
->subgroup
== subgrp
) {
221 subgroup_process_announce_selected(
232 return UPDWALK_CONTINUE
;
235 static void subgrp_show_adjq_vty(struct update_subgroup
*subgrp
,
236 struct vty
*vty
, uint8_t flags
)
238 struct bgp_table
*table
;
239 struct bgp_adj_out
*adj
;
240 unsigned long output_count
;
246 bgp
= SUBGRP_INST(subgrp
);
250 table
= bgp
->rib
[SUBGRP_AFI(subgrp
)][SUBGRP_SAFI(subgrp
)];
254 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
255 RB_FOREACH (adj
, bgp_adj_out_rb
, &rn
->adj_out
)
256 if (adj
->subgroup
== subgrp
) {
259 "BGP table version is %" PRIu64
260 ", local router ID is %s\n",
262 inet_ntoa(bgp
->router_id
));
263 vty_out(vty
, BGP_SHOW_SCODE_HEADER
);
264 vty_out(vty
, BGP_SHOW_OCODE_HEADER
);
268 vty_out(vty
, BGP_SHOW_HEADER
);
271 if ((flags
& UPDWALK_FLAGS_ADVQUEUE
) && adj
->adv
273 route_vty_out_tmp(vty
, &rn
->p
,
279 if ((flags
& UPDWALK_FLAGS_ADVERTISED
)
282 vty
, &rn
->p
, adj
->attr
,
283 SUBGRP_SAFI(subgrp
), 0, NULL
);
287 if (output_count
!= 0)
288 vty_out(vty
, "\nTotal number of prefixes %ld\n", output_count
);
291 static int updgrp_show_adj_walkcb(struct update_group
*updgrp
, void *arg
)
293 struct updwalk_context
*ctx
= arg
;
294 struct update_subgroup
*subgrp
;
298 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
299 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
301 vty_out(vty
, "update group %" PRIu64
", subgroup %" PRIu64
"\n",
302 updgrp
->id
, subgrp
->id
);
303 subgrp_show_adjq_vty(subgrp
, vty
, ctx
->flags
);
305 return UPDWALK_CONTINUE
;
308 static void updgrp_show_adj(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
309 struct vty
*vty
, uint64_t id
, uint8_t flags
)
311 struct updwalk_context ctx
;
312 memset(&ctx
, 0, sizeof(ctx
));
317 update_group_af_walk(bgp
, afi
, safi
, updgrp_show_adj_walkcb
, &ctx
);
320 static int subgroup_coalesce_timer(struct thread
*thread
)
322 struct update_subgroup
*subgrp
;
324 subgrp
= THREAD_ARG(thread
);
325 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
326 zlog_debug("u%" PRIu64
":s%" PRIu64
327 " announcing routes upon coalesce timer expiry(%u ms)",
328 (SUBGRP_UPDGRP(subgrp
))->id
, subgrp
->id
,
330 subgrp
->t_coalesce
= NULL
;
331 subgrp
->v_coalesce
= 0;
332 subgroup_announce_route(subgrp
);
335 /* While the announce_route() may kick off the route advertisement timer
337 * the members of the subgroup, we'd like to send the initial updates
339 * faster (i.e., without enforcing MRAI). Also, if there were no routes
341 * announce, this is the method currently employed to trigger the EOR.
343 if (!bgp_update_delay_active(SUBGRP_INST(subgrp
))) {
347 SUBGRP_FOREACH_PEER (subgrp
, paf
) {
348 peer
= PAF_PEER(paf
);
349 BGP_TIMER_OFF(peer
->t_routeadv
);
350 BGP_TIMER_ON(peer
->t_routeadv
, bgp_routeadv_timer
, 0);
357 static int update_group_announce_walkcb(struct update_group
*updgrp
, void *arg
)
359 struct update_subgroup
*subgrp
;
361 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
362 subgroup_announce_all(subgrp
);
365 return UPDWALK_CONTINUE
;
368 static int update_group_announce_rrc_walkcb(struct update_group
*updgrp
,
371 struct update_subgroup
*subgrp
;
376 afi
= UPDGRP_AFI(updgrp
);
377 safi
= UPDGRP_SAFI(updgrp
);
378 peer
= UPDGRP_PEER(updgrp
);
380 /* Only announce if this is a group of route-reflector-clients */
381 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_REFLECTOR_CLIENT
)) {
382 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
383 subgroup_announce_all(subgrp
);
387 return UPDWALK_CONTINUE
;
390 /********************
392 ********************/
395 * Allocate an adj-out object. Do proper initialization of its fields,
396 * primarily its association with the subgroup and the prefix.
398 struct bgp_adj_out
*bgp_adj_out_alloc(struct update_subgroup
*subgrp
,
400 uint32_t addpath_tx_id
)
402 struct bgp_adj_out
*adj
;
404 adj
= XCALLOC(MTYPE_BGP_ADJ_OUT
, sizeof(struct bgp_adj_out
));
405 adj
->subgroup
= subgrp
;
407 RB_INSERT(bgp_adj_out_rb
, &rn
->adj_out
, adj
);
412 adj
->addpath_tx_id
= addpath_tx_id
;
413 TAILQ_INSERT_TAIL(&(subgrp
->adjq
), adj
, subgrp_adj_train
);
414 SUBGRP_INCR_STAT(subgrp
, adj_count
);
419 struct bgp_advertise
*
420 bgp_advertise_clean_subgroup(struct update_subgroup
*subgrp
,
421 struct bgp_adj_out
*adj
)
423 struct bgp_advertise
*adv
;
424 struct bgp_advertise_attr
*baa
;
425 struct bgp_advertise
*next
;
426 struct bgp_adv_fifo_head
*fhead
;
433 fhead
= &subgrp
->sync
->update
;
435 /* Unlink myself from advertise attribute FIFO. */
436 bgp_advertise_delete(baa
, adv
);
438 /* Fetch next advertise candidate. */
441 /* Unintern BGP advertise attribute. */
442 bgp_advertise_unintern(subgrp
->hash
, baa
);
444 fhead
= &subgrp
->sync
->withdraw
;
447 /* Unlink myself from advertisement FIFO. */
448 bgp_adv_fifo_del(fhead
, adv
);
451 bgp_advertise_free(adj
->adv
);
457 void bgp_adj_out_set_subgroup(struct bgp_node
*rn
,
458 struct update_subgroup
*subgrp
, struct attr
*attr
,
459 struct bgp_path_info
*path
)
461 struct bgp_adj_out
*adj
= NULL
;
462 struct bgp_advertise
*adv
;
467 peer
= SUBGRP_PEER(subgrp
);
468 afi
= SUBGRP_AFI(subgrp
);
469 safi
= SUBGRP_SAFI(subgrp
);
471 if (DISABLE_BGP_ANNOUNCE
)
474 /* Look for adjacency information. */
477 bgp_addpath_id_for_peer(peer
, afi
, safi
, &path
->tx_addpath
));
480 adj
= bgp_adj_out_alloc(
482 bgp_addpath_id_for_peer(peer
, afi
, safi
,
489 bgp_advertise_clean_subgroup(subgrp
, adj
);
490 adj
->adv
= bgp_advertise_new();
494 assert(adv
->pathi
== NULL
);
495 /* bgp_path_info adj_out reference */
496 adv
->pathi
= bgp_path_info_lock(path
);
499 adv
->baa
= bgp_advertise_intern(subgrp
->hash
, attr
);
501 adv
->baa
= baa_new();
504 /* Add new advertisement to advertisement attribute list. */
505 bgp_advertise_add(adv
->baa
, adv
);
508 * If the update adv list is empty, trigger the member peers'
509 * mrai timers so the socket writes can happen.
511 if (!bgp_adv_fifo_count(&subgrp
->sync
->update
)) {
514 SUBGRP_FOREACH_PEER (subgrp
, paf
) {
515 bgp_adjust_routeadv(PAF_PEER(paf
));
519 bgp_adv_fifo_add_tail(&subgrp
->sync
->update
, adv
);
521 subgrp
->version
= max(subgrp
->version
, rn
->version
);
524 /* The only time 'withdraw' will be false is if we are sending
525 * the "neighbor x.x.x.x default-originate" default and need to clear
526 * bgp_adj_out for the 0.0.0.0/0 route in the BGP table.
528 void bgp_adj_out_unset_subgroup(struct bgp_node
*rn
,
529 struct update_subgroup
*subgrp
, char withdraw
,
530 uint32_t addpath_tx_id
)
532 struct bgp_adj_out
*adj
;
533 struct bgp_advertise
*adv
;
536 if (DISABLE_BGP_ANNOUNCE
)
539 /* Lookup existing adjacency */
540 if ((adj
= adj_lookup(rn
, subgrp
, addpath_tx_id
)) != NULL
) {
541 /* Clean up previous advertisement. */
543 bgp_advertise_clean_subgroup(subgrp
, adj
);
545 if (adj
->attr
&& withdraw
) {
546 /* We need advertisement structure. */
547 adj
->adv
= bgp_advertise_new();
552 /* Note if we need to trigger a packet write */
554 !bgp_adv_fifo_count(&subgrp
->sync
->withdraw
);
556 /* Add to synchronization entry for withdraw
558 bgp_adv_fifo_add_tail(&subgrp
->sync
->withdraw
, adv
);
561 subgroup_trigger_write(subgrp
);
563 /* Remove myself from adjacency. */
564 RB_REMOVE(bgp_adj_out_rb
, &rn
->adj_out
, adj
);
566 /* Free allocated information. */
573 subgrp
->version
= max(subgrp
->version
, rn
->version
);
576 void bgp_adj_out_remove_subgroup(struct bgp_node
*rn
, struct bgp_adj_out
*adj
,
577 struct update_subgroup
*subgrp
)
580 bgp_attr_unintern(&adj
->attr
);
583 bgp_advertise_clean_subgroup(subgrp
, adj
);
585 RB_REMOVE(bgp_adj_out_rb
, &rn
->adj_out
, adj
);
590 * Go through all the routes and clean up the adj/adv structures corresponding
593 void subgroup_clear_table(struct update_subgroup
*subgrp
)
595 struct bgp_adj_out
*aout
, *taout
;
597 SUBGRP_FOREACH_ADJ_SAFE (subgrp
, aout
, taout
) {
598 struct bgp_node
*rn
= aout
->rn
;
599 bgp_adj_out_remove_subgroup(rn
, aout
, subgrp
);
605 * subgroup_announce_table
607 void subgroup_announce_table(struct update_subgroup
*subgrp
,
608 struct bgp_table
*table
)
611 struct bgp_path_info
*ri
;
618 peer
= SUBGRP_PEER(subgrp
);
619 afi
= SUBGRP_AFI(subgrp
);
620 safi
= SUBGRP_SAFI(subgrp
);
621 addpath_capable
= bgp_addpath_encode_tx(peer
, afi
, safi
);
623 if (safi
== SAFI_LABELED_UNICAST
)
627 table
= peer
->bgp
->rib
[afi
][safi
];
629 if (safi
!= SAFI_MPLS_VPN
&& safi
!= SAFI_ENCAP
&& safi
!= SAFI_EVPN
630 && CHECK_FLAG(peer
->af_flags
[afi
][safi
],
631 PEER_FLAG_DEFAULT_ORIGINATE
))
632 subgroup_default_originate(subgrp
, 0);
634 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
))
635 for (ri
= bgp_node_get_bgp_path_info(rn
); ri
; ri
= ri
->next
)
637 if (CHECK_FLAG(ri
->flags
, BGP_PATH_SELECTED
)
639 && bgp_addpath_tx_path(
640 peer
->addpath_type
[afi
][safi
],
642 if (subgroup_announce_check(rn
, ri
, subgrp
,
644 bgp_adj_out_set_subgroup(rn
, subgrp
,
647 bgp_adj_out_unset_subgroup(
649 bgp_addpath_id_for_peer(
655 * We walked through the whole table -- make sure our version number
656 * is consistent with the one on the table. This should allow
657 * subgroups to merge sooner if a peer comes up when the route node
658 * with the largest version is no longer in the table. This also
659 * covers the pathological case where all routes in the table have
662 subgrp
->version
= max(subgrp
->version
, table
->version
);
665 * Start a task to merge the subgroup if necessary.
667 update_subgroup_trigger_merge_check(subgrp
, 0);
671 * subgroup_announce_route
673 * Refresh all routes out to a subgroup.
675 void subgroup_announce_route(struct update_subgroup
*subgrp
)
678 struct bgp_table
*table
;
679 struct peer
*onlypeer
;
681 if (update_subgroup_needs_refresh(subgrp
)) {
682 update_subgroup_set_needs_refresh(subgrp
, 0);
686 * First update is deferred until ORF or ROUTE-REFRESH is received
688 onlypeer
= ((SUBGRP_PCOUNT(subgrp
) == 1) ? (SUBGRP_PFIRST(subgrp
))->peer
690 if (onlypeer
&& CHECK_FLAG(onlypeer
->af_sflags
[SUBGRP_AFI(subgrp
)]
691 [SUBGRP_SAFI(subgrp
)],
692 PEER_STATUS_ORF_WAIT_REFRESH
))
695 if (SUBGRP_SAFI(subgrp
) != SAFI_MPLS_VPN
696 && SUBGRP_SAFI(subgrp
) != SAFI_ENCAP
697 && SUBGRP_SAFI(subgrp
) != SAFI_EVPN
)
698 subgroup_announce_table(subgrp
, NULL
);
700 for (rn
= bgp_table_top(update_subgroup_rib(subgrp
)); rn
;
701 rn
= bgp_route_next(rn
)) {
702 table
= bgp_node_get_bgp_table_info(rn
);
705 subgroup_announce_table(subgrp
, table
);
709 void subgroup_default_originate(struct update_subgroup
*subgrp
, int withdraw
)
713 struct aspath
*aspath
;
714 struct bgp_path_info tmp_info
;
718 struct bgp_path_info
*ri
;
720 route_map_result_t ret
= RMAP_DENYMATCH
;
727 peer
= SUBGRP_PEER(subgrp
);
728 afi
= SUBGRP_AFI(subgrp
);
729 safi
= SUBGRP_SAFI(subgrp
);
731 if (!(afi
== AFI_IP
|| afi
== AFI_IP6
))
735 from
= bgp
->peer_self
;
737 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
738 aspath
= attr
.aspath
;
740 attr
.local_pref
= bgp
->default_local_pref
;
742 memset(&p
, 0, sizeof(p
));
743 p
.family
= afi2family(afi
);
746 if ((afi
== AFI_IP6
) || peer_cap_enhe(peer
, afi
, safi
)) {
747 /* IPv6 global nexthop must be included. */
748 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL
;
750 /* If the peer is on shared nextwork and we have link-local
752 if (peer
->shared_network
753 && !IN6_IS_ADDR_UNSPECIFIED(&peer
->nexthop
.v6_local
))
754 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
;
757 if (peer
->default_rmap
[afi
][safi
].name
) {
758 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_DEFAULT
);
759 for (rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rn
;
760 rn
= bgp_route_next(rn
)) {
761 for (ri
= bgp_node_get_bgp_path_info(rn
);
763 struct attr dummy_attr
;
765 /* Provide dummy so the route-map can't modify
767 bgp_attr_dup(&dummy_attr
, ri
->attr
);
768 tmp_info
.peer
= ri
->peer
;
769 tmp_info
.attr
= &dummy_attr
;
771 ret
= route_map_apply(
772 peer
->default_rmap
[afi
][safi
].map
,
773 &rn
->p
, RMAP_BGP
, &tmp_info
);
775 /* The route map might have set attributes. If
776 * we don't flush them
777 * here, they will be leaked. */
778 bgp_attr_flush(&dummy_attr
);
779 if (ret
!= RMAP_DENYMATCH
)
782 if (ret
!= RMAP_DENYMATCH
)
785 bgp
->peer_self
->rmap_type
= 0;
787 if (ret
== RMAP_DENYMATCH
)
792 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
793 subgroup_default_withdraw_packet(subgrp
);
794 UNSET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
);
796 if (!CHECK_FLAG(subgrp
->sflags
,
797 SUBGRP_STATUS_DEFAULT_ORIGINATE
)) {
799 if (bgp_flag_check(bgp
, BGP_FLAG_GRACEFUL_SHUTDOWN
)) {
800 bgp_attr_add_gshut_community(&attr
);
803 SET_FLAG(subgrp
->sflags
,
804 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
805 subgroup_default_update_packet(subgrp
, &attr
, from
);
807 /* The 'neighbor x.x.x.x default-originate' default will
809 * implicit withdraw for any previous UPDATEs sent for
811 * clear adj_out for the 0.0.0.0/0 prefix in the BGP
814 memset(&p
, 0, sizeof(p
));
815 p
.family
= afi2family(afi
);
818 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
820 bgp_adj_out_unset_subgroup(
822 BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE
);
826 aspath_unintern(&aspath
);
830 * Announce the BGP table to a subgroup.
832 * At startup, we try to optimize route announcement by coalescing the
833 * peer-up events. This is done only the first time - from then on,
834 * subgrp->v_coalesce will be set to zero and the normal logic
837 void subgroup_announce_all(struct update_subgroup
*subgrp
)
843 * If coalesce timer value is not set, announce routes immediately.
845 if (!subgrp
->v_coalesce
) {
846 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
847 zlog_debug("u%" PRIu64
":s%" PRIu64
848 " announcing all routes",
849 subgrp
->update_group
->id
, subgrp
->id
);
850 subgroup_announce_route(subgrp
);
855 * We should wait for the coalesce timer. Arm the timer if not done.
857 if (!subgrp
->t_coalesce
) {
858 thread_add_timer_msec(bm
->master
, subgroup_coalesce_timer
,
859 subgrp
, subgrp
->v_coalesce
,
860 &subgrp
->t_coalesce
);
865 * Go through all update subgroups and set up the adv queue for the
868 void group_announce_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
869 struct bgp_node
*rn
, struct bgp_path_info
*pi
)
871 struct updwalk_context ctx
;
874 update_group_af_walk(bgp
, afi
, safi
, group_announce_route_walkcb
, &ctx
);
877 void update_group_show_adj_queue(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
878 struct vty
*vty
, uint64_t id
)
880 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVQUEUE
);
883 void update_group_show_advertised(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
884 struct vty
*vty
, uint64_t id
)
886 updgrp_show_adj(bgp
, afi
, safi
, vty
, id
, UPDWALK_FLAGS_ADVERTISED
);
889 void update_group_announce(struct bgp
*bgp
)
891 update_group_walk(bgp
, update_group_announce_walkcb
, NULL
);
894 void update_group_announce_rrclients(struct bgp
*bgp
)
896 update_group_walk(bgp
, update_group_announce_rrc_walkcb
, NULL
);