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