1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <rte_acl.h> 35 #include "acl.h" 36 37 TAILQ_HEAD(rte_acl_list, rte_tailq_entry); 38 39 static struct rte_tailq_elem rte_acl_tailq = { 40 .name = "RTE_ACL", 41 }; 42 EAL_REGISTER_TAILQ(rte_acl_tailq) 43 44 /* 45 * If the compiler doesn't support AVX2 instructions, 46 * then the dummy one would be used instead for AVX2 classify method. 47 */ 48 int __attribute__ ((weak)) 49 rte_acl_classify_avx2(__rte_unused const struct rte_acl_ctx *ctx, 50 __rte_unused const uint8_t **data, 51 __rte_unused uint32_t *results, 52 __rte_unused uint32_t num, 53 __rte_unused uint32_t categories) 54 { 55 return -ENOTSUP; 56 } 57 58 int __attribute__ ((weak)) 59 rte_acl_classify_sse(__rte_unused const struct rte_acl_ctx *ctx, 60 __rte_unused const uint8_t **data, 61 __rte_unused uint32_t *results, 62 __rte_unused uint32_t num, 63 __rte_unused uint32_t categories) 64 { 65 return -ENOTSUP; 66 } 67 68 int __attribute__ ((weak)) 69 rte_acl_classify_neon(__rte_unused const struct rte_acl_ctx *ctx, 70 __rte_unused const uint8_t **data, 71 __rte_unused uint32_t *results, 72 __rte_unused uint32_t num, 73 __rte_unused uint32_t categories) 74 { 75 return -ENOTSUP; 76 } 77 78 int __attribute__ ((weak)) 79 rte_acl_classify_altivec(__rte_unused const struct rte_acl_ctx *ctx, 80 __rte_unused const uint8_t **data, 81 __rte_unused uint32_t *results, 82 __rte_unused uint32_t num, 83 __rte_unused uint32_t categories) 84 { 85 return -ENOTSUP; 86 } 87 88 static const rte_acl_classify_t classify_fns[] = { 89 [RTE_ACL_CLASSIFY_DEFAULT] = rte_acl_classify_scalar, 90 [RTE_ACL_CLASSIFY_SCALAR] = rte_acl_classify_scalar, 91 [RTE_ACL_CLASSIFY_SSE] = rte_acl_classify_sse, 92 [RTE_ACL_CLASSIFY_AVX2] = rte_acl_classify_avx2, 93 [RTE_ACL_CLASSIFY_NEON] = rte_acl_classify_neon, 94 [RTE_ACL_CLASSIFY_ALTIVEC] = rte_acl_classify_altivec, 95 }; 96 97 /* by default, use always available scalar code path. */ 98 static enum rte_acl_classify_alg rte_acl_default_classify = 99 RTE_ACL_CLASSIFY_SCALAR; 100 101 static void 102 rte_acl_set_default_classify(enum rte_acl_classify_alg alg) 103 { 104 rte_acl_default_classify = alg; 105 } 106 107 extern int 108 rte_acl_set_ctx_classify(struct rte_acl_ctx *ctx, enum rte_acl_classify_alg alg) 109 { 110 if (ctx == NULL || (uint32_t)alg >= RTE_DIM(classify_fns)) 111 return -EINVAL; 112 113 ctx->alg = alg; 114 return 0; 115 } 116 117 /* 118 * Select highest available classify method as default one. 119 * Note that CLASSIFY_AVX2 should be set as a default only 120 * if both conditions are met: 121 * at build time compiler supports AVX2 and target cpu supports AVX2. 122 */ 123 RTE_INIT(rte_acl_init) 124 { 125 enum rte_acl_classify_alg alg = RTE_ACL_CLASSIFY_DEFAULT; 126 127 #if defined(RTE_ARCH_ARM64) 128 alg = RTE_ACL_CLASSIFY_NEON; 129 #elif defined(RTE_ARCH_ARM) 130 if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_NEON)) 131 alg = RTE_ACL_CLASSIFY_NEON; 132 #elif defined(RTE_ARCH_PPC_64) 133 alg = RTE_ACL_CLASSIFY_ALTIVEC; 134 #else 135 #ifdef CC_AVX2_SUPPORT 136 if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2)) 137 alg = RTE_ACL_CLASSIFY_AVX2; 138 else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1)) 139 #else 140 if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1)) 141 #endif 142 alg = RTE_ACL_CLASSIFY_SSE; 143 144 #endif 145 rte_acl_set_default_classify(alg); 146 } 147 148 int 149 rte_acl_classify_alg(const struct rte_acl_ctx *ctx, const uint8_t **data, 150 uint32_t *results, uint32_t num, uint32_t categories, 151 enum rte_acl_classify_alg alg) 152 { 153 if (categories != 1 && 154 ((RTE_ACL_RESULTS_MULTIPLIER - 1) & categories) != 0) 155 return -EINVAL; 156 157 return classify_fns[alg](ctx, data, results, num, categories); 158 } 159 160 int 161 rte_acl_classify(const struct rte_acl_ctx *ctx, const uint8_t **data, 162 uint32_t *results, uint32_t num, uint32_t categories) 163 { 164 return rte_acl_classify_alg(ctx, data, results, num, categories, 165 ctx->alg); 166 } 167 168 struct rte_acl_ctx * 169 rte_acl_find_existing(const char *name) 170 { 171 struct rte_acl_ctx *ctx = NULL; 172 struct rte_acl_list *acl_list; 173 struct rte_tailq_entry *te; 174 175 acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list); 176 177 rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK); 178 TAILQ_FOREACH(te, acl_list, next) { 179 ctx = (struct rte_acl_ctx *) te->data; 180 if (strncmp(name, ctx->name, sizeof(ctx->name)) == 0) 181 break; 182 } 183 rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK); 184 185 if (te == NULL) { 186 rte_errno = ENOENT; 187 return NULL; 188 } 189 return ctx; 190 } 191 192 void 193 rte_acl_free(struct rte_acl_ctx *ctx) 194 { 195 struct rte_acl_list *acl_list; 196 struct rte_tailq_entry *te; 197 198 if (ctx == NULL) 199 return; 200 201 acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list); 202 203 rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); 204 205 /* find our tailq entry */ 206 TAILQ_FOREACH(te, acl_list, next) { 207 if (te->data == (void *) ctx) 208 break; 209 } 210 if (te == NULL) { 211 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); 212 return; 213 } 214 215 TAILQ_REMOVE(acl_list, te, next); 216 217 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); 218 219 rte_free(ctx->mem); 220 rte_free(ctx); 221 rte_free(te); 222 } 223 224 struct rte_acl_ctx * 225 rte_acl_create(const struct rte_acl_param *param) 226 { 227 size_t sz; 228 struct rte_acl_ctx *ctx; 229 struct rte_acl_list *acl_list; 230 struct rte_tailq_entry *te; 231 char name[sizeof(ctx->name)]; 232 233 acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list); 234 235 /* check that input parameters are valid. */ 236 if (param == NULL || param->name == NULL) { 237 rte_errno = EINVAL; 238 return NULL; 239 } 240 241 snprintf(name, sizeof(name), "ACL_%s", param->name); 242 243 /* calculate amount of memory required for pattern set. */ 244 sz = sizeof(*ctx) + param->max_rule_num * param->rule_size; 245 246 /* get EAL TAILQ lock. */ 247 rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); 248 249 /* if we already have one with that name */ 250 TAILQ_FOREACH(te, acl_list, next) { 251 ctx = (struct rte_acl_ctx *) te->data; 252 if (strncmp(param->name, ctx->name, sizeof(ctx->name)) == 0) 253 break; 254 } 255 256 /* if ACL with such name doesn't exist, then create a new one. */ 257 if (te == NULL) { 258 ctx = NULL; 259 te = rte_zmalloc("ACL_TAILQ_ENTRY", sizeof(*te), 0); 260 261 if (te == NULL) { 262 RTE_LOG(ERR, ACL, "Cannot allocate tailq entry!\n"); 263 goto exit; 264 } 265 266 ctx = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE, param->socket_id); 267 268 if (ctx == NULL) { 269 RTE_LOG(ERR, ACL, 270 "allocation of %zu bytes on socket %d for %s failed\n", 271 sz, param->socket_id, name); 272 rte_free(te); 273 goto exit; 274 } 275 /* init new allocated context. */ 276 ctx->rules = ctx + 1; 277 ctx->max_rules = param->max_rule_num; 278 ctx->rule_sz = param->rule_size; 279 ctx->socket_id = param->socket_id; 280 ctx->alg = rte_acl_default_classify; 281 snprintf(ctx->name, sizeof(ctx->name), "%s", param->name); 282 283 te->data = (void *) ctx; 284 285 TAILQ_INSERT_TAIL(acl_list, te, next); 286 } 287 288 exit: 289 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); 290 return ctx; 291 } 292 293 static int 294 acl_add_rules(struct rte_acl_ctx *ctx, const void *rules, uint32_t num) 295 { 296 uint8_t *pos; 297 298 if (num + ctx->num_rules > ctx->max_rules) 299 return -ENOMEM; 300 301 pos = ctx->rules; 302 pos += ctx->rule_sz * ctx->num_rules; 303 memcpy(pos, rules, num * ctx->rule_sz); 304 ctx->num_rules += num; 305 306 return 0; 307 } 308 309 static int 310 acl_check_rule(const struct rte_acl_rule_data *rd) 311 { 312 if ((RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES, typeof(rd->category_mask)) & 313 rd->category_mask) == 0 || 314 rd->priority > RTE_ACL_MAX_PRIORITY || 315 rd->priority < RTE_ACL_MIN_PRIORITY) 316 return -EINVAL; 317 return 0; 318 } 319 320 int 321 rte_acl_add_rules(struct rte_acl_ctx *ctx, const struct rte_acl_rule *rules, 322 uint32_t num) 323 { 324 const struct rte_acl_rule *rv; 325 uint32_t i; 326 int32_t rc; 327 328 if (ctx == NULL || rules == NULL || 0 == ctx->rule_sz) 329 return -EINVAL; 330 331 for (i = 0; i != num; i++) { 332 rv = (const struct rte_acl_rule *) 333 ((uintptr_t)rules + i * ctx->rule_sz); 334 rc = acl_check_rule(&rv->data); 335 if (rc != 0) { 336 RTE_LOG(ERR, ACL, "%s(%s): rule #%u is invalid\n", 337 __func__, ctx->name, i + 1); 338 return rc; 339 } 340 } 341 342 return acl_add_rules(ctx, rules, num); 343 } 344 345 /* 346 * Reset all rules. 347 * Note that RT structures are not affected. 348 */ 349 void 350 rte_acl_reset_rules(struct rte_acl_ctx *ctx) 351 { 352 if (ctx != NULL) 353 ctx->num_rules = 0; 354 } 355 356 /* 357 * Reset all rules and destroys RT structures. 358 */ 359 void 360 rte_acl_reset(struct rte_acl_ctx *ctx) 361 { 362 if (ctx != NULL) { 363 rte_acl_reset_rules(ctx); 364 rte_acl_build(ctx, &ctx->config); 365 } 366 } 367 368 /* 369 * Dump ACL context to the stdout. 370 */ 371 void 372 rte_acl_dump(const struct rte_acl_ctx *ctx) 373 { 374 if (!ctx) 375 return; 376 printf("acl context <%s>@%p\n", ctx->name, ctx); 377 printf(" socket_id=%"PRId32"\n", ctx->socket_id); 378 printf(" alg=%"PRId32"\n", ctx->alg); 379 printf(" max_rules=%"PRIu32"\n", ctx->max_rules); 380 printf(" rule_size=%"PRIu32"\n", ctx->rule_sz); 381 printf(" num_rules=%"PRIu32"\n", ctx->num_rules); 382 printf(" num_categories=%"PRIu32"\n", ctx->num_categories); 383 printf(" num_tries=%"PRIu32"\n", ctx->num_tries); 384 } 385 386 /* 387 * Dump all ACL contexts to the stdout. 388 */ 389 void 390 rte_acl_list_dump(void) 391 { 392 struct rte_acl_ctx *ctx; 393 struct rte_acl_list *acl_list; 394 struct rte_tailq_entry *te; 395 396 acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list); 397 398 rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK); 399 TAILQ_FOREACH(te, acl_list, next) { 400 ctx = (struct rte_acl_ctx *) te->data; 401 rte_acl_dump(ctx); 402 } 403 rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK); 404 } 405