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 #include <sys/queue.h> 9 10 #include <rte_eal_memconfig.h> 11 #include <rte_errno.h> 12 #include <rte_malloc.h> 13 #include <rte_string_fns.h> 14 #include <rte_tailq.h> 15 16 #include <rte_rib.h> 17 #include <rte_fib.h> 18 19 #include "dir24_8.h" 20 #include "fib_log.h" 21 22 RTE_LOG_REGISTER_DEFAULT(fib_logtype, INFO); 23 24 TAILQ_HEAD(rte_fib_list, rte_tailq_entry); 25 static struct rte_tailq_elem rte_fib_tailq = { 26 .name = "RTE_FIB", 27 }; 28 EAL_REGISTER_TAILQ(rte_fib_tailq) 29 30 /* Maximum length of a FIB name. */ 31 #define RTE_FIB_NAMESIZE 64 32 33 #if defined(RTE_LIBRTE_FIB_DEBUG) 34 #define FIB_RETURN_IF_TRUE(cond, retval) do { \ 35 if (cond) \ 36 return retval; \ 37 } while (0) 38 #else 39 #define FIB_RETURN_IF_TRUE(cond, retval) 40 #endif 41 42 struct rte_fib { 43 char name[RTE_FIB_NAMESIZE]; 44 enum rte_fib_type type; /**< Type of FIB struct */ 45 struct rte_rib *rib; /**< RIB helper datastructure */ 46 void *dp; /**< pointer to the dataplane struct*/ 47 rte_fib_lookup_fn_t lookup; /**< FIB lookup function */ 48 rte_fib_modify_fn_t modify; /**< modify FIB datastructure */ 49 uint64_t def_nh; 50 }; 51 52 static void 53 dummy_lookup(void *fib_p, const uint32_t *ips, uint64_t *next_hops, 54 const unsigned int n) 55 { 56 unsigned int i; 57 struct rte_fib *fib = fib_p; 58 struct rte_rib_node *node; 59 60 for (i = 0; i < n; i++) { 61 node = rte_rib_lookup(fib->rib, ips[i]); 62 if (node != NULL) 63 rte_rib_get_nh(node, &next_hops[i]); 64 else 65 next_hops[i] = fib->def_nh; 66 } 67 } 68 69 static int 70 dummy_modify(struct rte_fib *fib, uint32_t ip, uint8_t depth, 71 uint64_t next_hop, int op) 72 { 73 struct rte_rib_node *node; 74 if ((fib == NULL) || (depth > RTE_FIB_MAXDEPTH)) 75 return -EINVAL; 76 77 node = rte_rib_lookup_exact(fib->rib, ip, depth); 78 79 switch (op) { 80 case RTE_FIB_ADD: 81 if (node == NULL) 82 node = rte_rib_insert(fib->rib, ip, depth); 83 if (node == NULL) 84 return -rte_errno; 85 return rte_rib_set_nh(node, next_hop); 86 case RTE_FIB_DEL: 87 if (node == NULL) 88 return -ENOENT; 89 rte_rib_remove(fib->rib, ip, depth); 90 return 0; 91 } 92 return -EINVAL; 93 } 94 95 static int 96 init_dataplane(struct rte_fib *fib, __rte_unused int socket_id, 97 struct rte_fib_conf *conf) 98 { 99 char dp_name[sizeof(void *)]; 100 101 snprintf(dp_name, sizeof(dp_name), "%p", fib); 102 switch (conf->type) { 103 case RTE_FIB_DUMMY: 104 fib->dp = fib; 105 fib->lookup = dummy_lookup; 106 fib->modify = dummy_modify; 107 return 0; 108 case RTE_FIB_DIR24_8: 109 fib->dp = dir24_8_create(dp_name, socket_id, conf); 110 if (fib->dp == NULL) 111 return -rte_errno; 112 fib->lookup = dir24_8_get_lookup_fn(fib->dp, 113 RTE_FIB_LOOKUP_DEFAULT); 114 fib->modify = dir24_8_modify; 115 return 0; 116 default: 117 return -EINVAL; 118 } 119 return 0; 120 } 121 122 int 123 rte_fib_add(struct rte_fib *fib, uint32_t ip, uint8_t depth, uint64_t next_hop) 124 { 125 if ((fib == NULL) || (fib->modify == NULL) || 126 (depth > RTE_FIB_MAXDEPTH)) 127 return -EINVAL; 128 return fib->modify(fib, ip, depth, next_hop, RTE_FIB_ADD); 129 } 130 131 int 132 rte_fib_delete(struct rte_fib *fib, uint32_t ip, uint8_t depth) 133 { 134 if ((fib == NULL) || (fib->modify == NULL) || 135 (depth > RTE_FIB_MAXDEPTH)) 136 return -EINVAL; 137 return fib->modify(fib, ip, depth, 0, RTE_FIB_DEL); 138 } 139 140 int 141 rte_fib_lookup_bulk(struct rte_fib *fib, uint32_t *ips, 142 uint64_t *next_hops, int n) 143 { 144 FIB_RETURN_IF_TRUE(((fib == NULL) || (ips == NULL) || 145 (next_hops == NULL) || (fib->lookup == NULL)), -EINVAL); 146 147 fib->lookup(fib->dp, ips, next_hops, n); 148 return 0; 149 } 150 151 struct rte_fib * 152 rte_fib_create(const char *name, int socket_id, struct rte_fib_conf *conf) 153 { 154 char mem_name[RTE_FIB_NAMESIZE]; 155 int ret; 156 struct rte_fib *fib = NULL; 157 struct rte_rib *rib = NULL; 158 struct rte_tailq_entry *te; 159 struct rte_fib_list *fib_list; 160 struct rte_rib_conf rib_conf; 161 162 /* Check user arguments. */ 163 if ((name == NULL) || (conf == NULL) || (conf->max_routes < 0) || 164 (conf->type > RTE_FIB_DIR24_8)) { 165 rte_errno = EINVAL; 166 return NULL; 167 } 168 169 rib_conf.ext_sz = conf->rib_ext_sz; 170 rib_conf.max_nodes = conf->max_routes * 2; 171 172 rib = rte_rib_create(name, socket_id, &rib_conf); 173 if (rib == NULL) { 174 FIB_LOG(ERR, 175 "Can not allocate RIB %s", name); 176 return NULL; 177 } 178 179 snprintf(mem_name, sizeof(mem_name), "FIB_%s", name); 180 fib_list = RTE_TAILQ_CAST(rte_fib_tailq.head, rte_fib_list); 181 182 rte_mcfg_tailq_write_lock(); 183 184 /* guarantee there's no existing */ 185 TAILQ_FOREACH(te, fib_list, next) { 186 fib = (struct rte_fib *)te->data; 187 if (strncmp(name, fib->name, RTE_FIB_NAMESIZE) == 0) 188 break; 189 } 190 fib = NULL; 191 if (te != NULL) { 192 rte_errno = EEXIST; 193 goto exit; 194 } 195 196 /* allocate tailq entry */ 197 te = rte_zmalloc("FIB_TAILQ_ENTRY", sizeof(*te), 0); 198 if (te == NULL) { 199 FIB_LOG(ERR, 200 "Can not allocate tailq entry for FIB %s", name); 201 rte_errno = ENOMEM; 202 goto exit; 203 } 204 205 /* Allocate memory to store the FIB data structures. */ 206 fib = rte_zmalloc_socket(mem_name, 207 sizeof(struct rte_fib), RTE_CACHE_LINE_SIZE, socket_id); 208 if (fib == NULL) { 209 FIB_LOG(ERR, "FIB %s memory allocation failed", name); 210 rte_errno = ENOMEM; 211 goto free_te; 212 } 213 214 rte_strlcpy(fib->name, name, sizeof(fib->name)); 215 fib->rib = rib; 216 fib->type = conf->type; 217 fib->def_nh = conf->default_nh; 218 ret = init_dataplane(fib, socket_id, conf); 219 if (ret < 0) { 220 FIB_LOG(ERR, 221 "FIB dataplane struct %s memory allocation failed " 222 "with err %d", name, ret); 223 rte_errno = -ret; 224 goto free_fib; 225 } 226 227 te->data = (void *)fib; 228 TAILQ_INSERT_TAIL(fib_list, te, next); 229 230 rte_mcfg_tailq_write_unlock(); 231 232 return fib; 233 234 free_fib: 235 rte_free(fib); 236 free_te: 237 rte_free(te); 238 exit: 239 rte_mcfg_tailq_write_unlock(); 240 rte_rib_free(rib); 241 242 return NULL; 243 } 244 245 struct rte_fib * 246 rte_fib_find_existing(const char *name) 247 { 248 struct rte_fib *fib = NULL; 249 struct rte_tailq_entry *te; 250 struct rte_fib_list *fib_list; 251 252 fib_list = RTE_TAILQ_CAST(rte_fib_tailq.head, rte_fib_list); 253 254 rte_mcfg_tailq_read_lock(); 255 TAILQ_FOREACH(te, fib_list, next) { 256 fib = (struct rte_fib *) te->data; 257 if (strncmp(name, fib->name, RTE_FIB_NAMESIZE) == 0) 258 break; 259 } 260 rte_mcfg_tailq_read_unlock(); 261 262 if (te == NULL) { 263 rte_errno = ENOENT; 264 return NULL; 265 } 266 267 return fib; 268 } 269 270 static void 271 free_dataplane(struct rte_fib *fib) 272 { 273 switch (fib->type) { 274 case RTE_FIB_DUMMY: 275 return; 276 case RTE_FIB_DIR24_8: 277 dir24_8_free(fib->dp); 278 default: 279 return; 280 } 281 } 282 283 void 284 rte_fib_free(struct rte_fib *fib) 285 { 286 struct rte_tailq_entry *te; 287 struct rte_fib_list *fib_list; 288 289 if (fib == NULL) 290 return; 291 292 fib_list = RTE_TAILQ_CAST(rte_fib_tailq.head, rte_fib_list); 293 294 rte_mcfg_tailq_write_lock(); 295 296 /* find our tailq entry */ 297 TAILQ_FOREACH(te, fib_list, next) { 298 if (te->data == (void *)fib) 299 break; 300 } 301 if (te != NULL) 302 TAILQ_REMOVE(fib_list, te, next); 303 304 rte_mcfg_tailq_write_unlock(); 305 306 free_dataplane(fib); 307 rte_rib_free(fib->rib); 308 rte_free(fib); 309 rte_free(te); 310 } 311 312 void * 313 rte_fib_get_dp(struct rte_fib *fib) 314 { 315 return (fib == NULL) ? NULL : fib->dp; 316 } 317 318 struct rte_rib * 319 rte_fib_get_rib(struct rte_fib *fib) 320 { 321 return (fib == NULL) ? NULL : fib->rib; 322 } 323 324 int 325 rte_fib_select_lookup(struct rte_fib *fib, 326 enum rte_fib_lookup_type type) 327 { 328 rte_fib_lookup_fn_t fn; 329 330 switch (fib->type) { 331 case RTE_FIB_DIR24_8: 332 fn = dir24_8_get_lookup_fn(fib->dp, type); 333 if (fn == NULL) 334 return -EINVAL; 335 fib->lookup = fn; 336 return 0; 337 default: 338 return -EINVAL; 339 } 340 } 341