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_errors.h"
51 #include "bgpd/bgp_fsm.h"
52 #include "bgpd/bgp_addpath.h"
53 #include "bgpd/bgp_advertise.h"
54 #include "bgpd/bgp_packet.h"
55 #include "bgpd/bgp_updgrp.h"
56 #include "bgpd/bgp_route.h"
57 #include "bgpd/bgp_filter.h"
58 #include "bgpd/bgp_io.h"
65 * assign a unique ID to update group and subgroup. Mostly for display/
66 * debugging purposes. It's a 64-bit space - used leisurely without a
67 * worry about its wrapping and about filling gaps. While at it, timestamp
70 static void update_group_checkin(struct update_group
*updgrp
)
72 updgrp
->id
= ++bm
->updgrp_idspace
;
73 updgrp
->uptime
= monotime(NULL
);
76 static void update_subgroup_checkin(struct update_subgroup
*subgrp
,
77 struct update_group
*updgrp
)
79 subgrp
->id
= ++bm
->subgrp_idspace
;
80 subgrp
->uptime
= monotime(NULL
);
83 static void sync_init(struct update_subgroup
*subgrp
,
84 struct update_group
*updgrp
)
86 struct peer
*peer
= UPDGRP_PEER(updgrp
);
89 XCALLOC(MTYPE_BGP_SYNCHRONISE
, sizeof(struct bgp_synchronize
));
90 bgp_adv_fifo_init(&subgrp
->sync
->update
);
91 bgp_adv_fifo_init(&subgrp
->sync
->withdraw
);
92 bgp_adv_fifo_init(&subgrp
->sync
->withdraw_low
);
94 hash_create(bgp_advertise_attr_hash_key
,
95 bgp_advertise_attr_hash_cmp
, "BGP SubGroup Hash");
97 /* We use a larger buffer for subgrp->work in the event that:
98 * - We RX a BGP_UPDATE where the attributes alone are just
99 * under 4096 or 65535 (if Extended Message capability negotiated).
100 * - The user configures an outbound route-map that does many as-path
101 * prepends or adds many communities. At most they can have
103 * args in a route-map so there is a finite limit on how large they
105 * make the attributes.
107 * Having a buffer with BGP_MAX_PACKET_SIZE_OVERFLOW allows us to avoid
109 * checking for every single attribute as we construct an UPDATE.
111 subgrp
->work
= stream_new(peer
->max_packet_size
112 + BGP_MAX_PACKET_SIZE_OVERFLOW
);
113 subgrp
->scratch
= stream_new(peer
->max_packet_size
);
116 static void sync_delete(struct update_subgroup
*subgrp
)
118 XFREE(MTYPE_BGP_SYNCHRONISE
, subgrp
->sync
);
120 hash_clean(subgrp
->hash
,
121 (void (*)(void *))bgp_advertise_attr_free
);
122 hash_free(subgrp
->hash
);
126 stream_free(subgrp
->work
);
129 stream_free(subgrp
->scratch
);
130 subgrp
->scratch
= NULL
;
136 * copy only those fields that are relevant to update group match
138 static void conf_copy(struct peer
*dst
, struct peer
*src
, afi_t afi
,
141 struct bgp_filter
*srcfilter
;
142 struct bgp_filter
*dstfilter
;
144 srcfilter
= &src
->filter
[afi
][safi
];
145 dstfilter
= &dst
->filter
[afi
][safi
];
148 dst
->sort
= src
->sort
;
150 dst
->v_routeadv
= src
->v_routeadv
;
151 dst
->flags
= src
->flags
;
152 dst
->af_flags
[afi
][safi
] = src
->af_flags
[afi
][safi
];
153 dst
->pmax_out
[afi
][safi
] = src
->pmax_out
[afi
][safi
];
154 dst
->max_packet_size
= src
->max_packet_size
;
155 XFREE(MTYPE_BGP_PEER_HOST
, dst
->host
);
157 dst
->host
= XSTRDUP(MTYPE_BGP_PEER_HOST
, src
->host
);
159 dst
->af_cap
[afi
][safi
] = src
->af_cap
[afi
][safi
];
160 dst
->afc_nego
[afi
][safi
] = src
->afc_nego
[afi
][safi
];
161 dst
->orf_plist
[afi
][safi
] = src
->orf_plist
[afi
][safi
];
162 dst
->addpath_type
[afi
][safi
] = src
->addpath_type
[afi
][safi
];
163 dst
->local_as
= src
->local_as
;
164 dst
->change_local_as
= src
->change_local_as
;
165 dst
->shared_network
= src
->shared_network
;
166 dst
->local_role
= src
->local_role
;
168 if (src
->soo
[afi
][safi
]) {
169 ecommunity_free(&dst
->soo
[afi
][safi
]);
170 dst
->soo
[afi
][safi
] = ecommunity_dup(src
->soo
[afi
][safi
]);
173 memcpy(&(dst
->nexthop
), &(src
->nexthop
), sizeof(struct bgp_nexthop
));
175 dst
->group
= src
->group
;
177 if (src
->default_rmap
[afi
][safi
].name
) {
178 dst
->default_rmap
[afi
][safi
].name
=
179 XSTRDUP(MTYPE_ROUTE_MAP_NAME
,
180 src
->default_rmap
[afi
][safi
].name
);
181 dst
->default_rmap
[afi
][safi
].map
=
182 src
->default_rmap
[afi
][safi
].map
;
185 if (DISTRIBUTE_OUT_NAME(srcfilter
)) {
186 DISTRIBUTE_OUT_NAME(dstfilter
) = XSTRDUP(
187 MTYPE_BGP_FILTER_NAME
, DISTRIBUTE_OUT_NAME(srcfilter
));
188 DISTRIBUTE_OUT(dstfilter
) = DISTRIBUTE_OUT(srcfilter
);
191 if (PREFIX_LIST_OUT_NAME(srcfilter
)) {
192 PREFIX_LIST_OUT_NAME(dstfilter
) = XSTRDUP(
193 MTYPE_BGP_FILTER_NAME
, PREFIX_LIST_OUT_NAME(srcfilter
));
194 PREFIX_LIST_OUT(dstfilter
) = PREFIX_LIST_OUT(srcfilter
);
197 if (FILTER_LIST_OUT_NAME(srcfilter
)) {
198 FILTER_LIST_OUT_NAME(dstfilter
) = XSTRDUP(
199 MTYPE_BGP_FILTER_NAME
, FILTER_LIST_OUT_NAME(srcfilter
));
200 FILTER_LIST_OUT(dstfilter
) = FILTER_LIST_OUT(srcfilter
);
203 if (ROUTE_MAP_OUT_NAME(srcfilter
)) {
204 ROUTE_MAP_OUT_NAME(dstfilter
) = XSTRDUP(
205 MTYPE_BGP_FILTER_NAME
, ROUTE_MAP_OUT_NAME(srcfilter
));
206 ROUTE_MAP_OUT(dstfilter
) = ROUTE_MAP_OUT(srcfilter
);
209 if (UNSUPPRESS_MAP_NAME(srcfilter
)) {
210 UNSUPPRESS_MAP_NAME(dstfilter
) = XSTRDUP(
211 MTYPE_BGP_FILTER_NAME
, UNSUPPRESS_MAP_NAME(srcfilter
));
212 UNSUPPRESS_MAP(dstfilter
) = UNSUPPRESS_MAP(srcfilter
);
215 if (ADVERTISE_MAP_NAME(srcfilter
)) {
216 ADVERTISE_MAP_NAME(dstfilter
) = XSTRDUP(
217 MTYPE_BGP_FILTER_NAME
, ADVERTISE_MAP_NAME(srcfilter
));
218 ADVERTISE_MAP(dstfilter
) = ADVERTISE_MAP(srcfilter
);
219 ADVERTISE_CONDITION(dstfilter
) = ADVERTISE_CONDITION(srcfilter
);
222 if (CONDITION_MAP_NAME(srcfilter
)) {
223 CONDITION_MAP_NAME(dstfilter
) = XSTRDUP(
224 MTYPE_BGP_FILTER_NAME
, CONDITION_MAP_NAME(srcfilter
));
225 CONDITION_MAP(dstfilter
) = CONDITION_MAP(srcfilter
);
228 dstfilter
->advmap
.update_type
= srcfilter
->advmap
.update_type
;
232 * since we did a bunch of XSTRDUP's in conf_copy, time to free them up
234 static void conf_release(struct peer
*src
, afi_t afi
, safi_t safi
)
236 struct bgp_filter
*srcfilter
;
238 srcfilter
= &src
->filter
[afi
][safi
];
240 XFREE(MTYPE_ROUTE_MAP_NAME
, src
->default_rmap
[afi
][safi
].name
);
242 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->dlist
[FILTER_OUT
].name
);
244 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->plist
[FILTER_OUT
].name
);
246 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->aslist
[FILTER_OUT
].name
);
248 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->map
[RMAP_OUT
].name
);
250 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->usmap
.name
);
252 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->advmap
.aname
);
254 XFREE(MTYPE_BGP_FILTER_NAME
, srcfilter
->advmap
.cname
);
256 XFREE(MTYPE_BGP_PEER_HOST
, src
->host
);
258 ecommunity_free(&src
->soo
[afi
][safi
]);
261 static void peer2_updgrp_copy(struct update_group
*updgrp
, struct peer_af
*paf
)
274 updgrp
->afi
= paf
->afi
;
275 updgrp
->safi
= paf
->safi
;
276 updgrp
->afid
= paf
->afid
;
277 updgrp
->bgp
= src
->bgp
;
279 conf_copy(dst
, src
, paf
->afi
, paf
->safi
);
283 * auxiliary functions to maintain the hash table.
284 * - updgrp_hash_alloc - to create a new entry, passed to hash_get
285 * - updgrp_hash_key_make - makes the key for update group search
286 * - updgrp_hash_cmp - compare two update groups.
288 static void *updgrp_hash_alloc(void *p
)
290 struct update_group
*updgrp
;
291 const struct update_group
*in
;
293 in
= (const struct update_group
*)p
;
294 updgrp
= XCALLOC(MTYPE_BGP_UPDGRP
, sizeof(struct update_group
));
295 memcpy(updgrp
, in
, sizeof(struct update_group
));
296 updgrp
->conf
= XCALLOC(MTYPE_BGP_PEER
, sizeof(struct peer
));
297 conf_copy(updgrp
->conf
, in
->conf
, in
->afi
, in
->safi
);
302 * The hash value for a peer is computed from the following variables:
304 * 1. IBGP (1) or EBGP (2)
305 * 2. FLAGS based on configuration:
306 * LOCAL_AS_NO_PREPEND
307 * LOCAL_AS_REPLACE_AS
308 * 3. AF_FLAGS based on configuration:
309 * Refer to definition in bgp_updgrp.h
310 * 4. (AF-independent) Capability flags:
312 * 5. (AF-dependent) Capability flags:
313 * ORF_PREFIX_SM_RCV (peer can send prefix ORF)
316 * 8. Outbound route-map name (neighbor route-map <> out)
317 * 9. Outbound distribute-list name (neighbor distribute-list <> out)
318 * 10. Outbound prefix-list name (neighbor prefix-list <> out)
319 * 11. Outbound as-list name (neighbor filter-list <> out)
320 * 12. Unsuppress map name (neighbor unsuppress-map <>)
321 * 13. default rmap name (neighbor default-originate route-map <>)
322 * 14. encoding both global and link-local nexthop?
323 * 15. If peer is configured to be a lonesoul, peer ip address
324 * 16. Local-as should match, if configured.
325 * 17. maximum-prefix-out
326 * 18. Local-role should also match, if configured.
329 static unsigned int updgrp_hash_key_make(const void *p
)
331 const struct update_group
*updgrp
;
332 const struct peer
*peer
;
333 const struct bgp_filter
*filter
;
340 #define SEED2 2147483647
346 flags
= peer
->af_flags
[afi
][safi
];
347 filter
= &peer
->filter
[afi
][safi
];
351 key
= jhash_1word(peer
->sort
, key
); /* EBGP or IBGP */
352 key
= jhash_1word((peer
->flags
& PEER_UPDGRP_FLAGS
), key
);
353 key
= jhash_1word((flags
& PEER_UPDGRP_AF_FLAGS
), key
);
354 key
= jhash_1word((uint32_t)peer
->addpath_type
[afi
][safi
], key
);
355 key
= jhash_1word((peer
->cap
& PEER_UPDGRP_CAP_FLAGS
), key
);
356 key
= jhash_1word((peer
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
),
358 key
= jhash_1word(peer
->v_routeadv
, key
);
359 key
= jhash_1word(peer
->change_local_as
, key
);
360 key
= jhash_1word(peer
->max_packet_size
, key
);
361 key
= jhash_1word(peer
->pmax_out
[afi
][safi
], key
);
364 key
= jhash_1word(jhash(peer
->group
->name
,
365 strlen(peer
->group
->name
), SEED1
),
368 if (filter
->map
[RMAP_OUT
].name
)
369 key
= jhash_1word(jhash(filter
->map
[RMAP_OUT
].name
,
370 strlen(filter
->map
[RMAP_OUT
].name
),
374 if (filter
->dlist
[FILTER_OUT
].name
)
375 key
= jhash_1word(jhash(filter
->dlist
[FILTER_OUT
].name
,
376 strlen(filter
->dlist
[FILTER_OUT
].name
),
380 if (filter
->plist
[FILTER_OUT
].name
)
381 key
= jhash_1word(jhash(filter
->plist
[FILTER_OUT
].name
,
382 strlen(filter
->plist
[FILTER_OUT
].name
),
386 if (filter
->aslist
[FILTER_OUT
].name
)
387 key
= jhash_1word(jhash(filter
->aslist
[FILTER_OUT
].name
,
388 strlen(filter
->aslist
[FILTER_OUT
].name
),
392 if (filter
->usmap
.name
)
393 key
= jhash_1word(jhash(filter
->usmap
.name
,
394 strlen(filter
->usmap
.name
), SEED1
),
397 if (filter
->advmap
.aname
)
398 key
= jhash_1word(jhash(filter
->advmap
.aname
,
399 strlen(filter
->advmap
.aname
), SEED1
),
402 if (filter
->advmap
.update_type
)
403 key
= jhash_1word(filter
->advmap
.update_type
, key
);
405 if (peer
->default_rmap
[afi
][safi
].name
)
407 jhash(peer
->default_rmap
[afi
][safi
].name
,
408 strlen(peer
->default_rmap
[afi
][safi
].name
),
412 /* If peer is on a shared network and is exchanging IPv6 prefixes,
413 * it needs to include link-local address. That's different from
414 * non-shared-network peers (nexthop encoded with 32 bytes vs 16
415 * bytes). We create different update groups to take care of that.
418 (peer
->shared_network
&& peer_afi_active_nego(peer
, AFI_IP6
)),
421 * There are certain peers that must get their own update-group:
423 * - peers that negotiated ORF
424 * - maximum-prefix-out is set
426 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
)
427 || CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_RCV
)
428 || CHECK_FLAG(peer
->af_cap
[afi
][safi
],
429 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
)
430 || CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_MAX_PREFIX_OUT
))
431 key
= jhash_1word(jhash(peer
->host
, strlen(peer
->host
), SEED2
),
434 * Multiple sessions with the same neighbor should get their own
435 * update-group if they have different roles.
437 key
= jhash_1word(peer
->local_role
, key
);
439 /* Neighbors configured with the AIGP attribute are put in a separate
440 * update group from other neighbors.
442 key
= jhash_1word((peer
->flags
& PEER_FLAG_AIGP
), key
);
444 if (peer
->soo
[afi
][safi
]) {
445 char *soo_str
= ecommunity_str(peer
->soo
[afi
][safi
]);
447 key
= jhash_1word(jhash(soo_str
, strlen(soo_str
), SEED1
), key
);
450 if (bgp_debug_neighbor_events(peer
)) {
452 "%pBP Update Group Hash: sort: %d UpdGrpFlags: %ju UpdGrpAFFlags: %ju",
454 (intmax_t)CHECK_FLAG(peer
->flags
, PEER_UPDGRP_FLAGS
),
455 (intmax_t)CHECK_FLAG(flags
, PEER_UPDGRP_AF_FLAGS
));
457 "%pBP Update Group Hash: addpath: %u UpdGrpCapFlag: %u UpdGrpCapAFFlag: %u route_adv: %u change local as: %u",
458 peer
, (uint32_t)peer
->addpath_type
[afi
][safi
],
459 CHECK_FLAG(peer
->cap
, PEER_UPDGRP_CAP_FLAGS
),
460 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
461 PEER_UPDGRP_AF_CAP_FLAGS
),
462 peer
->v_routeadv
, peer
->change_local_as
);
464 "%pBP Update Group Hash: max packet size: %u pmax_out: %u Peer Group: %s rmap out: %s",
465 peer
, peer
->max_packet_size
, peer
->pmax_out
[afi
][safi
],
466 peer
->group
? peer
->group
->name
: "(NONE)",
467 ROUTE_MAP_OUT_NAME(filter
) ? ROUTE_MAP_OUT_NAME(filter
)
470 "%pBP Update Group Hash: dlist out: %s plist out: %s aslist out: %s usmap out: %s advmap: %s",
472 DISTRIBUTE_OUT_NAME(filter
)
473 ? DISTRIBUTE_OUT_NAME(filter
)
475 PREFIX_LIST_OUT_NAME(filter
)
476 ? PREFIX_LIST_OUT_NAME(filter
)
478 FILTER_LIST_OUT_NAME(filter
)
479 ? FILTER_LIST_OUT_NAME(filter
)
481 UNSUPPRESS_MAP_NAME(filter
)
482 ? UNSUPPRESS_MAP_NAME(filter
)
484 ADVERTISE_MAP_NAME(filter
) ? ADVERTISE_MAP_NAME(filter
)
487 "%pBP Update Group Hash: default rmap: %s shared network and afi active network: %d",
489 peer
->default_rmap
[afi
][safi
].name
490 ? peer
->default_rmap
[afi
][safi
].name
492 peer
->shared_network
&&
493 peer_afi_active_nego(peer
, AFI_IP6
));
495 "%pBP Update Group Hash: Lonesoul: %d ORF prefix: %u ORF old: %u max prefix out: %ju",
496 peer
, !!CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
),
497 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
498 PEER_CAP_ORF_PREFIX_SM_RCV
),
499 CHECK_FLAG(peer
->af_cap
[afi
][safi
],
500 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
),
501 (intmax_t)CHECK_FLAG(peer
->af_flags
[afi
][safi
],
502 PEER_FLAG_MAX_PREFIX_OUT
));
503 zlog_debug("%pBP Update Group Hash key: %u", peer
, key
);
508 static bool updgrp_hash_cmp(const void *p1
, const void *p2
)
510 const struct update_group
*grp1
;
511 const struct update_group
*grp2
;
512 const struct peer
*pe1
;
513 const struct peer
*pe2
;
516 const struct bgp_filter
*fl1
;
517 const struct bgp_filter
*fl2
;
530 flags1
= pe1
->af_flags
[afi
][safi
];
531 flags2
= pe2
->af_flags
[afi
][safi
];
532 fl1
= &pe1
->filter
[afi
][safi
];
533 fl2
= &pe2
->filter
[afi
][safi
];
535 /* put EBGP and IBGP peers in different update groups */
536 if (pe1
->sort
!= pe2
->sort
)
539 /* check peer flags */
540 if ((pe1
->flags
& PEER_UPDGRP_FLAGS
)
541 != (pe2
->flags
& PEER_UPDGRP_FLAGS
))
544 /* If there is 'local-as' configured, it should match. */
545 if (pe1
->change_local_as
!= pe2
->change_local_as
)
548 if (pe1
->pmax_out
[afi
][safi
] != pe2
->pmax_out
[afi
][safi
])
551 /* flags like route reflector client */
552 if ((flags1
& PEER_UPDGRP_AF_FLAGS
) != (flags2
& PEER_UPDGRP_AF_FLAGS
))
555 if (pe1
->addpath_type
[afi
][safi
] != pe2
->addpath_type
[afi
][safi
])
558 if ((pe1
->cap
& PEER_UPDGRP_CAP_FLAGS
)
559 != (pe2
->cap
& PEER_UPDGRP_CAP_FLAGS
))
562 if ((pe1
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
)
563 != (pe2
->af_cap
[afi
][safi
] & PEER_UPDGRP_AF_CAP_FLAGS
))
566 if (pe1
->v_routeadv
!= pe2
->v_routeadv
)
569 if (pe1
->group
!= pe2
->group
)
572 /* Roles can affect filtering */
573 if (pe1
->local_role
!= pe2
->local_role
)
576 /* route-map names should be the same */
577 if ((fl1
->map
[RMAP_OUT
].name
&& !fl2
->map
[RMAP_OUT
].name
)
578 || (!fl1
->map
[RMAP_OUT
].name
&& fl2
->map
[RMAP_OUT
].name
)
579 || (fl1
->map
[RMAP_OUT
].name
&& fl2
->map
[RMAP_OUT
].name
580 && strcmp(fl1
->map
[RMAP_OUT
].name
, fl2
->map
[RMAP_OUT
].name
)))
583 if ((fl1
->dlist
[FILTER_OUT
].name
&& !fl2
->dlist
[FILTER_OUT
].name
)
584 || (!fl1
->dlist
[FILTER_OUT
].name
&& fl2
->dlist
[FILTER_OUT
].name
)
585 || (fl1
->dlist
[FILTER_OUT
].name
&& fl2
->dlist
[FILTER_OUT
].name
586 && strcmp(fl1
->dlist
[FILTER_OUT
].name
,
587 fl2
->dlist
[FILTER_OUT
].name
)))
590 if ((fl1
->plist
[FILTER_OUT
].name
&& !fl2
->plist
[FILTER_OUT
].name
)
591 || (!fl1
->plist
[FILTER_OUT
].name
&& fl2
->plist
[FILTER_OUT
].name
)
592 || (fl1
->plist
[FILTER_OUT
].name
&& fl2
->plist
[FILTER_OUT
].name
593 && strcmp(fl1
->plist
[FILTER_OUT
].name
,
594 fl2
->plist
[FILTER_OUT
].name
)))
597 if ((fl1
->aslist
[FILTER_OUT
].name
&& !fl2
->aslist
[FILTER_OUT
].name
)
598 || (!fl1
->aslist
[FILTER_OUT
].name
&& fl2
->aslist
[FILTER_OUT
].name
)
599 || (fl1
->aslist
[FILTER_OUT
].name
&& fl2
->aslist
[FILTER_OUT
].name
600 && strcmp(fl1
->aslist
[FILTER_OUT
].name
,
601 fl2
->aslist
[FILTER_OUT
].name
)))
604 if ((fl1
->usmap
.name
&& !fl2
->usmap
.name
)
605 || (!fl1
->usmap
.name
&& fl2
->usmap
.name
)
606 || (fl1
->usmap
.name
&& fl2
->usmap
.name
607 && strcmp(fl1
->usmap
.name
, fl2
->usmap
.name
)))
610 if ((fl1
->advmap
.aname
&& !fl2
->advmap
.aname
)
611 || (!fl1
->advmap
.aname
&& fl2
->advmap
.aname
)
612 || (fl1
->advmap
.aname
&& fl2
->advmap
.aname
613 && strcmp(fl1
->advmap
.aname
, fl2
->advmap
.aname
)))
616 if (fl1
->advmap
.update_type
!= fl2
->advmap
.update_type
)
619 if ((pe1
->default_rmap
[afi
][safi
].name
620 && !pe2
->default_rmap
[afi
][safi
].name
)
621 || (!pe1
->default_rmap
[afi
][safi
].name
622 && pe2
->default_rmap
[afi
][safi
].name
)
623 || (pe1
->default_rmap
[afi
][safi
].name
624 && pe2
->default_rmap
[afi
][safi
].name
625 && strcmp(pe1
->default_rmap
[afi
][safi
].name
,
626 pe2
->default_rmap
[afi
][safi
].name
)))
629 if ((afi
== AFI_IP6
) && (pe1
->shared_network
!= pe2
->shared_network
))
632 if ((CHECK_FLAG(pe1
->flags
, PEER_FLAG_LONESOUL
)
633 || CHECK_FLAG(pe1
->af_cap
[afi
][safi
], PEER_CAP_ORF_PREFIX_SM_RCV
)
634 || CHECK_FLAG(pe1
->af_cap
[afi
][safi
],
635 PEER_CAP_ORF_PREFIX_SM_OLD_RCV
))
636 && !sockunion_same(&pe1
->su
, &pe2
->su
))
642 static void peer_lonesoul_or_not(struct peer
*peer
, int set
)
644 /* no change in status? */
645 if (set
== (CHECK_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
) > 0))
649 SET_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
);
651 UNSET_FLAG(peer
->flags
, PEER_FLAG_LONESOUL
);
653 update_group_adjust_peer_afs(peer
);
657 * subgroup_total_packets_enqueued
659 * Returns the total number of packets enqueued to a subgroup.
662 subgroup_total_packets_enqueued(struct update_subgroup
*subgrp
)
666 pkt
= bpacket_queue_last(SUBGRP_PKTQ(subgrp
));
671 static int update_group_show_walkcb(struct update_group
*updgrp
, void *arg
)
673 struct updwalk_context
*ctx
= arg
;
675 struct update_subgroup
*subgrp
;
677 struct bgp_filter
*filter
;
678 struct peer
*peer
= UPDGRP_PEER(updgrp
);
684 if (ctx
->subgrp_id
) {
685 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
686 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
698 /* Since this routine is invoked from a walk, we cannot signal
700 /* error here, can only return. */
706 vty_out(vty
, "Update-group %" PRIu64
":\n", updgrp
->id
);
707 vty_out(vty
, " Created: %s", timestamp_string(updgrp
->uptime
));
708 filter
= &updgrp
->conf
->filter
[updgrp
->afi
][updgrp
->safi
];
709 if (filter
->map
[RMAP_OUT
].name
)
710 vty_out(vty
, " Outgoing route map: %s\n",
711 filter
->map
[RMAP_OUT
].name
);
712 vty_out(vty
, " MRAI value (seconds): %d\n", updgrp
->conf
->v_routeadv
);
713 if (updgrp
->conf
->change_local_as
)
714 vty_out(vty
, " Local AS %u%s%s\n",
715 updgrp
->conf
->change_local_as
,
716 CHECK_FLAG(updgrp
->conf
->flags
,
717 PEER_FLAG_LOCAL_AS_NO_PREPEND
)
720 CHECK_FLAG(updgrp
->conf
->flags
,
721 PEER_FLAG_LOCAL_AS_REPLACE_AS
)
725 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
726 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
729 vty_out(vty
, " Update-subgroup %" PRIu64
":\n", subgrp
->id
);
730 vty_out(vty
, " Created: %s",
731 timestamp_string(subgrp
->uptime
));
733 if (subgrp
->split_from
.update_group_id
734 || subgrp
->split_from
.subgroup_id
) {
735 vty_out(vty
, " Split from group id: %" PRIu64
"\n",
736 subgrp
->split_from
.update_group_id
);
738 " Split from subgroup id: %" PRIu64
"\n",
739 subgrp
->split_from
.subgroup_id
);
742 vty_out(vty
, " Join events: %u\n", subgrp
->join_events
);
743 vty_out(vty
, " Prune events: %u\n", subgrp
->prune_events
);
744 vty_out(vty
, " Merge events: %u\n", subgrp
->merge_events
);
745 vty_out(vty
, " Split events: %u\n", subgrp
->split_events
);
746 vty_out(vty
, " Update group switch events: %u\n",
747 subgrp
->updgrp_switch_events
);
748 vty_out(vty
, " Peer refreshes combined: %u\n",
749 subgrp
->peer_refreshes_combined
);
750 vty_out(vty
, " Merge checks triggered: %u\n",
751 subgrp
->merge_checks_triggered
);
752 vty_out(vty
, " Coalesce Time: %u%s\n",
753 (UPDGRP_INST(subgrp
->update_group
))->coalesce_time
,
754 subgrp
->t_coalesce
? "(Running)" : "");
755 vty_out(vty
, " Version: %" PRIu64
"\n", subgrp
->version
);
756 vty_out(vty
, " Packet queue length: %d\n",
757 bpacket_queue_length(SUBGRP_PKTQ(subgrp
)));
758 vty_out(vty
, " Total packets enqueued: %u\n",
759 subgroup_total_packets_enqueued(subgrp
));
760 vty_out(vty
, " Packet queue high watermark: %d\n",
761 bpacket_queue_hwm_length(SUBGRP_PKTQ(subgrp
)));
762 vty_out(vty
, " Adj-out list count: %u\n", subgrp
->adj_count
);
763 vty_out(vty
, " Advertise list: %s\n",
764 advertise_list_is_empty(subgrp
) ? "empty"
766 vty_out(vty
, " Flags: %s\n",
767 CHECK_FLAG(subgrp
->flags
, SUBGRP_FLAG_NEEDS_REFRESH
)
771 vty_out(vty
, " Max packet size: %d\n",
772 peer
->max_packet_size
);
773 if (subgrp
->peer_count
> 0) {
774 vty_out(vty
, " Peers:\n");
775 SUBGRP_FOREACH_PEER (subgrp
, paf
)
776 vty_out(vty
, " - %s\n", paf
->peer
->host
);
779 return UPDWALK_CONTINUE
;
783 * Helper function to show the packet queue for each subgroup of update group.
784 * Will be constrained to a particular subgroup id if id !=0
786 static int updgrp_show_packet_queue_walkcb(struct update_group
*updgrp
,
789 struct updwalk_context
*ctx
= arg
;
790 struct update_subgroup
*subgrp
;
794 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
795 if (ctx
->subgrp_id
&& (ctx
->subgrp_id
!= subgrp
->id
))
797 vty_out(vty
, "update group %" PRIu64
", subgroup %" PRIu64
"\n",
798 updgrp
->id
, subgrp
->id
);
799 bpacket_queue_show_vty(SUBGRP_PKTQ(subgrp
), vty
);
801 return UPDWALK_CONTINUE
;
805 * Show the packet queue for each subgroup of update group. Will be
806 * constrained to a particular subgroup id if id !=0
808 void update_group_show_packet_queue(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
809 struct vty
*vty
, uint64_t id
)
811 struct updwalk_context ctx
;
813 memset(&ctx
, 0, sizeof(ctx
));
817 update_group_af_walk(bgp
, afi
, safi
, updgrp_show_packet_queue_walkcb
,
821 static struct update_group
*update_group_find(struct peer_af
*paf
)
823 struct update_group
*updgrp
;
824 struct update_group tmp
;
825 struct peer tmp_conf
;
827 if (!peer_established(PAF_PEER(paf
)))
830 memset(&tmp
, 0, sizeof(tmp
));
831 memset(&tmp_conf
, 0, sizeof(tmp_conf
));
832 tmp
.conf
= &tmp_conf
;
833 peer2_updgrp_copy(&tmp
, paf
);
835 updgrp
= hash_lookup(paf
->peer
->bgp
->update_groups
[paf
->afid
], &tmp
);
836 conf_release(&tmp_conf
, paf
->afi
, paf
->safi
);
840 static struct update_group
*update_group_create(struct peer_af
*paf
)
842 struct update_group
*updgrp
;
843 struct update_group tmp
;
844 struct peer tmp_conf
;
846 memset(&tmp
, 0, sizeof(tmp
));
847 memset(&tmp_conf
, 0, sizeof(tmp_conf
));
848 tmp
.conf
= &tmp_conf
;
849 peer2_updgrp_copy(&tmp
, paf
);
851 updgrp
= hash_get(paf
->peer
->bgp
->update_groups
[paf
->afid
], &tmp
,
853 update_group_checkin(updgrp
);
855 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
856 zlog_debug("create update group %" PRIu64
, updgrp
->id
);
858 UPDGRP_GLOBAL_STAT(updgrp
, updgrps_created
) += 1;
860 conf_release(&tmp_conf
, paf
->afi
, paf
->safi
);
864 static void update_group_delete(struct update_group
*updgrp
)
866 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
867 zlog_debug("delete update group %" PRIu64
, updgrp
->id
);
869 UPDGRP_GLOBAL_STAT(updgrp
, updgrps_deleted
) += 1;
871 hash_release(updgrp
->bgp
->update_groups
[updgrp
->afid
], updgrp
);
872 conf_release(updgrp
->conf
, updgrp
->afi
, updgrp
->safi
);
874 XFREE(MTYPE_BGP_PEER_HOST
, updgrp
->conf
->host
);
876 XFREE(MTYPE_BGP_PEER_IFNAME
, updgrp
->conf
->ifname
);
878 XFREE(MTYPE_BGP_PEER
, updgrp
->conf
);
879 XFREE(MTYPE_BGP_UPDGRP
, updgrp
);
882 static void update_group_add_subgroup(struct update_group
*updgrp
,
883 struct update_subgroup
*subgrp
)
885 if (!updgrp
|| !subgrp
)
888 LIST_INSERT_HEAD(&(updgrp
->subgrps
), subgrp
, updgrp_train
);
889 subgrp
->update_group
= updgrp
;
892 static void update_group_remove_subgroup(struct update_group
*updgrp
,
893 struct update_subgroup
*subgrp
)
895 if (!updgrp
|| !subgrp
)
898 LIST_REMOVE(subgrp
, updgrp_train
);
899 subgrp
->update_group
= NULL
;
900 if (LIST_EMPTY(&(updgrp
->subgrps
)))
901 update_group_delete(updgrp
);
904 static struct update_subgroup
*
905 update_subgroup_create(struct update_group
*updgrp
)
907 struct update_subgroup
*subgrp
;
909 subgrp
= XCALLOC(MTYPE_BGP_UPD_SUBGRP
, sizeof(struct update_subgroup
));
910 update_subgroup_checkin(subgrp
, updgrp
);
911 subgrp
->v_coalesce
= (UPDGRP_INST(updgrp
))->coalesce_time
;
912 sync_init(subgrp
, updgrp
);
913 bpacket_queue_init(SUBGRP_PKTQ(subgrp
));
914 bpacket_queue_add(SUBGRP_PKTQ(subgrp
), NULL
, NULL
);
915 TAILQ_INIT(&(subgrp
->adjq
));
916 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
917 zlog_debug("create subgroup u%" PRIu64
":s%" PRIu64
, updgrp
->id
,
920 update_group_add_subgroup(updgrp
, subgrp
);
922 UPDGRP_INCR_STAT(updgrp
, subgrps_created
);
927 static void update_subgroup_delete(struct update_subgroup
*subgrp
)
932 if (subgrp
->update_group
)
933 UPDGRP_INCR_STAT(subgrp
->update_group
, subgrps_deleted
);
935 THREAD_OFF(subgrp
->t_merge_check
);
936 THREAD_OFF(subgrp
->t_coalesce
);
938 bpacket_queue_cleanup(SUBGRP_PKTQ(subgrp
));
939 subgroup_clear_table(subgrp
);
943 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
) && subgrp
->update_group
)
944 zlog_debug("delete subgroup u%" PRIu64
":s%" PRIu64
,
945 subgrp
->update_group
->id
, subgrp
->id
);
947 update_group_remove_subgroup(subgrp
->update_group
, subgrp
);
949 XFREE(MTYPE_BGP_UPD_SUBGRP
, subgrp
);
952 void update_subgroup_inherit_info(struct update_subgroup
*to
,
953 struct update_subgroup
*from
)
958 to
->sflags
= from
->sflags
;
962 * update_subgroup_check_delete
964 * Delete a subgroup if it is ready to be deleted.
966 * Returns true if the subgroup was deleted.
968 static bool update_subgroup_check_delete(struct update_subgroup
*subgrp
)
973 if (!LIST_EMPTY(&(subgrp
->peers
)))
976 update_subgroup_delete(subgrp
);
982 * update_subgroup_add_peer
984 * @param send_enqueued_packets If true all currently enqueued packets will
985 * also be sent to the peer.
987 static void update_subgroup_add_peer(struct update_subgroup
*subgrp
,
989 int send_enqueued_pkts
)
996 LIST_INSERT_HEAD(&(subgrp
->peers
), paf
, subgrp_train
);
997 paf
->subgroup
= subgrp
;
998 subgrp
->peer_count
++;
1000 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1001 UPDGRP_PEER_DBG_EN(subgrp
->update_group
);
1004 SUBGRP_INCR_STAT(subgrp
, join_events
);
1006 if (send_enqueued_pkts
) {
1007 pkt
= bpacket_queue_first(SUBGRP_PKTQ(subgrp
));
1011 * Hang the peer off of the last, placeholder, packet in the
1012 * queue. This means it won't see any of the packets that are
1013 * currently the queue.
1015 pkt
= bpacket_queue_last(SUBGRP_PKTQ(subgrp
));
1016 assert(pkt
->buffer
== NULL
);
1019 bpacket_add_peer(pkt
, paf
);
1021 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1022 zlog_debug("peer %s added to subgroup s%" PRIu64
,
1023 paf
->peer
->host
, subgrp
->id
);
1027 * update_subgroup_remove_peer_internal
1029 * Internal function that removes a peer from a subgroup, but does not
1030 * delete the subgroup. A call to this function must almost always be
1031 * followed by a call to update_subgroup_check_delete().
1033 * @see update_subgroup_remove_peer
1035 static void update_subgroup_remove_peer_internal(struct update_subgroup
*subgrp
,
1036 struct peer_af
*paf
)
1038 assert(subgrp
&& paf
&& subgrp
->update_group
);
1040 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1041 UPDGRP_PEER_DBG_DIS(subgrp
->update_group
);
1044 bpacket_queue_remove_peer(paf
);
1045 LIST_REMOVE(paf
, subgrp_train
);
1046 paf
->subgroup
= NULL
;
1047 subgrp
->peer_count
--;
1049 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1050 zlog_debug("peer %s deleted from subgroup s%"
1051 PRIu64
" peer cnt %d",
1052 paf
->peer
->host
, subgrp
->id
, subgrp
->peer_count
);
1053 SUBGRP_INCR_STAT(subgrp
, prune_events
);
1057 * update_subgroup_remove_peer
1059 void update_subgroup_remove_peer(struct update_subgroup
*subgrp
,
1060 struct peer_af
*paf
)
1062 if (!subgrp
|| !paf
)
1065 update_subgroup_remove_peer_internal(subgrp
, paf
);
1067 if (update_subgroup_check_delete(subgrp
))
1071 * The deletion of the peer may have caused some packets to be
1072 * deleted from the subgroup packet queue. Check if the subgroup can
1075 update_subgroup_check_merge(subgrp
, "removed peer from subgroup");
1078 static struct update_subgroup
*update_subgroup_find(struct update_group
*updgrp
,
1079 struct peer_af
*paf
)
1081 struct update_subgroup
*subgrp
= NULL
;
1084 if (paf
->subgroup
) {
1090 if (!peer_established(PAF_PEER(paf
)))
1093 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
1094 if (subgrp
->version
!= version
1095 || CHECK_FLAG(subgrp
->sflags
,
1096 SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1100 * The version number is not meaningful on a subgroup that needs
1103 if (update_subgroup_needs_refresh(subgrp
))
1113 * update_subgroup_ready_for_merge
1115 * Returns true if this subgroup is in a state that allows it to be
1116 * merged into another subgroup.
1118 static bool update_subgroup_ready_for_merge(struct update_subgroup
*subgrp
)
1122 * Not ready if there are any encoded packets waiting to be written
1125 if (!bpacket_queue_is_empty(SUBGRP_PKTQ(subgrp
)))
1129 * Not ready if there enqueued updates waiting to be encoded.
1131 if (!advertise_list_is_empty(subgrp
))
1135 * Don't attempt to merge a subgroup that needs a refresh. For one,
1136 * we can't determine if the adj_out of such a group matches that of
1139 if (update_subgroup_needs_refresh(subgrp
))
1146 * update_subgrp_can_merge_into
1148 * Returns true if the first subgroup can merge into the second
1151 static int update_subgroup_can_merge_into(struct update_subgroup
*subgrp
,
1152 struct update_subgroup
*target
)
1155 if (subgrp
== target
)
1159 * Both must have processed the BRIB to the same point in order to
1162 if (subgrp
->version
!= target
->version
)
1165 if (CHECK_FLAG(subgrp
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
)
1166 != CHECK_FLAG(target
->sflags
, SUBGRP_STATUS_DEFAULT_ORIGINATE
))
1169 if (subgrp
->adj_count
!= target
->adj_count
)
1172 return update_subgroup_ready_for_merge(target
);
1176 * update_subgroup_merge
1178 * Merge the first subgroup into the second one.
1180 static void update_subgroup_merge(struct update_subgroup
*subgrp
,
1181 struct update_subgroup
*target
,
1184 struct peer_af
*paf
;
1188 assert(subgrp
->adj_count
== target
->adj_count
);
1190 peer_count
= subgrp
->peer_count
;
1193 paf
= LIST_FIRST(&subgrp
->peers
);
1197 update_subgroup_remove_peer_internal(subgrp
, paf
);
1200 * Add the peer to the target subgroup, while making sure that
1201 * any currently enqueued packets won't be sent to it. Enqueued
1202 * packets could, for example, result in an unnecessary withdraw
1203 * followed by an advertise.
1205 update_subgroup_add_peer(target
, paf
, 0);
1208 SUBGRP_INCR_STAT(target
, merge_events
);
1210 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1211 zlog_debug("u%" PRIu64
":s%" PRIu64
" (%d peers) merged into u%" PRIu64
":s%" PRIu64
", trigger: %s",
1212 subgrp
->update_group
->id
, subgrp
->id
, peer_count
,
1213 target
->update_group
->id
, target
->id
,
1214 reason
? reason
: "unknown");
1216 result
= update_subgroup_check_delete(subgrp
);
1221 * update_subgroup_check_merge
1223 * Merge this subgroup into another subgroup if possible.
1225 * Returns true if the subgroup has been merged. The subgroup pointer
1226 * should not be accessed in this case.
1228 bool update_subgroup_check_merge(struct update_subgroup
*subgrp
,
1231 struct update_subgroup
*target
;
1233 if (!update_subgroup_ready_for_merge(subgrp
))
1237 * Look for a subgroup to merge into.
1239 UPDGRP_FOREACH_SUBGRP (subgrp
->update_group
, target
) {
1240 if (update_subgroup_can_merge_into(subgrp
, target
))
1247 update_subgroup_merge(subgrp
, target
, reason
);
1252 * update_subgroup_merge_check_thread_cb
1254 static void update_subgroup_merge_check_thread_cb(struct thread
*thread
)
1256 struct update_subgroup
*subgrp
;
1258 subgrp
= THREAD_ARG(thread
);
1260 subgrp
->t_merge_check
= NULL
;
1262 update_subgroup_check_merge(subgrp
, "triggered merge check");
1266 * update_subgroup_trigger_merge_check
1268 * Triggers a call to update_subgroup_check_merge() on a clean context.
1270 * @param force If true, the merge check will be triggered even if the
1271 * subgroup doesn't currently look ready for a merge.
1273 * Returns true if a merge check will be performed shortly.
1275 bool update_subgroup_trigger_merge_check(struct update_subgroup
*subgrp
,
1278 if (subgrp
->t_merge_check
)
1281 if (!force
&& !update_subgroup_ready_for_merge(subgrp
))
1284 subgrp
->t_merge_check
= NULL
;
1285 thread_add_timer_msec(bm
->master
, update_subgroup_merge_check_thread_cb
,
1286 subgrp
, 0, &subgrp
->t_merge_check
);
1288 SUBGRP_INCR_STAT(subgrp
, merge_checks_triggered
);
1294 * update_subgroup_copy_adj_out
1296 * Helper function that clones the adj out (state about advertised
1297 * routes) from one subgroup to another. It assumes that the adj out
1298 * of the target subgroup is empty.
1300 static void update_subgroup_copy_adj_out(struct update_subgroup
*source
,
1301 struct update_subgroup
*dest
)
1303 struct bgp_adj_out
*aout
, *aout_copy
;
1305 SUBGRP_FOREACH_ADJ (source
, aout
) {
1309 aout_copy
= bgp_adj_out_alloc(dest
, aout
->dest
,
1310 aout
->addpath_tx_id
);
1312 aout
->attr
? bgp_attr_intern(aout
->attr
) : NULL
;
1315 dest
->scount
= source
->scount
;
1319 * update_subgroup_copy_packets
1321 * Copy packets after and including the given packet to the subgroup
1324 * Returns the number of packets copied.
1326 static int update_subgroup_copy_packets(struct update_subgroup
*dest
,
1327 struct bpacket
*pkt
)
1332 while (pkt
&& pkt
->buffer
) {
1333 bpacket_queue_add(SUBGRP_PKTQ(dest
), stream_dup(pkt
->buffer
),
1336 pkt
= bpacket_next(pkt
);
1342 static bool updgrp_prefix_list_update(struct update_group
*updgrp
,
1346 struct bgp_filter
*filter
;
1348 peer
= UPDGRP_PEER(updgrp
);
1349 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1351 if (PREFIX_LIST_OUT_NAME(filter
)
1352 && (strcmp(name
, PREFIX_LIST_OUT_NAME(filter
)) == 0)) {
1353 PREFIX_LIST_OUT(filter
) = prefix_list_lookup(
1354 UPDGRP_AFI(updgrp
), PREFIX_LIST_OUT_NAME(filter
));
1360 static bool updgrp_filter_list_update(struct update_group
*updgrp
,
1364 struct bgp_filter
*filter
;
1366 peer
= UPDGRP_PEER(updgrp
);
1367 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1369 if (FILTER_LIST_OUT_NAME(filter
)
1370 && (strcmp(name
, FILTER_LIST_OUT_NAME(filter
)) == 0)) {
1371 FILTER_LIST_OUT(filter
) =
1372 as_list_lookup(FILTER_LIST_OUT_NAME(filter
));
1378 static bool updgrp_distribute_list_update(struct update_group
*updgrp
,
1382 struct bgp_filter
*filter
;
1384 peer
= UPDGRP_PEER(updgrp
);
1385 filter
= &peer
->filter
[UPDGRP_AFI(updgrp
)][UPDGRP_SAFI(updgrp
)];
1387 if (DISTRIBUTE_OUT_NAME(filter
)
1388 && (strcmp(name
, DISTRIBUTE_OUT_NAME(filter
)) == 0)) {
1389 DISTRIBUTE_OUT(filter
) = access_list_lookup(
1390 UPDGRP_AFI(updgrp
), DISTRIBUTE_OUT_NAME(filter
));
1396 static int updgrp_route_map_update(struct update_group
*updgrp
,
1397 const char *name
, int *def_rmap_changed
)
1400 struct bgp_filter
*filter
;
1405 peer
= UPDGRP_PEER(updgrp
);
1406 afi
= UPDGRP_AFI(updgrp
);
1407 safi
= UPDGRP_SAFI(updgrp
);
1408 filter
= &peer
->filter
[afi
][safi
];
1410 if (ROUTE_MAP_OUT_NAME(filter
)
1411 && (strcmp(name
, ROUTE_MAP_OUT_NAME(filter
)) == 0)) {
1412 ROUTE_MAP_OUT(filter
) = route_map_lookup_by_name(name
);
1417 if (UNSUPPRESS_MAP_NAME(filter
)
1418 && (strcmp(name
, UNSUPPRESS_MAP_NAME(filter
)) == 0)) {
1419 UNSUPPRESS_MAP(filter
) = route_map_lookup_by_name(name
);
1423 /* process default-originate route-map */
1424 if (peer
->default_rmap
[afi
][safi
].name
1425 && (strcmp(name
, peer
->default_rmap
[afi
][safi
].name
) == 0)) {
1426 peer
->default_rmap
[afi
][safi
].map
=
1427 route_map_lookup_by_name(name
);
1428 if (def_rmap_changed
)
1429 *def_rmap_changed
= 1;
1435 * hash iteration callback function to process a policy change for an
1436 * update group. Check if the changed policy matches the updgrp's
1437 * outbound route-map or unsuppress-map or default-originate map or
1438 * filter-list or prefix-list or distribute-list.
1439 * Trigger update generation accordingly.
1441 static int updgrp_policy_update_walkcb(struct update_group
*updgrp
, void *arg
)
1443 struct updwalk_context
*ctx
= arg
;
1444 struct update_subgroup
*subgrp
;
1446 int def_changed
= 0;
1448 if (!updgrp
|| !ctx
|| !ctx
->policy_name
)
1449 return UPDWALK_CONTINUE
;
1451 switch (ctx
->policy_type
) {
1452 case BGP_POLICY_ROUTE_MAP
:
1453 changed
= updgrp_route_map_update(updgrp
, ctx
->policy_name
,
1456 case BGP_POLICY_FILTER_LIST
:
1457 changed
= updgrp_filter_list_update(updgrp
, ctx
->policy_name
);
1459 case BGP_POLICY_PREFIX_LIST
:
1460 changed
= updgrp_prefix_list_update(updgrp
, ctx
->policy_name
);
1462 case BGP_POLICY_DISTRIBUTE_LIST
:
1464 updgrp_distribute_list_update(updgrp
, ctx
->policy_name
);
1470 /* If not doing route update, return after updating "config" */
1471 if (!ctx
->policy_route_update
)
1472 return UPDWALK_CONTINUE
;
1474 /* If nothing has changed, return after updating "config" */
1475 if (!changed
&& !def_changed
)
1476 return UPDWALK_CONTINUE
;
1479 * If something has changed, at the beginning of a route-map
1481 * event, mark each subgroup's needs-refresh bit. For one, it signals to
1482 * whoever that the subgroup needs a refresh. Second, it prevents
1484 * merge of this subgroup with another before a complete (outbound)
1487 if (ctx
->policy_event_start_flag
) {
1488 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
1489 update_subgroup_set_needs_refresh(subgrp
, 1);
1491 return UPDWALK_CONTINUE
;
1494 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
1495 /* Avoid supressing duplicate routes later
1496 * when processing in subgroup_announce_table().
1498 SET_FLAG(subgrp
->sflags
, SUBGRP_STATUS_FORCE_UPDATES
);
1501 if (bgp_debug_update(NULL
, NULL
, updgrp
, 0))
1503 "u%" PRIu64
":s%" PRIu64
" announcing routes upon policy %s (type %d) change",
1504 updgrp
->id
, subgrp
->id
,
1505 ctx
->policy_name
, ctx
->policy_type
);
1506 subgroup_announce_route(subgrp
);
1509 if (bgp_debug_update(NULL
, NULL
, updgrp
, 0))
1511 "u%" PRIu64
":s%" PRIu64
" announcing default upon default routemap %s change",
1512 updgrp
->id
, subgrp
->id
,
1514 if (route_map_lookup_by_name(ctx
->policy_name
)) {
1516 * When there is change in routemap, this flow
1517 * is triggered. the routemap is still present
1518 * in lib, hence its a update flow. The flag
1519 * needs to be unset.
1521 UNSET_FLAG(subgrp
->sflags
,
1522 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
1523 subgroup_default_originate(subgrp
, 0);
1526 * This is a explicit withdraw, since the
1527 * routemap is not present in routemap lib. need
1528 * to pass 1 for withdraw arg.
1530 subgroup_default_originate(subgrp
, 1);
1533 update_subgroup_set_needs_refresh(subgrp
, 0);
1535 return UPDWALK_CONTINUE
;
1538 static int update_group_walkcb(struct hash_bucket
*bucket
, void *arg
)
1540 struct update_group
*updgrp
= bucket
->data
;
1541 struct updwalk_context
*wctx
= arg
;
1542 int ret
= (*wctx
->cb
)(updgrp
, wctx
->context
);
1546 static int update_group_periodic_merge_walkcb(struct update_group
*updgrp
,
1549 struct update_subgroup
*subgrp
;
1550 struct update_subgroup
*tmp_subgrp
;
1551 const char *reason
= arg
;
1553 UPDGRP_FOREACH_SUBGRP_SAFE (updgrp
, subgrp
, tmp_subgrp
)
1554 update_subgroup_check_merge(subgrp
, reason
);
1555 return UPDWALK_CONTINUE
;
1558 /********************
1560 ********************/
1563 * trigger function when a policy (route-map/filter-list/prefix-list/
1564 * distribute-list etc.) content changes. Go through all the
1565 * update groups and process the change.
1567 * bgp: the bgp instance
1568 * ptype: the type of policy that got modified, see bgpd.h
1569 * pname: name of the policy
1570 * route_update: flag to control if an automatic update generation should
1572 * start_event: flag that indicates if it's the beginning of the change.
1573 * Esp. when the user is changing the content interactively
1574 * over multiple statements. Useful to set dirty flag on
1577 void update_group_policy_update(struct bgp
*bgp
, enum bgp_policy_type ptype
,
1578 const char *pname
, bool route_update
,
1581 struct updwalk_context ctx
;
1583 memset(&ctx
, 0, sizeof(ctx
));
1584 ctx
.policy_type
= ptype
;
1585 ctx
.policy_name
= pname
;
1586 ctx
.policy_route_update
= route_update
;
1587 ctx
.policy_event_start_flag
= start_event
;
1590 update_group_walk(bgp
, updgrp_policy_update_walkcb
, &ctx
);
1594 * update_subgroup_split_peer
1596 * Ensure that the given peer is in a subgroup of its own in the
1597 * specified update group.
1599 void update_subgroup_split_peer(struct peer_af
*paf
,
1600 struct update_group
*updgrp
)
1602 struct update_subgroup
*old_subgrp
, *subgrp
;
1606 old_subgrp
= paf
->subgroup
;
1609 updgrp
= old_subgrp
->update_group
;
1612 * If the peer is alone in its subgroup, reuse the existing
1615 if (old_subgrp
->peer_count
== 1) {
1616 if (updgrp
== old_subgrp
->update_group
)
1619 subgrp
= old_subgrp
;
1620 old_id
= old_subgrp
->update_group
->id
;
1622 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1623 UPDGRP_PEER_DBG_DIS(old_subgrp
->update_group
);
1626 update_group_remove_subgroup(old_subgrp
->update_group
,
1628 update_group_add_subgroup(updgrp
, subgrp
);
1630 if (bgp_debug_peer_updout_enabled(paf
->peer
->host
)) {
1631 UPDGRP_PEER_DBG_EN(updgrp
);
1633 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1634 zlog_debug("u%" PRIu64
":s%" PRIu64
" peer %s moved to u%" PRIu64
":s%" PRIu64
,
1635 old_id
, subgrp
->id
, paf
->peer
->host
,
1636 updgrp
->id
, subgrp
->id
);
1639 * The state of the subgroup (adj_out, advs, packet queue etc)
1640 * is consistent internally, but may not be identical to other
1641 * subgroups in the new update group even if the version number
1642 * matches up. Make sure a full refresh is done before the
1643 * subgroup is merged with another.
1645 update_subgroup_set_needs_refresh(subgrp
, 1);
1647 SUBGRP_INCR_STAT(subgrp
, updgrp_switch_events
);
1652 * Create a new subgroup under the specified update group, and copy
1653 * over relevant state to it.
1655 subgrp
= update_subgroup_create(updgrp
);
1656 update_subgroup_inherit_info(subgrp
, old_subgrp
);
1658 subgrp
->split_from
.update_group_id
= old_subgrp
->update_group
->id
;
1659 subgrp
->split_from
.subgroup_id
= old_subgrp
->id
;
1662 * Copy out relevant state from the old subgroup.
1664 update_subgroup_copy_adj_out(paf
->subgroup
, subgrp
);
1665 update_subgroup_copy_packets(subgrp
, paf
->next_pkt_to_send
);
1667 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1668 zlog_debug("u%" PRIu64
":s%" PRIu64
" peer %s split and moved into u%" PRIu64
":s%" PRIu64
,
1669 paf
->subgroup
->update_group
->id
, paf
->subgroup
->id
,
1670 paf
->peer
->host
, updgrp
->id
, subgrp
->id
);
1672 SUBGRP_INCR_STAT(paf
->subgroup
, split_events
);
1675 * Since queued advs were left behind, this new subgroup needs a
1678 update_subgroup_set_needs_refresh(subgrp
, 1);
1681 * Remove peer from old subgroup, and add it to the new one.
1683 update_subgroup_remove_peer(paf
->subgroup
, paf
);
1685 update_subgroup_add_peer(subgrp
, paf
, 1);
1688 void update_bgp_group_init(struct bgp
*bgp
)
1693 bgp
->update_groups
[afid
] =
1694 hash_create(updgrp_hash_key_make
, updgrp_hash_cmp
,
1695 "BGP Update Group Hash");
1698 void update_bgp_group_free(struct bgp
*bgp
)
1703 if (bgp
->update_groups
[afid
]) {
1704 hash_free(bgp
->update_groups
[afid
]);
1705 bgp
->update_groups
[afid
] = NULL
;
1710 void update_group_show(struct bgp
*bgp
, afi_t afi
, safi_t safi
, struct vty
*vty
,
1713 struct updwalk_context ctx
;
1714 memset(&ctx
, 0, sizeof(ctx
));
1716 ctx
.subgrp_id
= subgrp_id
;
1718 update_group_af_walk(bgp
, afi
, safi
, update_group_show_walkcb
, &ctx
);
1722 * update_group_show_stats
1724 * Show global statistics about update groups.
1726 void update_group_show_stats(struct bgp
*bgp
, struct vty
*vty
)
1728 vty_out(vty
, "Update groups created: %u\n",
1729 bgp
->update_group_stats
.updgrps_created
);
1730 vty_out(vty
, "Update groups deleted: %u\n",
1731 bgp
->update_group_stats
.updgrps_deleted
);
1732 vty_out(vty
, "Update subgroups created: %u\n",
1733 bgp
->update_group_stats
.subgrps_created
);
1734 vty_out(vty
, "Update subgroups deleted: %u\n",
1735 bgp
->update_group_stats
.subgrps_deleted
);
1736 vty_out(vty
, "Join events: %u\n", bgp
->update_group_stats
.join_events
);
1737 vty_out(vty
, "Prune events: %u\n",
1738 bgp
->update_group_stats
.prune_events
);
1739 vty_out(vty
, "Merge events: %u\n",
1740 bgp
->update_group_stats
.merge_events
);
1741 vty_out(vty
, "Split events: %u\n",
1742 bgp
->update_group_stats
.split_events
);
1743 vty_out(vty
, "Update group switch events: %u\n",
1744 bgp
->update_group_stats
.updgrp_switch_events
);
1745 vty_out(vty
, "Peer route refreshes combined: %u\n",
1746 bgp
->update_group_stats
.peer_refreshes_combined
);
1747 vty_out(vty
, "Merge checks triggered: %u\n",
1748 bgp
->update_group_stats
.merge_checks_triggered
);
1752 * update_group_adjust_peer
1754 void update_group_adjust_peer(struct peer_af
*paf
)
1756 struct update_group
*updgrp
;
1757 struct update_subgroup
*subgrp
, *old_subgrp
;
1763 peer
= PAF_PEER(paf
);
1764 if (!peer_established(peer
)) {
1768 if (!CHECK_FLAG(peer
->flags
, PEER_FLAG_CONFIG_NODE
)) {
1772 if (!peer
->afc_nego
[paf
->afi
][paf
->safi
]) {
1776 updgrp
= update_group_find(paf
);
1778 updgrp
= update_group_create(paf
);
1780 flog_err(EC_BGP_UPDGRP_CREATE
,
1781 "couldn't create update group for peer %s",
1787 old_subgrp
= paf
->subgroup
;
1792 * If the update group of the peer is unchanged, the peer can
1794 * in its existing subgroup and we're done.
1796 if (old_subgrp
->update_group
== updgrp
)
1800 * The peer is switching between update groups. Put it in its
1801 * own subgroup under the new update group.
1803 update_subgroup_split_peer(paf
, updgrp
);
1807 subgrp
= update_subgroup_find(updgrp
, paf
);
1809 subgrp
= update_subgroup_create(updgrp
);
1814 update_subgroup_add_peer(subgrp
, paf
, 1);
1815 if (BGP_DEBUG(update_groups
, UPDATE_GROUPS
))
1816 zlog_debug("u%" PRIu64
":s%" PRIu64
" add peer %s", updgrp
->id
,
1817 subgrp
->id
, paf
->peer
->host
);
1822 int update_group_adjust_soloness(struct peer
*peer
, int set
)
1824 struct peer_group
*group
;
1825 struct listnode
*node
, *nnode
;
1827 if (!CHECK_FLAG(peer
->sflags
, PEER_STATUS_GROUP
)) {
1828 peer_lonesoul_or_not(peer
, set
);
1829 if (peer_established(peer
))
1830 bgp_announce_route_all(peer
);
1832 group
= peer
->group
;
1833 for (ALL_LIST_ELEMENTS(group
->peer
, node
, nnode
, peer
)) {
1834 peer_lonesoul_or_not(peer
, set
);
1835 if (peer_established(peer
))
1836 bgp_announce_route_all(peer
);
1843 * update_subgroup_rib
1845 struct bgp_table
*update_subgroup_rib(struct update_subgroup
*subgrp
)
1849 bgp
= SUBGRP_INST(subgrp
);
1853 return bgp
->rib
[SUBGRP_AFI(subgrp
)][SUBGRP_SAFI(subgrp
)];
1856 void update_group_af_walk(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
1857 updgrp_walkcb cb
, void *ctx
)
1859 struct updwalk_context wctx
;
1864 afid
= afindex(afi
, safi
);
1865 if (afid
>= BGP_AF_MAX
)
1868 memset(&wctx
, 0, sizeof(wctx
));
1872 if (bgp
->update_groups
[afid
])
1873 hash_walk(bgp
->update_groups
[afid
], update_group_walkcb
, &wctx
);
1876 void update_group_walk(struct bgp
*bgp
, updgrp_walkcb cb
, void *ctx
)
1881 FOREACH_AFI_SAFI (afi
, safi
) {
1882 update_group_af_walk(bgp
, afi
, safi
, cb
, ctx
);
1886 void update_group_periodic_merge(struct bgp
*bgp
)
1888 char reason
[] = "periodic merge check";
1890 update_group_walk(bgp
, update_group_periodic_merge_walkcb
,
1895 update_group_default_originate_route_map_walkcb(struct update_group
*updgrp
,
1898 struct update_subgroup
*subgrp
;
1903 UPDGRP_FOREACH_SUBGRP (updgrp
, subgrp
) {
1904 peer
= SUBGRP_PEER(subgrp
);
1905 afi
= SUBGRP_AFI(subgrp
);
1906 safi
= SUBGRP_SAFI(subgrp
);
1908 if (peer
->default_rmap
[afi
][safi
].name
) {
1910 * When there is change in routemap this flow will
1911 * be triggered. We need to unset the Flag to ensure
1912 * the update flow gets triggered.
1914 UNSET_FLAG(subgrp
->sflags
,
1915 SUBGRP_STATUS_DEFAULT_ORIGINATE
);
1916 subgroup_default_originate(subgrp
, 0);
1920 return UPDWALK_CONTINUE
;
1923 void update_group_refresh_default_originate_route_map(struct thread
*thread
)
1926 char reason
[] = "refresh default-originate route-map";
1928 bgp
= THREAD_ARG(thread
);
1929 update_group_walk(bgp
, update_group_default_originate_route_map_walkcb
,
1931 THREAD_OFF(bgp
->t_rmap_def_originate_eval
);
1936 * peer_af_announce_route
1938 * Refreshes routes out to a peer_af immediately.
1940 * If the combine parameter is true, then this function will try to
1941 * gather other peers in the subgroup for which a route announcement
1942 * is pending and efficently announce routes to all of them.
1944 * For now, the 'combine' option has an effect only if all peers in
1945 * the subgroup have a route announcement pending.
1947 void peer_af_announce_route(struct peer_af
*paf
, int combine
)
1949 struct update_subgroup
*subgrp
;
1950 struct peer_af
*cur_paf
;
1953 subgrp
= paf
->subgroup
;
1958 * If there are other peers in the old subgroup that also need
1959 * routes to be announced, pull them into the peer's new
1961 * Combine route announcement with other peers if possible.
1963 * For now, we combine only if all peers in the subgroup have an
1964 * announcement pending.
1968 SUBGRP_FOREACH_PEER (subgrp
, cur_paf
) {
1972 if (cur_paf
->t_announce_route
)
1980 * Announce to the peer alone if we were not asked to combine peers,
1981 * or if some peers don't have a route annoucement pending.
1983 if (!combine
|| !all_pending
) {
1984 update_subgroup_split_peer(paf
, NULL
);
1985 subgrp
= paf
->subgroup
;
1987 assert(subgrp
&& subgrp
->update_group
);
1988 if (bgp_debug_update(paf
->peer
, NULL
, subgrp
->update_group
, 0))
1989 zlog_debug("u%" PRIu64
":s%" PRIu64
" %s announcing routes",
1990 subgrp
->update_group
->id
, subgrp
->id
,
1993 subgroup_announce_route(paf
->subgroup
);
1998 * We will announce routes the entire subgroup.
2000 * First stop refresh timers on all the other peers.
2002 SUBGRP_FOREACH_PEER (subgrp
, cur_paf
) {
2006 bgp_stop_announce_route_timer(cur_paf
);
2009 if (bgp_debug_update(paf
->peer
, NULL
, subgrp
->update_group
, 0))
2010 zlog_debug("u%" PRIu64
":s%" PRIu64
" announcing routes to %s, combined into %d peers",
2011 subgrp
->update_group
->id
, subgrp
->id
,
2012 paf
->peer
->host
, subgrp
->peer_count
);
2014 subgroup_announce_route(subgrp
);
2016 SUBGRP_INCR_STAT_BY(subgrp
, peer_refreshes_combined
,
2017 subgrp
->peer_count
- 1);
2020 void subgroup_trigger_write(struct update_subgroup
*subgrp
)
2022 struct peer_af
*paf
;
2025 * For each peer in the subgroup, schedule a job to pull packets from
2026 * the subgroup output queue into their own output queue. This action
2027 * will trigger a write job on the I/O thread.
2029 SUBGRP_FOREACH_PEER (subgrp
, paf
)
2030 if (peer_established(paf
->peer
))
2031 thread_add_timer_msec(
2032 bm
->master
, bgp_generate_updgrp_packets
,
2034 &paf
->peer
->t_generate_updgrp_packets
);
2037 int update_group_clear_update_dbg(struct update_group
*updgrp
, void *arg
)
2039 UPDGRP_PEER_DBG_OFF(updgrp
);
2040 return UPDWALK_CONTINUE
;
2043 /* Return true if we should addpath encode NLRI to this peer */
2044 bool bgp_addpath_encode_tx(struct peer
*peer
, afi_t afi
, safi_t safi
)
2046 return (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_TX_ADV
)
2047 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
2048 PEER_CAP_ADDPATH_AF_RX_RCV
));
2051 bool bgp_check_selected(struct bgp_path_info
*bpi
, struct peer
*peer
,
2052 bool addpath_capable
, afi_t afi
, safi_t safi
)
2054 return (CHECK_FLAG(bpi
->flags
, BGP_PATH_SELECTED
) ||
2056 bgp_addpath_tx_path(peer
->addpath_type
[afi
][safi
], bpi
)));