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