bgpd/bgp_damp.c

   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"
  29 #include "queue.h"
  30 #include "filter.h"
  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;
  41 static struct bgp_damp_config *damp = &bgp_damp_cfg;
  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)
  47
  48 /* Calculate reuse list index by penalty value.  */
  49 static int
  50 bgp_reuse_index (int penalty)
  51 {
  52   unsigned int i;
  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 }
  91
  92 /* Return decayed penalty value.  */
  93 int
  94 bgp_damp_decay (time_t tdiff, int penalty)
  95 {
  96   unsigned int i;
  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.  */
 111 static int
 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;
 117
 118   damp->t_reuse = NULL;
 119   damp->t_reuse =
 120     thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
 121
 122   t_now = bgp_clock ();
 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     {
 136       struct bgp *bgp = bdi->binfo->peer->bgp;
 137
 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.  */
 153           bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_DAMPED);
 154           bdi->suppress_time = 0;
 155
 156           if (bdi->lastrecord == BGP_RECORD_UPDATE)
 157             {
 158               bgp_info_unset_flag (bdi->rn, bdi->binfo, BGP_INFO_HISTORY);
 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;
 183   struct bgp_damp_info *bdi = NULL;
 184   double last_penalty = 0;
 185
 186   t_now = bgp_clock ();
 187
 188   /* Processing Unreachable Messages.  */
 189   if (binfo->extra)
 190     bdi = binfo->extra->damp_info;
 191
 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;
 211       (bgp_info_extra_get (binfo))->damp_info = bdi;
 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
 229   assert ((rn == bdi->rn) && (binfo == bdi->binfo));
 230
 231   bdi->lastrecord = BGP_RECORD_WITHDRAW;
 232   bdi->t_updated = t_now;
 233
 234   /* Make this route as historical status.  */
 235   bgp_info_set_flag (rn, binfo, BGP_INFO_HISTORY);
 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     {
 253       bgp_info_set_flag (rn, binfo, BGP_INFO_DAMPED);
 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
 270   if (!binfo->extra || !((bdi = binfo->extra->damp_info)))
 271     return BGP_DAMP_USED;
 272
 273   t_now = bgp_clock ();
 274   bgp_info_unset_flag (rn, binfo, BGP_INFO_HISTORY);
 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     {
 285       bgp_info_unset_flag (rn, binfo, BGP_INFO_DAMPED);
 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;
 308
 309   assert (binfo->extra && binfo->extra->damp_info);
 310
 311   t_now = bgp_clock ();
 312   bdi = binfo->extra->damp_info;
 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         {
 320           bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_DAMPED);
 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;
 355
 356   if (! bdi)
 357     return;
 358
 359   binfo = bdi->binfo;
 360   binfo->extra->damp_info = NULL;
 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
 367   bgp_info_unset_flag (bdi->rn, binfo, BGP_INFO_HISTORY|BGP_INFO_DAMPED);
 368
 369   if (bdi->lastrecord == BGP_RECORD_WITHDRAW && withdraw)
 370     bgp_info_delete (bdi->rn, binfo);
 371
 372   XFREE (MTYPE_BGP_DAMP_INFO, bdi);
 373 }
 374
 375 static void
 376 bgp_damp_parameter_set (int hlife, int reuse, int sup, int maxsup)
 377 {
 378   double reuse_max_ratio;
 379   unsigned int i;
 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 *));
 412
 413   /* Reuse-array computations */
 414   damp->reuse_index = XCALLOC (MTYPE_BGP_DAMP_ARRAY,
 415                                sizeof(int) * damp->reuse_index_size);
 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
 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)
 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 =
 452       thread_add_timer (bm->master, bgp_reuse_timer, NULL, DELTA_REUSE);
 453
 454   return 0;
 455 }
 456
 457 static void
 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
 472 bgp_damp_info_clean (void)
 473 {
 474   unsigned int i;
 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 {
 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
 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
 522 void
 523 bgp_config_write_damp (struct vty *vty)
 524 {
 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)
 534     vty_out (vty, " bgp dampening %lld%s",
 535              bgp_damp_cfg.half_life/60LL,
 536              VTY_NEWLINE);
 537   else
 538     vty_out (vty, " bgp dampening %lld %d %d %lld%s",
 539              bgp_damp_cfg.half_life/60LL,
 540              bgp_damp_cfg.reuse_limit,
 541              bgp_damp_cfg.suppress_value,
 542              bgp_damp_cfg.max_suppress_time/60LL,
 543              VTY_NEWLINE);
 544 }
 545
 546 static const char *
 547 bgp_get_reuse_time (unsigned int penalty, char *buf, size_t len, u_char use_json, json_object *json)
 548 {
 549   time_t reuse_time = 0;
 550   struct tm *tm = NULL;
 551   int time_store = 0;
 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)
 569     {
 570       if (use_json)
 571         json_object_int_add(json, "reuseTimerMsecs", 0);
 572       else
 573         snprintf (buf, len, "00:00:00");
 574     }
 575   else if (reuse_time < ONE_DAY_SECOND)
 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     }
 586   else if (reuse_time < ONE_WEEK_SECOND)
 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     }
 597   else
 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     }
 608
 609   return buf;
 610 }
 611
 612 void
 613 bgp_damp_info_vty (struct vty *vty, struct bgp_info *binfo,
 614                    json_object *json_path)
 615 {
 616   struct bgp_damp_info *bdi;
 617   time_t t_now, t_diff;
 618   char timebuf[BGP_UPTIME_LEN];
 619   int penalty;
 620
 621   if (!binfo->extra)
 622     return;
 623
 624   /* BGP dampening information.  */
 625   bdi = binfo->extra->damp_info;
 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.  */
 633   t_now = bgp_clock ();
 634   t_diff = t_now - bdi->t_updated;
 635   penalty = bgp_damp_decay (t_diff, bdi->penalty);
 636
 637   if (json_path)
 638     {
 639       json_object_int_add(json_path, "dampeningPenalty", penalty);
 640       json_object_int_add(json_path, "dampeningFlapCount", bdi->flap);
 641       peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 1, json_path);
 642
 643       if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)
 644           && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY))
 645         bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 1, json_path);
 646     }
 647   else
 648     {
 649       vty_out (vty, "      Dampinfo: penalty %d, flapped %d times in %s",
 650                penalty, bdi->flap,
 651                peer_uptime (bdi->start_time, timebuf, BGP_UPTIME_LEN, 0, json_path));
 652
 653       if (CHECK_FLAG (binfo->flags, BGP_INFO_DAMPED)
 654           && ! CHECK_FLAG (binfo->flags, BGP_INFO_HISTORY))
 655         vty_out (vty, ", reuse in %s",
 656                bgp_get_reuse_time (penalty, timebuf, BGP_UPTIME_LEN, 0, json_path));
 657
 658       vty_out (vty, "%s", VTY_NEWLINE);
 659     }
 660 }
 661
 662 const char *
 663 bgp_damp_reuse_time_vty (struct vty *vty, struct bgp_info *binfo,
 664                          char *timebuf, size_t len, u_char use_json, json_object *json)
 665 {
 666   struct bgp_damp_info *bdi;
 667   time_t t_now, t_diff;
 668   int penalty;
 669
 670   if (!binfo->extra)
 671     return NULL;
 672
 673   /* BGP dampening information.  */
 674   bdi = binfo->extra->damp_info;
 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.  */
 682   t_now = bgp_clock ();
 683   t_diff = t_now - bdi->t_updated;
 684   penalty = bgp_damp_decay (t_diff, bdi->penalty);
 685
 686   return  bgp_get_reuse_time (penalty, timebuf, len, use_json, json);
 687 }
 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     {
 703       vty_out (vty, "Half-life time: %ld min%s",
 704                     damp->half_life / 60, VTY_NEWLINE);
 705       vty_out (vty, "Reuse penalty: %d%s",
 706                     damp->reuse_limit, VTY_NEWLINE);
 707       vty_out (vty, "Suppress penalty: %d%s",
 708                     damp->suppress_value, VTY_NEWLINE);
 709       vty_out (vty, "Max suppress time: %ld min%s",
 710                     damp->max_suppress_time / 60, VTY_NEWLINE);
 711       vty_out (vty, "Max supress penalty: %u%s",
 712                     damp->ceiling, VTY_NEWLINE);
 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 }