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); 299