src/vnet/dpo/replicate_dpo.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  *
  18  */
  19
  20 #ifndef __REPLICATE_DPO_H__
  21 #define __REPLICATE_DPO_H__
  22
  23 #include <vlib/vlib.h>
  24 #include <vnet/ip/lookup.h>
  25 #include <vnet/dpo/dpo.h>
  26 #include <vnet/dpo/load_balance.h>
  27 #include <vnet/fib/fib_types.h>
  28
  29 /**
  30  * replicate main
  31  */
  32 typedef struct replicate_main_t_
  33 {
  34     vlib_combined_counter_main_t repm_counters;
  35
  36     /* per-cpu vector of cloned packets */
  37     u32 **clones;
  38 } replicate_main_t;
  39
  40 extern replicate_main_t replicate_main;
  41
  42 /**
  43  * The number of buckets that a load-balance object can have and still
  44  * fit in one cache-line
  45  */
  46 #define REP_NUM_INLINE_BUCKETS 4
  47
  48 /**
  49  * The FIB DPO provieds;
  50  *  - load-balancing over the next DPOs in the chain/graph
  51  *  - per-route counters
  52  */
  53 typedef struct replicate_t_ {
  54     /**
  55      * number of buckets in the load-balance. always a power of 2.
  56      */
  57     u16 rep_n_buckets;
  58
  59    /**
  60      * The protocol of packets that traverse this REP.
  61      * need in combination with the flow hash config to determine how to hash.
  62      * u8.
  63      */
  64     dpo_proto_t rep_proto;
  65
  66     /**
  67      * The number of locks, which is approximately the number of users,
  68      * of this load-balance.
  69      * Load-balance objects of via-entries are heavily shared by recursives,
  70      * so the lock count is a u32.
  71      */
  72     u32 rep_locks;
  73
  74     /**
  75      * Vector of buckets containing the next DPOs, sized as repo_num
  76      */
  77     dpo_id_t *rep_buckets;
  78
  79     /**
  80      * The rest of the cache line is used for buckets. In the common case
  81      * where there there are less than 4 buckets, then the buckets are
  82      * on the same cachlie and we save ourselves a pointer dereferance in
  83      * the data-path.
  84      */
  85     dpo_id_t rep_buckets_inline[REP_NUM_INLINE_BUCKETS];
  86 } replicate_t;
  87
  88 STATIC_ASSERT(sizeof(replicate_t) <= CLIB_CACHE_LINE_BYTES,
  89               "A replicate object size exceeds one cachline");
  90
  91 /**
  92  * Flags controlling load-balance formatting/display
  93  */
  94 typedef enum replicate_format_flags_t_ {
  95     REPLICATE_FORMAT_NONE,
  96     REPLICATE_FORMAT_DETAIL = (1 << 0),
  97 } replicate_format_flags_t;
  98
  99 extern index_t replicate_create(u32 num_buckets,
 100                                 dpo_proto_t rep_proto);
 101 extern void replicate_multipath_update(
 102     const dpo_id_t *dpo,
 103     load_balance_path_t *next_hops);
 104
 105 extern void replicate_set_bucket(index_t repi,
 106                                     u32 bucket,
 107                                     const dpo_id_t *next);
 108
 109 extern u8* format_replicate(u8 * s, va_list * args);
 110
 111 extern const dpo_id_t *replicate_get_bucket(index_t repi,
 112                                                u32 bucket);
 113 extern int replicate_is_drop(const dpo_id_t *dpo);
 114
 115 /**
 116  * The encapsulation breakages are for fast DP access
 117  */
 118 extern replicate_t *replicate_pool;
 119 static inline replicate_t*
 120 replicate_get (index_t repi)
 121 {
 122     return (pool_elt_at_index(replicate_pool, repi));
 123 }
 124
 125 #define REP_HAS_INLINE_BUCKETS(_rep)            \
 126     ((_rep)->rep_n_buckets <= REP_NUM_INLINE_BUCKETS)
 127
 128 static inline const dpo_id_t *
 129 replicate_get_bucket_i (const replicate_t *rep,
 130                            u32 bucket)
 131 {
 132     ASSERT(bucket < rep->rep_n_buckets);
 133
 134     if (PREDICT_TRUE(REP_HAS_INLINE_BUCKETS(rep)))
 135     {
 136         return (&rep->rep_buckets_inline[bucket]);
 137     }
 138     else
 139     {
 140         return (&rep->rep_buckets[bucket]);
 141     }
 142 }
 143
 144 extern void replicate_module_init(void);
 145
 146 #endif