lib/librte_fib/rte_fib6.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
   3  * Copyright(c) 2019 Intel Corporation
   4  */
   5
   6 #include <stdint.h>
   7 #include <string.h>
   8
   9 #include <rte_eal.h>
  10 #include <rte_eal_memconfig.h>
  11 #include <rte_tailq.h>
  12 #include <rte_errno.h>
  13 #include <rte_rwlock.h>
  14 #include <rte_malloc.h>
  15 #include <rte_string_fns.h>
  16
  17 #include <rte_rib6.h>
  18 #include <rte_fib6.h>
  19
  20 TAILQ_HEAD(rte_fib6_list, rte_tailq_entry);
  21 static struct rte_tailq_elem rte_fib6_tailq = {
  22         .name = "RTE_FIB6",
  23 };
  24 EAL_REGISTER_TAILQ(rte_fib6_tailq)
  25
  26 /* Maximum length of a FIB name. */
  27 #define FIB6_NAMESIZE   64
  28
  29 #if defined(RTE_LIBRTE_FIB_DEBUG)
  30 #define FIB6_RETURN_IF_TRUE(cond, retval) do {          \
  31         if (cond)                                       \
  32                 return retval;                          \
  33 } while (0)
  34 #else
  35 #define FIB6_RETURN_IF_TRUE(cond, retval)
  36 #endif
  37
  38 struct rte_fib6 {
  39         char                    name[FIB6_NAMESIZE];
  40         enum rte_fib6_type      type;   /**< Type of FIB struct */
  41         struct rte_rib6         *rib;   /**< RIB helper datastruct */
  42         void                    *dp;    /**< pointer to the dataplane struct*/
  43         rte_fib6_lookup_fn_t    lookup; /**< fib lookup function */
  44         rte_fib6_modify_fn_t    modify; /**< modify fib datastruct */
  45         uint64_t                def_nh;
  46 };
  47
  48 static void
  49 dummy_lookup(void *fib_p, uint8_t ips[][RTE_FIB6_IPV6_ADDR_SIZE],
  50         uint64_t *next_hops, const unsigned int n)
  51 {
  52         unsigned int i;
  53         struct rte_fib6 *fib = fib_p;
  54         struct rte_rib6_node *node;
  55
  56         for (i = 0; i < n; i++) {
  57                 node = rte_rib6_lookup(fib->rib, ips[i]);
  58                 if (node != NULL)
  59                         rte_rib6_get_nh(node, &next_hops[i]);
  60                 else
  61                         next_hops[i] = fib->def_nh;
  62         }
  63 }
  64
  65 static int
  66 dummy_modify(struct rte_fib6 *fib, const uint8_t ip[RTE_FIB6_IPV6_ADDR_SIZE],
  67         uint8_t depth, uint64_t next_hop, int op)
  68 {
  69         struct rte_rib6_node *node;
  70         if ((fib == NULL) || (depth > RTE_FIB6_MAXDEPTH))
  71                 return -EINVAL;
  72
  73         node = rte_rib6_lookup_exact(fib->rib, ip, depth);
  74
  75         switch (op) {
  76         case RTE_FIB6_ADD:
  77                 if (node == NULL)
  78                         node = rte_rib6_insert(fib->rib, ip, depth);
  79                 if (node == NULL)
  80                         return -rte_errno;
  81                 return rte_rib6_set_nh(node, next_hop);
  82         case RTE_FIB6_DEL:
  83                 if (node == NULL)
  84                         return -ENOENT;
  85                 rte_rib6_remove(fib->rib, ip, depth);
  86                 return 0;
  87         }
  88         return -EINVAL;
  89 }
  90
  91 static int
  92 init_dataplane(struct rte_fib6 *fib, __rte_unused int socket_id,
  93         struct rte_fib6_conf *conf)
  94 {
  95         switch (conf->type) {
  96         case RTE_FIB6_DUMMY:
  97                 fib->dp = fib;
  98                 fib->lookup = dummy_lookup;
  99                 fib->modify = dummy_modify;
 100                 return 0;
 101         default:
 102                 return -EINVAL;
 103         }
 104         return 0;
 105 }
 106
 107 int
 108 rte_fib6_add(struct rte_fib6 *fib, const uint8_t ip[RTE_FIB6_IPV6_ADDR_SIZE],
 109         uint8_t depth, uint64_t next_hop)
 110 {
 111         if ((fib == NULL) || (ip == NULL) || (fib->modify == NULL) ||
 112                         (depth > RTE_FIB6_MAXDEPTH))
 113                 return -EINVAL;
 114         return fib->modify(fib, ip, depth, next_hop, RTE_FIB6_ADD);
 115 }
 116
 117 int
 118 rte_fib6_delete(struct rte_fib6 *fib, const uint8_t ip[RTE_FIB6_IPV6_ADDR_SIZE],
 119         uint8_t depth)
 120 {
 121         if ((fib == NULL) || (ip == NULL) || (fib->modify == NULL) ||
 122                         (depth > RTE_FIB6_MAXDEPTH))
 123                 return -EINVAL;
 124         return fib->modify(fib, ip, depth, 0, RTE_FIB6_DEL);
 125 }
 126
 127 int
 128 rte_fib6_lookup_bulk(struct rte_fib6 *fib,
 129         uint8_t ips[][RTE_FIB6_IPV6_ADDR_SIZE],
 130         uint64_t *next_hops, int n)
 131 {
 132         FIB6_RETURN_IF_TRUE((fib == NULL) || (ips == NULL) ||
 133                 (next_hops == NULL) || (fib->lookup == NULL), -EINVAL);
 134         fib->lookup(fib->dp, ips, next_hops, n);
 135         return 0;
 136 }
 137
 138 struct rte_fib6 *
 139 rte_fib6_create(const char *name, int socket_id, struct rte_fib6_conf *conf)
 140 {
 141         char mem_name[FIB6_NAMESIZE];
 142         int ret;
 143         struct rte_fib6 *fib = NULL;
 144         struct rte_rib6 *rib = NULL;
 145         struct rte_tailq_entry *te;
 146         struct rte_fib6_list *fib_list;
 147         struct rte_rib6_conf rib_conf;
 148
 149         /* Check user arguments. */
 150         if ((name == NULL) || (conf == NULL) || (conf->max_routes < 0) ||
 151                         (conf->type >= RTE_FIB6_TYPE_MAX)) {
 152                 rte_errno = EINVAL;
 153                 return NULL;
 154         }
 155
 156         rib_conf.ext_sz = 0;
 157         rib_conf.max_nodes = conf->max_routes * 2;
 158
 159         rib = rte_rib6_create(name, socket_id, &rib_conf);
 160         if (rib == NULL) {
 161                 RTE_LOG(ERR, LPM,
 162                         "Can not allocate RIB %s\n", name);
 163                 return NULL;
 164         }
 165
 166         snprintf(mem_name, sizeof(mem_name), "FIB6_%s", name);
 167         fib_list = RTE_TAILQ_CAST(rte_fib6_tailq.head, rte_fib6_list);
 168
 169         rte_mcfg_tailq_write_lock();
 170
 171         /* guarantee there's no existing */
 172         TAILQ_FOREACH(te, fib_list, next) {
 173                 fib = (struct rte_fib6 *)te->data;
 174                 if (strncmp(name, fib->name, FIB6_NAMESIZE) == 0)
 175                         break;
 176         }
 177         fib = NULL;
 178         if (te != NULL) {
 179                 rte_errno = EEXIST;
 180                 goto exit;
 181         }
 182
 183         /* allocate tailq entry */
 184         te = rte_zmalloc("FIB_TAILQ_ENTRY", sizeof(*te), 0);
 185         if (te == NULL) {
 186                 RTE_LOG(ERR, LPM,
 187                         "Can not allocate tailq entry for FIB %s\n", name);
 188                 rte_errno = ENOMEM;
 189                 goto exit;
 190         }
 191
 192         /* Allocate memory to store the FIB data structures. */
 193         fib = rte_zmalloc_socket(mem_name,
 194                 sizeof(struct rte_fib6), RTE_CACHE_LINE_SIZE, socket_id);
 195         if (fib == NULL) {
 196                 RTE_LOG(ERR, LPM, "FIB %s memory allocation failed\n", name);
 197                 rte_errno = ENOMEM;
 198                 goto free_te;
 199         }
 200
 201         rte_strlcpy(fib->name, name, sizeof(fib->name));
 202         fib->rib = rib;
 203         fib->type = conf->type;
 204         fib->def_nh = conf->default_nh;
 205         ret = init_dataplane(fib, socket_id, conf);
 206         if (ret < 0) {
 207                 RTE_LOG(ERR, LPM,
 208                         "FIB dataplane struct %s memory allocation failed\n",
 209                         name);
 210                 rte_errno = -ret;
 211                 goto free_fib;
 212         }
 213
 214         te->data = (void *)fib;
 215         TAILQ_INSERT_TAIL(fib_list, te, next);
 216
 217         rte_mcfg_tailq_write_unlock();
 218
 219         return fib;
 220
 221 free_fib:
 222         rte_free(fib);
 223 free_te:
 224         rte_free(te);
 225 exit:
 226         rte_mcfg_tailq_write_unlock();
 227         rte_rib6_free(rib);
 228
 229         return NULL;
 230 }
 231
 232 struct rte_fib6 *
 233 rte_fib6_find_existing(const char *name)
 234 {
 235         struct rte_fib6 *fib = NULL;
 236         struct rte_tailq_entry *te;
 237         struct rte_fib6_list *fib_list;
 238
 239         fib_list = RTE_TAILQ_CAST(rte_fib6_tailq.head, rte_fib6_list);
 240
 241         rte_mcfg_tailq_read_lock();
 242         TAILQ_FOREACH(te, fib_list, next) {
 243                 fib = (struct rte_fib6 *) te->data;
 244                 if (strncmp(name, fib->name, FIB6_NAMESIZE) == 0)
 245                         break;
 246         }
 247         rte_mcfg_tailq_read_unlock();
 248
 249         if (te == NULL) {
 250                 rte_errno = ENOENT;
 251                 return NULL;
 252         }
 253
 254         return fib;
 255 }
 256
 257 static void
 258 free_dataplane(struct rte_fib6 *fib)
 259 {
 260         switch (fib->type) {
 261         case RTE_FIB6_DUMMY:
 262                 return;
 263         default:
 264                 return;
 265         }
 266 }
 267
 268 void
 269 rte_fib6_free(struct rte_fib6 *fib)
 270 {
 271         struct rte_tailq_entry *te;
 272         struct rte_fib6_list *fib_list;
 273
 274         if (fib == NULL)
 275                 return;
 276
 277         fib_list = RTE_TAILQ_CAST(rte_fib6_tailq.head, rte_fib6_list);
 278
 279         rte_mcfg_tailq_write_lock();
 280
 281         /* find our tailq entry */
 282         TAILQ_FOREACH(te, fib_list, next) {
 283                 if (te->data == (void *)fib)
 284                         break;
 285         }
 286         if (te != NULL)
 287                 TAILQ_REMOVE(fib_list, te, next);
 288
 289         rte_mcfg_tailq_write_unlock();
 290
 291         free_dataplane(fib);
 292         rte_rib6_free(fib->rib);
 293         rte_free(fib);
 294         rte_free(te);
 295 }
 296
 297 void *
 298 rte_fib6_get_dp(struct rte_fib6 *fib)
 299 {
 300         return (fib == NULL) ? NULL : fib->dp;
 301 }
 302
 303 struct rte_rib6 *
 304 rte_fib6_get_rib(struct rte_fib6 *fib)
 305 {
 306         return (fib == NULL) ? NULL : fib->rib;
 307 }
 308