src/vnet/dpo/load_balance.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  * \brief
  17  * The load-balance object represents an ECMP choice. The buckets of a load
  18  * balance object point to the sub-graph after the choice is made.
  19  * THe load-balance object is also object type returned from a FIB table lookup.
  20  * As such it needs to represent the case where there is only one coice. It may
  21  * seem like overkill to use a load-balance object in this case, but the reason
  22  * is for performance. If the load-balance object were not the result of the FIB
  23  * lookup, then some other object would be. The case where there was ECMP
  24  * this other object would need a load-balance as a parent and hence just add
  25  * an unnecessary indirection.
  26  *
  27  * It is also the object in the DP that represents a via-fib-entry in a recursive
  28  * route.
  29  *
  30  */
  31
  32 #ifndef __LOAD_BALANCE_H__
  33 #define __LOAD_BALANCE_H__
  34
  35 #include <vlib/vlib.h>
  36 #include <vnet/ip/lookup.h>
  37 #include <vnet/dpo/dpo.h>
  38 #include <vnet/fib/fib_types.h>
  39 #include <vnet/fib/fib_entry.h>
  40
  41 /**
  42  * Load-balance main
  43  */
  44 typedef struct load_balance_main_t_
  45 {
  46     vlib_combined_counter_main_t lbm_to_counters;
  47     vlib_combined_counter_main_t lbm_via_counters;
  48 } load_balance_main_t;
  49
  50 extern load_balance_main_t load_balance_main;
  51
  52 /**
  53  * The number of buckets that a load-balance object can have and still
  54  * fit in one cache-line
  55  */
  56 #define LB_NUM_INLINE_BUCKETS 4
  57
  58 /**
  59  * @brief One path from an [EU]CMP set that the client wants to add to a
  60  * load-balance object
  61  */
  62 typedef struct load_balance_path_t_ {
  63     /**
  64      * ID of the Data-path object.
  65      */
  66     dpo_id_t path_dpo;
  67
  68     /**
  69      * The index of the FIB path
  70      */
  71     fib_node_index_t path_index;
  72
  73     /**
  74      * weight for the path.
  75      */
  76     u32 path_weight;
  77 } load_balance_path_t;
  78
  79 /**
  80  * The FIB DPO provieds;
  81  *  - load-balancing over the next DPOs in the chain/graph
  82  *  - per-route counters
  83  */
  84 typedef struct load_balance_t_ {
  85     /**
  86      * required for pool_get_aligned.
  87      *  memebers used in the switch path come first!
  88      */
  89     CLIB_CACHE_LINE_ALIGN_MARK(cacheline0);
  90
  91     /**
  92      * number of buckets in the load-balance. always a power of 2.
  93      */
  94     u16 lb_n_buckets;
  95     /**
  96      * number of buckets in the load-balance - 1. used in the switch path
  97      * as part of the hash calculation.
  98      */
  99     u16 lb_n_buckets_minus_1;
 100
 101    /**
 102      * The protocol of packets that traverse this LB.
 103      * need in combination with the flow hash config to determine how to hash.
 104      * u8.
 105      */
 106     dpo_proto_t lb_proto;
 107
 108     /**
 109      * Flags from the load-balance's associated fib_entry_t
 110      */
 111     fib_entry_flag_t lb_fib_entry_flags;
 112
 113     /**
 114      * The number of locks, which is approximately the number of users,
 115      * of this load-balance.
 116      * Load-balance objects of via-entries are heavily shared by recursives,
 117      * so the lock count is a u32.
 118      */
 119     u32 lb_locks;
 120
 121     /**
 122      * index of the load-balance map, INVALID if this LB does not use one
 123      */
 124     index_t lb_map;
 125
 126     /**
 127      * This is the index of the uRPF list for this LB
 128      */
 129     index_t lb_urpf;
 130
 131     /**
 132      * the hash config to use when selecting a bucket. this is a u16
 133      */
 134     flow_hash_config_t lb_hash_config;
 135
 136     /**
 137      * Vector of buckets containing the next DPOs, sized as lbo_num
 138      */
 139     dpo_id_t *lb_buckets;
 140
 141     /**
 142      * The rest of the cache line is used for buckets. In the common case
 143      * where there there are less than 4 buckets, then the buckets are
 144      * on the same cachlie and we save ourselves a pointer dereferance in
 145      * the data-path.
 146      */
 147     dpo_id_t lb_buckets_inline[LB_NUM_INLINE_BUCKETS];
 148 } load_balance_t;
 149
 150 STATIC_ASSERT(sizeof(load_balance_t) <= CLIB_CACHE_LINE_BYTES,
 151               "A load_balance object size exceeds one cachline");
 152
 153 /**
 154  * Flags controlling load-balance formatting/display
 155  */
 156 typedef enum load_balance_format_flags_t_ {
 157     LOAD_BALANCE_FORMAT_NONE,
 158     LOAD_BALANCE_FORMAT_DETAIL = (1 << 0),
 159 } load_balance_format_flags_t;
 160
 161 /**
 162  * Flags controlling load-balance creation and modification
 163  */
 164 typedef enum load_balance_flags_t_ {
 165     LOAD_BALANCE_FLAG_NONE = 0,
 166     LOAD_BALANCE_FLAG_USES_MAP = (1 << 0),
 167 } load_balance_flags_t;
 168
 169 extern index_t load_balance_create(u32 num_buckets,
 170                                    dpo_proto_t lb_proto,
 171                                    flow_hash_config_t fhc);
 172 extern void load_balance_multipath_update(
 173     const dpo_id_t *dpo,
 174     const load_balance_path_t * raw_next_hops,
 175     load_balance_flags_t flags);
 176
 177 extern void load_balance_set_bucket(index_t lbi,
 178                                     u32 bucket,
 179                                     const dpo_id_t *next);
 180 extern void load_balance_set_urpf(index_t lbi,
 181                                   index_t urpf);
 182 extern void load_balance_set_fib_entry_flags(index_t lbi,
 183                                              fib_entry_flag_t flags);
 184 extern index_t load_balance_get_urpf(index_t lbi);
 185
 186 extern u8* format_load_balance(u8 * s, va_list * args);
 187
 188 extern const dpo_id_t *load_balance_get_bucket(index_t lbi,
 189                                                u32 bucket);
 190 extern int load_balance_is_drop(const dpo_id_t *dpo);
 191 extern u16 load_balance_n_buckets(index_t lbi);
 192
 193 extern f64 load_balance_get_multipath_tolerance(void);
 194
 195 /**
 196  * The encapsulation breakages are for fast DP access
 197  */
 198 extern load_balance_t *load_balance_pool;
 199 static inline load_balance_t*
 200 load_balance_get (index_t lbi)
 201 {
 202     return (pool_elt_at_index(load_balance_pool, lbi));
 203 }
 204
 205 #define LB_HAS_INLINE_BUCKETS(_lb)              \
 206     ((_lb)->lb_n_buckets <= LB_NUM_INLINE_BUCKETS)
 207
 208 static inline const dpo_id_t *
 209 load_balance_get_bucket_i (const load_balance_t *lb,
 210                            u32 bucket)
 211 {
 212     ASSERT(bucket < lb->lb_n_buckets);
 213
 214     if (PREDICT_TRUE(LB_HAS_INLINE_BUCKETS(lb)))
 215     {
 216         return (&lb->lb_buckets_inline[bucket]);
 217     }
 218     else
 219     {
 220         return (&lb->lb_buckets[bucket]);
 221     }
 222 }
 223
 224 extern void load_balance_module_init(void);
 225
 226 #endif