lib/librte_acl/rte_acl.c

   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 static void __attribute__((constructor))
 124 rte_acl_init(void)
 125 {
 126         enum rte_acl_classify_alg alg = RTE_ACL_CLASSIFY_DEFAULT;
 127
 128 #if defined(RTE_ARCH_ARM64)
 129         alg =  RTE_ACL_CLASSIFY_NEON;
 130 #elif defined(RTE_ARCH_ARM)
 131         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_NEON))
 132                 alg =  RTE_ACL_CLASSIFY_NEON;
 133 #elif defined(RTE_ARCH_PPC_64)
 134         alg = RTE_ACL_CLASSIFY_ALTIVEC;
 135 #else
 136 #ifdef CC_AVX2_SUPPORT
 137         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2))
 138                 alg = RTE_ACL_CLASSIFY_AVX2;
 139         else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
 140 #else
 141         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
 142 #endif
 143                 alg = RTE_ACL_CLASSIFY_SSE;
 144
 145 #endif
 146         rte_acl_set_default_classify(alg);
 147 }
 148
 149 int
 150 rte_acl_classify_alg(const struct rte_acl_ctx *ctx, const uint8_t **data,
 151         uint32_t *results, uint32_t num, uint32_t categories,
 152         enum rte_acl_classify_alg alg)
 153 {
 154         if (categories != 1 &&
 155                         ((RTE_ACL_RESULTS_MULTIPLIER - 1) & categories) != 0)
 156                 return -EINVAL;
 157
 158         return classify_fns[alg](ctx, data, results, num, categories);
 159 }
 160
 161 int
 162 rte_acl_classify(const struct rte_acl_ctx *ctx, const uint8_t **data,
 163         uint32_t *results, uint32_t num, uint32_t categories)
 164 {
 165         return rte_acl_classify_alg(ctx, data, results, num, categories,
 166                 ctx->alg);
 167 }
 168
 169 struct rte_acl_ctx *
 170 rte_acl_find_existing(const char *name)
 171 {
 172         struct rte_acl_ctx *ctx = NULL;
 173         struct rte_acl_list *acl_list;
 174         struct rte_tailq_entry *te;
 175
 176         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 177
 178         rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
 179         TAILQ_FOREACH(te, acl_list, next) {
 180                 ctx = (struct rte_acl_ctx *) te->data;
 181                 if (strncmp(name, ctx->name, sizeof(ctx->name)) == 0)
 182                         break;
 183         }
 184         rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
 185
 186         if (te == NULL) {
 187                 rte_errno = ENOENT;
 188                 return NULL;
 189         }
 190         return ctx;
 191 }
 192
 193 void
 194 rte_acl_free(struct rte_acl_ctx *ctx)
 195 {
 196         struct rte_acl_list *acl_list;
 197         struct rte_tailq_entry *te;
 198
 199         if (ctx == NULL)
 200                 return;
 201
 202         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 203
 204         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 205
 206         /* find our tailq entry */
 207         TAILQ_FOREACH(te, acl_list, next) {
 208                 if (te->data == (void *) ctx)
 209                         break;
 210         }
 211         if (te == NULL) {
 212                 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 213                 return;
 214         }
 215
 216         TAILQ_REMOVE(acl_list, te, next);
 217
 218         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 219
 220         rte_free(ctx->mem);
 221         rte_free(ctx);
 222         rte_free(te);
 223 }
 224
 225 struct rte_acl_ctx *
 226 rte_acl_create(const struct rte_acl_param *param)
 227 {
 228         size_t sz;
 229         struct rte_acl_ctx *ctx;
 230         struct rte_acl_list *acl_list;
 231         struct rte_tailq_entry *te;
 232         char name[sizeof(ctx->name)];
 233
 234         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 235
 236         /* check that input parameters are valid. */
 237         if (param == NULL || param->name == NULL) {
 238                 rte_errno = EINVAL;
 239                 return NULL;
 240         }
 241
 242         snprintf(name, sizeof(name), "ACL_%s", param->name);
 243
 244         /* calculate amount of memory required for pattern set. */
 245         sz = sizeof(*ctx) + param->max_rule_num * param->rule_size;
 246
 247         /* get EAL TAILQ lock. */
 248         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 249
 250         /* if we already have one with that name */
 251         TAILQ_FOREACH(te, acl_list, next) {
 252                 ctx = (struct rte_acl_ctx *) te->data;
 253                 if (strncmp(param->name, ctx->name, sizeof(ctx->name)) == 0)
 254                         break;
 255         }
 256
 257         /* if ACL with such name doesn't exist, then create a new one. */
 258         if (te == NULL) {
 259                 ctx = NULL;
 260                 te = rte_zmalloc("ACL_TAILQ_ENTRY", sizeof(*te), 0);
 261
 262                 if (te == NULL) {
 263                         RTE_LOG(ERR, ACL, "Cannot allocate tailq entry!\n");
 264                         goto exit;
 265                 }
 266
 267                 ctx = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE, param->socket_id);
 268
 269                 if (ctx == NULL) {
 270                         RTE_LOG(ERR, ACL,
 271                                 "allocation of %zu bytes on socket %d for %s failed\n",
 272                                 sz, param->socket_id, name);
 273                         rte_free(te);
 274                         goto exit;
 275                 }
 276                 /* init new allocated context. */
 277                 ctx->rules = ctx + 1;
 278                 ctx->max_rules = param->max_rule_num;
 279                 ctx->rule_sz = param->rule_size;
 280                 ctx->socket_id = param->socket_id;
 281                 ctx->alg = rte_acl_default_classify;
 282                 snprintf(ctx->name, sizeof(ctx->name), "%s", param->name);
 283
 284                 te->data = (void *) ctx;
 285
 286                 TAILQ_INSERT_TAIL(acl_list, te, next);
 287         }
 288
 289 exit:
 290         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 291         return ctx;
 292 }
 293
 294 static int
 295 acl_add_rules(struct rte_acl_ctx *ctx, const void *rules, uint32_t num)
 296 {
 297         uint8_t *pos;
 298
 299         if (num + ctx->num_rules > ctx->max_rules)
 300                 return -ENOMEM;
 301
 302         pos = ctx->rules;
 303         pos += ctx->rule_sz * ctx->num_rules;
 304         memcpy(pos, rules, num * ctx->rule_sz);
 305         ctx->num_rules += num;
 306
 307         return 0;
 308 }
 309
 310 static int
 311 acl_check_rule(const struct rte_acl_rule_data *rd)
 312 {
 313         if ((RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES, typeof(rd->category_mask)) &
 314                         rd->category_mask) == 0 ||
 315                         rd->priority > RTE_ACL_MAX_PRIORITY ||
 316                         rd->priority < RTE_ACL_MIN_PRIORITY ||
 317                         rd->userdata == RTE_ACL_INVALID_USERDATA)
 318                 return -EINVAL;
 319         return 0;
 320 }
 321
 322 int
 323 rte_acl_add_rules(struct rte_acl_ctx *ctx, const struct rte_acl_rule *rules,
 324         uint32_t num)
 325 {
 326         const struct rte_acl_rule *rv;
 327         uint32_t i;
 328         int32_t rc;
 329
 330         if (ctx == NULL || rules == NULL || 0 == ctx->rule_sz)
 331                 return -EINVAL;
 332
 333         for (i = 0; i != num; i++) {
 334                 rv = (const struct rte_acl_rule *)
 335                         ((uintptr_t)rules + i * ctx->rule_sz);
 336                 rc = acl_check_rule(&rv->data);
 337                 if (rc != 0) {
 338                         RTE_LOG(ERR, ACL, "%s(%s): rule #%u is invalid\n",
 339                                 __func__, ctx->name, i + 1);
 340                         return rc;
 341                 }
 342         }
 343
 344         return acl_add_rules(ctx, rules, num);
 345 }
 346
 347 /*
 348  * Reset all rules.
 349  * Note that RT structures are not affected.
 350  */
 351 void
 352 rte_acl_reset_rules(struct rte_acl_ctx *ctx)
 353 {
 354         if (ctx != NULL)
 355                 ctx->num_rules = 0;
 356 }
 357
 358 /*
 359  * Reset all rules and destroys RT structures.
 360  */
 361 void
 362 rte_acl_reset(struct rte_acl_ctx *ctx)
 363 {
 364         if (ctx != NULL) {
 365                 rte_acl_reset_rules(ctx);
 366                 rte_acl_build(ctx, &ctx->config);
 367         }
 368 }
 369
 370 /*
 371  * Dump ACL context to the stdout.
 372  */
 373 void
 374 rte_acl_dump(const struct rte_acl_ctx *ctx)
 375 {
 376         if (!ctx)
 377                 return;
 378         printf("acl context <%s>@%p\n", ctx->name, ctx);
 379         printf("  socket_id=%"PRId32"\n", ctx->socket_id);
 380         printf("  alg=%"PRId32"\n", ctx->alg);
 381         printf("  max_rules=%"PRIu32"\n", ctx->max_rules);
 382         printf("  rule_size=%"PRIu32"\n", ctx->rule_sz);
 383         printf("  num_rules=%"PRIu32"\n", ctx->num_rules);
 384         printf("  num_categories=%"PRIu32"\n", ctx->num_categories);
 385         printf("  num_tries=%"PRIu32"\n", ctx->num_tries);
 386 }
 387
 388 /*
 389  * Dump all ACL contexts to the stdout.
 390  */
 391 void
 392 rte_acl_list_dump(void)
 393 {
 394         struct rte_acl_ctx *ctx;
 395         struct rte_acl_list *acl_list;
 396         struct rte_tailq_entry *te;
 397
 398         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 399
 400         rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
 401         TAILQ_FOREACH(te, acl_list, next) {
 402                 ctx = (struct rte_acl_ctx *) te->data;
 403                 rte_acl_dump(ctx);
 404         }
 405         rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
 406 }