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