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