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 "fib_node.h"
  23 #include "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      * no uRPF - do not generate unicast RPF list for this path-list
  65      */
  66     FIB_PATH_LIST_ATTRIBUTE_NO_URPF,
  67     /**
  68      * Marher. Add new flags before this one, and then update it.
  69      */
  70     FIB_PATH_LIST_ATTRIBUTE_LAST = FIB_PATH_LIST_ATTRIBUTE_LOOPED,
  71 } fib_path_list_attribute_t;
  72
  73 typedef enum fib_path_list_flags_t_ {
  74     FIB_PATH_LIST_FLAG_NONE      = 0,
  75     FIB_PATH_LIST_FLAG_SHARED    = (1 << FIB_PATH_LIST_ATTRIBUTE_SHARED),
  76     FIB_PATH_LIST_FLAG_DROP      = (1 << FIB_PATH_LIST_ATTRIBUTE_DROP),
  77     FIB_PATH_LIST_FLAG_LOCAL     = (1 << FIB_PATH_LIST_ATTRIBUTE_LOCAL),
  78     FIB_PATH_LIST_FLAG_EXCLUSIVE = (1 << FIB_PATH_LIST_ATTRIBUTE_EXCLUSIVE),
  79     FIB_PATH_LIST_FLAG_RESOLVED  = (1 << FIB_PATH_LIST_ATTRIBUTE_RESOLVED),
  80     FIB_PATH_LIST_FLAG_LOOPED    = (1 << FIB_PATH_LIST_ATTRIBUTE_LOOPED),
  81     FIB_PATH_LIST_FLAG_NO_URPF   = (1 << FIB_PATH_LIST_ATTRIBUTE_NO_URPF),
  82 } fib_path_list_flags_t;
  83
  84 #define FIB_PATH_LIST_ATTRIBUTES {                       \
  85     [FIB_PATH_LIST_ATTRIBUTE_SHARED]    = "shared",      \
  86     [FIB_PATH_LIST_ATTRIBUTE_RESOLVED]  = "resolved",    \
  87     [FIB_PATH_LIST_ATTRIBUTE_DROP]      = "drop",        \
  88     [FIB_PATH_LIST_ATTRIBUTE_EXCLUSIVE] = "exclusive",   \
  89     [FIB_PATH_LIST_ATTRIBUTE_LOCAL]     = "local",       \
  90     [FIB_PATH_LIST_ATTRIBUTE_LOOPED]     = "looped",     \
  91     [FIB_PATH_LIST_ATTRIBUTE_NO_URPF]     = "no-uRPF",   \
  92 }
  93
  94 #define FOR_EACH_PATH_LIST_ATTRIBUTE(_item)             \
  95     for (_item = FIB_PATH_LIST_ATTRIBUTE_FIRST;         \
  96          _item <= FIB_PATH_LIST_ATTRIBUTE_LAST;         \
  97          _item++)
  98
  99 extern fib_node_index_t fib_path_list_create(fib_path_list_flags_t flags,
 100                                              const fib_route_path_t *paths);
 101 extern fib_node_index_t fib_path_list_create_special(fib_protocol_t nh_proto,
 102                                                      fib_path_list_flags_t flags,
 103                                                      const dpo_id_t *dpo);
 104
 105 extern fib_node_index_t fib_path_list_copy_and_path_add(
 106     fib_node_index_t pl_index,
 107     fib_path_list_flags_t flags,
 108     const fib_route_path_t *path);
 109 extern fib_node_index_t fib_path_list_copy_and_path_remove(
 110     fib_node_index_t pl_index,
 111     fib_path_list_flags_t flags,
 112     const fib_route_path_t *path);
 113 extern u32 fib_path_list_get_n_paths(fib_node_index_t pl_index);
 114
 115 extern void fib_path_list_contribute_forwarding(fib_node_index_t path_list_index,
 116                                                 fib_forward_chain_type_t type,
 117                                                 dpo_id_t *dpo);
 118 extern void fib_path_list_contribute_urpf(fib_node_index_t path_index,
 119                                           index_t urpf);
 120 extern index_t fib_path_list_get_urpf(fib_node_index_t path_list_index);
 121 extern index_t fib_path_list_get_adj(fib_node_index_t path_list_index,
 122                                      fib_forward_chain_type_t type);
 123
 124 extern u32 fib_path_list_child_add(fib_node_index_t pl_index,
 125                                    fib_node_type_t type,
 126                                    fib_node_index_t child_index);
 127 extern void fib_path_list_child_remove(fib_node_index_t pl_index,
 128                                        fib_node_index_t sibling_index);
 129 extern void fib_path_list_back_walk(fib_node_index_t pl_index,
 130                                     fib_node_back_walk_ctx_t *ctx);
 131 extern void fib_path_list_lock(fib_node_index_t pl_index);
 132 extern void fib_path_list_unlock(fib_node_index_t pl_index);
 133 extern int fib_path_list_recursive_loop_detect(fib_node_index_t path_list_index,
 134                                                fib_node_index_t **entry_indicies);
 135 extern u32 fib_path_list_get_resolving_interface(fib_node_index_t path_list_index);
 136 extern int fib_path_list_is_looped(fib_node_index_t path_list_index);
 137 extern fib_protocol_t fib_path_list_get_proto(fib_node_index_t path_list_index);
 138 extern u8 * fib_path_list_format(fib_node_index_t pl_index,
 139                                  u8 * s);
 140 extern u8 * fib_path_list_adjs_format(fib_node_index_t pl_index,
 141                                       u32 indent,
 142                                       u8 * s);
 143 extern index_t fib_path_list_lb_map_add_or_lock(fib_node_index_t pl_index,
 144                                                 const fib_node_index_t *pis);
 145 /**
 146  * A callback function type for walking a path-list's paths
 147  */
 148 typedef int (*fib_path_list_walk_fn_t)(fib_node_index_t pl_index,
 149                                        fib_node_index_t path_index,
 150                                        void *ctx);
 151
 152 extern void fib_path_list_walk(fib_node_index_t pl_index,
 153                                fib_path_list_walk_fn_t func,
 154                                void *ctx);
 155
 156 extern void fib_path_list_module_init(void);
 157
 158 extern void fib_path_list_module_init(void);
 159
 160 /*
 161  * functions for testing.
 162  */
 163 u32 fib_path_list_pool_size(void);
 164 u32 fib_path_list_db_size(void);
 165
 166 #endif