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
  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 bgp_reuse_index(int penalty)
  50 {
  51         unsigned int i;
  52         int index;
  53
  54         i = (int)(((double)penalty / damp->reuse_limit - 1.0)
  55                   * 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 bgp_reuse_list_add(struct bgp_damp_info *bdi)
  67 {
  68         int index;
  69
  70         index = bdi->index = bgp_reuse_index(bdi->penalty);
  71
  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;
  77 }
  78
  79 /* Delete BGP dampening information from reuse list.  */
  80 static void bgp_reuse_list_delete(struct bgp_damp_info *bdi)
  81 {
  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 }
  89
  90 /* Return decayed penalty value.  */
  91 int bgp_damp_decay(time_t tdiff, int penalty)
  92 {
  93         unsigned int i;
  94
  95         i = (int)((double)tdiff / DELTA_T);
  96
  97         if (i == 0)
  98                 return penalty;
  99
 100         if (i >= damp->decay_array_size)
 101                 return 0;
 102
 103         return (int)(penalty * damp->decay_array[i]);
 104 }
 105
 106 /* Handler of reuse timer event.  Each route in the current reuse-list
 107    is evaluated.  RFC2439 Section 4.8.7.  */
 108 static int bgp_reuse_timer(struct thread *t)
 109 {
 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);
 169         }
 170
 171         return 0;
 172 }
 173
 174 /* A route becomes unreachable (RFC2439 Section 4.8.2).  */
 175 int bgp_damp_withdraw(struct bgp_info *binfo, struct bgp_node *rn, afi_t afi,
 176                       safi_t safi, int attr_change)
 177 {
 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 && bdi->index >= 0) {
 237                         bgp_reuse_list_delete(bdi);
 238                         bgp_reuse_list_add(bdi);
 239                 }
 240                 return BGP_DAMP_SUPPRESSED;
 241         }
 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;
 253 }
 254
 255 int bgp_damp_update(struct bgp_info *binfo, struct bgp_node *rn, afi_t afi,
 256                     safi_t safi)
 257 {
 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;
 290 }
 291
 292 /* Remove dampening information and history route.  */
 293 int bgp_damp_scan(struct bgp_info *binfo, afi_t afi, safi_t safi)
 294 {
 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;
 333 }
 334
 335 void bgp_damp_info_free(struct bgp_damp_info *bdi, int withdraw)
 336 {
 337         struct bgp_info *binfo;
 338
 339         if (!bdi)
 340                 return;
 341
 342         binfo = bdi->binfo;
 343         binfo->extra->damp_info = NULL;
 344
 345         if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED))
 346                 bgp_reuse_list_delete(bdi);
 347         else
 348                 BGP_DAMP_LIST_DEL(damp, bdi);
 349
 350         bgp_info_unset_flag(bdi->rn, binfo, BGP_INFO_HISTORY | BGP_INFO_DAMPED);
 351
 352         if (bdi->lastrecord == BGP_RECORD_WITHDRAW && withdraw)
 353                 bgp_info_delete(bdi->rn, binfo);
 354
 355         XFREE(MTYPE_BGP_DAMP_INFO, bdi);
 356 }
 357
 358 static void bgp_damp_parameter_set(int hlife, int reuse, int sup, int maxsup)
 359 {
 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
 372         damp->ceiling =
 373                 (int)(damp->reuse_limit * (pow(2,
 374                                                (double)damp->max_suppress_time
 375                                                        / damp->half_life)));
 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)
 417                               * log10(1.0 / (damp->reuse_limit
 418                                              * (1.0 + ((double)i
 419                                                        / damp->scale_factor))))
 420                               / log10(0.5));
 421         }
 422 }
 423
 424 int 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)
 426 {
 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         }
 434
 435         SET_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING);
 436         bgp_damp_parameter_set(half, reuse, suppress, max);
 437
 438         /* Register reuse timer.  */
 439         thread_add_timer(bm->master, bgp_reuse_timer, NULL, DELTA_REUSE,
 440                          &damp->t_reuse);
 441
 442         return 0;
 443 }
 444
 445 static void bgp_damp_config_clean(struct bgp_damp_config *damp)
 446 {
 447         /* Free decay array */
 448         XFREE(MTYPE_BGP_DAMP_ARRAY, damp->decay_array);
 449
 450         /* Free reuse index array */
 451         XFREE(MTYPE_BGP_DAMP_ARRAY, damp->reuse_index);
 452
 453         /* Free reuse list array. */
 454         XFREE(MTYPE_BGP_DAMP_ARRAY, damp->reuse_list);
 455 }
 456
 457 /* Clean all the bgp_damp_info stored in reuse_list. */
 458 void bgp_damp_info_clean(void)
 459 {
 460         unsigned int i;
 461         struct bgp_damp_info *bdi, *next;
 462
 463         damp->reuse_offset = 0;
 464
 465         for (i = 0; i < damp->reuse_list_size; i++) {
 466                 if (!damp->reuse_list[i])
 467                         continue;
 468
 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;
 474         }
 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;
 481 }
 482
 483 int bgp_damp_disable(struct bgp *bgp, afi_t afi, safi_t safi)
 484 {
 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;
 488
 489         /* Cancel reuse thread. */
 490         if (damp->t_reuse)
 491                 thread_cancel(damp->t_reuse);
 492         damp->t_reuse = NULL;
 493
 494         /* Clean BGP dampening information.  */
 495         bgp_damp_info_clean();
 496
 497         /* Clear configuration */
 498         bgp_damp_config_clean(&bgp_damp_cfg);
 499
 500         UNSET_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING);
 501         return 0;
 502 }
 503
 504 void bgp_config_write_damp(struct vty *vty)
 505 {
 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);
 523 }
 524
 525 static const char *bgp_get_reuse_time(unsigned int penalty, char *buf,
 526                                       size_t len, uint8_t use_json,
 527                                       json_object *json)
 528 {
 529         time_t reuse_time = 0;
 530         struct tm *tm = NULL;
 531         int time_store = 0;
 532
 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]))));
 537
 538                 if (reuse_time > damp->max_suppress_time)
 539                         reuse_time = damp->max_suppress_time;
 540
 541                 tm = gmtime(&reuse_time);
 542         } else
 543                 reuse_time = 0;
 544
 545         /* Making formatted timer strings. */
 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;
 589 }
 590
 591 void bgp_damp_info_vty(struct vty *vty, struct bgp_info *binfo,
 592                        json_object *json_path)
 593 {
 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         }
 641 }
 642
 643 const char *bgp_damp_reuse_time_vty(struct vty *vty, struct bgp_info *binfo,
 644                                     char *timebuf, size_t len, uint8_t use_json,
 645                                     json_object *json)
 646 {
 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);
 668 }
 669
 670 int bgp_show_dampening_parameters(struct vty *vty, afi_t afi, safi_t safi)
 671 {
 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;
 694 }