src/vnet/fib/fib_path_list.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_PATH_LIST_H__
  17 #define __FIB_PATH_LIST_H__
  18
  19 #include <vlib/vlib.h>
  20 #include <vnet/adj/adj.h>
  21
  22 #include <vnet/fib/fib_node.h>
  23 #include <vnet/fib/fib_path.h>
  24
  25 /**
  26  * Enumeration of path-list flags.
  27  */
  28 typedef enum fib_path_list_attribute_t_ {
  29     /**
  30      * Marker. Add new flags after this one.
  31      */
  32     FIB_PATH_LIST_ATTRIBUTE_FIRST = 0,
  33     /**
  34      * This path list is shareable. Shareable path-lists
  35      * are inserted into the path-list data-base.
  36      * All path-list are inherently shareable, the reason we share some and
  37      * not others is to limit the size of the path-list database. This DB must
  38      * be searched for each route update.
  39      */
  40     FIB_PATH_LIST_ATTRIBUTE_SHARED = FIB_PATH_LIST_ATTRIBUTE_FIRST,
  41     /**
  42      * explicit drop path-list. Used when the entry source needs to
  43      * force a drop, despite the fact the path info is present.
  44      */
  45     FIB_PATH_LIST_ATTRIBUTE_DROP,
  46     /**
  47      * explicit local path-list.
  48      */
  49     FIB_PATH_LIST_ATTRIBUTE_LOCAL,
  50     /**
  51      * exclusive path-list. Exclusive means the path will resolve via the
  52      * exclusive (user provided) adj.
  53      */
  54     FIB_PATH_LIST_ATTRIBUTE_EXCLUSIVE,
  55     /**
  56      * resolved path-list
  57      */
  58     FIB_PATH_LIST_ATTRIBUTE_RESOLVED,
  59     /**
  60      * looped path-list. one path looped implies the whole list is
  61      */
  62     FIB_PATH_LIST_ATTRIBUTE_LOOPED,
  63     /**
  64      * a popular path-ist is one that is shared amongst many entries.
  65      * Path list become popular as they gain more children, but they
  66      * don't become unpopular as they lose them.
  67      */
  68     FIB_PATH_LIST_ATTRIBUTE_POPULAR,
  69     /**
  70      * no uRPF - do not generate unicast RPF list for this path-list
  71      */
  72     FIB_PATH_LIST_ATTRIBUTE_NO_URPF,
  73     /**
  74      * Marher. Add new flags before this one, and then update it.
  75      */
  76     FIB_PATH_LIST_ATTRIBUTE_LAST = FIB_PATH_LIST_ATTRIBUTE_NO_URPF,
  77 } fib_path_list_attribute_t;
  78
  79 typedef enum fib_path_list_flags_t_ {
  80     FIB_PATH_LIST_FLAG_NONE      = 0,
  81     FIB_PATH_LIST_FLAG_SHARED    = (1 << FIB_PATH_LIST_ATTRIBUTE_SHARED),
  82     FIB_PATH_LIST_FLAG_DROP      = (1 << FIB_PATH_LIST_ATTRIBUTE_DROP),
  83     FIB_PATH_LIST_FLAG_LOCAL     = (1 << FIB_PATH_LIST_ATTRIBUTE_LOCAL),
  84     FIB_PATH_LIST_FLAG_EXCLUSIVE = (1 << FIB_PATH_LIST_ATTRIBUTE_EXCLUSIVE),
  85     FIB_PATH_LIST_FLAG_RESOLVED  = (1 << FIB_PATH_LIST_ATTRIBUTE_RESOLVED),
  86     FIB_PATH_LIST_FLAG_LOOPED    = (1 << FIB_PATH_LIST_ATTRIBUTE_LOOPED),
  87     FIB_PATH_LIST_FLAG_POPULAR   = (1 << FIB_PATH_LIST_ATTRIBUTE_POPULAR),
  88     FIB_PATH_LIST_FLAG_NO_URPF   = (1 << FIB_PATH_LIST_ATTRIBUTE_NO_URPF),
  89 } fib_path_list_flags_t;
  90
  91 #define FIB_PATH_LIST_ATTRIBUTES {                       \
  92     [FIB_PATH_LIST_ATTRIBUTE_SHARED]    = "shared",      \
  93     [FIB_PATH_LIST_ATTRIBUTE_RESOLVED]  = "resolved",    \
  94     [FIB_PATH_LIST_ATTRIBUTE_DROP]      = "drop",        \
  95     [FIB_PATH_LIST_ATTRIBUTE_EXCLUSIVE] = "exclusive",   \
  96     [FIB_PATH_LIST_ATTRIBUTE_LOCAL]     = "local",       \
  97     [FIB_PATH_LIST_ATTRIBUTE_LOOPED]    = "looped",      \
  98     [FIB_PATH_LIST_ATTRIBUTE_POPULAR]   = "popular",     \
  99     [FIB_PATH_LIST_ATTRIBUTE_NO_URPF]   = "no-uRPF",     \
 100 }
 101
 102 #define FOR_EACH_PATH_LIST_ATTRIBUTE(_item)             \
 103     for (_item = FIB_PATH_LIST_ATTRIBUTE_FIRST;         \
 104          _item <= FIB_PATH_LIST_ATTRIBUTE_LAST;         \
 105          _item++)
 106
 107 extern fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags,
 108                                              const fib_route_path_t *paths);
 109 extern fib_node_index_t fib_path_list_create_special(dpo_proto_t nh_proto,
 110                                                      fib_path_list_flags_t flags,
 111                                                      const dpo_id_t *dpo);
 112
 113 extern fib_node_index_t fib_path_list_copy_and_path_add(
 114     fib_node_index_t pl_index,
 115     fib_path_list_flags_t flags,
 116     const fib_route_path_t *path);
 117 extern fib_node_index_t fib_path_list_copy_and_path_remove(
 118     fib_node_index_t pl_index,
 119     fib_path_list_flags_t flags,
 120     const fib_route_path_t *path);
 121 extern fib_node_index_t fib_path_list_path_add (
 122     fib_node_index_t path_list_index,
 123     const fib_route_path_t *rpaths);
 124 extern fib_node_index_t fib_path_list_path_remove (
 125     fib_node_index_t path_list_index,
 126     const fib_route_path_t *rpaths);
 127
 128 extern u32 fib_path_list_get_n_paths(fib_node_index_t pl_index);
 129
 130 /**
 131  * Flags to control how the path-list returns forwarding information
 132  */
 133 typedef enum fib_path_list_fwd_flags_t_
 134 {
 135     FIB_PATH_LIST_FWD_FLAG_NONE = 0,
 136     FIB_PATH_LIST_FWD_FLAG_COLLAPSE = (1 << 0),
 137     FIB_PATH_LIST_FWD_FLAG_STICKY = (1 << 1),
 138 } fib_path_list_fwd_flags_t;
 139
 140 extern void fib_path_list_contribute_forwarding(fib_node_index_t path_list_index,
 141                                                 fib_forward_chain_type_t type,
 142                                                 fib_path_list_fwd_flags_t flags,
 143                                                 dpo_id_t *dpo);
 144 extern void fib_path_list_contribute_urpf(fib_node_index_t path_index,
 145                                           index_t urpf);
 146 extern index_t fib_path_list_get_urpf(fib_node_index_t path_list_index);
 147 extern index_t fib_path_list_get_adj(fib_node_index_t path_list_index,
 148                                      fib_forward_chain_type_t type);
 149
 150 extern u32 fib_path_list_child_add(fib_node_index_t pl_index,
 151                                    fib_node_type_t type,
 152                                    fib_node_index_t child_index);
 153 extern void fib_path_list_child_remove(fib_node_index_t pl_index,
 154                                        fib_node_index_t sibling_index);
 155 extern void fib_path_list_back_walk(fib_node_index_t pl_index,
 156                                     fib_node_back_walk_ctx_t *ctx);
 157 extern void fib_path_list_lock(fib_node_index_t pl_index);
 158 extern void fib_path_list_unlock(fib_node_index_t pl_index);
 159 extern int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index,
 160                                                fib_node_index_t **entry_indicies);
 161 extern u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index);
 162 extern int fib_path_list_is_looped(fib_node_index_t path_list_index);
 163 extern int fib_path_list_is_popular(fib_node_index_t path_list_index);
 164 extern dpo_proto_t fib_path_list_get_proto(fib_node_index_t path_list_index);
 165 extern u8 * fib_path_list_format(fib_node_index_t pl_index,
 166                                  u8 * s);
 167 extern u8 * format_fib_path_list(u8 * s, va_list *args);
 168
 169 extern index_t fib_path_list_lb_map_add_or_lock(fib_node_index_t pl_index,
 170                                                 const fib_node_index_t *pis);
 171 extern u32 fib_path_list_find_rpath (fib_node_index_t path_list_index,
 172                                      const fib_route_path_t *rpath);
 173
 174 /**
 175  * A callback function type for walking a path-list's paths
 176  */
 177 typedef fib_path_list_walk_rc_t (*fib_path_list_walk_fn_t)(
 178     fib_node_index_t pl_index,
 179     fib_node_index_t path_index,
 180     void *ctx);
 181
 182 extern void fib_path_list_walk(fib_node_index_t pl_index,
 183                                fib_path_list_walk_fn_t func,
 184                                void *ctx);
 185
 186 typedef fib_path_list_walk_rc_t (*fib_path_list_walk_w_ext_fn_t)(
 187     fib_node_index_t pl_index,
 188     fib_node_index_t path_index,
 189     const struct fib_path_ext_t_ *ext_list,
 190     void *ctx);
 191
 192 extern void fib_path_list_walk_w_ext(fib_node_index_t pl_index,
 193                                      const fib_path_ext_list_t *ext_list,
 194                                      fib_path_list_walk_w_ext_fn_t func,
 195                                      void *ctx);
 196
 197 extern void fib_path_list_module_init(void);
 198
 199 extern void fib_path_list_module_init(void);
 200
 201 /*
 202  * functions for testing.
 203  */
 204 u32 fib_path_list_pool_size(void);
 205 u32 fib_path_list_db_size(void);
 206
 207 #endif