src/vnet/adj/adj_bfd.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/bfd/bfd_main.h>
  17
  18 #include <vnet/adj/adj_delegate.h>
  19 #include <vnet/adj/adj_nbr.h>
  20 #include <vnet/fib/fib_walk.h>
  21
  22 /**
  23  * Distillation of the BFD session states into a go/no-go for using
  24  * the associated tracked adjacency
  25  */
  26 typedef enum adj_bfd_state_t_
  27 {
  28     ADJ_BFD_STATE_DOWN,
  29     ADJ_BFD_STATE_UP,
  30 } adj_bfd_state_t;
  31
  32 #define ADJ_BFD_STATES {                        \
  33     [ADJ_BFD_STATE_DOWN] = "down",              \
  34     [ADJ_BFD_STATE_UP]   = "up",                \
  35 }
  36
  37 static const char *adj_bfd_state_names[] = ADJ_BFD_STATES;
  38
  39 /**
  40  * BFD delegate daa
  41  */
  42 typedef struct adj_bfd_delegate_t_
  43 {
  44     /**
  45      * BFD session state
  46      */
  47     adj_bfd_state_t abd_state;
  48
  49     /**
  50      * BFD session index
  51      */
  52     u32 abd_index;
  53 } adj_bfd_delegate_t;
  54
  55 /**
  56  * Pool of delegates
  57 */
  58 static adj_bfd_delegate_t *abd_pool;
  59
  60 static inline adj_bfd_delegate_t*
  61 adj_bfd_from_base (adj_delegate_t *ad)
  62 {
  63     if (NULL != ad)
  64     {
  65         return (pool_elt_at_index(abd_pool, ad->ad_index));
  66     }
  67     return (NULL);
  68 }
  69
  70 static inline const adj_bfd_delegate_t*
  71 adj_bfd_from_const_base (const adj_delegate_t *ad)
  72 {
  73     if (NULL != ad)
  74     {
  75         return (pool_elt_at_index(abd_pool, ad->ad_index));
  76     }
  77     return (NULL);
  78 }
  79
  80 static adj_bfd_state_t
  81 adj_bfd_bfd_state_to_fib (bfd_state_e bstate)
  82 {
  83     switch (bstate)
  84     {
  85     case BFD_STATE_up:
  86         return (ADJ_BFD_STATE_UP);
  87     case BFD_STATE_down:
  88     case BFD_STATE_admin_down:
  89     case BFD_STATE_init:
  90         return (ADJ_BFD_STATE_DOWN);
  91     }
  92     return (ADJ_BFD_STATE_DOWN);
  93 }
  94
  95 static void
  96 adj_bfd_update_walk (adj_index_t ai)
  97 {
  98     /*
  99      * initiate a backwalk of dependent children
 100      * to notify of the state change of this adj.
 101      */
 102     fib_node_back_walk_ctx_t ctx = {
 103         .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE,
 104     };
 105     fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &ctx);
 106 }
 107
 108 /**
 109  * @brief Callback function registered with BFD module to receive notifications
 110  * of the CRUD of BFD sessions
 111  * would be static but for the fact it's called from the unit-tests
 112  */
 113 void
 114 adj_bfd_notify (bfd_listen_event_e event,
 115                 const bfd_session_t *session)
 116 {
 117     const bfd_udp_key_t *key;
 118     adj_bfd_delegate_t *abd;
 119     fib_protocol_t fproto;
 120     adj_delegate_t *aed;
 121     adj_index_t ai;
 122
 123     if (BFD_HOP_TYPE_SINGLE != session->hop_type)
 124     {
 125         /*
 126          * multi-hop BFD sessions attach directly to the FIB entry
 127          * single-hop adj to the associate adjacency.
 128          */
 129         return;
 130     }
 131
 132     key = &session->udp.key;
 133
 134     fproto = (ip46_address_is_ip4 (&key->peer_addr) ?
 135               FIB_PROTOCOL_IP4:
 136               FIB_PROTOCOL_IP6);
 137
 138     /*
 139      * find the adj that corresponds to the BFD session.
 140      */
 141     ai = adj_nbr_add_or_lock(fproto,
 142                              fib_proto_to_link(fproto),
 143                              &key->peer_addr,
 144                              key->sw_if_index);
 145
 146     switch (event)
 147     {
 148     case BFD_LISTEN_EVENT_CREATE:
 149         /*
 150          * The creation of a new session
 151          */
 152         if ((ADJ_INDEX_INVALID != ai) &&
 153             (aed = adj_delegate_get(adj_get(ai),
 154                                     ADJ_DELEGATE_BFD)))
 155         {
 156             /*
 157              * already got state for this adj
 158              */
 159         }
 160         else
 161         {
 162             /*
 163              * lock the adj. add the delegate.
 164              * Locking the adj prevents it being removed and thus maintains
 165              * the BFD derived states
 166              */
 167             adj_lock(ai);
 168
 169             /*
 170              * allocate and init a new delegate struct
 171              */
 172             pool_get(abd_pool, abd);
 173
 174             /*
 175              * it would be best here if we could ignore this create and just
 176              * wait for the first update, but this is not possible because
 177              * BFD sessions are created in the down state, and can remain this
 178              * way without transitioning to another state if the peer is
 179              * unresponsive. So we have to assume down and wait for up.
 180              */
 181             abd->abd_state = ADJ_BFD_STATE_DOWN;
 182             abd->abd_index = session->bs_idx;
 183
 184             adj_delegate_add(adj_get(ai), ADJ_DELEGATE_BFD, abd - abd_pool);
 185             adj_bfd_update_walk(ai);
 186         }
 187         break;
 188
 189     case BFD_LISTEN_EVENT_UPDATE:
 190         /*
 191          * state change up/down and
 192          */
 193         abd = adj_bfd_from_base(adj_delegate_get(adj_get(ai), ADJ_DELEGATE_BFD));
 194
 195         if (NULL != abd)
 196         {
 197             abd->abd_state = adj_bfd_bfd_state_to_fib(session->local_state);
 198             adj_bfd_update_walk(ai);
 199         }
 200         /*
 201          * else
 202          *   not an adj with BFD state
 203          */
 204         break;
 205
 206     case BFD_LISTEN_EVENT_DELETE:
 207         /*
 208          * session has been removed.
 209          */
 210         abd = adj_bfd_from_base(adj_delegate_get(adj_get(ai), ADJ_DELEGATE_BFD));
 211
 212         if (NULL != abd)
 213         {
 214             /*
 215              * has an associated BFD tracking delegate
 216              * remove the BFD tracking delegate, update children, then
 217              * unlock the adj
 218              */
 219             adj_delegate_remove(ai, ADJ_DELEGATE_BFD);
 220             pool_put(abd_pool, abd);
 221
 222             adj_bfd_update_walk(ai);
 223             adj_unlock(ai);
 224         }
 225         /*
 226          * else
 227          *  no BFD associated state
 228          */
 229         break;
 230     }
 231
 232     /*
 233      * unlock match of the add-or-lock at the start
 234      */
 235     adj_unlock(ai);
 236 }
 237
 238 int
 239 adj_bfd_is_up (adj_index_t ai)
 240 {
 241     const adj_bfd_delegate_t *abd;
 242
 243     abd = adj_bfd_from_base(adj_delegate_get(adj_get(ai), ADJ_DELEGATE_BFD));
 244
 245     if (NULL == abd)
 246     {
 247         /*
 248          * no BFD tracking - resolved
 249          */
 250         return (!0);
 251     }
 252     else
 253     {
 254         /*
 255          * defer to the state of the BFD tracking
 256          */
 257         return (ADJ_BFD_STATE_UP == abd->abd_state);
 258     }
 259 }
 260
 261 /**
 262  * Print a delegate that represents BFD tracking
 263  */
 264 static u8 *
 265 adj_delegate_fmt_bfd (const adj_delegate_t *aed, u8 *s)
 266 {
 267     const adj_bfd_delegate_t *abd = adj_bfd_from_const_base(aed);
 268
 269     s = format(s, "BFD:[state:%s index:%d]",
 270                adj_bfd_state_names[abd->abd_state],
 271                abd->abd_index);
 272
 273     return (s);
 274 }
 275
 276 const static adj_delegate_vft_t adj_delegate_vft = {
 277   .adv_format = adj_delegate_fmt_bfd,
 278 };
 279
 280 static clib_error_t *
 281 adj_bfd_main_init (vlib_main_t * vm)
 282 {
 283     clib_error_t * error = NULL;
 284
 285     if ((error = vlib_call_init_function (vm, bfd_main_init)))
 286         return (error);
 287
 288     bfd_register_listener(adj_bfd_notify);
 289
 290     adj_delegate_register_type (ADJ_DELEGATE_BFD, &adj_delegate_vft);
 291
 292     return (error);
 293 }
 294
 295 VLIB_INIT_FUNCTION (adj_bfd_main_init);