]>
Commit | Line | Data |
---|---|---|
718e3744 | 1 | /* BGP flap dampening |
2 | Copyright (C) 2001 IP Infusion Inc. | |
3 | ||
4 | This file is part of GNU Zebra. | |
5 | ||
6 | GNU Zebra is free software; you can redistribute it and/or modify it | |
7 | under the terms of the GNU General Public License as published by the | |
8 | Free Software Foundation; either version 2, or (at your option) any | |
9 | later version. | |
10 | ||
11 | GNU Zebra is distributed in the hope that it will be useful, but | |
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GNU Zebra; see the file COPYING. If not, write to the Free | |
18 | Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | |
19 | 02111-1307, USA. */ | |
20 | ||
21 | #include <zebra.h> | |
22 | #include <math.h> | |
23 | ||
24 | #include "prefix.h" | |
25 | #include "memory.h" | |
26 | #include "command.h" | |
27 | #include "log.h" | |
28 | #include "thread.h" | |
3f9c7369 | 29 | #include "queue.h" |
039f3a34 | 30 | #include "filter.h" |
718e3744 | 31 | |
32 | #include "bgpd/bgpd.h" | |
33 | #include "bgpd/bgp_damp.h" | |
34 | #include "bgpd/bgp_table.h" | |
35 | #include "bgpd/bgp_route.h" | |
36 | #include "bgpd/bgp_attr.h" | |
37 | #include "bgpd/bgp_advertise.h" | |
38 | ||
39 | /* Global variable to access damping configuration */ | |
40 | struct bgp_damp_config bgp_damp_cfg; | |
e9dc9f24 | 41 | static struct bgp_damp_config *damp = &bgp_damp_cfg; |
718e3744 | 42 | |
43 | /* Utility macro to add and delete BGP dampening information to no | |
44 | used list. */ | |
45 | #define BGP_DAMP_LIST_ADD(N,A) BGP_INFO_ADD(N,A,no_reuse_list) | |
46 | #define BGP_DAMP_LIST_DEL(N,A) BGP_INFO_DEL(N,A,no_reuse_list) | |
6b0655a2 | 47 | |
718e3744 | 48 | /* Calculate reuse list index by penalty value. */ |
49 | static int | |
50 | bgp_reuse_index (int penalty) | |
51 | { | |
fd79ac91 | 52 | unsigned int i; |
718e3744 | 53 | int index; |
54 | ||
55 | i = (int)(((double) penalty / damp->reuse_limit - 1.0) * damp->scale_factor); | |
56 | ||
57 | if ( i >= damp->reuse_index_size ) | |
58 | i = damp->reuse_index_size - 1; | |
59 | ||
60 | index = damp->reuse_index[i] - damp->reuse_index[0]; | |
61 | ||
62 | return (damp->reuse_offset + index) % damp->reuse_list_size; | |
63 | } | |
64 | ||
65 | /* Add BGP dampening information to reuse list. */ | |
66 | static void | |
67 | bgp_reuse_list_add (struct bgp_damp_info *bdi) | |
68 | { | |
69 | int index; | |
70 | ||
71 | index = bdi->index = bgp_reuse_index (bdi->penalty); | |
72 | ||
73 | bdi->prev = NULL; | |
74 | bdi->next = damp->reuse_list[index]; | |
75 | if (damp->reuse_list[index]) | |
76 | damp->reuse_list[index]->prev = bdi; | |
77 | damp->reuse_list[index] = bdi; | |
78 | } | |
79 | ||
80 | /* Delete BGP dampening information from reuse list. */ | |
81 | static void | |
82 | bgp_reuse_list_delete (struct bgp_damp_info *bdi) | |
83 | { | |
84 | if (bdi->next) | |
85 | bdi->next->prev = bdi->prev; | |
86 | if (bdi->prev) | |
87 | bdi->prev->next = bdi->next; | |
88 | else | |
89 | damp->reuse_list[bdi->index] = bdi->next; | |
90 | } | |
6b0655a2 | 91 | |
718e3744 | 92 | /* Return decayed penalty value. */ |
93 | int | |
94 | bgp_damp_decay (time_t tdiff, int penalty) | |
95 | { | |
fd79ac91 | 96 | unsigned int i; |
718e3744 | 97 | |
98 | i = (int) ((double) tdiff / DELTA_T); | |
99 | ||
100 | if (i == 0) | |
101 | return penalty; | |
102 | ||
103 | if (i >= damp->decay_array_size) | |
104 | return 0; | |
105 | ||
106 | return (int) (penalty * damp->decay_array[i]); | |
107 | } | |
108 | ||
109 | /* Handler of reuse timer event. Each route in the current reuse-list | |
110 | is evaluated. RFC2439 Section 4.8.7. */ | |
94f2b392 | 111 | static int |
718e3744 | 112 | bgp_reuse_timer (struct thread *t) |
113 | { | |
114 | struct bgp_damp_info *bdi; | |
115 | struct bgp_damp_info *next; | |
116 | time_t t_now, t_diff; | |
41200856 | 117 | |
718e3744 | 118 | damp->t_reuse = NULL; |
119 | damp->t_reuse = | |
9229d914 | 120 | thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE); |
718e3744 | 121 | |
65957886 | 122 | t_now = bgp_clock (); |
718e3744 | 123 | |
124 | /* 1. save a pointer to the current zeroth queue head and zero the | |
125 | list head entry. */ | |
126 | bdi = damp->reuse_list[damp->reuse_offset]; | |
127 | damp->reuse_list[damp->reuse_offset] = NULL; | |
128 | ||
129 | /* 2. set offset = modulo reuse-list-size ( offset + 1 ), thereby | |
130 | rotating the circular queue of list-heads. */ | |
131 | damp->reuse_offset = (damp->reuse_offset + 1) % damp->reuse_list_size; | |
132 | ||
133 | /* 3. if ( the saved list head pointer is non-empty ) */ | |
134 | for (; bdi; bdi = next) | |
135 | { | |
41200856 | 136 | struct bgp *bgp = bdi->binfo->peer->bgp; |
137 | ||
718e3744 | 138 | next = bdi->next; |
139 | ||
140 | /* Set t-diff = t-now - t-updated. */ | |
141 | t_diff = t_now - bdi->t_updated; | |
142 | ||
143 | /* Set figure-of-merit = figure-of-merit * decay-array-ok [t-diff] */ | |
144 | bdi->penalty = bgp_damp_decay (t_diff, bdi->penalty); | |
145 | ||
146 | /* Set t-updated = t-now. */ | |
147 | bdi->t_updated = t_now; | |
148 | ||
149 | /* if (figure-of-merit < reuse). */ | |
150 | if (bdi->penalty < damp->reuse_limit) | |
151 | { | |
152 | /* Reuse the route. */ | |
1a392d46 | 153 | bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_DAMPED); |
718e3744 | 154 | bdi->suppress_time = 0; |
155 | ||
156 | if (bdi->lastrecord == BGP_RECORD_UPDATE) | |
157 | { | |
1a392d46 | 158 | bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_HISTORY); |
718e3744 | 159 | bgp_aggregate_increment (bgp, &bdi->rn->p, bdi->binfo, |
160 | bdi->afi, bdi->safi); | |
161 | bgp_process (bgp, bdi->rn, bdi->afi, bdi->safi); | |
162 | } | |
163 | ||
164 | if (bdi->penalty <= damp->reuse_limit / 2.0) | |
165 | bgp_damp_info_free (bdi, 1); | |
166 | else | |
167 | BGP_DAMP_LIST_ADD (damp, bdi); | |
168 | } | |
169 | else | |
170 | /* Re-insert into another list (See RFC2439 Section 4.8.6). */ | |
171 | bgp_reuse_list_add (bdi); | |
172 | } | |
173 | ||
174 | return 0; | |
175 | } | |
176 | ||
177 | /* A route becomes unreachable (RFC2439 Section 4.8.2). */ | |
178 | int | |
179 | bgp_damp_withdraw (struct bgp_info *binfo, struct bgp_node *rn, | |
180 | afi_t afi, safi_t safi, int attr_change) | |
181 | { | |
182 | time_t t_now; | |
fb982c25 | 183 | struct bgp_damp_info *bdi = NULL; |
718e3744 | 184 | double last_penalty = 0; |
185 | ||
65957886 | 186 | t_now = bgp_clock (); |
718e3744 | 187 | |
188 | /* Processing Unreachable Messages. */ | |
fb982c25 PJ |
189 | if (binfo->extra) |
190 | bdi = binfo->extra->damp_info; | |
191 | ||
718e3744 | 192 | if (bdi == NULL) |
193 | { | |
194 | /* If there is no previous stability history. */ | |
195 | ||
196 | /* RFC2439 said: | |
197 | 1. allocate a damping structure. | |
198 | 2. set figure-of-merit = 1. | |
199 | 3. withdraw the route. */ | |
200 | ||
201 | bdi = XCALLOC (MTYPE_BGP_DAMP_INFO, sizeof (struct bgp_damp_info)); | |
202 | bdi->binfo = binfo; | |
203 | bdi->rn = rn; | |
204 | bdi->penalty = (attr_change ? DEFAULT_PENALTY / 2 : DEFAULT_PENALTY); | |
205 | bdi->flap = 1; | |
206 | bdi->start_time = t_now; | |
207 | bdi->suppress_time = 0; | |
208 | bdi->index = -1; | |
209 | bdi->afi = afi; | |
210 | bdi->safi = safi; | |
fb982c25 | 211 | (bgp_info_extra_get (binfo))->damp_info = bdi; |
718e3744 | 212 | BGP_DAMP_LIST_ADD (damp, bdi); |
213 | } | |
214 | else | |
215 | { | |
216 | last_penalty = bdi->penalty; | |
217 | ||
218 | /* 1. Set t-diff = t-now - t-updated. */ | |
219 | bdi->penalty = | |
220 | (bgp_damp_decay (t_now - bdi->t_updated, bdi->penalty) | |
221 | + (attr_change ? DEFAULT_PENALTY / 2 : DEFAULT_PENALTY)); | |
222 | ||
223 | if (bdi->penalty > damp->ceiling) | |
224 | bdi->penalty = damp->ceiling; | |
225 | ||
226 | bdi->flap++; | |
227 | } | |
228 | ||
1a392d46 PJ |
229 | assert ((rn == bdi->rn) && (binfo == bdi->binfo)); |
230 | ||
718e3744 | 231 | bdi->lastrecord = BGP_RECORD_WITHDRAW; |
232 | bdi->t_updated = t_now; | |
233 | ||
234 | /* Make this route as historical status. */ | |
1a392d46 | 235 | bgp_info_set_flag (rn, binfo, BGP_INFO_HISTORY); |
718e3744 | 236 | |
237 | /* Remove the route from a reuse list if it is on one. */ | |
238 | if (CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED)) | |
239 | { | |
240 | /* If decay rate isn't equal to 0, reinsert brn. */ | |
241 | if (bdi->penalty != last_penalty) | |
242 | { | |
243 | bgp_reuse_list_delete (bdi); | |
244 | bgp_reuse_list_add (bdi); | |
245 | } | |
246 | return BGP_DAMP_SUPPRESSED; | |
247 | } | |
248 | ||
249 | /* If not suppressed before, do annonunce this withdraw and | |
250 | insert into reuse_list. */ | |
251 | if (bdi->penalty >= damp->suppress_value) | |
252 | { | |
1a392d46 | 253 | bgp_info_set_flag (rn, binfo, BGP_INFO_DAMPED); |
718e3744 | 254 | bdi->suppress_time = t_now; |
255 | BGP_DAMP_LIST_DEL (damp, bdi); | |
256 | bgp_reuse_list_add (bdi); | |
257 | } | |
258 | ||
259 | return BGP_DAMP_USED; | |
260 | } | |
261 | ||
262 | int | |
263 | bgp_damp_update (struct bgp_info *binfo, struct bgp_node *rn, | |
264 | afi_t afi, safi_t safi) | |
265 | { | |
266 | time_t t_now; | |
267 | struct bgp_damp_info *bdi; | |
268 | int status; | |
269 | ||
fb982c25 | 270 | if (!binfo->extra || !((bdi = binfo->extra->damp_info))) |
718e3744 | 271 | return BGP_DAMP_USED; |
272 | ||
65957886 | 273 | t_now = bgp_clock (); |
1a392d46 | 274 | bgp_info_unset_flag (rn, binfo, BGP_INFO_HISTORY); |
718e3744 | 275 | |
276 | bdi->lastrecord = BGP_RECORD_UPDATE; | |
277 | bdi->penalty = bgp_damp_decay (t_now - bdi->t_updated, bdi->penalty); | |
278 | ||
279 | if (! CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED) | |
280 | && (bdi->penalty < damp->suppress_value)) | |
281 | status = BGP_DAMP_USED; | |
282 | else if (CHECK_FLAG (bdi->binfo->flags, BGP_INFO_DAMPED) | |
283 | && (bdi->penalty < damp->reuse_limit) ) | |
284 | { | |
1a392d46 | 285 | bgp_info_unset_flag (rn, binfo, BGP_INFO_DAMPED); |
718e3744 | 286 | bgp_reuse_list_delete (bdi); |
287 | BGP_DAMP_LIST_ADD (damp, bdi); | |
288 | bdi->suppress_time = 0; | |
289 | status = BGP_DAMP_USED; | |
290 | } | |
291 | else | |
292 | status = BGP_DAMP_SUPPRESSED; | |
293 | ||
294 | if (bdi->penalty > damp->reuse_limit / 2.0) | |
295 | bdi->t_updated = t_now; | |
296 | else | |
297 | bgp_damp_info_free (bdi, 0); | |
298 | ||
299 | return status; | |
300 | } | |
301 | ||
302 | /* Remove dampening information and history route. */ | |
303 | int | |
304 | bgp_damp_scan (struct bgp_info *binfo, afi_t afi, safi_t safi) | |
305 | { | |
306 | time_t t_now, t_diff; | |
307 | struct bgp_damp_info *bdi; | |
fb982c25 PJ |
308 | |
309 | assert (binfo->extra && binfo->extra->damp_info); | |
310 | ||
65957886 | 311 | t_now = bgp_clock (); |
fb982c25 | 312 | bdi = binfo->extra->damp_info; |
718e3744 | 313 | |
314 | if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)) | |
315 | { | |
316 | t_diff = t_now - bdi->suppress_time; | |
317 | ||
318 | if (t_diff >= damp->max_suppress_time) | |
319 | { | |
1a392d46 | 320 | bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_DAMPED); |
718e3744 | 321 | bgp_reuse_list_delete (bdi); |
322 | BGP_DAMP_LIST_ADD (damp, bdi); | |
323 | bdi->penalty = damp->reuse_limit; | |
324 | bdi->suppress_time = 0; | |
325 | bdi->t_updated = t_now; | |
326 | ||
327 | /* Need to announce UPDATE once this binfo is usable again. */ | |
328 | if (bdi->lastrecord == BGP_RECORD_UPDATE) | |
329 | return 1; | |
330 | else | |
331 | return 0; | |
332 | } | |
333 | } | |
334 | else | |
335 | { | |
336 | t_diff = t_now - bdi->t_updated; | |
337 | bdi->penalty = bgp_damp_decay (t_diff, bdi->penalty); | |
338 | ||
339 | if (bdi->penalty <= damp->reuse_limit / 2.0) | |
340 | { | |
341 | /* release the bdi, bdi->binfo. */ | |
342 | bgp_damp_info_free (bdi, 1); | |
343 | return 0; | |
344 | } | |
345 | else | |
346 | bdi->t_updated = t_now; | |
347 | } | |
348 | return 0; | |
349 | } | |
350 | ||
351 | void | |
352 | bgp_damp_info_free (struct bgp_damp_info *bdi, int withdraw) | |
353 | { | |
354 | struct bgp_info *binfo; | |
718e3744 | 355 | |
356 | if (! bdi) | |
357 | return; | |
358 | ||
359 | binfo = bdi->binfo; | |
fb982c25 | 360 | binfo->extra->damp_info = NULL; |
718e3744 | 361 | |
362 | if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)) | |
363 | bgp_reuse_list_delete (bdi); | |
364 | else | |
365 | BGP_DAMP_LIST_DEL (damp, bdi); | |
366 | ||
1a392d46 | 367 | bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_HISTORY|BGP_INFO_DAMPED); |
718e3744 | 368 | |
369 | if (bdi->lastrecord == BGP_RECORD_WITHDRAW && withdraw) | |
200df115 | 370 | bgp_info_delete (bdi->rn, binfo); |
371 | ||
718e3744 | 372 | XFREE (MTYPE_BGP_DAMP_INFO, bdi); |
373 | } | |
374 | ||
94f2b392 | 375 | static void |
718e3744 | 376 | bgp_damp_parameter_set (int hlife, int reuse, int sup, int maxsup) |
377 | { | |
378 | double reuse_max_ratio; | |
fd79ac91 | 379 | unsigned int i; |
718e3744 | 380 | double j; |
381 | ||
382 | damp->suppress_value = sup; | |
383 | damp->half_life = hlife; | |
384 | damp->reuse_limit = reuse; | |
385 | damp->max_suppress_time = maxsup; | |
386 | ||
387 | /* Initialize params per bgp_damp_config. */ | |
388 | damp->reuse_index_size = REUSE_ARRAY_SIZE; | |
389 | ||
390 | damp->ceiling = (int)(damp->reuse_limit * (pow(2, (double)damp->max_suppress_time/damp->half_life))); | |
391 | ||
392 | /* Decay-array computations */ | |
393 | damp->decay_array_size = ceil ((double) damp->max_suppress_time / DELTA_T); | |
394 | damp->decay_array = XMALLOC (MTYPE_BGP_DAMP_ARRAY, | |
395 | sizeof(double) * (damp->decay_array_size)); | |
396 | damp->decay_array[0] = 1.0; | |
397 | damp->decay_array[1] = exp ((1.0/((double)damp->half_life/DELTA_T)) * log(0.5)); | |
398 | ||
399 | /* Calculate decay values for all possible times */ | |
400 | for (i = 2; i < damp->decay_array_size; i++) | |
401 | damp->decay_array[i] = damp->decay_array[i-1] * damp->decay_array[1]; | |
402 | ||
403 | /* Reuse-list computations */ | |
404 | i = ceil ((double)damp->max_suppress_time / DELTA_REUSE) + 1; | |
405 | if (i > REUSE_LIST_SIZE || i == 0) | |
406 | i = REUSE_LIST_SIZE; | |
407 | damp->reuse_list_size = i; | |
408 | ||
409 | damp->reuse_list = XCALLOC (MTYPE_BGP_DAMP_ARRAY, | |
410 | damp->reuse_list_size | |
411 | * sizeof (struct bgp_reuse_node *)); | |
718e3744 | 412 | |
413 | /* Reuse-array computations */ | |
fac9c6b6 | 414 | damp->reuse_index = XCALLOC (MTYPE_BGP_DAMP_ARRAY, |
718e3744 | 415 | sizeof(int) * damp->reuse_index_size); |
718e3744 | 416 | |
417 | reuse_max_ratio = (double)damp->ceiling/damp->reuse_limit; | |
418 | j = (exp((double)damp->max_suppress_time/damp->half_life) * log10(2.0)); | |
419 | if ( reuse_max_ratio > j && j != 0 ) | |
420 | reuse_max_ratio = j; | |
421 | ||
422 | damp->scale_factor = (double)damp->reuse_index_size/(reuse_max_ratio - 1); | |
423 | ||
424 | for (i = 0; i < damp->reuse_index_size; i++) | |
425 | { | |
426 | damp->reuse_index[i] = | |
427 | (int)(((double)damp->half_life / DELTA_REUSE) | |
428 | * log10 (1.0 / (damp->reuse_limit * ( 1.0 + ((double)i/damp->scale_factor)))) / log10(0.5)); | |
429 | } | |
430 | } | |
431 | ||
432 | int | |
fd79ac91 | 433 | bgp_damp_enable (struct bgp *bgp, afi_t afi, safi_t safi, time_t half, |
434 | unsigned int reuse, unsigned int suppress, time_t max) | |
718e3744 | 435 | { |
436 | if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)) | |
437 | { | |
438 | if (damp->half_life == half | |
439 | && damp->reuse_limit == reuse | |
440 | && damp->suppress_value == suppress | |
441 | && damp->max_suppress_time == max) | |
442 | return 0; | |
443 | bgp_damp_disable (bgp, afi, safi); | |
444 | } | |
445 | ||
446 | SET_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING); | |
447 | bgp_damp_parameter_set (half, reuse, suppress, max); | |
448 | ||
449 | /* Register reuse timer. */ | |
450 | if (! damp->t_reuse) | |
451 | damp->t_reuse = | |
9229d914 | 452 | thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE); |
718e3744 | 453 | |
454 | return 0; | |
455 | } | |
456 | ||
94f2b392 | 457 | static void |
718e3744 | 458 | bgp_damp_config_clean (struct bgp_damp_config *damp) |
459 | { | |
460 | /* Free decay array */ | |
461 | XFREE (MTYPE_BGP_DAMP_ARRAY, damp->decay_array); | |
462 | ||
463 | /* Free reuse index array */ | |
464 | XFREE (MTYPE_BGP_DAMP_ARRAY, damp->reuse_index); | |
465 | ||
466 | /* Free reuse list array. */ | |
467 | XFREE (MTYPE_BGP_DAMP_ARRAY, damp->reuse_list); | |
468 | } | |
469 | ||
470 | /* Clean all the bgp_damp_info stored in reuse_list. */ | |
471 | void | |
94f2b392 | 472 | bgp_damp_info_clean (void) |
718e3744 | 473 | { |
fd79ac91 | 474 | unsigned int i; |
718e3744 | 475 | struct bgp_damp_info *bdi, *next; |
476 | ||
477 | damp->reuse_offset = 0; | |
478 | ||
479 | for (i = 0; i < damp->reuse_list_size; i++) | |
480 | { | |
481 | if (! damp->reuse_list[i]) | |
482 | continue; | |
483 | ||
484 | for (bdi = damp->reuse_list[i]; bdi; bdi = next) | |
485 | { | |
486 | next = bdi->next; | |
487 | bgp_damp_info_free (bdi, 1); | |
488 | } | |
489 | damp->reuse_list[i] = NULL; | |
490 | } | |
491 | ||
492 | for (bdi = damp->no_reuse_list; bdi; bdi = next) | |
493 | { | |
494 | next = bdi->next; | |
495 | bgp_damp_info_free (bdi, 1); | |
496 | } | |
497 | damp->no_reuse_list = NULL; | |
498 | } | |
499 | ||
500 | int | |
501 | bgp_damp_disable (struct bgp *bgp, afi_t afi, safi_t safi) | |
502 | { | |
fa4094ac JBD |
503 | /* If it wasn't enabled, there's nothing to do. */ |
504 | if (! CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)) | |
505 | return 0; | |
506 | ||
718e3744 | 507 | /* Cancel reuse thread. */ |
508 | if (damp->t_reuse ) | |
509 | thread_cancel (damp->t_reuse); | |
510 | damp->t_reuse = NULL; | |
511 | ||
512 | /* Clean BGP dampening information. */ | |
513 | bgp_damp_info_clean (); | |
514 | ||
515 | /* Clear configuration */ | |
516 | bgp_damp_config_clean (&bgp_damp_cfg); | |
517 | ||
518 | UNSET_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING); | |
519 | return 0; | |
520 | } | |
521 | ||
f3019aff | 522 | void |
718e3744 | 523 | bgp_config_write_damp (struct vty *vty) |
524 | { | |
f3019aff SH |
525 | if (bgp_damp_cfg.half_life == DEFAULT_HALF_LIFE*60 |
526 | && bgp_damp_cfg.reuse_limit == DEFAULT_REUSE | |
527 | && bgp_damp_cfg.suppress_value == DEFAULT_SUPPRESS | |
528 | && bgp_damp_cfg.max_suppress_time == bgp_damp_cfg.half_life*4) | |
529 | vty_out (vty, " bgp dampening%s", VTY_NEWLINE); | |
530 | else if (bgp_damp_cfg.half_life != DEFAULT_HALF_LIFE*60 | |
531 | && bgp_damp_cfg.reuse_limit == DEFAULT_REUSE | |
532 | && bgp_damp_cfg.suppress_value == DEFAULT_SUPPRESS | |
533 | && bgp_damp_cfg.max_suppress_time == bgp_damp_cfg.half_life*4) | |
8f2c16aa DL |
534 | vty_out (vty, " bgp dampening %lld%s", |
535 | bgp_damp_cfg.half_life/60LL, | |
f3019aff SH |
536 | VTY_NEWLINE); |
537 | else | |
8f2c16aa DL |
538 | vty_out (vty, " bgp dampening %lld %d %d %lld%s", |
539 | bgp_damp_cfg.half_life/60LL, | |
f3019aff SH |
540 | bgp_damp_cfg.reuse_limit, |
541 | bgp_damp_cfg.suppress_value, | |
8f2c16aa | 542 | bgp_damp_cfg.max_suppress_time/60LL, |
f3019aff | 543 | VTY_NEWLINE); |
718e3744 | 544 | } |
545 | ||
e9dc9f24 | 546 | static const char * |
856ca177 | 547 | bgp_get_reuse_time (unsigned int penalty, char *buf, size_t len, u_char use_json, json_object *json) |
718e3744 | 548 | { |
549 | time_t reuse_time = 0; | |
550 | struct tm *tm = NULL; | |
856ca177 | 551 | int time_store = 0; |
718e3744 | 552 | |
553 | if (penalty > damp->reuse_limit) | |
554 | { | |
555 | reuse_time = (int) (DELTA_T * ((log((double)damp->reuse_limit/penalty))/(log(damp->decay_array[1])))); | |
556 | ||
557 | if (reuse_time > damp->max_suppress_time) | |
558 | reuse_time = damp->max_suppress_time; | |
559 | ||
560 | tm = gmtime (&reuse_time); | |
561 | } | |
562 | else | |
563 | reuse_time = 0; | |
564 | ||
565 | /* Making formatted timer strings. */ | |
566 | #define ONE_DAY_SECOND 60*60*24 | |
567 | #define ONE_WEEK_SECOND 60*60*24*7 | |
568 | if (reuse_time == 0) | |
856ca177 MS |
569 | { |
570 | if (use_json) | |
571 | json_object_int_add(json, "reuseTimerMsecs", 0); | |
572 | else | |
573 | snprintf (buf, len, "00:00:00"); | |
574 | } | |
718e3744 | 575 | else if (reuse_time < ONE_DAY_SECOND) |
856ca177 MS |
576 | { |
577 | if (use_json) | |
578 | { | |
579 | time_store = (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec); | |
580 | json_object_int_add(json, "reuseTimerMsecs", time_store); | |
581 | } | |
582 | else | |
583 | snprintf (buf, len, "%02d:%02d:%02d", | |
584 | tm->tm_hour, tm->tm_min, tm->tm_sec); | |
585 | } | |
718e3744 | 586 | else if (reuse_time < ONE_WEEK_SECOND) |
856ca177 MS |
587 | { |
588 | if (use_json) | |
589 | { | |
590 | time_store = (86400000 * tm->tm_yday) + (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec); | |
591 | json_object_int_add(json, "reuseTimerMsecs", time_store); | |
592 | } | |
593 | else | |
594 | snprintf (buf, len, "%dd%02dh%02dm", | |
595 | tm->tm_yday, tm->tm_hour, tm->tm_min); | |
596 | } | |
718e3744 | 597 | else |
856ca177 MS |
598 | { |
599 | if (use_json) | |
600 | { | |
601 | time_store = (604800000 * tm->tm_yday/7) + (86400000 * (tm->tm_yday - ((tm->tm_yday/7) * 7))) + (3600000 * tm->tm_hour) + (60000 * tm->tm_min) + (1000 * tm->tm_sec); | |
602 | json_object_int_add(json, "reuseTimerMsecs", time_store); | |
603 | } | |
604 | else | |
605 | snprintf (buf, len, "%02dw%dd%02dh", | |
606 | tm->tm_yday/7, tm->tm_yday - ((tm->tm_yday/7) * 7), tm->tm_hour); | |
607 | } | |
718e3744 | 608 | |
609 | return buf; | |
610 | } | |
611 | ||
612 | void | |
b05a1c8b DS |
613 | bgp_damp_info_vty (struct vty *vty, struct bgp_info *binfo, |
614 | json_object *json_path) | |
718e3744 | 615 | { |
616 | struct bgp_damp_info *bdi; | |
617 | time_t t_now, t_diff; | |
618 | char timebuf[BGP_UPTIME_LEN]; | |
619 | int penalty; | |
620 | ||
fb982c25 PJ |
621 | if (!binfo->extra) |
622 | return; | |
623 | ||
718e3744 | 624 | /* BGP dampening information. */ |
fb982c25 | 625 | bdi = binfo->extra->damp_info; |
718e3744 | 626 | |
627 | /* If dampening is not enabled or there is no dampening information, | |
628 | return immediately. */ | |
629 | if (! damp || ! bdi) | |
630 | return; | |
631 | ||
632 | /* Calculate new penalty. */ | |
65957886 | 633 | t_now = bgp_clock (); |
718e3744 | 634 | t_diff = t_now - bdi->t_updated; |
635 | penalty = bgp_damp_decay (t_diff, bdi->penalty); | |
636 | ||
b05a1c8b DS |
637 | if (json_path) |
638 | { | |
62d6dca0 DS |
639 | json_object_int_add(json_path, "dampeningPenalty", penalty); |
640 | json_object_int_add(json_path, "dampeningFlapCount", bdi->flap); | |
856ca177 | 641 | peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 1, json_path); |
b05a1c8b DS |
642 | |
643 | if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED) | |
644 | && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY)) | |
856ca177 | 645 | bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 1, json_path); |
b05a1c8b DS |
646 | } |
647 | else | |
648 | { | |
649 | vty_out (vty, " Dampinfo: penalty %d, flapped %d times in %s", | |
650 | penalty, bdi->flap, | |
856ca177 | 651 | peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 0, json_path)); |
718e3744 | 652 | |
b05a1c8b DS |
653 | if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED) |
654 | && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY)) | |
655 | vty_out (vty, ", reuse in %s", | |
856ca177 | 656 | bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 0, json_path)); |
718e3744 | 657 | |
b05a1c8b DS |
658 | vty_out (vty, "%s", VTY_NEWLINE); |
659 | } | |
718e3744 | 660 | } |
661 | ||
e9dc9f24 | 662 | const char * |
50aef6f3 | 663 | bgp_damp_reuse_time_vty (struct vty *vty, struct bgp_info *binfo, |
856ca177 | 664 | char *timebuf, size_t len, u_char use_json, json_object *json) |
718e3744 | 665 | { |
666 | struct bgp_damp_info *bdi; | |
667 | time_t t_now, t_diff; | |
718e3744 | 668 | int penalty; |
fb982c25 PJ |
669 | |
670 | if (!binfo->extra) | |
671 | return NULL; | |
672 | ||
718e3744 | 673 | /* BGP dampening information. */ |
fb982c25 | 674 | bdi = binfo->extra->damp_info; |
718e3744 | 675 | |
676 | /* If dampening is not enabled or there is no dampening information, | |
677 | return immediately. */ | |
678 | if (! damp || ! bdi) | |
679 | return NULL; | |
680 | ||
681 | /* Calculate new penalty. */ | |
65957886 | 682 | t_now = bgp_clock (); |
718e3744 | 683 | t_diff = t_now - bdi->t_updated; |
684 | penalty = bgp_damp_decay (t_diff, bdi->penalty); | |
685 | ||
856ca177 | 686 | return bgp_get_reuse_time (penalty, timebuf, len, use_json, json); |
718e3744 | 687 | } |
9914e022 B |
688 | |
689 | int | |
690 | bgp_show_dampening_parameters (struct vty *vty, afi_t afi, safi_t safi) | |
691 | { | |
692 | struct bgp *bgp; | |
693 | bgp = bgp_get_default(); | |
694 | ||
695 | if (bgp == NULL) | |
696 | { | |
697 | vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE); | |
698 | return CMD_WARNING; | |
699 | } | |
700 | ||
701 | if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)) | |
702 | { | |
389e3fe0 | 703 | vty_out (vty, "Half-life time: %lld min%s", |
44b8cd53 | 704 | (long long)damp->half_life / 60, VTY_NEWLINE); |
9914e022 | 705 | vty_out (vty, "Reuse penalty: %d%s", |
44b8cd53 | 706 | damp->reuse_limit, VTY_NEWLINE); |
9914e022 | 707 | vty_out (vty, "Suppress penalty: %d%s", |
44b8cd53 | 708 | damp->suppress_value, VTY_NEWLINE); |
389e3fe0 | 709 | vty_out (vty, "Max suppress time: %lld min%s", |
44b8cd53 | 710 | (long long)damp->max_suppress_time / 60, VTY_NEWLINE); |
9914e022 | 711 | vty_out (vty, "Max supress penalty: %u%s", |
44b8cd53 | 712 | damp->ceiling, VTY_NEWLINE); |
9914e022 B |
713 | vty_out (vty, "%s", VTY_NEWLINE); |
714 | } | |
715 | else | |
716 | vty_out (vty, "dampening not enabled for %s%s", | |
717 | afi == AFI_IP ? "IPv4" : "IPv6", VTY_NEWLINE); | |
718 | ||
719 | return CMD_SUCCESS; | |
720 | } |