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