bgpd/bgp_keepalives.c

   1 /* BGP Keepalives.
   2  * Implements a producer thread to generate BGP keepalives for peers.
   3  * Copyright (C) 2017 Cumulus Networks, Inc.
   4  * Quentin Young
   5  *
   6  * This file is part of FRRouting.
   7  *
   8  * FRRouting is free software; you can redistribute it and/or modify it under
   9  * the terms of the GNU General Public License as published by the Free
  10  * Software Foundation; either version 2, or (at your option) any later
  11  * version.
  12  *
  13  * FRRouting is distributed in the hope that it will be useful, but WITHOUT ANY
  14  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /* clang-format off */
  24 #include <zebra.h>
  25 #include <pthread.h>            // for pthread_mutex_lock, pthread_mutex_unlock
  26
  27 #include "frr_pthread.h"        // for frr_pthread
  28 #include "hash.h"               // for hash, hash_clean, hash_create_size...
  29 #include "log.h"                // for zlog_debug
  30 #include "memory.h"             // for MTYPE_TMP, XFREE, XCALLOC, XMALLOC
  31 #include "monotime.h"           // for monotime, monotime_since
  32
  33 #include "bgpd/bgpd.h"          // for peer, PEER_THREAD_KEEPALIVES_ON, peer...
  34 #include "bgpd/bgp_debug.h"     // for bgp_debug_neighbor_events
  35 #include "bgpd/bgp_packet.h"    // for bgp_keepalive_send
  36 #include "bgpd/bgp_keepalives.h"
  37 /* clang-format on */
  38
  39 /*
  40  * Peer KeepAlive Timer.
  41  * Associates a peer with the time of its last keepalive.
  42  */
  43 struct pkat {
  44         /* the peer to send keepalives to */
  45         struct peer *peer;
  46         /* absolute time of last keepalive sent */
  47         struct timeval last;
  48 };
  49
  50 /* List of peers we are sending keepalives for, and associated mutex. */
  51 static pthread_mutex_t *peerhash_mtx;
  52 static pthread_cond_t *peerhash_cond;
  53 static struct hash *peerhash;
  54
  55 static struct pkat *pkat_new(struct peer *peer)
  56 {
  57         struct pkat *pkat = XMALLOC(MTYPE_TMP, sizeof(struct pkat));
  58         pkat->peer = peer;
  59         monotime(&pkat->last);
  60         return pkat;
  61 }
  62
  63 static void pkat_del(void *pkat)
  64 {
  65         XFREE(MTYPE_TMP, pkat);
  66 }
  67
  68
  69 /*
  70  * Callback for hash_iterate. Determines if a peer needs a keepalive and if so,
  71  * generates and sends it.
  72  *
  73  * For any given peer, if the elapsed time since its last keepalive exceeds its
  74  * configured keepalive timer, a keepalive is sent to the peer and its
  75  * last-sent time is reset. Additionally, If the elapsed time does not exceed
  76  * the configured keepalive timer, but the time until the next keepalive is due
  77  * is within a hardcoded tolerance, a keepalive is sent as if the configured
  78  * timer was exceeded. Doing this helps alleviate nanosecond sleeps between
  79  * ticks by grouping together peers who are due for keepalives at roughly the
  80  * same time. This tolerance value is arbitrarily chosen to be 100ms.
  81  *
  82  * In addition, this function calculates the maximum amount of time that the
  83  * keepalive thread can sleep before another tick needs to take place. This is
  84  * equivalent to shortest time until a keepalive is due for any one peer.
  85  *
  86  * @return maximum time to wait until next update (0 if infinity)
  87  */
  88 static void peer_process(struct hash_bucket *hb, void *arg)
  89 {
  90         struct pkat *pkat = hb->data;
  91
  92         struct timeval *next_update = arg;
  93
  94         static struct timeval elapsed;  // elapsed time since keepalive
  95         static struct timeval ka = {0}; // peer->v_keepalive as a timeval
  96         static struct timeval diff;     // ka - elapsed
  97
  98         static const struct timeval tolerance = {0, 100000};
  99
 100         uint32_t v_ka = atomic_load_explicit(&pkat->peer->v_keepalive,
 101                                              memory_order_relaxed);
 102
 103         /* 0 keepalive timer means no keepalives */
 104         if (v_ka == 0)
 105                 return;
 106
 107         /* calculate elapsed time since last keepalive */
 108         monotime_since(&pkat->last, &elapsed);
 109
 110         /* calculate difference between elapsed time and configured time */
 111         ka.tv_sec = v_ka;
 112         timersub(&ka, &elapsed, &diff);
 113
 114         int send_keepalive =
 115                 elapsed.tv_sec >= ka.tv_sec || timercmp(&diff, &tolerance, <);
 116
 117         if (send_keepalive) {
 118                 if (bgp_debug_neighbor_events(pkat->peer))
 119                         zlog_debug("%s [FSM] Timer (keepalive timer expire)",
 120                                    pkat->peer->host);
 121
 122                 bgp_keepalive_send(pkat->peer);
 123                 monotime(&pkat->last);
 124                 memset(&elapsed, 0x00, sizeof(struct timeval));
 125                 diff = ka;
 126         }
 127
 128         /* if calculated next update for this peer < current delay, use it */
 129         if (next_update->tv_sec < 0 || timercmp(&diff, next_update, <))
 130                 *next_update = diff;
 131 }
 132
 133 static bool peer_hash_cmp(const void *f, const void *s)
 134 {
 135         const struct pkat *p1 = f;
 136         const struct pkat *p2 = s;
 137
 138         return p1->peer == p2->peer;
 139 }
 140
 141 static unsigned int peer_hash_key(const void *arg)
 142 {
 143         const struct pkat *pkat = arg;
 144         return (uintptr_t)pkat->peer;
 145 }
 146
 147 /* Cleanup handler / deinitializer. */
 148 static void bgp_keepalives_finish(void *arg)
 149 {
 150         if (peerhash) {
 151                 hash_clean(peerhash, pkat_del);
 152                 hash_free(peerhash);
 153         }
 154
 155         peerhash = NULL;
 156
 157         pthread_mutex_unlock(peerhash_mtx);
 158         pthread_mutex_destroy(peerhash_mtx);
 159         pthread_cond_destroy(peerhash_cond);
 160
 161         XFREE(MTYPE_TMP, peerhash_mtx);
 162         XFREE(MTYPE_TMP, peerhash_cond);
 163 }
 164
 165 /*
 166  * Entry function for peer keepalive generation pthread.
 167  */
 168 void *bgp_keepalives_start(void *arg)
 169 {
 170         struct frr_pthread *fpt = arg;
 171         fpt->master->owner = pthread_self();
 172
 173         struct timeval currtime = {0, 0};
 174         struct timeval aftertime = {0, 0};
 175         struct timeval next_update = {0, 0};
 176         struct timespec next_update_ts = {0, 0};
 177
 178         peerhash_mtx = XCALLOC(MTYPE_TMP, sizeof(pthread_mutex_t));
 179         peerhash_cond = XCALLOC(MTYPE_TMP, sizeof(pthread_cond_t));
 180
 181         /* initialize mutex */
 182         pthread_mutex_init(peerhash_mtx, NULL);
 183
 184         /* use monotonic clock with condition variable */
 185         pthread_condattr_t attrs;
 186         pthread_condattr_init(&attrs);
 187         pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC);
 188         pthread_cond_init(peerhash_cond, &attrs);
 189         pthread_condattr_destroy(&attrs);
 190
 191         /*
 192          * We are not using normal FRR pthread mechanics and are
 193          * not using fpt_run
 194          */
 195         frr_pthread_set_name(fpt);
 196
 197         /* initialize peer hashtable */
 198         peerhash = hash_create_size(2048, peer_hash_key, peer_hash_cmp, NULL);
 199         pthread_mutex_lock(peerhash_mtx);
 200
 201         /* register cleanup handler */
 202         pthread_cleanup_push(&bgp_keepalives_finish, NULL);
 203
 204         /* notify anybody waiting on us that we are done starting up */
 205         frr_pthread_notify_running(fpt);
 206
 207         while (atomic_load_explicit(&fpt->running, memory_order_relaxed)) {
 208                 if (peerhash->count > 0)
 209                         pthread_cond_timedwait(peerhash_cond, peerhash_mtx,
 210                                                &next_update_ts);
 211                 else
 212                         while (peerhash->count == 0
 213                                && atomic_load_explicit(&fpt->running,
 214                                                        memory_order_relaxed))
 215                                 pthread_cond_wait(peerhash_cond, peerhash_mtx);
 216
 217                 monotime(&currtime);
 218
 219                 next_update.tv_sec = -1;
 220
 221                 hash_iterate(peerhash, peer_process, &next_update);
 222                 if (next_update.tv_sec == -1)
 223                         memset(&next_update, 0x00, sizeof(next_update));
 224
 225                 monotime_since(&currtime, &aftertime);
 226
 227                 timeradd(&currtime, &next_update, &next_update);
 228                 TIMEVAL_TO_TIMESPEC(&next_update, &next_update_ts);
 229         }
 230
 231         /* clean up */
 232         pthread_cleanup_pop(1);
 233
 234         return NULL;
 235 }
 236
 237 /* --- thread external functions ------------------------------------------- */
 238
 239 void bgp_keepalives_on(struct peer *peer)
 240 {
 241         if (CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
 242                 return;
 243
 244         struct frr_pthread *fpt = bgp_pth_ka;
 245         assert(fpt->running);
 246
 247         /* placeholder bucket data to use for fast key lookups */
 248         static struct pkat holder = {0};
 249
 250         /*
 251          * We need to ensure that bgp_keepalives_init was called first
 252          */
 253         assert(peerhash_mtx);
 254
 255         frr_with_mutex(peerhash_mtx) {
 256                 holder.peer = peer;
 257                 if (!hash_lookup(peerhash, &holder)) {
 258                         struct pkat *pkat = pkat_new(peer);
 259                         hash_get(peerhash, pkat, hash_alloc_intern);
 260                         peer_lock(peer);
 261                 }
 262                 SET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
 263         }
 264         bgp_keepalives_wake();
 265 }
 266
 267 void bgp_keepalives_off(struct peer *peer)
 268 {
 269         if (!CHECK_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON))
 270                 return;
 271
 272         struct frr_pthread *fpt = bgp_pth_ka;
 273         assert(fpt->running);
 274
 275         /* placeholder bucket data to use for fast key lookups */
 276         static struct pkat holder = {0};
 277
 278         /*
 279          * We need to ensure that bgp_keepalives_init was called first
 280          */
 281         assert(peerhash_mtx);
 282
 283         frr_with_mutex(peerhash_mtx) {
 284                 holder.peer = peer;
 285                 struct pkat *res = hash_release(peerhash, &holder);
 286                 if (res) {
 287                         pkat_del(res);
 288                         peer_unlock(peer);
 289                 }
 290                 UNSET_FLAG(peer->thread_flags, PEER_THREAD_KEEPALIVES_ON);
 291         }
 292 }
 293
 294 void bgp_keepalives_wake(void)
 295 {
 296         frr_with_mutex(peerhash_mtx) {
 297                 pthread_cond_signal(peerhash_cond);
 298         }
 299 }
 300
 301 int bgp_keepalives_stop(struct frr_pthread *fpt, void **result)
 302 {
 303         assert(fpt->running);
 304
 305         atomic_store_explicit(&fpt->running, false, memory_order_relaxed);
 306         bgp_keepalives_wake();
 307
 308         pthread_join(fpt->thread, result);
 309         return 0;
 310 }