src/vnet/fib/fib_path.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 /**
  17  * Given a route of the form;
  18  *   q.r.s.t/Y
  19  *     via <interface> <next-hop>
  20  *
  21  * The prefix is: q.r.s.t./Y
  22  * the path is: 'via <interface> <next-hop>
  23  *
  24  * The path is the description of where to send the traffic, and the
  25  * the prefix is a description of which traffic to send.
  26  * It is the aim of the FIB to resolve the path, i.e. to find the corresponding
  27  * adjacency to match the path's description.
  28  */
  29
  30 #ifndef __FIB_PATH_H__
  31 #define __FIB_PATH_H__
  32
  33 #include <vnet/ip/ip.h>
  34 #include <vnet/dpo/load_balance.h>
  35
  36 #include <vnet/fib/fib_types.h>
  37 #include <vnet/adj/adj_types.h>
  38 #include <vnet/bier/bier_types.h>
  39
  40 /**
  41  * Enurmeration of path configuration attributes
  42  */
  43 typedef enum fib_path_cfg_attribute_t_ {
  44     /**
  45      * Marker. Add new types after this one.
  46      */
  47     FIB_PATH_CFG_ATTRIBUTE_FIRST = 0,
  48     /**
  49      * The path is forced to a drop, whatever the next-hop info says.
  50      * something somewhere knows better...
  51      */
  52     FIB_PATH_CFG_ATTRIBUTE_DROP = FIB_PATH_CFG_ATTRIBUTE_FIRST,
  53     /**
  54      * The path uses an adj that is exclusive. I.e. it is known only by
  55      * the source of the route.
  56      */
  57     FIB_PATH_CFG_ATTRIBUTE_EXCLUSIVE,
  58     /**
  59      * Recursion constraint via host
  60      */
  61     FIB_PATH_CFG_ATTRIBUTE_RESOLVE_HOST,
  62     /**
  63      * Recursion constraint via attached
  64      */
  65     FIB_PATH_CFG_ATTRIBUTE_RESOLVE_ATTACHED,
  66     /**
  67      * The path is attached
  68      */
  69     FIB_PATH_CFG_ATTRIBUTE_ATTACHED,
  70     /**
  71      * The path is a for-us path
  72      */
  73     FIB_PATH_CFG_ATTRIBUTE_INTF_RX,
  74     /**
  75      * The path is a deag with rpf-id
  76      */
  77     FIB_PATH_CFG_ATTRIBUTE_RPF_ID,
  78     /**
  79      * The path is an interface recieve
  80      */
  81     FIB_PATH_CFG_ATTRIBUTE_LOCAL,
  82     /**
  83      * The path reolves via an ICMP unreachable
  84      */
  85     FIB_PATH_CFG_ATTRIBUTE_ICMP_UNREACH,
  86     /**
  87      * The path reolves via an ICMP prohibit
  88      */
  89     FIB_PATH_CFG_ATTRIBUTE_ICMP_PROHIBIT,
  90     /**
  91      * The path reolves via a classify
  92      */
  93     FIB_PATH_CFG_ATTRIBUTE_CLASSIFY,
  94     /**
  95      * The deag path does a source lookup
  96      */
  97     FIB_PATH_CFG_ATTRIBUTE_DEAG_SRC,
  98     /**
  99      * The path pops a Psuedo Wire Control Word
 100      */
 101     FIB_PATH_CFG_ATTRIBUTE_POP_PW_CW,
 102     /**
 103      * The path is a glean
 104      */
 105     FIB_PATH_CFG_ATTRIBUTE_GLEAN,
 106     /**
 107      * Marker. Add new types before this one, then update it.
 108      */
 109     FIB_PATH_CFG_ATTRIBUTE_LAST = FIB_PATH_CFG_ATTRIBUTE_GLEAN,
 110 } __attribute__ ((packed)) fib_path_cfg_attribute_t;
 111
 112 /**
 113  * The maximum number of path attributes
 114  */
 115 #define FIB_PATH_CFG_ATTRIBUTE_MAX (FIB_PATH_CFG_ATTRIBUTE_LAST + 1)
 116
 117 #define FIB_PATH_CFG_ATTRIBUTES {                       \
 118     [FIB_PATH_CFG_ATTRIBUTE_DROP]  = "drop",            \
 119     [FIB_PATH_CFG_ATTRIBUTE_EXCLUSIVE] = "exclusive",   \
 120     [FIB_PATH_CFG_ATTRIBUTE_RESOLVE_HOST] = "resolve-host", \
 121     [FIB_PATH_CFG_ATTRIBUTE_RESOLVE_ATTACHED] = "resolve-attached", \
 122     [FIB_PATH_CFG_ATTRIBUTE_LOCAL] = "local",           \
 123     [FIB_PATH_CFG_ATTRIBUTE_ICMP_UNREACH] = "icmp-unreach",   \
 124     [FIB_PATH_CFG_ATTRIBUTE_ICMP_PROHIBIT] = "icmp-prohibit", \
 125     [FIB_PATH_CFG_ATTRIBUTE_CLASSIFY] = "classify", \
 126     [FIB_PATH_CFG_ATTRIBUTE_ATTACHED] = "attached",     \
 127     [FIB_PATH_CFG_ATTRIBUTE_INTF_RX] = "interface-rx",  \
 128     [FIB_PATH_CFG_ATTRIBUTE_RPF_ID] = "rpf-id",         \
 129     [FIB_PATH_CFG_ATTRIBUTE_DEAG_SRC] = "deag-src",     \
 130     [FIB_PATH_CFG_ATTRIBUTE_POP_PW_CW] = "pop-pw-cw",   \
 131     [FIB_PATH_CFG_ATTRIBUTE_GLEAN] = "glean",           \
 132 }
 133
 134 #define FOR_EACH_FIB_PATH_CFG_ATTRIBUTE(_item) \
 135     for (_item = FIB_PATH_CFG_ATTRIBUTE_FIRST; \
 136          _item <= FIB_PATH_CFG_ATTRIBUTE_LAST; \
 137          _item++)
 138
 139 /**
 140  * Path config flags from the attributes
 141  */
 142 typedef enum fib_path_cfg_flags_t_ {
 143     FIB_PATH_CFG_FLAG_NONE  = 0,
 144     FIB_PATH_CFG_FLAG_DROP  = (1 << FIB_PATH_CFG_ATTRIBUTE_DROP),
 145     FIB_PATH_CFG_FLAG_EXCLUSIVE = (1 << FIB_PATH_CFG_ATTRIBUTE_EXCLUSIVE),
 146     FIB_PATH_CFG_FLAG_RESOLVE_HOST = (1 << FIB_PATH_CFG_ATTRIBUTE_RESOLVE_HOST),
 147     FIB_PATH_CFG_FLAG_RESOLVE_ATTACHED = (1 << FIB_PATH_CFG_ATTRIBUTE_RESOLVE_ATTACHED),
 148     FIB_PATH_CFG_FLAG_LOCAL = (1 << FIB_PATH_CFG_ATTRIBUTE_LOCAL),
 149     FIB_PATH_CFG_FLAG_ICMP_UNREACH = (1 << FIB_PATH_CFG_ATTRIBUTE_ICMP_UNREACH),
 150     FIB_PATH_CFG_FLAG_ICMP_PROHIBIT = (1 << FIB_PATH_CFG_ATTRIBUTE_ICMP_PROHIBIT),
 151     FIB_PATH_CFG_FLAG_CLASSIFY = (1 << FIB_PATH_CFG_ATTRIBUTE_CLASSIFY),
 152     FIB_PATH_CFG_FLAG_ATTACHED = (1 << FIB_PATH_CFG_ATTRIBUTE_ATTACHED),
 153     FIB_PATH_CFG_FLAG_INTF_RX = (1 << FIB_PATH_CFG_ATTRIBUTE_INTF_RX),
 154     FIB_PATH_CFG_FLAG_RPF_ID = (1 << FIB_PATH_CFG_ATTRIBUTE_RPF_ID),
 155     FIB_PATH_CFG_FLAG_DEAG_SRC = (1 << FIB_PATH_CFG_ATTRIBUTE_DEAG_SRC),
 156     FIB_PATH_CFG_FLAG_POP_PW_CW = (1 << FIB_PATH_CFG_ATTRIBUTE_POP_PW_CW),
 157     FIB_PATH_CFG_FLAG_GLEAN = (1 << FIB_PATH_CFG_ATTRIBUTE_GLEAN),
 158 } __attribute__ ((packed)) fib_path_cfg_flags_t;
 159
 160 typedef enum fib_path_format_flags_t_
 161 {
 162     FIB_PATH_FORMAT_FLAGS_NONE = 0,
 163     FIB_PATH_FORMAT_FLAGS_ONE_LINE = (1 << 0),
 164 } fib_format_path_flags_t;
 165
 166 extern u8 *format_fib_path(u8 *s, va_list *args);
 167
 168 extern fib_node_index_t fib_path_create(fib_node_index_t pl_index,
 169                                         const fib_route_path_t *path);
 170 extern fib_node_index_t fib_path_create_special(fib_node_index_t pl_index,
 171                                                 dpo_proto_t nh_proto,
 172                                                 fib_path_cfg_flags_t flags,
 173                                                 const dpo_id_t *dpo);
 174
 175 extern int fib_path_cmp(fib_node_index_t path_index1,
 176                         fib_node_index_t path_index2);
 177 extern int fib_path_cmp_for_sort(void * a1, void * a2);
 178 extern int fib_path_cmp_w_route_path(fib_node_index_t path_index,
 179                                      const fib_route_path_t *rpath);
 180 extern fib_node_index_t fib_path_copy(fib_node_index_t path_index,
 181                                       fib_node_index_t path_list_index);
 182 extern int fib_path_resolve(fib_node_index_t path_index);
 183 extern int fib_path_is_resolved(fib_node_index_t path_index);
 184 extern int fib_path_is_recursive_constrained(fib_node_index_t path_index);
 185 extern int fib_path_is_exclusive(fib_node_index_t path_index);
 186 extern int fib_path_is_deag(fib_node_index_t path_index);
 187 extern int fib_path_is_looped(fib_node_index_t path_index);
 188 extern dpo_proto_t fib_path_get_proto(fib_node_index_t path_index);
 189 extern void fib_path_destroy(fib_node_index_t path_index);
 190 extern uword fib_path_hash(fib_node_index_t path_index);
 191 extern load_balance_path_t * fib_path_append_nh_for_multipath_hash(
 192     fib_node_index_t path_index,
 193     fib_forward_chain_type_t fct,
 194     load_balance_path_t *hash_key);
 195 extern void fib_path_stack_mpls_disp(fib_node_index_t path_index,
 196                                      dpo_proto_t payload_proto,
 197                                      fib_mpls_lsp_mode_t mode,
 198                                      dpo_id_t *dpo);
 199 extern void fib_path_contribute_forwarding(fib_node_index_t path_index,
 200                                            fib_forward_chain_type_t type,
 201                                            dpo_id_t *dpo);
 202 extern void fib_path_contribute_urpf(fib_node_index_t path_index,
 203                                      index_t urpf);
 204 extern adj_index_t fib_path_get_adj(fib_node_index_t path_index);
 205 extern int fib_path_recursive_loop_detect(fib_node_index_t path_index,
 206                                           fib_node_index_t **entry_indicies);
 207 extern u32 fib_path_get_resolving_interface(fib_node_index_t fib_entry_index);
 208 extern index_t fib_path_get_resolving_index(fib_node_index_t path_index);
 209 extern u16 fib_path_get_weight(fib_node_index_t path_index);
 210 extern u16 fib_path_get_preference(fib_node_index_t path_index);
 211 extern u32 fib_path_get_rpf_id(fib_node_index_t path_index);
 212
 213 extern void fib_path_module_init(void);
 214
 215 /**
 216  * Path encode context to use when walking a path-list
 217  * to encode paths
 218  */
 219 typedef struct fib_path_encode_ctx_t_
 220 {
 221     fib_route_path_t *rpaths;
 222 } fib_path_encode_ctx_t;
 223
 224 extern fib_path_list_walk_rc_t fib_path_encode(fib_node_index_t path_list_index,
 225                                                fib_node_index_t path_index,
 226                                                const struct fib_path_ext_t_ *ext_list,
 227                                                void *ctx);
 228
 229 #endif