src/vnet/fib/fib_entry_src.h

   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 #ifndef __FIB_ENTRY_SRC_H__
  17 #define __FIB_ENTRY_SRC_H__
  18
  19 #include "fib_entry.h"
  20 #include "fib_path_list.h"
  21 #include "fib_internal.h"
  22
  23 /**
  24  * Debug macro
  25  */
  26 extern vlib_log_class_t fib_entry_logger;
  27
  28 #define FIB_ENTRY_DBG(_e, _fmt, _args...)               \
  29 {                                                       \
  30     vlib_log_debug(fib_entry_logger,                    \
  31                    "[@%d:[%U]:%U:%U]: " _fmt,           \
  32                    fib_entry_get_index(_e),             \
  33                    format_fib_prefix,                   \
  34                    &_e->fe_prefix,                      \
  35                    format_fib_entry_flags,              \
  36                    fib_entry_get_flags_i(_e),           \
  37                    format_fib_source,                   \
  38                    fib_entry_get_source_i(_e),          \
  39                    ##_args);                            \
  40 }
  41
  42 /**
  43  * Source initialisation Function
  44  */
  45 typedef void (*fib_entry_src_init_t)(fib_entry_src_t *src);
  46
  47 /**
  48  * Source deinitialisation Function
  49  */
  50 typedef void (*fib_entry_src_deinit_t)(fib_entry_src_t *src);
  51
  52 /**
  53  * Source activation. Called when the source is the new best source on the entry.
  54  * Return non-zero if the entry can now install, 0 otherwise
  55  */
  56 typedef int (*fib_entry_src_activate_t)(fib_entry_src_t *src,
  57                                          const fib_entry_t *fib_entry);
  58
  59 /**
  60  * Source re-activation. Called when the source is updated and remains
  61  * the best source.
  62  */
  63 typedef int (*fib_entry_src_reactivate_t)(fib_entry_src_t *src,
  64                                           const fib_entry_t *fib_entry);
  65
  66 /**
  67  * Source Deactivate.
  68  * Called when the source is no longer best source on the entry
  69  */
  70 typedef void (*fib_entry_src_deactivate_t)(fib_entry_src_t *src,
  71                                            const fib_entry_t *fib_entry);
  72
  73 /**
  74  * Source Add.
  75  * Called when the source is added to the entry
  76  */
  77 typedef void (*fib_entry_src_add_t)(fib_entry_src_t *src,
  78                                     const fib_entry_t *entry,
  79                                     fib_entry_flag_t flags,
  80                                     dpo_proto_t proto,
  81                                     const dpo_id_t *dpo);
  82
  83 /**
  84  * Source Remove.
  85  */
  86 typedef void (*fib_entry_src_remove_t)(fib_entry_src_t *src);
  87
  88 /**
  89  * Result from a cover update/change
  90  */
  91 typedef struct fib_entry_src_cover_res_t_ {
  92     u16 install;
  93     fib_node_bw_reason_flag_t bw_reason;
  94 } fib_entry_src_cover_res_t;
  95
  96 /**
  97  * Cover changed. the source should re-evaluate its cover.
  98  */
  99 typedef fib_entry_src_cover_res_t (*fib_entry_src_cover_change_t)(
 100     fib_entry_src_t *src,
 101     const fib_entry_t *fib_entry);
 102
 103 /**
 104  * Cover updated. The cover the source has, has updated (i.e. its forwarding)
 105  * the source may need to re-evaluate.
 106  */
 107 typedef fib_entry_src_cover_res_t (*fib_entry_src_cover_update_t)(
 108     fib_entry_src_t *src,
 109     const fib_entry_t *fib_entry);
 110
 111 /**
 112  * Forwarding updated. Notification that the forwarding information for the
 113  * entry has been updated. This notification is sent to all sources, not just
 114  * the active best.
 115  */
 116 typedef void (*fib_entry_src_fwd_update_t)(fib_entry_src_t *src,
 117                                            const fib_entry_t *fib_entry,
 118                                            fib_source_t best_source);
 119
 120 /**
 121  * Installed. Notification that the source is now installed as
 122  * the entry's forwarding source.
 123  */
 124 typedef void (*fib_entry_src_installed_t)(fib_entry_src_t *src,
 125                                           const fib_entry_t *fib_entry);
 126
 127 /**
 128  * format.
 129  */
 130 typedef u8* (*fib_entry_src_format_t)(fib_entry_src_t *src,
 131                                       u8* s);
 132
 133 /**
 134  * Source path add
 135  * the source is adding a new path
 136  */
 137 typedef void (*fib_entry_src_path_add_t)(fib_entry_src_t *src,
 138                                          const fib_entry_t *fib_entry,
 139                                          fib_path_list_flags_t pl_flags,
 140                                          const fib_route_path_t *path);
 141
 142 /**
 143  * Source path remove
 144  * the source is remoinvg a path
 145  */
 146 typedef void (*fib_entry_src_path_remove_t)(fib_entry_src_t *src,
 147                                             fib_path_list_flags_t pl_flags,
 148                                             const fib_route_path_t *path);
 149
 150 /**
 151  * Source path replace/swap
 152  * the source is providing a new set of paths
 153  */
 154 typedef void (*fib_entry_src_path_swap_t)(fib_entry_src_t *src,
 155                                           const fib_entry_t *fib_entry,
 156                                           fib_path_list_flags_t pl_flags,
 157                                           const fib_route_path_t *path);
 158
 159 /**
 160  * Set source specific opaque data
 161  */
 162 typedef void (*fib_entry_src_set_data_t)(fib_entry_src_t *src,
 163                                          const fib_entry_t *fib_entry,
 164                                          const void *data);
 165
 166 /**
 167  * Get source specific opaque data
 168  */
 169 typedef const void* (*fib_entry_src_get_data_t)(fib_entry_src_t *src,
 170                                                 const fib_entry_t *fib_entry);
 171
 172 /**
 173  * Contribute forwarding to interpose inthe chain
 174  */
 175 typedef const dpo_id_t* (*fib_entry_src_contribute_interpose_t)(const fib_entry_src_t *src,
 176                                                          const fib_entry_t *fib_entry);
 177
 178 /**
 179  * The fib entry flags for this source are changing
 180  */
 181 typedef void (*fib_entry_src_flag_change_t)(fib_entry_src_t *src,
 182                                             const fib_entry_t *fib_entry,
 183                                             fib_entry_flag_t new_flags);
 184
 185 /**
 186  * The fib entry flags for this source are changing
 187  */
 188 typedef void (*fib_entry_src_copy_t)(const fib_entry_src_t *orig_src,
 189                                      const fib_entry_t *fib_entry,
 190                                      fib_entry_src_t *copy_src);
 191
 192 /**
 193  * Virtual function table each FIB entry source will register
 194  */
 195 typedef struct fib_entry_src_vft_t_ {
 196     fib_entry_src_init_t fesv_init;
 197     fib_entry_src_deinit_t fesv_deinit;
 198     fib_entry_src_activate_t fesv_activate;
 199     fib_entry_src_deactivate_t fesv_deactivate;
 200     fib_entry_src_reactivate_t fesv_reactivate;
 201     fib_entry_src_add_t fesv_add;
 202     fib_entry_src_remove_t fesv_remove;
 203     fib_entry_src_path_swap_t fesv_path_swap;
 204     fib_entry_src_path_add_t fesv_path_add;
 205     fib_entry_src_path_remove_t fesv_path_remove;
 206     fib_entry_src_cover_change_t fesv_cover_change;
 207     fib_entry_src_cover_update_t fesv_cover_update;
 208     fib_entry_src_format_t fesv_format;
 209     fib_entry_src_installed_t fesv_installed;
 210     fib_entry_src_fwd_update_t fesv_fwd_update;
 211     fib_entry_src_get_data_t fesv_get_data;
 212     fib_entry_src_set_data_t fesv_set_data;
 213     fib_entry_src_contribute_interpose_t fesv_contribute_interpose;
 214     fib_entry_src_flag_change_t fesv_flags_change;
 215     fib_entry_src_copy_t fesv_copy;
 216 } fib_entry_src_vft_t;
 217
 218 #define FOR_EACH_SRC_ADDED(_entry, _src, _source, action)       \
 219 {                                                               \
 220     vec_foreach(_src, (_entry)->fe_srcs)                        \
 221     {                                                           \
 222         if (_src->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED) {       \
 223             _source = (_src)->fes_src;                          \
 224             action;                                             \
 225         }                                                       \
 226     }                                                           \
 227 }
 228
 229 #define FIB_ENTRY_SRC_VFT_INVOKE(esrc, func, args)             \
 230 {                                                              \
 231     const fib_entry_src_vft_t *_vft;                           \
 232     _vft = fib_entry_src_get_vft(esrc);                        \
 233     if (_vft->func) {                                          \
 234         (esrc)->fes_flags &= ~FIB_ENTRY_SRC_FLAG_STALE;        \
 235         _vft->func args;                                       \
 236     }                                                          \
 237 }
 238
 239 #define FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, func, args)  \
 240 {                                                              \
 241     const fib_entry_src_vft_t *_vft;                           \
 242     _vft = fib_entry_src_get_vft(esrc);                        \
 243     if (_vft->func) {                                          \
 244         (esrc)->fes_flags &= ~FIB_ENTRY_SRC_FLAG_STALE;        \
 245         return (_vft->func args);                              \
 246     }                                                          \
 247 }
 248
 249 #define FIB_ENTRY_SRC_VFT_EXISTS(esrc, func)        \
 250 {                                                   \
 251     const fib_entry_src_vft_t *_vft;                \
 252     _vft = fib_entry_src_get_vft(esrc);             \
 253     (_vft->func);                                   \
 254 }
 255
 256 extern const fib_entry_src_vft_t*fib_entry_src_get_vft(
 257     const fib_entry_src_t *esrc);
 258
 259 extern u8* fib_entry_src_format(fib_entry_t *entry,
 260                                 fib_source_t source,
 261                                 u8* s);
 262
 263 extern void fib_entry_src_register(fib_source_t source,
 264                                    const fib_entry_src_vft_t *vft);
 265
 266 extern fib_entry_src_cover_res_t fib_entry_src_action_cover_change(
 267     fib_entry_t *entry,
 268     fib_entry_src_t *esrc);
 269
 270 extern fib_entry_src_cover_res_t fib_entry_src_action_cover_update(
 271     fib_entry_t *fib_entry,
 272     fib_entry_src_t *esrc);
 273
 274 extern void fib_entry_src_action_activate(fib_entry_t *fib_entry,
 275                                           fib_source_t source);
 276
 277 extern void fib_entry_src_action_deactivate(fib_entry_t *fib_entry,
 278                                             fib_source_t source);
 279 extern void fib_entry_src_action_reactivate(fib_entry_t *fib_entry,
 280                                             fib_source_t source);
 281
 282 extern fib_entry_t* fib_entry_src_action_add(fib_entry_t *fib_entry,
 283                                              fib_source_t source,
 284                                              fib_entry_flag_t flags,
 285                                              const dpo_id_t *dpo);
 286 extern fib_entry_t* fib_entry_src_action_update(fib_entry_t *fib_entry,
 287                                                 fib_source_t source,
 288                                                 fib_entry_flag_t flags,
 289                                                 const dpo_id_t *dpo);
 290
 291 extern fib_entry_src_flag_t fib_entry_src_action_remove(fib_entry_t *fib_entry,
 292                                                         fib_source_t source);
 293 extern fib_entry_src_flag_t
 294 fib_entry_src_action_remove_or_update_inherit(fib_entry_t *fib_entry,
 295                                               fib_source_t source);
 296
 297 extern void fib_entry_src_action_install(fib_entry_t *fib_entry,
 298                                          fib_source_t source);
 299
 300 extern void fib_entry_src_action_uninstall(fib_entry_t *fib_entry);
 301
 302 extern fib_entry_t* fib_entry_src_action_path_add(fib_entry_t *fib_entry,
 303                                                   fib_source_t source,
 304                                                   fib_entry_flag_t flags,
 305                                                   const fib_route_path_t *path);
 306
 307 extern fib_entry_t* fib_entry_src_action_path_swap(fib_entry_t *fib_entry,
 308                                                    fib_source_t source,
 309                                                    fib_entry_flag_t flags,
 310                                                    const fib_route_path_t *path);
 311
 312 extern fib_entry_src_flag_t fib_entry_src_action_path_remove(fib_entry_t *fib_entry,
 313                                                              fib_source_t source,
 314                                                              const fib_route_path_t *path);
 315
 316 extern void fib_entry_src_action_installed(const fib_entry_t *fib_entry,
 317                                            fib_source_t source);
 318 extern void fib_entry_src_inherit (const fib_entry_t *cover,
 319                                    fib_entry_t *covered);
 320
 321 extern fib_forward_chain_type_t fib_entry_get_default_chain_type(
 322     const fib_entry_t *fib_entry);
 323 extern fib_source_t fib_entry_get_source_i(const fib_entry_t *fib_entry);
 324 extern fib_entry_flag_t fib_entry_get_flags_i(const fib_entry_t *fib_entry);
 325
 326 extern fib_path_list_flags_t fib_entry_src_flags_2_path_list_flags(
 327     fib_entry_flag_t eflags);
 328
 329 extern fib_forward_chain_type_t fib_entry_chain_type_fixup(const fib_entry_t *entry,
 330                                                            fib_forward_chain_type_t fct);
 331
 332 extern void fib_entry_src_mk_lb (fib_entry_t *fib_entry,
 333                                  const fib_entry_src_t *esrc,
 334                                  fib_forward_chain_type_t fct,
 335                                  dpo_id_t *dpo_lb);
 336
 337 extern fib_protocol_t fib_entry_get_proto(const fib_entry_t * fib_entry);
 338 extern dpo_proto_t fib_entry_get_dpo_proto(const fib_entry_t * fib_entry);
 339
 340 extern void fib_entry_source_change(fib_entry_t *fib_entry,
 341                                     fib_source_t old_source,
 342                                     fib_source_t new_source);
 343
 344 /*
 345  * Per-source registration. declared here so we save a separate .h file for each
 346  */
 347 extern void fib_entry_src_default_register(void);
 348 extern void fib_entry_src_rr_register(void);
 349 extern void fib_entry_src_interface_register(void);
 350 extern void fib_entry_src_interpose_register(void);
 351 extern void fib_entry_src_default_route_register(void);
 352 extern void fib_entry_src_special_register(void);
 353 extern void fib_entry_src_api_register(void);
 354 extern void fib_entry_src_adj_register(void);
 355 extern void fib_entry_src_mpls_register(void);
 356 extern void fib_entry_src_lisp_register(void);
 357
 358 extern void fib_entry_src_module_init(void);
 359
 360 #endif