]>
Commit | Line | Data |
---|---|---|
3f9c7369 DS |
1 | /** |
2 | * bgp_updgrp_adv.c: BGP update group advertisement and adjacency | |
3 | * maintenance | |
4 | * | |
5 | * | |
6 | * @copyright Copyright (C) 2014 Cumulus Networks, Inc. | |
7 | * | |
8 | * @author Avneesh Sachdev <avneesh@sproute.net> | |
9 | * @author Rajesh Varadarajan <rajesh@sproute.net> | |
10 | * @author Pradosh Mohapatra <pradosh@sproute.net> | |
11 | * | |
12 | * This file is part of GNU Zebra. | |
13 | * | |
14 | * GNU Zebra is free software; you can redistribute it and/or modify it | |
15 | * under the terms of the GNU General Public License as published by the | |
16 | * Free Software Foundation; either version 2, or (at your option) any | |
17 | * later version. | |
18 | * | |
19 | * GNU Zebra is distributed in the hope that it will be useful, but | |
20 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
22 | * General Public License for more details. | |
23 | * | |
896014f4 DL |
24 | * You should have received a copy of the GNU General Public License along |
25 | * with this program; see the file COPYING; if not, write to the Free Software | |
26 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
3f9c7369 DS |
27 | */ |
28 | ||
29 | #include <zebra.h> | |
30 | ||
31 | #include "command.h" | |
32 | #include "memory.h" | |
33 | #include "prefix.h" | |
34 | #include "hash.h" | |
35 | #include "thread.h" | |
36 | #include "queue.h" | |
37 | #include "routemap.h" | |
039f3a34 | 38 | #include "filter.h" |
3f9c7369 DS |
39 | |
40 | #include "bgpd/bgpd.h" | |
41 | #include "bgpd/bgp_table.h" | |
42 | #include "bgpd/bgp_debug.h" | |
43 | #include "bgpd/bgp_route.h" | |
44 | #include "bgpd/bgp_advertise.h" | |
45 | #include "bgpd/bgp_attr.h" | |
46 | #include "bgpd/bgp_aspath.h" | |
47 | #include "bgpd/bgp_packet.h" | |
48 | #include "bgpd/bgp_fsm.h" | |
49 | #include "bgpd/bgp_mplsvpn.h" | |
50 | #include "bgpd/bgp_updgrp.h" | |
51 | #include "bgpd/bgp_advertise.h" | |
dcc68b5e | 52 | #include "bgpd/bgp_addpath.h" |
3f9c7369 DS |
53 | |
54 | ||
55 | /******************** | |
56 | * PRIVATE FUNCTIONS | |
57 | ********************/ | |
a79c04e7 DS |
58 | static int bgp_adj_out_compare(const struct bgp_adj_out *o1, |
59 | const struct bgp_adj_out *o2) | |
60 | { | |
61 | if (o1->subgroup < o2->subgroup) | |
62 | return -1; | |
63 | ||
64 | if (o1->subgroup > o2->subgroup) | |
65 | return 1; | |
66 | ||
67 | return 0; | |
68 | } | |
69 | RB_GENERATE(bgp_adj_out_rb, bgp_adj_out, adj_entry, bgp_adj_out_compare); | |
3f9c7369 | 70 | |
d62a17ae | 71 | static inline struct bgp_adj_out *adj_lookup(struct bgp_node *rn, |
72 | struct update_subgroup *subgrp, | |
d7c0a89a | 73 | uint32_t addpath_tx_id) |
3f9c7369 | 74 | { |
a79c04e7 | 75 | struct bgp_adj_out *adj, lookup; |
d62a17ae | 76 | struct peer *peer; |
77 | afi_t afi; | |
78 | safi_t safi; | |
79 | int addpath_capable; | |
80 | ||
81 | if (!rn || !subgrp) | |
82 | return NULL; | |
83 | ||
84 | peer = SUBGRP_PEER(subgrp); | |
85 | afi = SUBGRP_AFI(subgrp); | |
86 | safi = SUBGRP_SAFI(subgrp); | |
87 | addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); | |
88 | ||
89 | /* update-groups that do not support addpath will pass 0 for | |
90 | * addpath_tx_id so do not both matching against it */ | |
a79c04e7 DS |
91 | lookup.subgroup = subgrp; |
92 | adj = RB_FIND(bgp_adj_out_rb, &rn->adj_out, &lookup); | |
93 | if (adj) { | |
94 | if (addpath_capable) { | |
95 | if (adj->addpath_tx_id == addpath_tx_id) | |
96 | return adj; | |
97 | } else | |
98 | return adj; | |
d62a17ae | 99 | } |
a79c04e7 | 100 | return NULL; |
3f9c7369 DS |
101 | } |
102 | ||
d62a17ae | 103 | static void adj_free(struct bgp_adj_out *adj) |
3f9c7369 | 104 | { |
d62a17ae | 105 | TAILQ_REMOVE(&(adj->subgroup->adjq), adj, subgrp_adj_train); |
106 | SUBGRP_DECR_STAT(adj->subgroup, adj_count); | |
107 | XFREE(MTYPE_BGP_ADJ_OUT, adj); | |
3f9c7369 DS |
108 | } |
109 | ||
dcc68b5e MS |
110 | static void subgrp_withdraw_stale_addpath(struct updwalk_context *ctx, |
111 | struct update_subgroup *subgrp) | |
112 | { | |
113 | struct bgp_adj_out *adj, *adj_next; | |
114 | uint32_t id; | |
115 | struct bgp_path_info *pi; | |
116 | afi_t afi = SUBGRP_AFI(subgrp); | |
117 | safi_t safi = SUBGRP_SAFI(subgrp); | |
118 | struct peer *peer = SUBGRP_PEER(subgrp); | |
119 | ||
120 | /* Look through all of the paths we have advertised for this rn and send | |
121 | * a withdraw for the ones that are no longer present */ | |
a79c04e7 | 122 | RB_FOREACH_SAFE (adj, bgp_adj_out_rb, &ctx->rn->adj_out, adj_next) { |
dcc68b5e MS |
123 | |
124 | if (adj->subgroup == subgrp) { | |
6f94b685 DS |
125 | for (pi = bgp_node_get_bgp_path_info(ctx->rn); |
126 | pi; pi = pi->next) { | |
dcc68b5e MS |
127 | id = bgp_addpath_id_for_peer(peer, afi, safi, |
128 | &pi->tx_addpath); | |
129 | ||
130 | if (id == adj->addpath_tx_id) { | |
131 | break; | |
132 | } | |
133 | } | |
134 | ||
135 | if (!pi) { | |
136 | subgroup_process_announce_selected( | |
137 | subgrp, NULL, ctx->rn, | |
138 | adj->addpath_tx_id); | |
139 | } | |
140 | } | |
141 | } | |
142 | } | |
143 | ||
d62a17ae | 144 | static int group_announce_route_walkcb(struct update_group *updgrp, void *arg) |
3f9c7369 | 145 | { |
d62a17ae | 146 | struct updwalk_context *ctx = arg; |
147 | struct update_subgroup *subgrp; | |
40381db7 | 148 | struct bgp_path_info *pi; |
d62a17ae | 149 | afi_t afi; |
150 | safi_t safi; | |
151 | struct peer *peer; | |
152 | struct bgp_adj_out *adj, *adj_next; | |
153 | int addpath_capable; | |
154 | ||
155 | afi = UPDGRP_AFI(updgrp); | |
156 | safi = UPDGRP_SAFI(updgrp); | |
157 | peer = UPDGRP_PEER(updgrp); | |
158 | addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); | |
159 | ||
e0207895 PZ |
160 | if (BGP_DEBUG(update, UPDATE_OUT)) { |
161 | char buf_prefix[PREFIX_STRLEN]; | |
162 | prefix2str(&ctx->rn->p, buf_prefix, sizeof(buf_prefix)); | |
163 | zlog_debug("%s: afi=%s, safi=%s, p=%s", __func__, afi2str(afi), | |
164 | safi2str(safi), buf_prefix); | |
165 | } | |
166 | ||
167 | ||
a2addae8 | 168 | UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) { |
3f9c7369 | 169 | |
d62a17ae | 170 | /* |
171 | * Skip the subgroups that have coalesce timer running. We will | |
172 | * walk the entire prefix table for those subgroups when the | |
173 | * coalesce timer fires. | |
174 | */ | |
175 | if (!subgrp->t_coalesce) { | |
176 | /* An update-group that uses addpath */ | |
177 | if (addpath_capable) { | |
dcc68b5e | 178 | subgrp_withdraw_stale_addpath(ctx, subgrp); |
d62a17ae | 179 | |
6f94b685 DS |
180 | for (pi = bgp_node_get_bgp_path_info(ctx->rn); |
181 | pi; pi = pi->next) { | |
d62a17ae | 182 | /* Skip the bestpath for now */ |
40381db7 | 183 | if (pi == ctx->pi) |
d62a17ae | 184 | continue; |
185 | ||
186 | subgroup_process_announce_selected( | |
40381db7 | 187 | subgrp, pi, ctx->rn, |
dcc68b5e MS |
188 | bgp_addpath_id_for_peer( |
189 | peer, afi, safi, | |
190 | &pi->tx_addpath)); | |
d62a17ae | 191 | } |
192 | ||
193 | /* Process the bestpath last so the "show [ip] | |
194 | * bgp neighbor x.x.x.x advertised" | |
195 | * output shows the attributes from the bestpath | |
196 | */ | |
40381db7 | 197 | if (ctx->pi) |
d62a17ae | 198 | subgroup_process_announce_selected( |
40381db7 | 199 | subgrp, ctx->pi, ctx->rn, |
dcc68b5e MS |
200 | bgp_addpath_id_for_peer( |
201 | peer, afi, safi, | |
202 | &ctx->pi->tx_addpath)); | |
d62a17ae | 203 | } |
204 | ||
205 | /* An update-group that does not use addpath */ | |
206 | else { | |
40381db7 | 207 | if (ctx->pi) { |
d62a17ae | 208 | subgroup_process_announce_selected( |
40381db7 | 209 | subgrp, ctx->pi, ctx->rn, |
dcc68b5e MS |
210 | bgp_addpath_id_for_peer( |
211 | peer, afi, safi, | |
212 | &ctx->pi->tx_addpath)); | |
d62a17ae | 213 | } else { |
214 | /* Find the addpath_tx_id of the path we | |
215 | * had advertised and | |
216 | * send a withdraw */ | |
a79c04e7 DS |
217 | RB_FOREACH_SAFE (adj, bgp_adj_out_rb, |
218 | &ctx->rn->adj_out, | |
219 | adj_next) { | |
d62a17ae | 220 | if (adj->subgroup == subgrp) { |
221 | subgroup_process_announce_selected( | |
222 | subgrp, NULL, | |
223 | ctx->rn, | |
224 | adj->addpath_tx_id); | |
225 | } | |
226 | } | |
227 | } | |
228 | } | |
229 | } | |
230 | } | |
3f9c7369 | 231 | |
d62a17ae | 232 | return UPDWALK_CONTINUE; |
233 | } | |
3f9c7369 | 234 | |
d62a17ae | 235 | static void subgrp_show_adjq_vty(struct update_subgroup *subgrp, |
d7c0a89a | 236 | struct vty *vty, uint8_t flags) |
d62a17ae | 237 | { |
238 | struct bgp_table *table; | |
239 | struct bgp_adj_out *adj; | |
240 | unsigned long output_count; | |
241 | struct bgp_node *rn; | |
242 | int header1 = 1; | |
243 | struct bgp *bgp; | |
244 | int header2 = 1; | |
245 | ||
246 | bgp = SUBGRP_INST(subgrp); | |
247 | if (!bgp) | |
248 | return; | |
249 | ||
250 | table = bgp->rib[SUBGRP_AFI(subgrp)][SUBGRP_SAFI(subgrp)]; | |
251 | ||
252 | output_count = 0; | |
253 | ||
254 | for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) | |
a79c04e7 | 255 | RB_FOREACH (adj, bgp_adj_out_rb, &rn->adj_out) |
d62a17ae | 256 | if (adj->subgroup == subgrp) { |
257 | if (header1) { | |
258 | vty_out(vty, | |
259 | "BGP table version is %" PRIu64 | |
260 | ", local router ID is %s\n", | |
261 | table->version, | |
262 | inet_ntoa(bgp->router_id)); | |
263 | vty_out(vty, BGP_SHOW_SCODE_HEADER); | |
264 | vty_out(vty, BGP_SHOW_OCODE_HEADER); | |
265 | header1 = 0; | |
266 | } | |
267 | if (header2) { | |
268 | vty_out(vty, BGP_SHOW_HEADER); | |
269 | header2 = 0; | |
270 | } | |
271 | if ((flags & UPDWALK_FLAGS_ADVQUEUE) && adj->adv | |
272 | && adj->adv->baa) { | |
273 | route_vty_out_tmp(vty, &rn->p, | |
274 | adj->adv->baa->attr, | |
275 | SUBGRP_SAFI(subgrp), | |
276 | 0, NULL); | |
277 | output_count++; | |
278 | } | |
279 | if ((flags & UPDWALK_FLAGS_ADVERTISED) | |
280 | && adj->attr) { | |
281 | route_vty_out_tmp( | |
282 | vty, &rn->p, adj->attr, | |
283 | SUBGRP_SAFI(subgrp), 0, NULL); | |
284 | output_count++; | |
285 | } | |
286 | } | |
287 | if (output_count != 0) | |
288 | vty_out(vty, "\nTotal number of prefixes %ld\n", output_count); | |
3f9c7369 DS |
289 | } |
290 | ||
d62a17ae | 291 | static int updgrp_show_adj_walkcb(struct update_group *updgrp, void *arg) |
3f9c7369 | 292 | { |
d62a17ae | 293 | struct updwalk_context *ctx = arg; |
294 | struct update_subgroup *subgrp; | |
295 | struct vty *vty; | |
296 | ||
297 | vty = ctx->vty; | |
a2addae8 | 298 | UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) { |
d62a17ae | 299 | if (ctx->subgrp_id && (ctx->subgrp_id != subgrp->id)) |
300 | continue; | |
301 | vty_out(vty, "update group %" PRIu64 ", subgroup %" PRIu64 "\n", | |
302 | updgrp->id, subgrp->id); | |
303 | subgrp_show_adjq_vty(subgrp, vty, ctx->flags); | |
304 | } | |
305 | return UPDWALK_CONTINUE; | |
3f9c7369 DS |
306 | } |
307 | ||
d62a17ae | 308 | static void updgrp_show_adj(struct bgp *bgp, afi_t afi, safi_t safi, |
d7c0a89a | 309 | struct vty *vty, uint64_t id, uint8_t flags) |
3f9c7369 | 310 | { |
d62a17ae | 311 | struct updwalk_context ctx; |
312 | memset(&ctx, 0, sizeof(ctx)); | |
313 | ctx.vty = vty; | |
314 | ctx.subgrp_id = id; | |
315 | ctx.flags = flags; | |
3f9c7369 | 316 | |
d62a17ae | 317 | update_group_af_walk(bgp, afi, safi, updgrp_show_adj_walkcb, &ctx); |
3f9c7369 DS |
318 | } |
319 | ||
d62a17ae | 320 | static int subgroup_coalesce_timer(struct thread *thread) |
3f9c7369 | 321 | { |
d62a17ae | 322 | struct update_subgroup *subgrp; |
323 | ||
324 | subgrp = THREAD_ARG(thread); | |
325 | if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) | |
326 | zlog_debug("u%" PRIu64 ":s%" PRIu64 | |
5b18ef82 DS |
327 | " announcing routes upon coalesce timer expiry(%u ms)", |
328 | (SUBGRP_UPDGRP(subgrp))->id, subgrp->id, | |
329 | subgrp->v_coalesce), | |
d62a17ae | 330 | subgrp->t_coalesce = NULL; |
331 | subgrp->v_coalesce = 0; | |
332 | subgroup_announce_route(subgrp); | |
333 | ||
334 | ||
335 | /* While the announce_route() may kick off the route advertisement timer | |
336 | * for | |
337 | * the members of the subgroup, we'd like to send the initial updates | |
338 | * much | |
339 | * faster (i.e., without enforcing MRAI). Also, if there were no routes | |
340 | * to | |
341 | * announce, this is the method currently employed to trigger the EOR. | |
342 | */ | |
343 | if (!bgp_update_delay_active(SUBGRP_INST(subgrp))) { | |
344 | struct peer_af *paf; | |
345 | struct peer *peer; | |
346 | ||
a2addae8 | 347 | SUBGRP_FOREACH_PEER (subgrp, paf) { |
d62a17ae | 348 | peer = PAF_PEER(paf); |
349 | BGP_TIMER_OFF(peer->t_routeadv); | |
350 | BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0); | |
351 | } | |
352 | } | |
353 | ||
354 | return 0; | |
3f9c7369 DS |
355 | } |
356 | ||
d62a17ae | 357 | static int update_group_announce_walkcb(struct update_group *updgrp, void *arg) |
3f9c7369 | 358 | { |
d62a17ae | 359 | struct update_subgroup *subgrp; |
3f9c7369 | 360 | |
a2addae8 | 361 | UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) { |
d62a17ae | 362 | subgroup_announce_all(subgrp); |
363 | } | |
3f9c7369 | 364 | |
d62a17ae | 365 | return UPDWALK_CONTINUE; |
3f9c7369 DS |
366 | } |
367 | ||
d62a17ae | 368 | static int update_group_announce_rrc_walkcb(struct update_group *updgrp, |
369 | void *arg) | |
3f9c7369 | 370 | { |
d62a17ae | 371 | struct update_subgroup *subgrp; |
372 | afi_t afi; | |
373 | safi_t safi; | |
374 | struct peer *peer; | |
375 | ||
376 | afi = UPDGRP_AFI(updgrp); | |
377 | safi = UPDGRP_SAFI(updgrp); | |
378 | peer = UPDGRP_PEER(updgrp); | |
379 | ||
380 | /* Only announce if this is a group of route-reflector-clients */ | |
381 | if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_REFLECTOR_CLIENT)) { | |
a2addae8 | 382 | UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) { |
d62a17ae | 383 | subgroup_announce_all(subgrp); |
384 | } | |
385 | } | |
386 | ||
387 | return UPDWALK_CONTINUE; | |
3f9c7369 DS |
388 | } |
389 | ||
390 | /******************** | |
391 | * PUBLIC FUNCTIONS | |
392 | ********************/ | |
393 | ||
394 | /** | |
395 | * Allocate an adj-out object. Do proper initialization of its fields, | |
396 | * primarily its association with the subgroup and the prefix. | |
397 | */ | |
d62a17ae | 398 | struct bgp_adj_out *bgp_adj_out_alloc(struct update_subgroup *subgrp, |
399 | struct bgp_node *rn, | |
d7c0a89a | 400 | uint32_t addpath_tx_id) |
3f9c7369 | 401 | { |
d62a17ae | 402 | struct bgp_adj_out *adj; |
403 | ||
404 | adj = XCALLOC(MTYPE_BGP_ADJ_OUT, sizeof(struct bgp_adj_out)); | |
405 | adj->subgroup = subgrp; | |
406 | if (rn) { | |
a79c04e7 | 407 | RB_INSERT(bgp_adj_out_rb, &rn->adj_out, adj); |
d62a17ae | 408 | bgp_lock_node(rn); |
409 | adj->rn = rn; | |
410 | } | |
411 | ||
412 | adj->addpath_tx_id = addpath_tx_id; | |
413 | TAILQ_INSERT_TAIL(&(subgrp->adjq), adj, subgrp_adj_train); | |
414 | SUBGRP_INCR_STAT(subgrp, adj_count); | |
415 | return adj; | |
3f9c7369 DS |
416 | } |
417 | ||
418 | ||
419 | struct bgp_advertise * | |
d62a17ae | 420 | bgp_advertise_clean_subgroup(struct update_subgroup *subgrp, |
421 | struct bgp_adj_out *adj) | |
3f9c7369 | 422 | { |
d62a17ae | 423 | struct bgp_advertise *adv; |
424 | struct bgp_advertise_attr *baa; | |
425 | struct bgp_advertise *next; | |
a274fef8 | 426 | struct bgp_adv_fifo_head *fhead; |
3f9c7369 | 427 | |
d62a17ae | 428 | adv = adj->adv; |
429 | baa = adv->baa; | |
430 | next = NULL; | |
3f9c7369 | 431 | |
d62a17ae | 432 | if (baa) { |
433 | fhead = &subgrp->sync->update; | |
3f9c7369 | 434 | |
d62a17ae | 435 | /* Unlink myself from advertise attribute FIFO. */ |
436 | bgp_advertise_delete(baa, adv); | |
3f9c7369 | 437 | |
d62a17ae | 438 | /* Fetch next advertise candidate. */ |
439 | next = baa->adv; | |
3f9c7369 | 440 | |
d62a17ae | 441 | /* Unintern BGP advertise attribute. */ |
442 | bgp_advertise_unintern(subgrp->hash, baa); | |
443 | } else | |
444 | fhead = &subgrp->sync->withdraw; | |
3f9c7369 DS |
445 | |
446 | ||
d62a17ae | 447 | /* Unlink myself from advertisement FIFO. */ |
a274fef8 | 448 | bgp_adv_fifo_del(fhead, adv); |
3f9c7369 | 449 | |
d62a17ae | 450 | /* Free memory. */ |
451 | bgp_advertise_free(adj->adv); | |
452 | adj->adv = NULL; | |
3f9c7369 | 453 | |
d62a17ae | 454 | return next; |
3f9c7369 DS |
455 | } |
456 | ||
d62a17ae | 457 | void bgp_adj_out_set_subgroup(struct bgp_node *rn, |
458 | struct update_subgroup *subgrp, struct attr *attr, | |
9b6d8fcf | 459 | struct bgp_path_info *path) |
3f9c7369 | 460 | { |
d62a17ae | 461 | struct bgp_adj_out *adj = NULL; |
462 | struct bgp_advertise *adv; | |
dcc68b5e MS |
463 | struct peer *peer; |
464 | afi_t afi; | |
465 | safi_t safi; | |
466 | ||
467 | peer = SUBGRP_PEER(subgrp); | |
468 | afi = SUBGRP_AFI(subgrp); | |
469 | safi = SUBGRP_SAFI(subgrp); | |
d62a17ae | 470 | |
471 | if (DISABLE_BGP_ANNOUNCE) | |
472 | return; | |
473 | ||
474 | /* Look for adjacency information. */ | |
dcc68b5e MS |
475 | adj = adj_lookup( |
476 | rn, subgrp, | |
477 | bgp_addpath_id_for_peer(peer, afi, safi, &path->tx_addpath)); | |
d62a17ae | 478 | |
479 | if (!adj) { | |
dcc68b5e MS |
480 | adj = bgp_adj_out_alloc( |
481 | subgrp, rn, | |
482 | bgp_addpath_id_for_peer(peer, afi, safi, | |
483 | &path->tx_addpath)); | |
d62a17ae | 484 | if (!adj) |
485 | return; | |
486 | } | |
487 | ||
488 | if (adj->adv) | |
489 | bgp_advertise_clean_subgroup(subgrp, adj); | |
490 | adj->adv = bgp_advertise_new(); | |
491 | ||
492 | adv = adj->adv; | |
493 | adv->rn = rn; | |
9b6d8fcf | 494 | assert(adv->pathi == NULL); |
4b7e6066 | 495 | /* bgp_path_info adj_out reference */ |
9b6d8fcf | 496 | adv->pathi = bgp_path_info_lock(path); |
d62a17ae | 497 | |
498 | if (attr) | |
499 | adv->baa = bgp_advertise_intern(subgrp->hash, attr); | |
500 | else | |
501 | adv->baa = baa_new(); | |
502 | adv->adj = adj; | |
503 | ||
504 | /* Add new advertisement to advertisement attribute list. */ | |
505 | bgp_advertise_add(adv->baa, adv); | |
506 | ||
507 | /* | |
508 | * If the update adv list is empty, trigger the member peers' | |
509 | * mrai timers so the socket writes can happen. | |
510 | */ | |
a274fef8 | 511 | if (!bgp_adv_fifo_count(&subgrp->sync->update)) { |
d62a17ae | 512 | struct peer_af *paf; |
513 | ||
a2addae8 | 514 | SUBGRP_FOREACH_PEER (subgrp, paf) { |
d62a17ae | 515 | bgp_adjust_routeadv(PAF_PEER(paf)); |
516 | } | |
3f9c7369 | 517 | } |
3f9c7369 | 518 | |
a274fef8 | 519 | bgp_adv_fifo_add_tail(&subgrp->sync->update, adv); |
3f9c7369 | 520 | |
d62a17ae | 521 | subgrp->version = max(subgrp->version, rn->version); |
3f9c7369 DS |
522 | } |
523 | ||
4125bb67 DS |
524 | /* The only time 'withdraw' will be false is if we are sending |
525 | * the "neighbor x.x.x.x default-originate" default and need to clear | |
526 | * bgp_adj_out for the 0.0.0.0/0 route in the BGP table. | |
527 | */ | |
d62a17ae | 528 | void bgp_adj_out_unset_subgroup(struct bgp_node *rn, |
529 | struct update_subgroup *subgrp, char withdraw, | |
d7c0a89a | 530 | uint32_t addpath_tx_id) |
3f9c7369 | 531 | { |
d62a17ae | 532 | struct bgp_adj_out *adj; |
533 | struct bgp_advertise *adv; | |
2fc102e1 | 534 | bool trigger_write; |
d62a17ae | 535 | |
536 | if (DISABLE_BGP_ANNOUNCE) | |
537 | return; | |
538 | ||
539 | /* Lookup existing adjacency */ | |
540 | if ((adj = adj_lookup(rn, subgrp, addpath_tx_id)) != NULL) { | |
541 | /* Clean up previous advertisement. */ | |
542 | if (adj->adv) | |
543 | bgp_advertise_clean_subgroup(subgrp, adj); | |
544 | ||
545 | if (adj->attr && withdraw) { | |
546 | /* We need advertisement structure. */ | |
547 | adj->adv = bgp_advertise_new(); | |
548 | adv = adj->adv; | |
549 | adv->rn = rn; | |
550 | adv->adj = adj; | |
551 | ||
2fc102e1 QY |
552 | /* Note if we need to trigger a packet write */ |
553 | trigger_write = | |
a274fef8 | 554 | !bgp_adv_fifo_count(&subgrp->sync->withdraw); |
2fc102e1 | 555 | |
d62a17ae | 556 | /* Add to synchronization entry for withdraw |
557 | * announcement. */ | |
a274fef8 | 558 | bgp_adv_fifo_add_tail(&subgrp->sync->withdraw, adv); |
2fc102e1 QY |
559 | |
560 | if (trigger_write) | |
561 | subgroup_trigger_write(subgrp); | |
d62a17ae | 562 | } else { |
563 | /* Remove myself from adjacency. */ | |
a79c04e7 | 564 | RB_REMOVE(bgp_adj_out_rb, &rn->adj_out, adj); |
d62a17ae | 565 | |
566 | /* Free allocated information. */ | |
567 | adj_free(adj); | |
568 | ||
569 | bgp_unlock_node(rn); | |
570 | } | |
571 | } | |
572 | ||
573 | subgrp->version = max(subgrp->version, rn->version); | |
3f9c7369 DS |
574 | } |
575 | ||
d62a17ae | 576 | void bgp_adj_out_remove_subgroup(struct bgp_node *rn, struct bgp_adj_out *adj, |
577 | struct update_subgroup *subgrp) | |
3f9c7369 | 578 | { |
d62a17ae | 579 | if (adj->attr) |
580 | bgp_attr_unintern(&adj->attr); | |
3f9c7369 | 581 | |
d62a17ae | 582 | if (adj->adv) |
583 | bgp_advertise_clean_subgroup(subgrp, adj); | |
3f9c7369 | 584 | |
a79c04e7 | 585 | RB_REMOVE(bgp_adj_out_rb, &rn->adj_out, adj); |
d62a17ae | 586 | adj_free(adj); |
3f9c7369 DS |
587 | } |
588 | ||
589 | /* | |
590 | * Go through all the routes and clean up the adj/adv structures corresponding | |
591 | * to the subgroup. | |
592 | */ | |
d62a17ae | 593 | void subgroup_clear_table(struct update_subgroup *subgrp) |
3f9c7369 | 594 | { |
d62a17ae | 595 | struct bgp_adj_out *aout, *taout; |
596 | ||
a2addae8 | 597 | SUBGRP_FOREACH_ADJ_SAFE (subgrp, aout, taout) { |
d62a17ae | 598 | struct bgp_node *rn = aout->rn; |
599 | bgp_adj_out_remove_subgroup(rn, aout, subgrp); | |
600 | bgp_unlock_node(rn); | |
601 | } | |
3f9c7369 DS |
602 | } |
603 | ||
604 | /* | |
605 | * subgroup_announce_table | |
606 | */ | |
d62a17ae | 607 | void subgroup_announce_table(struct update_subgroup *subgrp, |
608 | struct bgp_table *table) | |
3f9c7369 | 609 | { |
d62a17ae | 610 | struct bgp_node *rn; |
4b7e6066 | 611 | struct bgp_path_info *ri; |
d62a17ae | 612 | struct attr attr; |
613 | struct peer *peer; | |
614 | afi_t afi; | |
615 | safi_t safi; | |
616 | int addpath_capable; | |
617 | ||
618 | peer = SUBGRP_PEER(subgrp); | |
619 | afi = SUBGRP_AFI(subgrp); | |
620 | safi = SUBGRP_SAFI(subgrp); | |
621 | addpath_capable = bgp_addpath_encode_tx(peer, afi, safi); | |
622 | ||
623 | if (safi == SAFI_LABELED_UNICAST) | |
624 | safi = SAFI_UNICAST; | |
625 | ||
626 | if (!table) | |
627 | table = peer->bgp->rib[afi][safi]; | |
628 | ||
629 | if (safi != SAFI_MPLS_VPN && safi != SAFI_ENCAP && safi != SAFI_EVPN | |
630 | && CHECK_FLAG(peer->af_flags[afi][safi], | |
631 | PEER_FLAG_DEFAULT_ORIGINATE)) | |
632 | subgroup_default_originate(subgrp, 0); | |
633 | ||
634 | for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) | |
6f94b685 | 635 | for (ri = bgp_node_get_bgp_path_info(rn); ri; ri = ri->next) |
d62a17ae | 636 | |
1defdda8 | 637 | if (CHECK_FLAG(ri->flags, BGP_PATH_SELECTED) |
d62a17ae | 638 | || (addpath_capable |
dcc68b5e MS |
639 | && bgp_addpath_tx_path( |
640 | peer->addpath_type[afi][safi], | |
641 | ri))) { | |
d62a17ae | 642 | if (subgroup_announce_check(rn, ri, subgrp, |
643 | &rn->p, &attr)) | |
644 | bgp_adj_out_set_subgroup(rn, subgrp, | |
645 | &attr, ri); | |
646 | else | |
647 | bgp_adj_out_unset_subgroup( | |
648 | rn, subgrp, 1, | |
dcc68b5e MS |
649 | bgp_addpath_id_for_peer( |
650 | peer, afi, safi, | |
651 | &ri->tx_addpath)); | |
d62a17ae | 652 | } |
653 | ||
654 | /* | |
655 | * We walked through the whole table -- make sure our version number | |
656 | * is consistent with the one on the table. This should allow | |
657 | * subgroups to merge sooner if a peer comes up when the route node | |
658 | * with the largest version is no longer in the table. This also | |
659 | * covers the pathological case where all routes in the table have | |
660 | * now been deleted. | |
661 | */ | |
662 | subgrp->version = max(subgrp->version, table->version); | |
663 | ||
664 | /* | |
665 | * Start a task to merge the subgroup if necessary. | |
666 | */ | |
667 | update_subgroup_trigger_merge_check(subgrp, 0); | |
3f9c7369 DS |
668 | } |
669 | ||
670 | /* | |
671 | * subgroup_announce_route | |
672 | * | |
673 | * Refresh all routes out to a subgroup. | |
674 | */ | |
d62a17ae | 675 | void subgroup_announce_route(struct update_subgroup *subgrp) |
3f9c7369 | 676 | { |
d62a17ae | 677 | struct bgp_node *rn; |
678 | struct bgp_table *table; | |
679 | struct peer *onlypeer; | |
680 | ||
681 | if (update_subgroup_needs_refresh(subgrp)) { | |
682 | update_subgroup_set_needs_refresh(subgrp, 0); | |
683 | } | |
684 | ||
685 | /* | |
686 | * First update is deferred until ORF or ROUTE-REFRESH is received | |
687 | */ | |
688 | onlypeer = ((SUBGRP_PCOUNT(subgrp) == 1) ? (SUBGRP_PFIRST(subgrp))->peer | |
689 | : NULL); | |
9d303b37 DL |
690 | if (onlypeer && CHECK_FLAG(onlypeer->af_sflags[SUBGRP_AFI(subgrp)] |
691 | [SUBGRP_SAFI(subgrp)], | |
692 | PEER_STATUS_ORF_WAIT_REFRESH)) | |
d62a17ae | 693 | return; |
694 | ||
695 | if (SUBGRP_SAFI(subgrp) != SAFI_MPLS_VPN | |
696 | && SUBGRP_SAFI(subgrp) != SAFI_ENCAP | |
697 | && SUBGRP_SAFI(subgrp) != SAFI_EVPN) | |
698 | subgroup_announce_table(subgrp, NULL); | |
699 | else | |
700 | for (rn = bgp_table_top(update_subgroup_rib(subgrp)); rn; | |
67009e22 DS |
701 | rn = bgp_route_next(rn)) { |
702 | table = bgp_node_get_bgp_table_info(rn); | |
703 | if (!table) | |
704 | continue; | |
705 | subgroup_announce_table(subgrp, table); | |
706 | } | |
3f9c7369 DS |
707 | } |
708 | ||
d62a17ae | 709 | void subgroup_default_originate(struct update_subgroup *subgrp, int withdraw) |
3f9c7369 | 710 | { |
d62a17ae | 711 | struct bgp *bgp; |
e50c68b2 DS |
712 | struct attr attr; |
713 | struct aspath *aspath; | |
714 | struct bgp_path_info tmp_info; | |
d62a17ae | 715 | struct prefix p; |
716 | struct peer *from; | |
717 | struct bgp_node *rn; | |
4b7e6066 | 718 | struct bgp_path_info *ri; |
d62a17ae | 719 | struct peer *peer; |
b68885f9 | 720 | route_map_result_t ret = RMAP_DENYMATCH; |
d62a17ae | 721 | afi_t afi; |
722 | safi_t safi; | |
723 | ||
724 | if (!subgrp) | |
725 | return; | |
726 | ||
727 | peer = SUBGRP_PEER(subgrp); | |
728 | afi = SUBGRP_AFI(subgrp); | |
729 | safi = SUBGRP_SAFI(subgrp); | |
730 | ||
731 | if (!(afi == AFI_IP || afi == AFI_IP6)) | |
732 | return; | |
733 | ||
734 | bgp = peer->bgp; | |
735 | from = bgp->peer_self; | |
736 | ||
e50c68b2 DS |
737 | bgp_attr_default_set(&attr, BGP_ORIGIN_IGP); |
738 | aspath = attr.aspath; | |
739 | ||
740 | attr.local_pref = bgp->default_local_pref; | |
d62a17ae | 741 | |
cbb65f5e RW |
742 | memset(&p, 0, sizeof(p)); |
743 | p.family = afi2family(afi); | |
744 | p.prefixlen = 0; | |
d62a17ae | 745 | |
e50c68b2 DS |
746 | if ((afi == AFI_IP6) || peer_cap_enhe(peer, afi, safi)) { |
747 | /* IPv6 global nexthop must be included. */ | |
748 | attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; | |
749 | ||
750 | /* If the peer is on shared nextwork and we have link-local | |
751 | nexthop set it. */ | |
752 | if (peer->shared_network | |
753 | && !IN6_IS_ADDR_UNSPECIFIED(&peer->nexthop.v6_local)) | |
754 | attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; | |
755 | } | |
756 | ||
d62a17ae | 757 | if (peer->default_rmap[afi][safi].name) { |
758 | SET_FLAG(bgp->peer_self->rmap_type, PEER_RMAP_TYPE_DEFAULT); | |
759 | for (rn = bgp_table_top(bgp->rib[afi][safi]); rn; | |
760 | rn = bgp_route_next(rn)) { | |
6f94b685 DS |
761 | for (ri = bgp_node_get_bgp_path_info(rn); |
762 | ri; ri = ri->next) { | |
e50c68b2 DS |
763 | struct attr dummy_attr; |
764 | ||
765 | /* Provide dummy so the route-map can't modify | |
766 | * the attributes */ | |
6f4f49b2 | 767 | dummy_attr = *ri->attr; |
74401e62 | 768 | tmp_info.peer = ri->peer; |
e50c68b2 | 769 | tmp_info.attr = &dummy_attr; |
d62a17ae | 770 | |
771 | ret = route_map_apply( | |
772 | peer->default_rmap[afi][safi].map, | |
74401e62 DA |
773 | &rn->p, RMAP_BGP, &tmp_info); |
774 | ||
e50c68b2 DS |
775 | /* The route map might have set attributes. If |
776 | * we don't flush them | |
777 | * here, they will be leaked. */ | |
778 | bgp_attr_flush(&dummy_attr); | |
d62a17ae | 779 | if (ret != RMAP_DENYMATCH) |
780 | break; | |
781 | } | |
782 | if (ret != RMAP_DENYMATCH) | |
783 | break; | |
784 | } | |
785 | bgp->peer_self->rmap_type = 0; | |
786 | ||
787 | if (ret == RMAP_DENYMATCH) | |
788 | withdraw = 1; | |
3f9c7369 | 789 | } |
3f9c7369 | 790 | |
d62a17ae | 791 | if (withdraw) { |
792 | if (CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE)) | |
793 | subgroup_default_withdraw_packet(subgrp); | |
794 | UNSET_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE); | |
795 | } else { | |
796 | if (!CHECK_FLAG(subgrp->sflags, | |
797 | SUBGRP_STATUS_DEFAULT_ORIGINATE)) { | |
7f323236 DW |
798 | |
799 | if (bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)) { | |
e50c68b2 | 800 | bgp_attr_add_gshut_community(&attr); |
7f323236 DW |
801 | } |
802 | ||
d62a17ae | 803 | SET_FLAG(subgrp->sflags, |
804 | SUBGRP_STATUS_DEFAULT_ORIGINATE); | |
e50c68b2 | 805 | subgroup_default_update_packet(subgrp, &attr, from); |
d62a17ae | 806 | |
807 | /* The 'neighbor x.x.x.x default-originate' default will | |
808 | * act as an | |
809 | * implicit withdraw for any previous UPDATEs sent for | |
810 | * 0.0.0.0/0 so | |
811 | * clear adj_out for the 0.0.0.0/0 prefix in the BGP | |
812 | * table. | |
813 | */ | |
cbb65f5e RW |
814 | memset(&p, 0, sizeof(p)); |
815 | p.family = afi2family(afi); | |
816 | p.prefixlen = 0; | |
d62a17ae | 817 | |
818 | rn = bgp_afi_node_get(bgp->rib[afi][safi], afi, safi, | |
819 | &p, NULL); | |
820 | bgp_adj_out_unset_subgroup( | |
821 | rn, subgrp, 0, | |
822 | BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); | |
823 | } | |
824 | } | |
e50c68b2 DS |
825 | |
826 | aspath_unintern(&aspath); | |
3f9c7369 DS |
827 | } |
828 | ||
829 | /* | |
830 | * Announce the BGP table to a subgroup. | |
831 | * | |
832 | * At startup, we try to optimize route announcement by coalescing the | |
833 | * peer-up events. This is done only the first time - from then on, | |
834 | * subgrp->v_coalesce will be set to zero and the normal logic | |
835 | * prevails. | |
836 | */ | |
d62a17ae | 837 | void subgroup_announce_all(struct update_subgroup *subgrp) |
3f9c7369 | 838 | { |
d62a17ae | 839 | if (!subgrp) |
840 | return; | |
841 | ||
842 | /* | |
843 | * If coalesce timer value is not set, announce routes immediately. | |
844 | */ | |
845 | if (!subgrp->v_coalesce) { | |
846 | if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0)) | |
847 | zlog_debug("u%" PRIu64 ":s%" PRIu64 | |
848 | " announcing all routes", | |
849 | subgrp->update_group->id, subgrp->id); | |
850 | subgroup_announce_route(subgrp); | |
851 | return; | |
852 | } | |
853 | ||
854 | /* | |
855 | * We should wait for the coalesce timer. Arm the timer if not done. | |
856 | */ | |
857 | if (!subgrp->t_coalesce) { | |
858 | thread_add_timer_msec(bm->master, subgroup_coalesce_timer, | |
859 | subgrp, subgrp->v_coalesce, | |
860 | &subgrp->t_coalesce); | |
861 | } | |
3f9c7369 DS |
862 | } |
863 | ||
864 | /* | |
865 | * Go through all update subgroups and set up the adv queue for the | |
866 | * input route. | |
867 | */ | |
d62a17ae | 868 | void group_announce_route(struct bgp *bgp, afi_t afi, safi_t safi, |
40381db7 | 869 | struct bgp_node *rn, struct bgp_path_info *pi) |
3f9c7369 | 870 | { |
d62a17ae | 871 | struct updwalk_context ctx; |
40381db7 | 872 | ctx.pi = pi; |
d62a17ae | 873 | ctx.rn = rn; |
874 | update_group_af_walk(bgp, afi, safi, group_announce_route_walkcb, &ctx); | |
3f9c7369 DS |
875 | } |
876 | ||
d62a17ae | 877 | void update_group_show_adj_queue(struct bgp *bgp, afi_t afi, safi_t safi, |
878 | struct vty *vty, uint64_t id) | |
3f9c7369 | 879 | { |
d62a17ae | 880 | updgrp_show_adj(bgp, afi, safi, vty, id, UPDWALK_FLAGS_ADVQUEUE); |
3f9c7369 DS |
881 | } |
882 | ||
d62a17ae | 883 | void update_group_show_advertised(struct bgp *bgp, afi_t afi, safi_t safi, |
884 | struct vty *vty, uint64_t id) | |
3f9c7369 | 885 | { |
d62a17ae | 886 | updgrp_show_adj(bgp, afi, safi, vty, id, UPDWALK_FLAGS_ADVERTISED); |
3f9c7369 DS |
887 | } |
888 | ||
d62a17ae | 889 | void update_group_announce(struct bgp *bgp) |
3f9c7369 | 890 | { |
d62a17ae | 891 | update_group_walk(bgp, update_group_announce_walkcb, NULL); |
3f9c7369 DS |
892 | } |
893 | ||
d62a17ae | 894 | void update_group_announce_rrclients(struct bgp *bgp) |
3f9c7369 | 895 | { |
d62a17ae | 896 | update_group_walk(bgp, update_group_announce_rrc_walkcb, NULL); |
3f9c7369 | 897 | } |