]>
Commit | Line | Data |
---|---|---|
dcc68b5e MS |
1 | /* |
2 | * Addpath TX ID selection, and related utilities | |
3 | * Copyright (C) 2018 Amazon.com, Inc. or its affiliates | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms of the GNU General Public License as published by the Free | |
7 | * Software Foundation; either version 2 of the License, or (at your option) | |
8 | * any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along | |
16 | * with this program; see the file COPYING; if not, write to the Free Software | |
17 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
18 | */ | |
19 | ||
2618a52e DL |
20 | #ifdef HAVE_CONFIG_H |
21 | #include "config.h" | |
22 | #endif | |
23 | ||
dcc68b5e MS |
24 | #include "bgp_addpath.h" |
25 | #include "bgp_route.h" | |
26 | ||
2b64873d | 27 | static const struct bgp_addpath_strategy_names strat_names[BGP_ADDPATH_MAX] = { |
dcc68b5e MS |
28 | { |
29 | .config_name = "addpath-tx-all-paths", | |
30 | .human_name = "All", | |
31 | .human_description = "Advertise all paths via addpath", | |
32 | .type_json_name = "addpathTxAllPaths", | |
33 | .id_json_name = "addpathTxIdAll" | |
34 | }, | |
35 | { | |
36 | .config_name = "addpath-tx-bestpath-per-AS", | |
37 | .human_name = "Best-Per-AS", | |
38 | .human_description = "Advertise bestpath per AS via addpath", | |
39 | .type_json_name = "addpathTxBestpathPerAS", | |
40 | .id_json_name = "addpathTxIdBestPerAS" | |
41 | } | |
42 | }; | |
43 | ||
2b64873d | 44 | static const struct bgp_addpath_strategy_names unknown_names = { |
dcc68b5e MS |
45 | .config_name = "addpath-tx-unknown", |
46 | .human_name = "Unknown-Addpath-Strategy", | |
47 | .human_description = "Unknown Addpath Strategy", | |
48 | .type_json_name = "addpathTxUnknown", | |
49 | .id_json_name = "addpathTxIdUnknown" | |
50 | }; | |
51 | ||
52 | /* | |
53 | * Returns a structure full of strings associated with an addpath type. Will | |
54 | * never return null. | |
55 | */ | |
2b64873d | 56 | const struct bgp_addpath_strategy_names * |
dcc68b5e MS |
57 | bgp_addpath_names(enum bgp_addpath_strat strat) |
58 | { | |
59 | if (strat < BGP_ADDPATH_MAX) | |
60 | return &(strat_names[strat]); | |
61 | else | |
62 | return &unknown_names; | |
63 | }; | |
64 | ||
65 | /* | |
66 | * Returns if any peer is transmitting addpaths for a given afi/safi. | |
67 | */ | |
3dc339cd DA |
68 | bool bgp_addpath_is_addpath_used(struct bgp_addpath_bgp_data *d, afi_t afi, |
69 | safi_t safi) | |
dcc68b5e MS |
70 | { |
71 | return d->total_peercount[afi][safi] > 0; | |
72 | } | |
73 | ||
74 | /* | |
75 | * Initialize the BGP instance level data for addpath. | |
76 | */ | |
77 | void bgp_addpath_init_bgp_data(struct bgp_addpath_bgp_data *d) | |
78 | { | |
79 | safi_t safi; | |
80 | afi_t afi; | |
81 | int i; | |
82 | ||
f18ba3cd DS |
83 | FOREACH_AFI_SAFI (afi, safi) { |
84 | for (i = 0; i < BGP_ADDPATH_MAX; i++) { | |
85 | d->id_allocators[afi][safi][i] = NULL; | |
86 | d->peercount[afi][safi][i] = 0; | |
dcc68b5e | 87 | } |
f18ba3cd | 88 | d->total_peercount[afi][safi] = 0; |
dcc68b5e MS |
89 | } |
90 | } | |
91 | ||
92 | /* | |
93 | * Free up resources associated with BGP route info structures. | |
94 | */ | |
95 | void bgp_addpath_free_info_data(struct bgp_addpath_info_data *d, | |
96 | struct bgp_addpath_node_data *nd) | |
97 | { | |
98 | int i; | |
99 | ||
100 | for (i = 0; i < BGP_ADDPATH_MAX; i++) { | |
101 | if (d->addpath_tx_id[i] != IDALLOC_INVALID) | |
102 | idalloc_free_to_pool(&nd->free_ids[i], | |
103 | d->addpath_tx_id[i]); | |
104 | } | |
105 | } | |
106 | ||
107 | /* | |
108 | * Return the addpath ID used to send a particular route, to a particular peer, | |
109 | * in a particular AFI/SAFI. | |
110 | */ | |
111 | uint32_t bgp_addpath_id_for_peer(struct peer *peer, afi_t afi, safi_t safi, | |
112 | struct bgp_addpath_info_data *d) | |
113 | { | |
114 | if (peer->addpath_type[afi][safi] < BGP_ADDPATH_MAX) | |
115 | return d->addpath_tx_id[peer->addpath_type[afi][safi]]; | |
116 | else | |
117 | return IDALLOC_INVALID; | |
118 | } | |
119 | ||
120 | /* | |
121 | * Returns true if the path has an assigned addpath ID for any of the addpath | |
122 | * strategies. | |
123 | */ | |
3dc339cd | 124 | bool bgp_addpath_info_has_ids(struct bgp_addpath_info_data *d) |
dcc68b5e MS |
125 | { |
126 | int i; | |
127 | ||
128 | for (i = 0; i < BGP_ADDPATH_MAX; i++) | |
129 | if (d->addpath_tx_id[i] != 0) | |
3dc339cd | 130 | return true; |
dcc68b5e | 131 | |
3dc339cd | 132 | return false; |
dcc68b5e MS |
133 | } |
134 | ||
135 | /* | |
136 | * Releases any ID's associated with the BGP prefix. | |
137 | */ | |
138 | void bgp_addpath_free_node_data(struct bgp_addpath_bgp_data *bd, | |
139 | struct bgp_addpath_node_data *nd, afi_t afi, | |
140 | safi_t safi) | |
141 | { | |
142 | int i; | |
143 | ||
144 | for (i = 0; i < BGP_ADDPATH_MAX; i++) { | |
145 | idalloc_drain_pool(bd->id_allocators[afi][safi][i], | |
146 | &(nd->free_ids[i])); | |
147 | } | |
148 | } | |
149 | ||
150 | /* | |
151 | * Check to see if the addpath strategy requires DMED to be configured to work. | |
152 | */ | |
3dc339cd | 153 | bool bgp_addpath_dmed_required(int strategy) |
dcc68b5e MS |
154 | { |
155 | return strategy == BGP_ADDPATH_BEST_PER_AS; | |
156 | } | |
157 | ||
158 | /* | |
159 | * Return true if this is a path we should advertise due to a | |
160 | * configured addpath-tx knob | |
161 | */ | |
3dc339cd | 162 | bool bgp_addpath_tx_path(enum bgp_addpath_strat strat, struct bgp_path_info *pi) |
dcc68b5e MS |
163 | { |
164 | switch (strat) { | |
165 | case BGP_ADDPATH_NONE: | |
3dc339cd | 166 | return false; |
dcc68b5e | 167 | case BGP_ADDPATH_ALL: |
3dc339cd | 168 | return true; |
dcc68b5e MS |
169 | case BGP_ADDPATH_BEST_PER_AS: |
170 | if (CHECK_FLAG(pi->flags, BGP_PATH_DMED_SELECTED)) | |
3dc339cd | 171 | return true; |
dcc68b5e | 172 | else |
3dc339cd | 173 | return false; |
dcc68b5e | 174 | default: |
3dc339cd | 175 | return false; |
dcc68b5e MS |
176 | } |
177 | } | |
178 | ||
6ff96d00 RW |
179 | static void bgp_addpath_flush_type_rn(struct bgp *bgp, afi_t afi, safi_t safi, |
180 | enum bgp_addpath_strat addpath_type, | |
9bcb3eef | 181 | struct bgp_dest *dest) |
6ff96d00 RW |
182 | { |
183 | struct bgp_path_info *pi; | |
184 | ||
185 | idalloc_drain_pool( | |
186 | bgp->tx_addpath.id_allocators[afi][safi][addpath_type], | |
9bcb3eef DS |
187 | &(dest->tx_addpath.free_ids[addpath_type])); |
188 | for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) { | |
6ff96d00 RW |
189 | if (pi->tx_addpath.addpath_tx_id[addpath_type] |
190 | != IDALLOC_INVALID) { | |
191 | idalloc_free( | |
192 | bgp->tx_addpath | |
193 | .id_allocators[afi][safi][addpath_type], | |
194 | pi->tx_addpath.addpath_tx_id[addpath_type]); | |
195 | pi->tx_addpath.addpath_tx_id[addpath_type] = | |
196 | IDALLOC_INVALID; | |
197 | } | |
198 | } | |
199 | } | |
200 | ||
dcc68b5e MS |
201 | /* |
202 | * Purge all addpath ID's on a BGP instance associated with the addpath | |
203 | * strategy, and afi/safi combination. This lets us let go of all memory held to | |
204 | * track ID numbers associated with an addpath type not in use. Since | |
205 | * post-bestpath ID processing is skipped for types not used, this is the only | |
206 | * chance to free this data. | |
207 | */ | |
208 | static void bgp_addpath_flush_type(struct bgp *bgp, afi_t afi, safi_t safi, | |
209 | enum bgp_addpath_strat addpath_type) | |
210 | { | |
9bcb3eef | 211 | struct bgp_dest *dest, *ndest; |
dcc68b5e | 212 | |
9bcb3eef DS |
213 | for (dest = bgp_table_top(bgp->rib[afi][safi]); dest; |
214 | dest = bgp_route_next(dest)) { | |
6ff96d00 RW |
215 | if (safi == SAFI_MPLS_VPN) { |
216 | struct bgp_table *table; | |
217 | ||
9bcb3eef | 218 | table = bgp_dest_get_bgp_table_info(dest); |
6ff96d00 RW |
219 | if (!table) |
220 | continue; | |
221 | ||
9bcb3eef DS |
222 | for (ndest = bgp_table_top(table); ndest; |
223 | ndest = bgp_route_next(ndest)) | |
6ff96d00 | 224 | bgp_addpath_flush_type_rn(bgp, afi, safi, |
9bcb3eef | 225 | addpath_type, ndest); |
6ff96d00 RW |
226 | } else { |
227 | bgp_addpath_flush_type_rn(bgp, afi, safi, addpath_type, | |
9bcb3eef | 228 | dest); |
dcc68b5e MS |
229 | } |
230 | } | |
231 | ||
232 | idalloc_destroy(bgp->tx_addpath.id_allocators[afi][safi][addpath_type]); | |
233 | bgp->tx_addpath.id_allocators[afi][safi][addpath_type] = NULL; | |
234 | } | |
235 | ||
236 | /* | |
237 | * Allocate an Addpath ID for the given type on a path, if necessary. | |
238 | */ | |
239 | static void bgp_addpath_populate_path(struct id_alloc *allocator, | |
240 | struct bgp_path_info *path, | |
241 | enum bgp_addpath_strat addpath_type) | |
242 | { | |
243 | if (bgp_addpath_tx_path(addpath_type, path)) { | |
244 | path->tx_addpath.addpath_tx_id[addpath_type] = | |
245 | idalloc_allocate(allocator); | |
246 | } | |
247 | } | |
248 | ||
249 | /* | |
250 | * Compute addpath ID's on a BGP instance associated with the addpath strategy, | |
251 | * and afi/safi combination. Since we won't waste the time computing addpath IDs | |
252 | * for unused strategies, the first time a peer is configured to use a strategy, | |
253 | * we have to backfill the data. | |
254 | */ | |
255 | static void bgp_addpath_populate_type(struct bgp *bgp, afi_t afi, safi_t safi, | |
256 | enum bgp_addpath_strat addpath_type) | |
257 | { | |
9bcb3eef | 258 | struct bgp_dest *dest, *ndest; |
dcc68b5e MS |
259 | char buf[200]; |
260 | struct id_alloc *allocator; | |
261 | ||
262 | snprintf(buf, sizeof(buf), "Addpath ID Allocator %s:%d/%d", | |
263 | bgp_addpath_names(addpath_type)->config_name, (int)afi, | |
264 | (int)safi); | |
265 | buf[sizeof(buf) - 1] = '\0'; | |
266 | zlog_info("Computing addpath IDs for addpath type %s", | |
267 | bgp_addpath_names(addpath_type)->human_name); | |
268 | ||
269 | bgp->tx_addpath.id_allocators[afi][safi][addpath_type] = | |
270 | idalloc_new(buf); | |
271 | ||
272 | idalloc_reserve(bgp->tx_addpath.id_allocators[afi][safi][addpath_type], | |
273 | BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE); | |
274 | ||
275 | allocator = bgp->tx_addpath.id_allocators[afi][safi][addpath_type]; | |
276 | ||
9bcb3eef DS |
277 | for (dest = bgp_table_top(bgp->rib[afi][safi]); dest; |
278 | dest = bgp_route_next(dest)) { | |
6ff96d00 RW |
279 | struct bgp_path_info *bi; |
280 | ||
281 | if (safi == SAFI_MPLS_VPN) { | |
282 | struct bgp_table *table; | |
283 | ||
9bcb3eef | 284 | table = bgp_dest_get_bgp_table_info(dest); |
6ff96d00 RW |
285 | if (!table) |
286 | continue; | |
287 | ||
9bcb3eef DS |
288 | for (ndest = bgp_table_top(table); ndest; |
289 | ndest = bgp_route_next(ndest)) | |
290 | for (bi = bgp_dest_get_bgp_path_info(ndest); bi; | |
6ff96d00 RW |
291 | bi = bi->next) |
292 | bgp_addpath_populate_path(allocator, bi, | |
293 | addpath_type); | |
294 | } else { | |
9bcb3eef | 295 | for (bi = bgp_dest_get_bgp_path_info(dest); bi; |
6ff96d00 RW |
296 | bi = bi->next) |
297 | bgp_addpath_populate_path(allocator, bi, | |
298 | addpath_type); | |
299 | } | |
300 | } | |
dcc68b5e MS |
301 | } |
302 | ||
303 | /* | |
304 | * Handle updates to a peer or group's addpath strategy. If after adjusting | |
305 | * counts a addpath strategy is in use for the first time, or no longer in use, | |
306 | * the IDs for that strategy will be populated or flushed. | |
307 | */ | |
308 | void bgp_addpath_type_changed(struct bgp *bgp) | |
309 | { | |
310 | afi_t afi; | |
311 | safi_t safi; | |
312 | struct listnode *node, *nnode; | |
313 | struct peer *peer; | |
314 | int peer_count[AFI_MAX][SAFI_MAX][BGP_ADDPATH_MAX]; | |
315 | enum bgp_addpath_strat type; | |
316 | ||
317 | FOREACH_AFI_SAFI(afi, safi) { | |
318 | for (type=0; type<BGP_ADDPATH_MAX; type++) { | |
319 | peer_count[afi][safi][type] = 0; | |
320 | } | |
d4a0d83b | 321 | bgp->tx_addpath.total_peercount[afi][safi] = 0; |
dcc68b5e MS |
322 | } |
323 | ||
324 | for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) { | |
325 | FOREACH_AFI_SAFI(afi, safi) { | |
326 | type = peer->addpath_type[afi][safi]; | |
327 | if (type != BGP_ADDPATH_NONE) { | |
328 | peer_count[afi][safi][type] += 1; | |
d4a0d83b | 329 | bgp->tx_addpath.total_peercount[afi][safi] += 1; |
dcc68b5e MS |
330 | } |
331 | } | |
332 | } | |
333 | ||
334 | FOREACH_AFI_SAFI(afi, safi) { | |
335 | for (type=0; type<BGP_ADDPATH_MAX; type++) { | |
336 | int old = bgp->tx_addpath.peercount[afi][safi][type]; | |
337 | int new = peer_count[afi][safi][type]; | |
338 | ||
339 | bgp->tx_addpath.peercount[afi][safi][type] = new; | |
340 | ||
341 | if (old == 0 && new != 0) { | |
342 | bgp_addpath_populate_type(bgp, afi, safi, | |
343 | type); | |
344 | } else if (old != 0 && new == 0) { | |
345 | bgp_addpath_flush_type(bgp, afi, safi, type); | |
346 | } | |
347 | } | |
348 | } | |
349 | } | |
350 | ||
351 | /* | |
352 | * Change the addpath type assigned to a peer, or peer group. In addition to | |
353 | * adjusting the counts, peer sessions will be reset as needed to make the | |
354 | * change take effect. | |
355 | */ | |
356 | void bgp_addpath_set_peer_type(struct peer *peer, afi_t afi, safi_t safi, | |
357 | enum bgp_addpath_strat addpath_type) | |
358 | { | |
359 | struct bgp *bgp = peer->bgp; | |
360 | enum bgp_addpath_strat old_type = peer->addpath_type[afi][safi]; | |
361 | struct listnode *node, *nnode; | |
362 | struct peer *tmp_peer; | |
363 | struct peer_group *group; | |
364 | ||
365 | if (addpath_type == old_type) | |
366 | return; | |
367 | ||
368 | if (addpath_type == BGP_ADDPATH_NONE && peer->group && | |
369 | !CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) { | |
370 | /* A "no" config on a group member inherits group */ | |
371 | addpath_type = peer->group->conf->addpath_type[afi][safi]; | |
372 | } | |
373 | ||
374 | peer->addpath_type[afi][safi] = addpath_type; | |
375 | ||
376 | bgp_addpath_type_changed(bgp); | |
377 | ||
378 | if (addpath_type != BGP_ADDPATH_NONE) { | |
379 | if (bgp_addpath_dmed_required(addpath_type)) { | |
892fedb6 DA |
380 | if (!CHECK_FLAG(bgp->flags, |
381 | BGP_FLAG_DETERMINISTIC_MED)) { | |
dcc68b5e MS |
382 | zlog_warn( |
383 | "%s: enabling bgp deterministic-med, this is required for addpath-tx-bestpath-per-AS", | |
384 | peer->host); | |
892fedb6 DA |
385 | SET_FLAG(bgp->flags, |
386 | BGP_FLAG_DETERMINISTIC_MED); | |
dcc68b5e MS |
387 | bgp_recalculate_all_bestpaths(bgp); |
388 | } | |
389 | } | |
390 | } | |
391 | ||
9165c5f5 | 392 | zlog_info("Resetting peer %s%s due to change in addpath config", |
dcc68b5e MS |
393 | CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP) ? "group " : "", |
394 | peer->host); | |
395 | ||
396 | if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) { | |
397 | group = peer->group; | |
398 | ||
399 | /* group will be null as peer_group_delete calls peer_delete on | |
400 | * group->conf. That peer_delete will eventuallly end up here | |
401 | * if the group was configured to tx addpaths. | |
402 | */ | |
403 | if (group != NULL) { | |
404 | for (ALL_LIST_ELEMENTS(group->peer, node, nnode, | |
405 | tmp_peer)) { | |
406 | if (tmp_peer->addpath_type[afi][safi] == | |
407 | old_type) { | |
408 | bgp_addpath_set_peer_type(tmp_peer, | |
409 | afi, | |
410 | safi, | |
411 | addpath_type); | |
412 | } | |
413 | } | |
414 | } | |
415 | } else { | |
416 | peer_change_action(peer, afi, safi, peer_change_reset); | |
417 | } | |
418 | ||
419 | } | |
420 | ||
421 | /* | |
422 | * Intended to run after bestpath. This function will take TX IDs from paths | |
423 | * that no longer need them, and give them to paths that do. This prevents | |
424 | * best-per-as updates from needing to do a separate withdraw and update just to | |
425 | * swap out which path is sent. | |
426 | */ | |
9bcb3eef DS |
427 | void bgp_addpath_update_ids(struct bgp *bgp, struct bgp_dest *bn, afi_t afi, |
428 | safi_t safi) | |
dcc68b5e MS |
429 | { |
430 | int i; | |
431 | struct bgp_path_info *pi; | |
432 | struct id_alloc_pool **pool_ptr; | |
433 | ||
434 | for (i = 0; i < BGP_ADDPATH_MAX; i++) { | |
435 | struct id_alloc *alloc = | |
436 | bgp->tx_addpath.id_allocators[afi][safi][i]; | |
437 | pool_ptr = &(bn->tx_addpath.free_ids[i]); | |
438 | ||
439 | if (bgp->tx_addpath.peercount[afi][safi][i] == 0) | |
440 | continue; | |
441 | ||
442 | /* Free Unused IDs back to the pool.*/ | |
9bcb3eef | 443 | for (pi = bgp_dest_get_bgp_path_info(bn); pi; pi = pi->next) { |
dcc68b5e MS |
444 | if (pi->tx_addpath.addpath_tx_id[i] != IDALLOC_INVALID |
445 | && !bgp_addpath_tx_path(i, pi)) { | |
446 | idalloc_free_to_pool(pool_ptr, | |
447 | pi->tx_addpath.addpath_tx_id[i]); | |
448 | pi->tx_addpath.addpath_tx_id[i] = | |
449 | IDALLOC_INVALID; | |
450 | } | |
451 | } | |
452 | ||
453 | /* Give IDs to paths that need them (pulling from the pool) */ | |
9bcb3eef | 454 | for (pi = bgp_dest_get_bgp_path_info(bn); pi; pi = pi->next) { |
dcc68b5e MS |
455 | if (pi->tx_addpath.addpath_tx_id[i] == IDALLOC_INVALID |
456 | && bgp_addpath_tx_path(i, pi)) { | |
457 | pi->tx_addpath.addpath_tx_id[i] = | |
458 | idalloc_allocate_prefer_pool( | |
459 | alloc, pool_ptr); | |
460 | } | |
461 | } | |
462 | ||
463 | /* Free any IDs left in the pool to the main allocator */ | |
464 | idalloc_drain_pool(alloc, pool_ptr); | |
465 | } | |
466 | } |