2 * bgp_updgrp.c: BGP update group structures
4 * @copyright Copyright (C) 2014 Cumulus Networks, Inc.
6 * @author Avneesh Sachdev <avneesh@sproute.net>
7 * @author Rajesh Varadarajan <rajesh@sproute.net>
8 * @author Pradosh Mohapatra <pradosh@sproute.net>
10 * This file is part of GNU Zebra.
12 * GNU Zebra is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2, or (at your option) any
17 * GNU Zebra is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU General Public License along
23 * with this program; see the file COPYING; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "sockunion.h"
42 #include "workqueue.h"
47 #include "bgpd/bgpd.h"
48 #include "bgpd/bgp_table.h"
49 #include "bgpd/bgp_debug.h"
50 #include "bgpd/bgp_fsm.h"
51 #include "bgpd/bgp_advertise.h"
52 #include "bgpd/bgp_packet.h"
53 #include "bgpd/bgp_updgrp.h"
54 #include "bgpd/bgp_route.h"
55 #include "bgpd/bgp_filter.h"
62 * assign a unique ID to update group and subgroup. Mostly for display/
63 * debugging purposes. It's a 64-bit space - used leisurely without a
64 * worry about its wrapping and about filling gaps. While at it, timestamp
67 static void update_group_checkin(struct update_group
*updgrp
)
69 updgrp
->id
= ++bm
->updgrp_idspace
;
70 updgrp
->uptime
= bgp_clock();
73 static void update_subgroup_checkin(struct update_subgroup
*subgrp
,
74 struct update_group
*updgrp
)
76 subgrp
->id
= ++bm
->subgrp_idspace
;
77 subgrp
->uptime
= bgp_clock();
80 static void sync_init(struct update_subgroup
*subgrp
)
83 XCALLOC(MTYPE_BGP_SYNCHRONISE
, sizeof(struct bgp_synchronize
));
84 BGP_ADV_FIFO_INIT(&subgrp
->sync
->update
);
85 BGP_ADV_FIFO_INIT(&subgrp
->sync
->withdraw
);
86 BGP_ADV_FIFO_INIT(&subgrp
->sync
->withdraw_low
);
87 subgrp
->hash
= hash_create(baa_hash_key
,
91 /* We use a larger buffer for subgrp->work in the event that:
92 * - We RX a BGP_UPDATE where the attributes alone are just
93 * under BGP_MAX_PACKET_SIZE
94 * - The user configures an outbound route-map that does many as-path
95 * prepends or adds many communities. At most they can have
97 * args in a route-map so there is a finite limit on how large they
99 * make the attributes.
101 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
103 * checking for every single attribute as we construct an UPDATE.
106 stream_new(BGP_MAX_PACKET_SIZE
+ BGP_MAX_PACKET_SIZE_OVERFLOW
);
107 subgrp
->scratch
= stream_new(BGP_MAX_PACKET_SIZE
);
110 static void sync_delete(struct update_subgroup
*subgrp
)
113 XFREE(MTYPE_BGP_SYNCHRONISE
, subgrp
->sync
);
116 hash_free(subgrp
->hash
);
119 stream_free(subgrp
->work
);
122 stream_free(subgrp
->scratch
);
123 subgrp
->scratch
= NULL
;
129 * copy only those fields that are relevant to update group match
131 static void conf_copy(struct peer
*dst
, struct peer
*src
, afi_t afi
,
134 struct bgp_filter
*srcfilter
;
135 struct bgp_filter
*dstfilter
;
137 srcfilter
= &src
->filter
[afi
][safi
];
138 dstfilter
= &dst
->filter
[afi
][safi
];
141 dst
->sort
= src
->sort
;
143 dst
->v_routeadv
= src
->v_routeadv
;
144 dst
->flags
= src
->flags
;
145 dst
->af_flags
[afi
][safi
] = src
->af_flags
[afi
][safi
];
147 XFREE(MTYPE_BGP_PEER_HOST
, dst
->host
);
149 dst
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, src
->host
);
151 dst
->af_cap
[afi
][safi
] = src
->af_cap
[afi
][safi
];
152 dst
->afc_nego
[afi
][safi
] = src
->afc_nego
[afi
][safi
];
153 dst
->orf_plist
[afi
][safi
] = src
->orf_plist
[afi
][safi
];
154 dst
->local_as
= src
->local_as
;
155 dst
->change_local_as
= src
->change_local_as
;
156 dst
->shared_network
= src
->shared_network
;
157 memcpy(&(dst
->nexthop
), &(src
->nexthop
), sizeof(struct bgp_nexthop
));
159 dst
->group
= src
->group
;
161 if (src
->default_rmap
[afi
][safi
].name
) {
162 dst
->default_rmap
[afi
][safi
].name
=
163 XSTRDUP(MTYPE_ROUTE_MAP_NAME
,
164 src
->default_rmap
[afi
][safi
].name
);
165 dst
->default_rmap
[afi
][safi
].map
=
166 src
->default_rmap
[afi
][safi
].map
;
169 if (DISTRIBUTE_OUT_NAME(srcfilter
)) {
170 DISTRIBUTE_OUT_NAME(dstfilter
) = XSTRDUP(
171 MTYPE_BGP_FILTER_NAME
, DISTRIBUTE_OUT_NAME(srcfilter
));
172 DISTRIBUTE_OUT(dstfilter
) = DISTRIBUTE_OUT(srcfilter
);
175 if (PREFIX_LIST_OUT_NAME(srcfilter
)) {
176 PREFIX_LIST_OUT_NAME(dstfilter
) = XSTRDUP(
177 MTYPE_BGP_FILTER_NAME
, PREFIX_LIST_OUT_NAME(srcfilter
));
178 PREFIX_LIST_OUT(dstfilter
) = PREFIX_LIST_OUT(srcfilter
);
181 if (FILTER_LIST_OUT_NAME(srcfilter
)) {
182 FILTER_LIST_OUT_NAME(dstfilter
) = XSTRDUP(
183 MTYPE_BGP_FILTER_NAME
, FILTER_LIST_OUT_NAME(srcfilter
));
184 FILTER_LIST_OUT(dstfilter
) = FILTER_LIST_OUT(srcfilter
);
187 if (ROUTE_MAP_OUT_NAME(srcfilter
)) {
188 ROUTE_MAP_OUT_NAME(dstfilter
) = XSTRDUP(
189 MTYPE_BGP_FILTER_NAME
, ROUTE_MAP_OUT_NAME(srcfilter
));
190 ROUTE_MAP_OUT(dstfilter
) = ROUTE_MAP_OUT(srcfilter
);
193 if (UNSUPPRESS_MAP_NAME(srcfilter
)) {
194 UNSUPPRESS_MAP_NAME(dstfilter
) = XSTRDUP(
195 MTYPE_BGP_FILTER_NAME
, UNSUPPRESS_MAP_NAME(srcfilter
));
196 UNSUPPRESS_MAP(dstfilter
) = UNSUPPRESS_MAP(srcfilter
);
201 * since we did a bunch of XSTRDUP's in conf_copy, time to free them up
203 static void conf_release(struct peer
*src
, afi_t afi
, safi_t safi
)
205 struct bgp_filter
*srcfilter
;
207 srcfilter
= &src
->filter
[afi
][safi
];
209 if (src
->default_rmap
[afi
][safi
].name
)
210 XFREE(MTYPE_ROUTE_MAP_NAME
, src
->default_rmap
[afi
][safi
].name
);
212 if (srcfilter
->dlist
[FILTER_OUT
].name
)
213 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->dlist
[FILTER_OUT
].name
);
215 if (srcfilter
->plist
[FILTER_OUT
].name
)
216 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->plist
[FILTER_OUT
].name
);
218 if (srcfilter
->aslist
[FILTER_OUT
].name
)
219 XFREE(MTYPE_BGP_FILTER_NAME
,
220 srcfilter
->aslist
[FILTER_OUT
].name
);
222 if (srcfilter
->map
[RMAP_OUT
].name
)
223 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->map
[RMAP_OUT
].name
);
225 if (srcfilter
->usmap
.name
)
226 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->usmap
.name
);
229 XFREE(MTYPE_BGP_PEER_HOST
, src
->host
);
233 static void peer2_updgrp_copy(struct update_group
*updgrp
, struct peer_af
*paf
)
246 updgrp
->afi
= paf
->afi
;
247 updgrp
->safi
= paf
->safi
;
248 updgrp
->afid
= paf
->afid
;
249 updgrp
->bgp
= src
->bgp
;
251 conf_copy(dst
, src
, paf
->afi
, paf
->safi
);
255 * auxiliary functions to maintain the hash table.
256 * - updgrp_hash_alloc - to create a new entry, passed to hash_get
257 * - updgrp_hash_key_make - makes the key for update group search
258 * - updgrp_hash_cmp - compare two update groups.
260 static void *updgrp_hash_alloc(void *p
)
262 struct update_group
*updgrp
;
263 const struct update_group
*in
;
265 in
= (const struct update_group
*)p
;
266 updgrp
= XCALLOC(MTYPE_BGP_UPDGRP
, sizeof(struct update_group
));
267 memcpy(updgrp
, in
, sizeof(struct update_group
));
268 updgrp
->conf
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
269 conf_copy(updgrp
->conf
, in
->conf
, in
->afi
, in
->safi
);
274 * The hash value for a peer is computed from the following variables:
276 * 1. IBGP (1) or EBGP (2)
277 * 2. FLAGS based on configuration:
278 * LOCAL_AS_NO_PREPEND
279 * LOCAL_AS_REPLACE_AS
280 * 3. AF_FLAGS based on configuration:
281 * Refer to definition in bgp_updgrp.h
282 * 4. (AF-independent) Capability flags:
284 * 5. (AF-dependent) Capability flags:
285 * ORF_PREFIX_SM_RCV (peer can send prefix ORF)
288 * 8. Outbound route-map name (neighbor route-map <> out)
289 * 9. Outbound distribute-list name (neighbor distribute-list <> out)
290 * 10. Outbound prefix-list name (neighbor prefix-list <> out)
291 * 11. Outbound as-list name (neighbor filter-list <> out)
292 * 12. Unsuppress map name (neighbor unsuppress-map <>)
293 * 13. default rmap name (neighbor default-originate route-map <>)
294 * 14. encoding both global and link-local nexthop?
295 * 15. If peer is configured to be a lonesoul, peer ip address
296 * 16. Local-as should match, if configured.
299 static unsigned int updgrp_hash_key_make(void *p
)
301 const struct update_group
*updgrp
;
302 const struct peer
*peer
;
303 const struct bgp_filter
*filter
;
310 #define SEED2 2147483647
316 flags
= peer
->af_flags
[afi
][safi
];
317 filter
= &peer
->filter
[afi
][safi
];
321 key
= jhash_1word(peer
->sort
, key
); /* EBGP or IBGP */
322 key
= jhash_1word((peer
->flags
& PEER_UPDGRP_FLAGS
), key
);
323 key
= jhash_1word((flags
& PEER_UPDGRP_AF_FLAGS
), key
);
324 key
= jhash_1word((peer
->cap
& PEER_UPDGRP_CAP_FLAGS
), key
);
325 key
= jhash_1word((peer
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
),
327 key
= jhash_1word(peer
->v_routeadv
, key
);
328 key
= jhash_1word(peer
->change_local_as
, key
);
331 key
= jhash_1word(jhash(peer
->group
->name
,
332 strlen(peer
->group
->name
), SEED1
),
335 if (filter
->map
[RMAP_OUT
].name
)
336 key
= jhash_1word(jhash(filter
->map
[RMAP_OUT
].name
,
337 strlen(filter
->map
[RMAP_OUT
].name
),
341 if (filter
->dlist
[FILTER_OUT
].name
)
342 key
= jhash_1word(jhash(filter
->dlist
[FILTER_OUT
].name
,
343 strlen(filter
->dlist
[FILTER_OUT
].name
),
347 if (filter
->plist
[FILTER_OUT
].name
)
348 key
= jhash_1word(jhash(filter
->plist
[FILTER_OUT
].name
,
349 strlen(filter
->plist
[FILTER_OUT
].name
),
353 if (filter
->aslist
[FILTER_OUT
].name
)
354 key
= jhash_1word(jhash(filter
->aslist
[FILTER_OUT
].name
,
355 strlen(filter
->aslist
[FILTER_OUT
].name
),
359 if (filter
->usmap
.name
)
360 key
= jhash_1word(jhash(filter
->usmap
.name
,
361 strlen(filter
->usmap
.name
), SEED1
),
364 if (peer
->default_rmap
[afi
][safi
].name
)
366 jhash(peer
->default_rmap
[afi
][safi
].name
,
367 strlen(peer
->default_rmap
[afi
][safi
].name
),
371 /* If peer is on a shared network and is exchanging IPv6 prefixes,
372 * it needs to include link-local address. That's different from
373 * non-shared-network peers (nexthop encoded with 32 bytes vs 16
374 * bytes). We create different update groups to take care of that.
377 (peer
->shared_network
&& peer_afi_active_nego(peer
, AFI_IP6
)),
381 * There are certain peers that must get their own update-group:
383 * - peers that negotiated ORF
385 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
)
386 || CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_RCV
)
387 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
388 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
389 key
= jhash_1word(jhash(peer
->host
, strlen(peer
->host
), SEED2
),
395 static int updgrp_hash_cmp(const void *p1
, const void *p2
)
397 const struct update_group
*grp1
;
398 const struct update_group
*grp2
;
399 const struct peer
*pe1
;
400 const struct peer
*pe2
;
403 const struct bgp_filter
*fl1
;
404 const struct bgp_filter
*fl2
;
417 flags1
= pe1
->af_flags
[afi
][safi
];
418 flags2
= pe2
->af_flags
[afi
][safi
];
419 fl1
= &pe1
->filter
[afi
][safi
];
420 fl2
= &pe2
->filter
[afi
][safi
];
422 /* put EBGP and IBGP peers in different update groups */
423 if (pe1
->sort
!= pe2
->sort
)
426 /* check peer flags */
427 if ((pe1
->flags
& PEER_UPDGRP_FLAGS
)
428 != (pe2
->flags
& PEER_UPDGRP_FLAGS
))
431 /* If there is 'local-as' configured, it should match. */
432 if (pe1
->change_local_as
!= pe2
->change_local_as
)
435 /* flags like route reflector client */
436 if ((flags1
& PEER_UPDGRP_AF_FLAGS
) != (flags2
& PEER_UPDGRP_AF_FLAGS
))
439 if ((pe1
->cap
& PEER_UPDGRP_CAP_FLAGS
)
440 != (pe2
->cap
& PEER_UPDGRP_CAP_FLAGS
))
443 if ((pe1
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
)
444 != (pe2
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
))
447 if (pe1
->v_routeadv
!= pe2
->v_routeadv
)
450 if (pe1
->group
!= pe2
->group
)
453 /* route-map names should be the same */
454 if ((fl1
->map
[RMAP_OUT
].name
&& !fl2
->map
[RMAP_OUT
].name
)
455 || (!fl1
->map
[RMAP_OUT
].name
&& fl2
->map
[RMAP_OUT
].name
)
456 || (fl1
->map
[RMAP_OUT
].name
&& fl2
->map
[RMAP_OUT
].name
457 && strcmp(fl1
->map
[RMAP_OUT
].name
, fl2
->map
[RMAP_OUT
].name
)))
460 if ((fl1
->dlist
[FILTER_OUT
].name
&& !fl2
->dlist
[FILTER_OUT
].name
)
461 || (!fl1
->dlist
[FILTER_OUT
].name
&& fl2
->dlist
[FILTER_OUT
].name
)
462 || (fl1
->dlist
[FILTER_OUT
].name
&& fl2
->dlist
[FILTER_OUT
].name
463 && strcmp(fl1
->dlist
[FILTER_OUT
].name
,
464 fl2
->dlist
[FILTER_OUT
].name
)))
467 if ((fl1
->plist
[FILTER_OUT
].name
&& !fl2
->plist
[FILTER_OUT
].name
)
468 || (!fl1
->plist
[FILTER_OUT
].name
&& fl2
->plist
[FILTER_OUT
].name
)
469 || (fl1
->plist
[FILTER_OUT
].name
&& fl2
->plist
[FILTER_OUT
].name
470 && strcmp(fl1
->plist
[FILTER_OUT
].name
,
471 fl2
->plist
[FILTER_OUT
].name
)))
474 if ((fl1
->aslist
[FILTER_OUT
].name
&& !fl2
->aslist
[FILTER_OUT
].name
)
475 || (!fl1
->aslist
[FILTER_OUT
].name
&& fl2
->aslist
[FILTER_OUT
].name
)
476 || (fl1
->aslist
[FILTER_OUT
].name
&& fl2
->aslist
[FILTER_OUT
].name
477 && strcmp(fl1
->aslist
[FILTER_OUT
].name
,
478 fl2
->aslist
[FILTER_OUT
].name
)))
481 if ((fl1
->usmap
.name
&& !fl2
->usmap
.name
)
482 || (!fl1
->usmap
.name
&& fl2
->usmap
.name
)
483 || (fl1
->usmap
.name
&& fl2
->usmap
.name
484 && strcmp(fl1
->usmap
.name
, fl2
->usmap
.name
)))
487 if ((pe1
->default_rmap
[afi
][safi
].name
488 && !pe2
->default_rmap
[afi
][safi
].name
)
489 || (!pe1
->default_rmap
[afi
][safi
].name
490 && pe2
->default_rmap
[afi
][safi
].name
)
491 || (pe1
->default_rmap
[afi
][safi
].name
492 && pe2
->default_rmap
[afi
][safi
].name
493 && strcmp(pe1
->default_rmap
[afi
][safi
].name
,
494 pe2
->default_rmap
[afi
][safi
].name
)))
497 if ((afi
== AFI_IP6
) && (pe1
->shared_network
!= pe2
->shared_network
))
500 if ((CHECK_FLAG(pe1
->flags
, PEER_FLAG_LONESOUL
)
501 || CHECK_FLAG(pe1
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_RCV
)
502 || CHECK_FLAG(pe1
->af_cap
[afi
][safi
],
503 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
504 && !sockunion_same(&pe1
->su
, &pe2
->su
))
510 static void peer_lonesoul_or_not(struct peer
*peer
, int set
)
512 /* no change in status? */
513 if (set
== (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
) > 0))
517 SET_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
);
519 UNSET_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
);
521 update_group_adjust_peer_afs(peer
);
525 * subgroup_total_packets_enqueued
527 * Returns the total number of packets enqueued to a subgroup.
530 subgroup_total_packets_enqueued(struct update_subgroup
*subgrp
)
534 pkt
= bpacket_queue_last(SUBGRP_PKTQ(subgrp
));
539 static int update_group_show_walkcb(struct update_group
*updgrp
, void *arg
)
541 struct updwalk_context
*ctx
= arg
;
543 struct update_subgroup
*subgrp
;
545 struct bgp_filter
*filter
;
551 if (ctx
->subgrp_id
) {
552 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
554 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
566 /* Since this routine is invoked from a walk, we cannot signal
568 /* error here, can only return. */
574 vty_out(vty
, "Update-group %" PRIu64
":\n", updgrp
->id
);
575 vty_out(vty
, " Created: %s", timestamp_string(updgrp
->uptime
));
576 filter
= &updgrp
->conf
->filter
[updgrp
->afi
][updgrp
->safi
];
577 if (filter
->map
[RMAP_OUT
].name
)
578 vty_out(vty
, " Outgoing route map: %s%s\n",
579 filter
->map
[RMAP_OUT
].map
? "X" : "",
580 filter
->map
[RMAP_OUT
].name
);
581 vty_out(vty
, " MRAI value (seconds): %d\n", updgrp
->conf
->v_routeadv
);
582 if (updgrp
->conf
->change_local_as
)
583 vty_out(vty
, " Local AS %u%s%s\n",
584 updgrp
->conf
->change_local_as
,
585 CHECK_FLAG(updgrp
->conf
->flags
,
586 PEER_FLAG_LOCAL_AS_NO_PREPEND
)
589 CHECK_FLAG(updgrp
->conf
->flags
,
590 PEER_FLAG_LOCAL_AS_REPLACE_AS
)
594 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
596 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
599 vty_out(vty
, " Update-subgroup %" PRIu64
":\n", subgrp
->id
);
600 vty_out(vty
, " Created: %s",
601 timestamp_string(subgrp
->uptime
));
603 if (subgrp
->split_from
.update_group_id
604 || subgrp
->split_from
.subgroup_id
) {
605 vty_out(vty
, " Split from group id: %" PRIu64
"\n",
606 subgrp
->split_from
.update_group_id
);
608 " Split from subgroup id: %" PRIu64
"\n",
609 subgrp
->split_from
.subgroup_id
);
612 vty_out(vty
, " Join events: %u\n", subgrp
->join_events
);
613 vty_out(vty
, " Prune events: %u\n", subgrp
->prune_events
);
614 vty_out(vty
, " Merge events: %u\n", subgrp
->merge_events
);
615 vty_out(vty
, " Split events: %u\n", subgrp
->split_events
);
616 vty_out(vty
, " Update group switch events: %u\n",
617 subgrp
->updgrp_switch_events
);
618 vty_out(vty
, " Peer refreshes combined: %u\n",
619 subgrp
->peer_refreshes_combined
);
620 vty_out(vty
, " Merge checks triggered: %u\n",
621 subgrp
->merge_checks_triggered
);
622 vty_out(vty
, " Version: %" PRIu64
"\n", subgrp
->version
);
623 vty_out(vty
, " Packet queue length: %d\n",
624 bpacket_queue_length(SUBGRP_PKTQ(subgrp
)));
625 vty_out(vty
, " Total packets enqueued: %u\n",
626 subgroup_total_packets_enqueued(subgrp
));
627 vty_out(vty
, " Packet queue high watermark: %d\n",
628 bpacket_queue_hwm_length(SUBGRP_PKTQ(subgrp
)));
629 vty_out(vty
, " Adj-out list count: %u\n", subgrp
->adj_count
);
630 vty_out(vty
, " Advertise list: %s\n",
631 advertise_list_is_empty(subgrp
) ? "empty"
633 vty_out(vty
, " Flags: %s\n",
634 CHECK_FLAG(subgrp
->flags
, SUBGRP_FLAG_NEEDS_REFRESH
)
637 if (subgrp
->peer_count
> 0) {
638 vty_out(vty
, " Peers:\n");
639 SUBGRP_FOREACH_PEER(subgrp
, paf
)
640 vty_out(vty
, " - %s\n", paf
->peer
->host
);
643 return UPDWALK_CONTINUE
;
647 * Helper function to show the packet queue for each subgroup of update group.
648 * Will be constrained to a particular subgroup id if id !=0
650 static int updgrp_show_packet_queue_walkcb(struct update_group
*updgrp
,
653 struct updwalk_context
*ctx
= arg
;
654 struct update_subgroup
*subgrp
;
658 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
660 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
662 vty_out(vty
, "update group %" PRIu64
", subgroup %" PRIu64
"\n",
663 updgrp
->id
, subgrp
->id
);
664 bpacket_queue_show_vty(SUBGRP_PKTQ(subgrp
), vty
);
666 return UPDWALK_CONTINUE
;
670 * Show the packet queue for each subgroup of update group. Will be
671 * constrained to a particular subgroup id if id !=0
673 void update_group_show_packet_queue(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
674 struct vty
*vty
, uint64_t id
)
676 struct updwalk_context ctx
;
678 memset(&ctx
, 0, sizeof(ctx
));
682 update_group_af_walk(bgp
, afi
, safi
, updgrp_show_packet_queue_walkcb
,
686 static struct update_group
*update_group_find(struct peer_af
*paf
)
688 struct update_group
*updgrp
;
689 struct update_group tmp
;
690 struct peer tmp_conf
;
692 if (!peer_established(PAF_PEER(paf
)))
695 memset(&tmp
, 0, sizeof(tmp
));
696 memset(&tmp_conf
, 0, sizeof(tmp_conf
));
697 tmp
.conf
= &tmp_conf
;
698 peer2_updgrp_copy(&tmp
, paf
);
700 updgrp
= hash_lookup(paf
->peer
->bgp
->update_groups
[paf
->afid
], &tmp
);
701 conf_release(&tmp_conf
, paf
->afi
, paf
->safi
);
705 static struct update_group
*update_group_create(struct peer_af
*paf
)
707 struct update_group
*updgrp
;
708 struct update_group tmp
;
709 struct peer tmp_conf
;
711 memset(&tmp
, 0, sizeof(tmp
));
712 memset(&tmp_conf
, 0, sizeof(tmp_conf
));
713 tmp
.conf
= &tmp_conf
;
714 peer2_updgrp_copy(&tmp
, paf
);
716 updgrp
= hash_get(paf
->peer
->bgp
->update_groups
[paf
->afid
], &tmp
,
720 update_group_checkin(updgrp
);
722 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
723 zlog_debug("create update group %" PRIu64
, updgrp
->id
);
725 UPDGRP_GLOBAL_STAT(updgrp
, updgrps_created
) += 1;
727 conf_release(&tmp_conf
, paf
->afi
, paf
->safi
);
731 static void update_group_delete(struct update_group
*updgrp
)
733 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
734 zlog_debug("delete update group %" PRIu64
, updgrp
->id
);
736 UPDGRP_GLOBAL_STAT(updgrp
, updgrps_deleted
) += 1;
738 hash_release(updgrp
->bgp
->update_groups
[updgrp
->afid
], updgrp
);
739 conf_release(updgrp
->conf
, updgrp
->afi
, updgrp
->safi
);
741 if (updgrp
->conf
->host
)
742 XFREE(MTYPE_BGP_PEER_HOST
, updgrp
->conf
->host
);
743 updgrp
->conf
->host
= NULL
;
745 if (updgrp
->conf
->ifname
)
746 XFREE(MTYPE_BGP_PEER_IFNAME
, updgrp
->conf
->ifname
);
748 XFREE(MTYPE_BGP_PEER
, updgrp
->conf
);
749 XFREE(MTYPE_BGP_UPDGRP
, updgrp
);
752 static void update_group_add_subgroup(struct update_group
*updgrp
,
753 struct update_subgroup
*subgrp
)
755 if (!updgrp
|| !subgrp
)
758 LIST_INSERT_HEAD(&(updgrp
->subgrps
), subgrp
, updgrp_train
);
759 subgrp
->update_group
= updgrp
;
762 static void update_group_remove_subgroup(struct update_group
*updgrp
,
763 struct update_subgroup
*subgrp
)
765 if (!updgrp
|| !subgrp
)
768 LIST_REMOVE(subgrp
, updgrp_train
);
769 subgrp
->update_group
= NULL
;
770 if (LIST_EMPTY(&(updgrp
->subgrps
)))
771 update_group_delete(updgrp
);
774 static struct update_subgroup
*
775 update_subgroup_create(struct update_group
*updgrp
)
777 struct update_subgroup
*subgrp
;
779 subgrp
= XCALLOC(MTYPE_BGP_UPD_SUBGRP
, sizeof(struct update_subgroup
));
780 update_subgroup_checkin(subgrp
, updgrp
);
781 subgrp
->v_coalesce
= (UPDGRP_INST(updgrp
))->coalesce_time
;
783 bpacket_queue_init(SUBGRP_PKTQ(subgrp
));
784 bpacket_queue_add(SUBGRP_PKTQ(subgrp
), NULL
, NULL
);
785 TAILQ_INIT(&(subgrp
->adjq
));
786 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
787 zlog_debug("create subgroup u%" PRIu64
":s%" PRIu64
, updgrp
->id
,
790 update_group_add_subgroup(updgrp
, subgrp
);
792 UPDGRP_INCR_STAT(updgrp
, subgrps_created
);
797 static void update_subgroup_delete(struct update_subgroup
*subgrp
)
802 if (subgrp
->update_group
)
803 UPDGRP_INCR_STAT(subgrp
->update_group
, subgrps_deleted
);
805 if (subgrp
->t_merge_check
)
806 THREAD_OFF(subgrp
->t_merge_check
);
808 if (subgrp
->t_coalesce
)
809 THREAD_TIMER_OFF(subgrp
->t_coalesce
);
811 bpacket_queue_cleanup(SUBGRP_PKTQ(subgrp
));
812 subgroup_clear_table(subgrp
);
814 if (subgrp
->t_coalesce
)
815 THREAD_TIMER_OFF(subgrp
->t_coalesce
);
818 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
819 zlog_debug("delete subgroup u%" PRIu64
":s%" PRIu64
,
820 subgrp
->update_group
->id
, subgrp
->id
);
822 update_group_remove_subgroup(subgrp
->update_group
, subgrp
);
824 XFREE(MTYPE_BGP_UPD_SUBGRP
, subgrp
);
827 void update_subgroup_inherit_info(struct update_subgroup
*to
,
828 struct update_subgroup
*from
)
833 to
->sflags
= from
->sflags
;
837 * update_subgroup_check_delete
839 * Delete a subgroup if it is ready to be deleted.
841 * Returns TRUE if the subgroup was deleted.
843 static int update_subgroup_check_delete(struct update_subgroup
*subgrp
)
848 if (!LIST_EMPTY(&(subgrp
->peers
)))
851 update_subgroup_delete(subgrp
);
857 * update_subgroup_add_peer
859 * @param send_enqueued_packets If true all currently enqueued packets will
860 * also be sent to the peer.
862 static void update_subgroup_add_peer(struct update_subgroup
*subgrp
,
864 int send_enqueued_pkts
)
871 LIST_INSERT_HEAD(&(subgrp
->peers
), paf
, subgrp_train
);
872 paf
->subgroup
= subgrp
;
873 subgrp
->peer_count
++;
875 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
876 UPDGRP_PEER_DBG_EN(subgrp
->update_group
);
879 SUBGRP_INCR_STAT(subgrp
, join_events
);
881 if (send_enqueued_pkts
) {
882 pkt
= bpacket_queue_first(SUBGRP_PKTQ(subgrp
));
886 * Hang the peer off of the last, placeholder, packet in the
887 * queue. This means it won't see any of the packets that are
888 * currently the queue.
890 pkt
= bpacket_queue_last(SUBGRP_PKTQ(subgrp
));
891 assert(pkt
->buffer
== NULL
);
894 bpacket_add_peer(pkt
, paf
);
896 bpacket_queue_sanity_check(SUBGRP_PKTQ(subgrp
));
900 * update_subgroup_remove_peer_internal
902 * Internal function that removes a peer from a subgroup, but does not
903 * delete the subgroup. A call to this function must almost always be
904 * followed by a call to update_subgroup_check_delete().
906 * @see update_subgroup_remove_peer
908 static void update_subgroup_remove_peer_internal(struct update_subgroup
*subgrp
,
911 assert(subgrp
&& paf
);
913 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
914 UPDGRP_PEER_DBG_DIS(subgrp
->update_group
);
917 bpacket_queue_remove_peer(paf
);
918 LIST_REMOVE(paf
, subgrp_train
);
919 paf
->subgroup
= NULL
;
920 subgrp
->peer_count
--;
922 SUBGRP_INCR_STAT(subgrp
, prune_events
);
926 * update_subgroup_remove_peer
928 void update_subgroup_remove_peer(struct update_subgroup
*subgrp
,
934 update_subgroup_remove_peer_internal(subgrp
, paf
);
936 if (update_subgroup_check_delete(subgrp
))
940 * The deletion of the peer may have caused some packets to be
941 * deleted from the subgroup packet queue. Check if the subgroup can
944 update_subgroup_check_merge(subgrp
, "removed peer from subgroup");
947 static struct update_subgroup
*update_subgroup_find(struct update_group
*updgrp
,
950 struct update_subgroup
*subgrp
= NULL
;
959 if (!peer_established(PAF_PEER(paf
)))
962 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
964 if (subgrp
->version
!= version
965 || CHECK_FLAG(subgrp
->sflags
,
966 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
970 * The version number is not meaningful on a subgroup that needs
973 if (update_subgroup_needs_refresh(subgrp
))
983 * update_subgroup_ready_for_merge
985 * Returns TRUE if this subgroup is in a state that allows it to be
986 * merged into another subgroup.
988 static int update_subgroup_ready_for_merge(struct update_subgroup
*subgrp
)
992 * Not ready if there are any encoded packets waiting to be written
995 if (!bpacket_queue_is_empty(SUBGRP_PKTQ(subgrp
)))
999 * Not ready if there enqueued updates waiting to be encoded.
1001 if (!advertise_list_is_empty(subgrp
))
1005 * Don't attempt to merge a subgroup that needs a refresh. For one,
1006 * we can't determine if the adj_out of such a group matches that of
1009 if (update_subgroup_needs_refresh(subgrp
))
1016 * update_subgrp_can_merge_into
1018 * Returns TRUE if the first subgroup can merge into the second
1021 static int update_subgroup_can_merge_into(struct update_subgroup
*subgrp
,
1022 struct update_subgroup
*target
)
1025 if (subgrp
== target
)
1029 * Both must have processed the BRIB to the same point in order to
1032 if (subgrp
->version
!= target
->version
)
1035 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
)
1036 != CHECK_FLAG(target
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1039 if (subgrp
->adj_count
!= target
->adj_count
)
1042 return update_subgroup_ready_for_merge(target
);
1046 * update_subgroup_merge
1048 * Merge the first subgroup into the second one.
1050 static void update_subgroup_merge(struct update_subgroup
*subgrp
,
1051 struct update_subgroup
*target
,
1054 struct peer_af
*paf
;
1058 assert(subgrp
->adj_count
== target
->adj_count
);
1060 peer_count
= subgrp
->peer_count
;
1063 paf
= LIST_FIRST(&subgrp
->peers
);
1067 update_subgroup_remove_peer_internal(subgrp
, paf
);
1070 * Add the peer to the target subgroup, while making sure that
1071 * any currently enqueued packets won't be sent to it. Enqueued
1072 * packets could, for example, result in an unnecessary withdraw
1073 * followed by an advertise.
1075 update_subgroup_add_peer(target
, paf
, 0);
1078 SUBGRP_INCR_STAT(target
, merge_events
);
1080 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1081 zlog_debug("u%" PRIu64
":s%" PRIu64
1082 " (%d peers) merged into u%" PRIu64
":s%" PRIu64
1085 subgrp
->update_group
->id
, subgrp
->id
, peer_count
,
1086 target
->update_group
->id
, target
->id
,
1087 reason
? reason
: "unknown");
1089 result
= update_subgroup_check_delete(subgrp
);
1094 * update_subgroup_check_merge
1096 * Merge this subgroup into another subgroup if possible.
1098 * Returns TRUE if the subgroup has been merged. The subgroup pointer
1099 * should not be accessed in this case.
1101 int update_subgroup_check_merge(struct update_subgroup
*subgrp
,
1104 struct update_subgroup
*target
;
1106 if (!update_subgroup_ready_for_merge(subgrp
))
1110 * Look for a subgroup to merge into.
1112 UPDGRP_FOREACH_SUBGRP(subgrp
->update_group
, target
)
1114 if (update_subgroup_can_merge_into(subgrp
, target
))
1121 update_subgroup_merge(subgrp
, target
, reason
);
1126 * update_subgroup_merge_check_thread_cb
1128 static int update_subgroup_merge_check_thread_cb(struct thread
*thread
)
1130 struct update_subgroup
*subgrp
;
1132 subgrp
= THREAD_ARG(thread
);
1134 subgrp
->t_merge_check
= NULL
;
1136 update_subgroup_check_merge(subgrp
, "triggered merge check");
1141 * update_subgroup_trigger_merge_check
1143 * Triggers a call to update_subgroup_check_merge() on a clean context.
1145 * @param force If true, the merge check will be triggered even if the
1146 * subgroup doesn't currently look ready for a merge.
1148 * Returns TRUE if a merge check will be performed shortly.
1150 int update_subgroup_trigger_merge_check(struct update_subgroup
*subgrp
,
1153 if (subgrp
->t_merge_check
)
1156 if (!force
&& !update_subgroup_ready_for_merge(subgrp
))
1159 subgrp
->t_merge_check
= NULL
;
1160 thread_add_timer_msec(bm
->master
, update_subgroup_merge_check_thread_cb
,
1161 subgrp
, 0, &subgrp
->t_merge_check
);
1163 SUBGRP_INCR_STAT(subgrp
, merge_checks_triggered
);
1169 * update_subgroup_copy_adj_out
1171 * Helper function that clones the adj out (state about advertised
1172 * routes) from one subgroup to another. It assumes that the adj out
1173 * of the target subgroup is empty.
1175 static void update_subgroup_copy_adj_out(struct update_subgroup
*source
,
1176 struct update_subgroup
*dest
)
1178 struct bgp_adj_out
*aout
, *aout_copy
;
1180 SUBGRP_FOREACH_ADJ(source
, aout
)
1186 bgp_adj_out_alloc(dest
, aout
->rn
, aout
->addpath_tx_id
);
1188 aout
->attr
? bgp_attr_intern(aout
->attr
) : NULL
;
1193 * update_subgroup_copy_packets
1195 * Copy packets after and including the given packet to the subgroup
1198 * Returns the number of packets copied.
1200 static int update_subgroup_copy_packets(struct update_subgroup
*dest
,
1201 struct bpacket
*pkt
)
1206 while (pkt
&& pkt
->buffer
) {
1207 bpacket_queue_add(SUBGRP_PKTQ(dest
), stream_dup(pkt
->buffer
),
1210 pkt
= bpacket_next(pkt
);
1213 bpacket_queue_sanity_check(SUBGRP_PKTQ(dest
));
1218 static int updgrp_prefix_list_update(struct update_group
*updgrp
,
1222 struct bgp_filter
*filter
;
1224 peer
= UPDGRP_PEER(updgrp
);
1225 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1227 if (PREFIX_LIST_OUT_NAME(filter
)
1228 && (strcmp(name
, PREFIX_LIST_OUT_NAME(filter
)) == 0)) {
1229 PREFIX_LIST_OUT(filter
) = prefix_list_lookup(
1230 UPDGRP_AFI(updgrp
), PREFIX_LIST_OUT_NAME(filter
));
1236 static int updgrp_filter_list_update(struct update_group
*updgrp
,
1240 struct bgp_filter
*filter
;
1242 peer
= UPDGRP_PEER(updgrp
);
1243 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1245 if (FILTER_LIST_OUT_NAME(filter
)
1246 && (strcmp(name
, FILTER_LIST_OUT_NAME(filter
)) == 0)) {
1247 FILTER_LIST_OUT(filter
) =
1248 as_list_lookup(FILTER_LIST_OUT_NAME(filter
));
1254 static int updgrp_distribute_list_update(struct update_group
*updgrp
,
1258 struct bgp_filter
*filter
;
1260 peer
= UPDGRP_PEER(updgrp
);
1261 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1263 if (DISTRIBUTE_OUT_NAME(filter
)
1264 && (strcmp(name
, DISTRIBUTE_OUT_NAME(filter
)) == 0)) {
1265 DISTRIBUTE_OUT(filter
) = access_list_lookup(
1266 UPDGRP_AFI(updgrp
), DISTRIBUTE_OUT_NAME(filter
));
1272 static int updgrp_route_map_update(struct update_group
*updgrp
,
1273 const char *name
, int *def_rmap_changed
)
1276 struct bgp_filter
*filter
;
1281 peer
= UPDGRP_PEER(updgrp
);
1282 afi
= UPDGRP_AFI(updgrp
);
1283 safi
= UPDGRP_SAFI(updgrp
);
1284 filter
= &peer
->filter
[afi
][safi
];
1286 if (ROUTE_MAP_OUT_NAME(filter
)
1287 && (strcmp(name
, ROUTE_MAP_OUT_NAME(filter
)) == 0)) {
1288 ROUTE_MAP_OUT(filter
) = route_map_lookup_by_name(name
);
1293 if (UNSUPPRESS_MAP_NAME(filter
)
1294 && (strcmp(name
, UNSUPPRESS_MAP_NAME(filter
)) == 0)) {
1295 UNSUPPRESS_MAP(filter
) = route_map_lookup_by_name(name
);
1299 /* process default-originate route-map */
1300 if (peer
->default_rmap
[afi
][safi
].name
1301 && (strcmp(name
, peer
->default_rmap
[afi
][safi
].name
) == 0)) {
1302 peer
->default_rmap
[afi
][safi
].map
=
1303 route_map_lookup_by_name(name
);
1304 if (def_rmap_changed
)
1305 *def_rmap_changed
= 1;
1311 * hash iteration callback function to process a policy change for an
1312 * update group. Check if the changed policy matches the updgrp's
1313 * outbound route-map or unsuppress-map or default-originate map or
1314 * filter-list or prefix-list or distribute-list.
1315 * Trigger update generation accordingly.
1317 static int updgrp_policy_update_walkcb(struct update_group
*updgrp
, void *arg
)
1319 struct updwalk_context
*ctx
= arg
;
1320 struct update_subgroup
*subgrp
;
1322 int def_changed
= 0;
1324 if (!updgrp
|| !ctx
|| !ctx
->policy_name
)
1325 return UPDWALK_CONTINUE
;
1327 switch (ctx
->policy_type
) {
1328 case BGP_POLICY_ROUTE_MAP
:
1329 changed
= updgrp_route_map_update(updgrp
, ctx
->policy_name
,
1332 case BGP_POLICY_FILTER_LIST
:
1333 changed
= updgrp_filter_list_update(updgrp
, ctx
->policy_name
);
1335 case BGP_POLICY_PREFIX_LIST
:
1336 changed
= updgrp_prefix_list_update(updgrp
, ctx
->policy_name
);
1338 case BGP_POLICY_DISTRIBUTE_LIST
:
1340 updgrp_distribute_list_update(updgrp
, ctx
->policy_name
);
1346 /* If not doing route update, return after updating "config" */
1347 if (!ctx
->policy_route_update
)
1348 return UPDWALK_CONTINUE
;
1350 /* If nothing has changed, return after updating "config" */
1351 if (!changed
&& !def_changed
)
1352 return UPDWALK_CONTINUE
;
1355 * If something has changed, at the beginning of a route-map
1357 * event, mark each subgroup's needs-refresh bit. For one, it signals to
1358 * whoever that the subgroup needs a refresh. Second, it prevents
1360 * merge of this subgroup with another before a complete (outbound)
1363 if (ctx
->policy_event_start_flag
) {
1364 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
1366 update_subgroup_set_needs_refresh(subgrp
, 1);
1368 return UPDWALK_CONTINUE
;
1371 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
1374 if (bgp_debug_update(NULL
, NULL
, updgrp
, 0))
1376 "u%" PRIu64
":s%" PRIu64
1377 " announcing routes upon policy %s (type %d) change",
1378 updgrp
->id
, subgrp
->id
,
1379 ctx
->policy_name
, ctx
->policy_type
);
1380 subgroup_announce_route(subgrp
);
1383 if (bgp_debug_update(NULL
, NULL
, updgrp
, 0))
1385 "u%" PRIu64
":s%" PRIu64
1386 " announcing default upon default routemap %s change",
1387 updgrp
->id
, subgrp
->id
,
1389 subgroup_default_originate(subgrp
, 0);
1391 update_subgroup_set_needs_refresh(subgrp
, 0);
1393 return UPDWALK_CONTINUE
;
1396 static int update_group_walkcb(struct hash_backet
*backet
, void *arg
)
1398 struct update_group
*updgrp
= backet
->data
;
1399 struct updwalk_context
*wctx
= arg
;
1400 int ret
= (*wctx
->cb
)(updgrp
, wctx
->context
);
1404 static int update_group_periodic_merge_walkcb(struct update_group
*updgrp
,
1407 struct update_subgroup
*subgrp
;
1408 struct update_subgroup
*tmp_subgrp
;
1409 const char *reason
= arg
;
1411 UPDGRP_FOREACH_SUBGRP_SAFE(updgrp
, subgrp
, tmp_subgrp
)
1412 update_subgroup_check_merge(subgrp
, reason
);
1413 return UPDWALK_CONTINUE
;
1416 /********************
1418 ********************/
1421 * trigger function when a policy (route-map/filter-list/prefix-list/
1422 * distribute-list etc.) content changes. Go through all the
1423 * update groups and process the change.
1425 * bgp: the bgp instance
1426 * ptype: the type of policy that got modified, see bgpd.h
1427 * pname: name of the policy
1428 * route_update: flag to control if an automatic update generation should
1430 * start_event: flag that indicates if it's the beginning of the change.
1431 * Esp. when the user is changing the content interactively
1432 * over multiple statements. Useful to set dirty flag on
1435 void update_group_policy_update(struct bgp
*bgp
, bgp_policy_type_e ptype
,
1436 const char *pname
, int route_update
,
1439 struct updwalk_context ctx
;
1441 memset(&ctx
, 0, sizeof(ctx
));
1442 ctx
.policy_type
= ptype
;
1443 ctx
.policy_name
= pname
;
1444 ctx
.policy_route_update
= route_update
;
1445 ctx
.policy_event_start_flag
= start_event
;
1448 update_group_walk(bgp
, updgrp_policy_update_walkcb
, &ctx
);
1452 * update_subgroup_split_peer
1454 * Ensure that the given peer is in a subgroup of its own in the
1455 * specified update group.
1457 void update_subgroup_split_peer(struct peer_af
*paf
,
1458 struct update_group
*updgrp
)
1460 struct update_subgroup
*old_subgrp
, *subgrp
;
1464 old_subgrp
= paf
->subgroup
;
1467 updgrp
= old_subgrp
->update_group
;
1470 * If the peer is alone in its subgroup, reuse the existing
1473 if (old_subgrp
->peer_count
== 1) {
1474 if (updgrp
== old_subgrp
->update_group
)
1477 subgrp
= old_subgrp
;
1478 old_id
= old_subgrp
->update_group
->id
;
1480 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1481 UPDGRP_PEER_DBG_DIS(old_subgrp
->update_group
);
1484 update_group_remove_subgroup(old_subgrp
->update_group
,
1486 update_group_add_subgroup(updgrp
, subgrp
);
1488 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1489 UPDGRP_PEER_DBG_EN(updgrp
);
1491 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1492 zlog_debug("u%" PRIu64
":s%" PRIu64
1493 " peer %s moved to u%" PRIu64
":s%" PRIu64
,
1494 old_id
, subgrp
->id
, paf
->peer
->host
,
1495 updgrp
->id
, subgrp
->id
);
1498 * The state of the subgroup (adj_out, advs, packet queue etc)
1499 * is consistent internally, but may not be identical to other
1500 * subgroups in the new update group even if the version number
1501 * matches up. Make sure a full refresh is done before the
1502 * subgroup is merged with another.
1504 update_subgroup_set_needs_refresh(subgrp
, 1);
1506 SUBGRP_INCR_STAT(subgrp
, updgrp_switch_events
);
1511 * Create a new subgroup under the specified update group, and copy
1512 * over relevant state to it.
1514 subgrp
= update_subgroup_create(updgrp
);
1515 update_subgroup_inherit_info(subgrp
, old_subgrp
);
1517 subgrp
->split_from
.update_group_id
= old_subgrp
->update_group
->id
;
1518 subgrp
->split_from
.subgroup_id
= old_subgrp
->id
;
1521 * Copy out relevant state from the old subgroup.
1523 update_subgroup_copy_adj_out(paf
->subgroup
, subgrp
);
1524 update_subgroup_copy_packets(subgrp
, paf
->next_pkt_to_send
);
1526 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1527 zlog_debug("u%" PRIu64
":s%" PRIu64
1528 " peer %s split and moved into u%" PRIu64
1530 paf
->subgroup
->update_group
->id
, paf
->subgroup
->id
,
1531 paf
->peer
->host
, updgrp
->id
, subgrp
->id
);
1533 SUBGRP_INCR_STAT(paf
->subgroup
, split_events
);
1536 * Since queued advs were left behind, this new subgroup needs a
1539 update_subgroup_set_needs_refresh(subgrp
, 1);
1542 * Remove peer from old subgroup, and add it to the new one.
1544 update_subgroup_remove_peer(paf
->subgroup
, paf
);
1546 update_subgroup_add_peer(subgrp
, paf
, 1);
1549 void update_bgp_group_init(struct bgp
*bgp
)
1554 bgp
->update_groups
[afid
] =
1555 hash_create(updgrp_hash_key_make
,
1557 "BGP Update Group Hash");
1560 void update_bgp_group_free(struct bgp
*bgp
)
1566 if (bgp
->update_groups
[afid
]) {
1567 hash_free(bgp
->update_groups
[afid
]);
1568 bgp
->update_groups
[afid
] = NULL
;
1573 void update_group_show(struct bgp
*bgp
, afi_t afi
, safi_t safi
, struct vty
*vty
,
1576 struct updwalk_context ctx
;
1577 memset(&ctx
, 0, sizeof(ctx
));
1579 ctx
.subgrp_id
= subgrp_id
;
1581 update_group_af_walk(bgp
, afi
, safi
, update_group_show_walkcb
, &ctx
);
1585 * update_group_show_stats
1587 * Show global statistics about update groups.
1589 void update_group_show_stats(struct bgp
*bgp
, struct vty
*vty
)
1591 vty_out(vty
, "Update groups created: %u\n",
1592 bgp
->update_group_stats
.updgrps_created
);
1593 vty_out(vty
, "Update groups deleted: %u\n",
1594 bgp
->update_group_stats
.updgrps_deleted
);
1595 vty_out(vty
, "Update subgroups created: %u\n",
1596 bgp
->update_group_stats
.subgrps_created
);
1597 vty_out(vty
, "Update subgroups deleted: %u\n",
1598 bgp
->update_group_stats
.subgrps_deleted
);
1599 vty_out(vty
, "Join events: %u\n", bgp
->update_group_stats
.join_events
);
1600 vty_out(vty
, "Prune events: %u\n",
1601 bgp
->update_group_stats
.prune_events
);
1602 vty_out(vty
, "Merge events: %u\n",
1603 bgp
->update_group_stats
.merge_events
);
1604 vty_out(vty
, "Split events: %u\n",
1605 bgp
->update_group_stats
.split_events
);
1606 vty_out(vty
, "Update group switch events: %u\n",
1607 bgp
->update_group_stats
.updgrp_switch_events
);
1608 vty_out(vty
, "Peer route refreshes combined: %u\n",
1609 bgp
->update_group_stats
.peer_refreshes_combined
);
1610 vty_out(vty
, "Merge checks triggered: %u\n",
1611 bgp
->update_group_stats
.merge_checks_triggered
);
1615 * update_group_adjust_peer
1617 void update_group_adjust_peer(struct peer_af
*paf
)
1619 struct update_group
*updgrp
;
1620 struct update_subgroup
*subgrp
, *old_subgrp
;
1626 peer
= PAF_PEER(paf
);
1627 if (!peer_established(peer
)) {
1631 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)) {
1635 if (!peer
->afc_nego
[paf
->afi
][paf
->safi
]) {
1639 updgrp
= update_group_find(paf
);
1641 updgrp
= update_group_create(paf
);
1643 zlog_err("couldn't create update group for peer %s",
1649 old_subgrp
= paf
->subgroup
;
1654 * If the update group of the peer is unchanged, the peer can
1656 * in its existing subgroup and we're done.
1658 if (old_subgrp
->update_group
== updgrp
)
1662 * The peer is switching between update groups. Put it in its
1663 * own subgroup under the new update group.
1665 update_subgroup_split_peer(paf
, updgrp
);
1669 subgrp
= update_subgroup_find(updgrp
, paf
);
1671 subgrp
= update_subgroup_create(updgrp
);
1676 update_subgroup_add_peer(subgrp
, paf
, 1);
1677 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1678 zlog_debug("u%" PRIu64
":s%" PRIu64
" add peer %s", updgrp
->id
,
1679 subgrp
->id
, paf
->peer
->host
);
1684 int update_group_adjust_soloness(struct peer
*peer
, int set
)
1686 struct peer_group
*group
;
1687 struct listnode
*node
, *nnode
;
1689 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1690 peer_lonesoul_or_not(peer
, set
);
1691 if (peer
->status
== Established
)
1692 bgp_announce_route_all(peer
);
1694 group
= peer
->group
;
1695 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
1696 peer_lonesoul_or_not(peer
, set
);
1697 if (peer
->status
== Established
)
1698 bgp_announce_route_all(peer
);
1705 * update_subgroup_rib
1707 struct bgp_table
*update_subgroup_rib(struct update_subgroup
*subgrp
)
1711 bgp
= SUBGRP_INST(subgrp
);
1715 return bgp
->rib
[SUBGRP_AFI(subgrp
)][SUBGRP_SAFI(subgrp
)];
1718 void update_group_af_walk(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1719 updgrp_walkcb cb
, void *ctx
)
1721 struct updwalk_context wctx
;
1726 afid
= afindex(afi
, safi
);
1727 if (afid
>= BGP_AF_MAX
)
1730 memset(&wctx
, 0, sizeof(wctx
));
1734 if (bgp
->update_groups
[afid
])
1735 hash_walk(bgp
->update_groups
[afid
], update_group_walkcb
, &wctx
);
1738 void update_group_walk(struct bgp
*bgp
, updgrp_walkcb cb
, void *ctx
)
1743 FOREACH_AFI_SAFI(afi
, safi
)
1745 update_group_af_walk(bgp
, afi
, safi
, cb
, ctx
);
1749 void update_group_periodic_merge(struct bgp
*bgp
)
1751 char reason
[] = "periodic merge check";
1753 update_group_walk(bgp
, update_group_periodic_merge_walkcb
,
1758 update_group_default_originate_route_map_walkcb(struct update_group
*updgrp
,
1761 struct update_subgroup
*subgrp
;
1766 UPDGRP_FOREACH_SUBGRP(updgrp
, subgrp
)
1768 peer
= SUBGRP_PEER(subgrp
);
1769 afi
= SUBGRP_AFI(subgrp
);
1770 safi
= SUBGRP_SAFI(subgrp
);
1772 if (peer
->default_rmap
[afi
][safi
].name
) {
1773 subgroup_default_originate(subgrp
, 0);
1777 return UPDWALK_CONTINUE
;
1780 int update_group_refresh_default_originate_route_map(struct thread
*thread
)
1783 char reason
[] = "refresh default-originate route-map";
1785 bgp
= THREAD_ARG(thread
);
1786 update_group_walk(bgp
, update_group_default_originate_route_map_walkcb
,
1788 THREAD_TIMER_OFF(bgp
->t_rmap_def_originate_eval
);
1795 * peer_af_announce_route
1797 * Refreshes routes out to a peer_af immediately.
1799 * If the combine parameter is TRUE, then this function will try to
1800 * gather other peers in the subgroup for which a route announcement
1801 * is pending and efficently announce routes to all of them.
1803 * For now, the 'combine' option has an effect only if all peers in
1804 * the subgroup have a route announcement pending.
1806 void peer_af_announce_route(struct peer_af
*paf
, int combine
)
1808 struct update_subgroup
*subgrp
;
1809 struct peer_af
*cur_paf
;
1812 subgrp
= paf
->subgroup
;
1817 * If there are other peers in the old subgroup that also need
1818 * routes to be announced, pull them into the peer's new
1820 * Combine route announcement with other peers if possible.
1822 * For now, we combine only if all peers in the subgroup have an
1823 * announcement pending.
1827 SUBGRP_FOREACH_PEER(subgrp
, cur_paf
)
1832 if (cur_paf
->t_announce_route
)
1840 * Announce to the peer alone if we were not asked to combine peers,
1841 * or if some peers don't have a route annoucement pending.
1843 if (!combine
|| !all_pending
) {
1844 update_subgroup_split_peer(paf
, NULL
);
1848 if (bgp_debug_update(paf
->peer
, NULL
, subgrp
->update_group
, 0))
1849 zlog_debug("u%" PRIu64
":s%" PRIu64
1850 " %s announcing routes",
1851 subgrp
->update_group
->id
, subgrp
->id
,
1854 subgroup_announce_route(paf
->subgroup
);
1859 * We will announce routes the entire subgroup.
1861 * First stop refresh timers on all the other peers.
1863 SUBGRP_FOREACH_PEER(subgrp
, cur_paf
)
1868 bgp_stop_announce_route_timer(cur_paf
);
1871 if (bgp_debug_update(paf
->peer
, NULL
, subgrp
->update_group
, 0))
1872 zlog_debug("u%" PRIu64
":s%" PRIu64
1873 " announcing routes to %s, combined into %d peers",
1874 subgrp
->update_group
->id
, subgrp
->id
,
1875 paf
->peer
->host
, subgrp
->peer_count
);
1877 subgroup_announce_route(subgrp
);
1879 SUBGRP_INCR_STAT_BY(subgrp
, peer_refreshes_combined
,
1880 subgrp
->peer_count
- 1);
1883 void subgroup_trigger_write(struct update_subgroup
*subgrp
)
1885 struct peer_af
*paf
;
1888 if (bgp_debug_update(NULL
, NULL
, subgrp
->update_group
, 0))
1889 zlog_debug("u%llu:s%llu scheduling write thread for peers",
1890 subgrp
->update_group
->id
, subgrp
->id
);
1892 SUBGRP_FOREACH_PEER(subgrp
, paf
)
1894 if (paf
->peer
->status
== Established
) {
1895 BGP_PEER_WRITE_ON(paf
->peer
->t_write
, bgp_write
,
1896 paf
->peer
->fd
, paf
->peer
);
1901 int update_group_clear_update_dbg(struct update_group
*updgrp
, void *arg
)
1903 UPDGRP_PEER_DBG_OFF(updgrp
);
1904 return UPDWALK_CONTINUE
;
1907 /* Return true if we should addpath encode NLRI to this peer */
1908 int bgp_addpath_encode_tx(struct peer
*peer
, afi_t afi
, safi_t safi
)
1910 return (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
)
1911 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
1912 PEER_CAP_ADDPATH_AF_RX_RCV
));
1916 * Return true if this is a path we should advertise due to a
1917 * configured addpath-tx knob
1919 int bgp_addpath_tx_path(struct peer
*peer
, afi_t afi
, safi_t safi
,
1920 struct bgp_info
*ri
)
1922 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1923 PEER_FLAG_ADDPATH_TX_ALL_PATHS
))
1926 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
1927 PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS
)
1928 && CHECK_FLAG(ri
->flags
, BGP_INFO_DMED_SELECTED
))