lib/librte_member/rte_member.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6
   7 #include <rte_string_fns.h>
   8 #include <rte_eal.h>
   9 #include <rte_eal_memconfig.h>
  10 #include <rte_memory.h>
  11 #include <rte_malloc.h>
  12 #include <rte_errno.h>
  13 #include <rte_tailq.h>
  14
  15 #include "rte_member.h"
  16 #include "rte_member_ht.h"
  17 #include "rte_member_vbf.h"
  18
  19 int librte_member_logtype;
  20
  21 TAILQ_HEAD(rte_member_list, rte_tailq_entry);
  22 static struct rte_tailq_elem rte_member_tailq = {
  23         .name = "RTE_MEMBER",
  24 };
  25 EAL_REGISTER_TAILQ(rte_member_tailq)
  26
  27 struct rte_member_setsum *
  28 rte_member_find_existing(const char *name)
  29 {
  30         struct rte_member_setsum *setsum = NULL;
  31         struct rte_tailq_entry *te;
  32         struct rte_member_list *member_list;
  33
  34         member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
  35
  36         rte_mcfg_tailq_read_lock();
  37         TAILQ_FOREACH(te, member_list, next) {
  38                 setsum = (struct rte_member_setsum *) te->data;
  39                 if (strncmp(name, setsum->name, RTE_MEMBER_NAMESIZE) == 0)
  40                         break;
  41         }
  42         rte_mcfg_tailq_read_unlock();
  43
  44         if (te == NULL) {
  45                 rte_errno = ENOENT;
  46                 return NULL;
  47         }
  48         return setsum;
  49 }
  50
  51 void
  52 rte_member_free(struct rte_member_setsum *setsum)
  53 {
  54         struct rte_member_list *member_list;
  55         struct rte_tailq_entry *te;
  56
  57         if (setsum == NULL)
  58                 return;
  59         member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
  60         rte_mcfg_tailq_write_lock();
  61         TAILQ_FOREACH(te, member_list, next) {
  62                 if (te->data == (void *)setsum)
  63                         break;
  64         }
  65         if (te == NULL) {
  66                 rte_mcfg_tailq_write_unlock();
  67                 return;
  68         }
  69         TAILQ_REMOVE(member_list, te, next);
  70         rte_mcfg_tailq_write_unlock();
  71
  72         switch (setsum->type) {
  73         case RTE_MEMBER_TYPE_HT:
  74                 rte_member_free_ht(setsum);
  75                 break;
  76         case RTE_MEMBER_TYPE_VBF:
  77                 rte_member_free_vbf(setsum);
  78                 break;
  79         default:
  80                 break;
  81         }
  82         rte_free(setsum);
  83         rte_free(te);
  84 }
  85
  86 struct rte_member_setsum *
  87 rte_member_create(const struct rte_member_parameters *params)
  88 {
  89         struct rte_tailq_entry *te;
  90         struct rte_member_list *member_list;
  91         struct rte_member_setsum *setsum;
  92         int ret;
  93
  94         if (params == NULL) {
  95                 rte_errno = EINVAL;
  96                 return NULL;
  97         }
  98
  99         if (params->key_len == 0 ||
 100                         params->prim_hash_seed == params->sec_hash_seed) {
 101                 rte_errno = EINVAL;
 102                 RTE_MEMBER_LOG(ERR, "Create setsummary with "
 103                                         "invalid parameters\n");
 104                 return NULL;
 105         }
 106
 107         member_list = RTE_TAILQ_CAST(rte_member_tailq.head, rte_member_list);
 108
 109         rte_mcfg_tailq_write_lock();
 110
 111         TAILQ_FOREACH(te, member_list, next) {
 112                 setsum = te->data;
 113                 if (strncmp(params->name, setsum->name,
 114                                 RTE_MEMBER_NAMESIZE) == 0)
 115                         break;
 116         }
 117         setsum = NULL;
 118         if (te != NULL) {
 119                 rte_errno = EEXIST;
 120                 te = NULL;
 121                 goto error_unlock_exit;
 122         }
 123         te = rte_zmalloc("MEMBER_TAILQ_ENTRY", sizeof(*te), 0);
 124         if (te == NULL) {
 125                 RTE_MEMBER_LOG(ERR, "tailq entry allocation failed\n");
 126                 goto error_unlock_exit;
 127         }
 128
 129         /* Create a new setsum structure */
 130         setsum = rte_zmalloc_socket(params->name,
 131                         sizeof(struct rte_member_setsum), RTE_CACHE_LINE_SIZE,
 132                         params->socket_id);
 133         if (setsum == NULL) {
 134                 RTE_MEMBER_LOG(ERR, "Create setsummary failed\n");
 135                 goto error_unlock_exit;
 136         }
 137         strlcpy(setsum->name, params->name, sizeof(setsum->name));
 138         setsum->type = params->type;
 139         setsum->socket_id = params->socket_id;
 140         setsum->key_len = params->key_len;
 141         setsum->num_set = params->num_set;
 142         setsum->prim_hash_seed = params->prim_hash_seed;
 143         setsum->sec_hash_seed = params->sec_hash_seed;
 144
 145         switch (setsum->type) {
 146         case RTE_MEMBER_TYPE_HT:
 147                 ret = rte_member_create_ht(setsum, params);
 148                 break;
 149         case RTE_MEMBER_TYPE_VBF:
 150                 ret = rte_member_create_vbf(setsum, params);
 151                 break;
 152         default:
 153                 goto error_unlock_exit;
 154         }
 155         if (ret < 0)
 156                 goto error_unlock_exit;
 157
 158         RTE_MEMBER_LOG(DEBUG, "Creating a setsummary table with "
 159                         "mode %u\n", setsum->type);
 160
 161         te->data = (void *)setsum;
 162         TAILQ_INSERT_TAIL(member_list, te, next);
 163         rte_mcfg_tailq_write_unlock();
 164         return setsum;
 165
 166 error_unlock_exit:
 167         rte_free(te);
 168         rte_free(setsum);
 169         rte_mcfg_tailq_write_unlock();
 170         return NULL;
 171 }
 172
 173 int
 174 rte_member_add(const struct rte_member_setsum *setsum, const void *key,
 175                         member_set_t set_id)
 176 {
 177         if (setsum == NULL || key == NULL)
 178                 return -EINVAL;
 179
 180         switch (setsum->type) {
 181         case RTE_MEMBER_TYPE_HT:
 182                 return rte_member_add_ht(setsum, key, set_id);
 183         case RTE_MEMBER_TYPE_VBF:
 184                 return rte_member_add_vbf(setsum, key, set_id);
 185         default:
 186                 return -EINVAL;
 187         }
 188 }
 189
 190 int
 191 rte_member_lookup(const struct rte_member_setsum *setsum, const void *key,
 192                         member_set_t *set_id)
 193 {
 194         if (setsum == NULL || key == NULL || set_id == NULL)
 195                 return -EINVAL;
 196
 197         switch (setsum->type) {
 198         case RTE_MEMBER_TYPE_HT:
 199                 return rte_member_lookup_ht(setsum, key, set_id);
 200         case RTE_MEMBER_TYPE_VBF:
 201                 return rte_member_lookup_vbf(setsum, key, set_id);
 202         default:
 203                 return -EINVAL;
 204         }
 205 }
 206
 207 int
 208 rte_member_lookup_bulk(const struct rte_member_setsum *setsum,
 209                                 const void **keys, uint32_t num_keys,
 210                                 member_set_t *set_ids)
 211 {
 212         if (setsum == NULL || keys == NULL || set_ids == NULL)
 213                 return -EINVAL;
 214
 215         switch (setsum->type) {
 216         case RTE_MEMBER_TYPE_HT:
 217                 return rte_member_lookup_bulk_ht(setsum, keys, num_keys,
 218                                 set_ids);
 219         case RTE_MEMBER_TYPE_VBF:
 220                 return rte_member_lookup_bulk_vbf(setsum, keys, num_keys,
 221                                 set_ids);
 222         default:
 223                 return -EINVAL;
 224         }
 225 }
 226
 227 int
 228 rte_member_lookup_multi(const struct rte_member_setsum *setsum, const void *key,
 229                                 uint32_t match_per_key, member_set_t *set_id)
 230 {
 231         if (setsum == NULL || key == NULL || set_id == NULL)
 232                 return -EINVAL;
 233
 234         switch (setsum->type) {
 235         case RTE_MEMBER_TYPE_HT:
 236                 return rte_member_lookup_multi_ht(setsum, key, match_per_key,
 237                                 set_id);
 238         case RTE_MEMBER_TYPE_VBF:
 239                 return rte_member_lookup_multi_vbf(setsum, key, match_per_key,
 240                                 set_id);
 241         default:
 242                 return -EINVAL;
 243         }
 244 }
 245
 246 int
 247 rte_member_lookup_multi_bulk(const struct rte_member_setsum *setsum,
 248                         const void **keys, uint32_t num_keys,
 249                         uint32_t max_match_per_key, uint32_t *match_count,
 250                         member_set_t *set_ids)
 251 {
 252         if (setsum == NULL || keys == NULL || set_ids == NULL ||
 253                         match_count == NULL)
 254                 return -EINVAL;
 255
 256         switch (setsum->type) {
 257         case RTE_MEMBER_TYPE_HT:
 258                 return rte_member_lookup_multi_bulk_ht(setsum, keys, num_keys,
 259                                 max_match_per_key, match_count, set_ids);
 260         case RTE_MEMBER_TYPE_VBF:
 261                 return rte_member_lookup_multi_bulk_vbf(setsum, keys, num_keys,
 262                                 max_match_per_key, match_count, set_ids);
 263         default:
 264                 return -EINVAL;
 265         }
 266 }
 267
 268 int
 269 rte_member_delete(const struct rte_member_setsum *setsum, const void *key,
 270                         member_set_t set_id)
 271 {
 272         if (setsum == NULL || key == NULL)
 273                 return -EINVAL;
 274
 275         switch (setsum->type) {
 276         case RTE_MEMBER_TYPE_HT:
 277                 return rte_member_delete_ht(setsum, key, set_id);
 278         /* current vBF implementation does not support delete function */
 279         case RTE_MEMBER_TYPE_VBF:
 280         default:
 281                 return -EINVAL;
 282         }
 283 }
 284
 285 void
 286 rte_member_reset(const struct rte_member_setsum *setsum)
 287 {
 288         if (setsum == NULL)
 289                 return;
 290         switch (setsum->type) {
 291         case RTE_MEMBER_TYPE_HT:
 292                 rte_member_reset_ht(setsum);
 293                 return;
 294         case RTE_MEMBER_TYPE_VBF:
 295                 rte_member_reset_vbf(setsum);
 296                 return;
 297         default:
 298                 return;
 299         }
 300 }
 301
 302 RTE_INIT(librte_member_init_log)
 303 {
 304         librte_member_logtype = rte_log_register("lib.member");
 305         if (librte_member_logtype >= 0)
 306                 rte_log_set_level(librte_member_logtype, RTE_LOG_DEBUG);
 307 }