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 #define BIT_SIZEOF(x)   (sizeof(x) * CHAR_BIT)
  38
  39 TAILQ_HEAD(rte_acl_list, rte_tailq_entry);
  40
  41 static struct rte_tailq_elem rte_acl_tailq = {
  42         .name = "RTE_ACL",
  43 };
  44 EAL_REGISTER_TAILQ(rte_acl_tailq)
  45
  46 /*
  47  * If the compiler doesn't support AVX2 instructions,
  48  * then the dummy one would be used instead for AVX2 classify method.
  49  */
  50 int __attribute__ ((weak))
  51 rte_acl_classify_avx2(__rte_unused const struct rte_acl_ctx *ctx,
  52         __rte_unused const uint8_t **data,
  53         __rte_unused uint32_t *results,
  54         __rte_unused uint32_t num,
  55         __rte_unused uint32_t categories)
  56 {
  57         return -ENOTSUP;
  58 }
  59
  60 static const rte_acl_classify_t classify_fns[] = {
  61         [RTE_ACL_CLASSIFY_DEFAULT] = rte_acl_classify_scalar,
  62         [RTE_ACL_CLASSIFY_SCALAR] = rte_acl_classify_scalar,
  63         [RTE_ACL_CLASSIFY_SSE] = rte_acl_classify_sse,
  64         [RTE_ACL_CLASSIFY_AVX2] = rte_acl_classify_avx2,
  65 };
  66
  67 /* by default, use always available scalar code path. */
  68 static enum rte_acl_classify_alg rte_acl_default_classify =
  69         RTE_ACL_CLASSIFY_SCALAR;
  70
  71 static void
  72 rte_acl_set_default_classify(enum rte_acl_classify_alg alg)
  73 {
  74         rte_acl_default_classify = alg;
  75 }
  76
  77 extern int
  78 rte_acl_set_ctx_classify(struct rte_acl_ctx *ctx, enum rte_acl_classify_alg alg)
  79 {
  80         if (ctx == NULL || (uint32_t)alg >= RTE_DIM(classify_fns))
  81                 return -EINVAL;
  82
  83         ctx->alg = alg;
  84         return 0;
  85 }
  86
  87 /*
  88  * Select highest available classify method as default one.
  89  * Note that CLASSIFY_AVX2 should be set as a default only
  90  * if both conditions are met:
  91  * at build time compiler supports AVX2 and target cpu supports AVX2.
  92  */
  93 static void __attribute__((constructor))
  94 rte_acl_init(void)
  95 {
  96         enum rte_acl_classify_alg alg = RTE_ACL_CLASSIFY_DEFAULT;
  97
  98 #ifdef CC_AVX2_SUPPORT
  99         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2))
 100                 alg = RTE_ACL_CLASSIFY_AVX2;
 101         else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
 102 #else
 103         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
 104 #endif
 105                 alg = RTE_ACL_CLASSIFY_SSE;
 106
 107         rte_acl_set_default_classify(alg);
 108 }
 109
 110 int
 111 rte_acl_classify_alg(const struct rte_acl_ctx *ctx, const uint8_t **data,
 112         uint32_t *results, uint32_t num, uint32_t categories,
 113         enum rte_acl_classify_alg alg)
 114 {
 115         if (categories != 1 &&
 116                         ((RTE_ACL_RESULTS_MULTIPLIER - 1) & categories) != 0)
 117                 return -EINVAL;
 118
 119         return classify_fns[alg](ctx, data, results, num, categories);
 120 }
 121
 122 int
 123 rte_acl_classify(const struct rte_acl_ctx *ctx, const uint8_t **data,
 124         uint32_t *results, uint32_t num, uint32_t categories)
 125 {
 126         return rte_acl_classify_alg(ctx, data, results, num, categories,
 127                 ctx->alg);
 128 }
 129
 130 struct rte_acl_ctx *
 131 rte_acl_find_existing(const char *name)
 132 {
 133         struct rte_acl_ctx *ctx = NULL;
 134         struct rte_acl_list *acl_list;
 135         struct rte_tailq_entry *te;
 136
 137         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 138
 139         rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
 140         TAILQ_FOREACH(te, acl_list, next) {
 141                 ctx = (struct rte_acl_ctx *) te->data;
 142                 if (strncmp(name, ctx->name, sizeof(ctx->name)) == 0)
 143                         break;
 144         }
 145         rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
 146
 147         if (te == NULL) {
 148                 rte_errno = ENOENT;
 149                 return NULL;
 150         }
 151         return ctx;
 152 }
 153
 154 void
 155 rte_acl_free(struct rte_acl_ctx *ctx)
 156 {
 157         struct rte_acl_list *acl_list;
 158         struct rte_tailq_entry *te;
 159
 160         if (ctx == NULL)
 161                 return;
 162
 163         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 164
 165         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 166
 167         /* find our tailq entry */
 168         TAILQ_FOREACH(te, acl_list, next) {
 169                 if (te->data == (void *) ctx)
 170                         break;
 171         }
 172         if (te == NULL) {
 173                 rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 174                 return;
 175         }
 176
 177         TAILQ_REMOVE(acl_list, te, next);
 178
 179         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 180
 181         rte_free(ctx->mem);
 182         rte_free(ctx);
 183         rte_free(te);
 184 }
 185
 186 struct rte_acl_ctx *
 187 rte_acl_create(const struct rte_acl_param *param)
 188 {
 189         size_t sz;
 190         struct rte_acl_ctx *ctx;
 191         struct rte_acl_list *acl_list;
 192         struct rte_tailq_entry *te;
 193         char name[sizeof(ctx->name)];
 194
 195         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 196
 197         /* check that input parameters are valid. */
 198         if (param == NULL || param->name == NULL) {
 199                 rte_errno = EINVAL;
 200                 return NULL;
 201         }
 202
 203         snprintf(name, sizeof(name), "ACL_%s", param->name);
 204
 205         /* calculate amount of memory required for pattern set. */
 206         sz = sizeof(*ctx) + param->max_rule_num * param->rule_size;
 207
 208         /* get EAL TAILQ lock. */
 209         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 210
 211         /* if we already have one with that name */
 212         TAILQ_FOREACH(te, acl_list, next) {
 213                 ctx = (struct rte_acl_ctx *) te->data;
 214                 if (strncmp(param->name, ctx->name, sizeof(ctx->name)) == 0)
 215                         break;
 216         }
 217
 218         /* if ACL with such name doesn't exist, then create a new one. */
 219         if (te == NULL) {
 220                 ctx = NULL;
 221                 te = rte_zmalloc("ACL_TAILQ_ENTRY", sizeof(*te), 0);
 222
 223                 if (te == NULL) {
 224                         RTE_LOG(ERR, ACL, "Cannot allocate tailq entry!\n");
 225                         goto exit;
 226                 }
 227
 228                 ctx = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE, param->socket_id);
 229
 230                 if (ctx == NULL) {
 231                         RTE_LOG(ERR, ACL,
 232                                 "allocation of %zu bytes on socket %d for %s failed\n",
 233                                 sz, param->socket_id, name);
 234                         rte_free(te);
 235                         goto exit;
 236                 }
 237                 /* init new allocated context. */
 238                 ctx->rules = ctx + 1;
 239                 ctx->max_rules = param->max_rule_num;
 240                 ctx->rule_sz = param->rule_size;
 241                 ctx->socket_id = param->socket_id;
 242                 ctx->alg = rte_acl_default_classify;
 243                 snprintf(ctx->name, sizeof(ctx->name), "%s", param->name);
 244
 245                 te->data = (void *) ctx;
 246
 247                 TAILQ_INSERT_TAIL(acl_list, te, next);
 248         }
 249
 250 exit:
 251         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 252         return ctx;
 253 }
 254
 255 static int
 256 acl_add_rules(struct rte_acl_ctx *ctx, const void *rules, uint32_t num)
 257 {
 258         uint8_t *pos;
 259
 260         if (num + ctx->num_rules > ctx->max_rules)
 261                 return -ENOMEM;
 262
 263         pos = ctx->rules;
 264         pos += ctx->rule_sz * ctx->num_rules;
 265         memcpy(pos, rules, num * ctx->rule_sz);
 266         ctx->num_rules += num;
 267
 268         return 0;
 269 }
 270
 271 static int
 272 acl_check_rule(const struct rte_acl_rule_data *rd)
 273 {
 274         if ((RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES, typeof(rd->category_mask)) &
 275                         rd->category_mask) == 0 ||
 276                         rd->priority > RTE_ACL_MAX_PRIORITY ||
 277                         rd->priority < RTE_ACL_MIN_PRIORITY ||
 278                         rd->userdata == RTE_ACL_INVALID_USERDATA)
 279                 return -EINVAL;
 280         return 0;
 281 }
 282
 283 int
 284 rte_acl_add_rules(struct rte_acl_ctx *ctx, const struct rte_acl_rule *rules,
 285         uint32_t num)
 286 {
 287         const struct rte_acl_rule *rv;
 288         uint32_t i;
 289         int32_t rc;
 290
 291         if (ctx == NULL || rules == NULL || 0 == ctx->rule_sz)
 292                 return -EINVAL;
 293
 294         for (i = 0; i != num; i++) {
 295                 rv = (const struct rte_acl_rule *)
 296                         ((uintptr_t)rules + i * ctx->rule_sz);
 297                 rc = acl_check_rule(&rv->data);
 298                 if (rc != 0) {
 299                         RTE_LOG(ERR, ACL, "%s(%s): rule #%u is invalid\n",
 300                                 __func__, ctx->name, i + 1);
 301                         return rc;
 302                 }
 303         }
 304
 305         return acl_add_rules(ctx, rules, num);
 306 }
 307
 308 /*
 309  * Reset all rules.
 310  * Note that RT structures are not affected.
 311  */
 312 void
 313 rte_acl_reset_rules(struct rte_acl_ctx *ctx)
 314 {
 315         if (ctx != NULL)
 316                 ctx->num_rules = 0;
 317 }
 318
 319 /*
 320  * Reset all rules and destroys RT structures.
 321  */
 322 void
 323 rte_acl_reset(struct rte_acl_ctx *ctx)
 324 {
 325         if (ctx != NULL) {
 326                 rte_acl_reset_rules(ctx);
 327                 rte_acl_build(ctx, &ctx->config);
 328         }
 329 }
 330
 331 /*
 332  * Dump ACL context to the stdout.
 333  */
 334 void
 335 rte_acl_dump(const struct rte_acl_ctx *ctx)
 336 {
 337         if (!ctx)
 338                 return;
 339         printf("acl context <%s>@%p\n", ctx->name, ctx);
 340         printf("  socket_id=%"PRId32"\n", ctx->socket_id);
 341         printf("  alg=%"PRId32"\n", ctx->alg);
 342         printf("  max_rules=%"PRIu32"\n", ctx->max_rules);
 343         printf("  rule_size=%"PRIu32"\n", ctx->rule_sz);
 344         printf("  num_rules=%"PRIu32"\n", ctx->num_rules);
 345         printf("  num_categories=%"PRIu32"\n", ctx->num_categories);
 346         printf("  num_tries=%"PRIu32"\n", ctx->num_tries);
 347 }
 348
 349 /*
 350  * Dump all ACL contexts to the stdout.
 351  */
 352 void
 353 rte_acl_list_dump(void)
 354 {
 355         struct rte_acl_ctx *ctx;
 356         struct rte_acl_list *acl_list;
 357         struct rte_tailq_entry *te;
 358
 359         acl_list = RTE_TAILQ_CAST(rte_acl_tailq.head, rte_acl_list);
 360
 361         rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
 362         TAILQ_FOREACH(te, acl_list, next) {
 363                 ctx = (struct rte_acl_ctx *) te->data;
 364                 rte_acl_dump(ctx);
 365         }
 366         rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
 367 }
 368
 369 /*
 370  * Support for legacy ipv4vlan rules.
 371  */
 372
 373 RTE_ACL_RULE_DEF(acl_ipv4vlan_rule, RTE_ACL_IPV4VLAN_NUM_FIELDS);
 374
 375 static int
 376 acl_ipv4vlan_check_rule(const struct rte_acl_ipv4vlan_rule *rule)
 377 {
 378         if (rule->src_port_low > rule->src_port_high ||
 379                         rule->dst_port_low > rule->dst_port_high ||
 380                         rule->src_mask_len > BIT_SIZEOF(rule->src_addr) ||
 381                         rule->dst_mask_len > BIT_SIZEOF(rule->dst_addr))
 382                 return -EINVAL;
 383
 384         return acl_check_rule(&rule->data);
 385 }
 386
 387 static void
 388 acl_ipv4vlan_convert_rule(const struct rte_acl_ipv4vlan_rule *ri,
 389         struct acl_ipv4vlan_rule *ro)
 390 {
 391         ro->data = ri->data;
 392
 393         ro->field[RTE_ACL_IPV4VLAN_PROTO_FIELD].value.u8 = ri->proto;
 394         ro->field[RTE_ACL_IPV4VLAN_VLAN1_FIELD].value.u16 = ri->vlan;
 395         ro->field[RTE_ACL_IPV4VLAN_VLAN2_FIELD].value.u16 = ri->domain;
 396         ro->field[RTE_ACL_IPV4VLAN_SRC_FIELD].value.u32 = ri->src_addr;
 397         ro->field[RTE_ACL_IPV4VLAN_DST_FIELD].value.u32 = ri->dst_addr;
 398         ro->field[RTE_ACL_IPV4VLAN_SRCP_FIELD].value.u16 = ri->src_port_low;
 399         ro->field[RTE_ACL_IPV4VLAN_DSTP_FIELD].value.u16 = ri->dst_port_low;
 400
 401         ro->field[RTE_ACL_IPV4VLAN_PROTO_FIELD].mask_range.u8 = ri->proto_mask;
 402         ro->field[RTE_ACL_IPV4VLAN_VLAN1_FIELD].mask_range.u16 = ri->vlan_mask;
 403         ro->field[RTE_ACL_IPV4VLAN_VLAN2_FIELD].mask_range.u16 =
 404                 ri->domain_mask;
 405         ro->field[RTE_ACL_IPV4VLAN_SRC_FIELD].mask_range.u32 =
 406                 ri->src_mask_len;
 407         ro->field[RTE_ACL_IPV4VLAN_DST_FIELD].mask_range.u32 = ri->dst_mask_len;
 408         ro->field[RTE_ACL_IPV4VLAN_SRCP_FIELD].mask_range.u16 =
 409                 ri->src_port_high;
 410         ro->field[RTE_ACL_IPV4VLAN_DSTP_FIELD].mask_range.u16 =
 411                 ri->dst_port_high;
 412 }
 413
 414 int
 415 rte_acl_ipv4vlan_add_rules(struct rte_acl_ctx *ctx,
 416         const struct rte_acl_ipv4vlan_rule *rules,
 417         uint32_t num)
 418 {
 419         int32_t rc;
 420         uint32_t i;
 421         struct acl_ipv4vlan_rule rv;
 422
 423         if (ctx == NULL || rules == NULL || ctx->rule_sz != sizeof(rv))
 424                 return -EINVAL;
 425
 426         /* check input rules. */
 427         for (i = 0; i != num; i++) {
 428                 rc = acl_ipv4vlan_check_rule(rules + i);
 429                 if (rc != 0) {
 430                         RTE_LOG(ERR, ACL, "%s(%s): rule #%u is invalid\n",
 431                                 __func__, ctx->name, i + 1);
 432                         return rc;
 433                 }
 434         }
 435
 436         if (num + ctx->num_rules > ctx->max_rules)
 437                 return -ENOMEM;
 438
 439         /* perform conversion to the internal format and add to the context. */
 440         for (i = 0, rc = 0; i != num && rc == 0; i++) {
 441                 acl_ipv4vlan_convert_rule(rules + i, &rv);
 442                 rc = acl_add_rules(ctx, &rv, 1);
 443         }
 444
 445         return rc;
 446 }
 447
 448 static void
 449 acl_ipv4vlan_config(struct rte_acl_config *cfg,
 450         const uint32_t layout[RTE_ACL_IPV4VLAN_NUM],
 451         uint32_t num_categories)
 452 {
 453         static const struct rte_acl_field_def
 454                 ipv4_defs[RTE_ACL_IPV4VLAN_NUM_FIELDS] = {
 455                 {
 456                         .type = RTE_ACL_FIELD_TYPE_BITMASK,
 457                         .size = sizeof(uint8_t),
 458                         .field_index = RTE_ACL_IPV4VLAN_PROTO_FIELD,
 459                         .input_index = RTE_ACL_IPV4VLAN_PROTO,
 460                 },
 461                 {
 462                         .type = RTE_ACL_FIELD_TYPE_BITMASK,
 463                         .size = sizeof(uint16_t),
 464                         .field_index = RTE_ACL_IPV4VLAN_VLAN1_FIELD,
 465                         .input_index = RTE_ACL_IPV4VLAN_VLAN,
 466                 },
 467                 {
 468                         .type = RTE_ACL_FIELD_TYPE_BITMASK,
 469                         .size = sizeof(uint16_t),
 470                         .field_index = RTE_ACL_IPV4VLAN_VLAN2_FIELD,
 471                         .input_index = RTE_ACL_IPV4VLAN_VLAN,
 472                 },
 473                 {
 474                         .type = RTE_ACL_FIELD_TYPE_MASK,
 475                         .size = sizeof(uint32_t),
 476                         .field_index = RTE_ACL_IPV4VLAN_SRC_FIELD,
 477                         .input_index = RTE_ACL_IPV4VLAN_SRC,
 478                 },
 479                 {
 480                         .type = RTE_ACL_FIELD_TYPE_MASK,
 481                         .size = sizeof(uint32_t),
 482                         .field_index = RTE_ACL_IPV4VLAN_DST_FIELD,
 483                         .input_index = RTE_ACL_IPV4VLAN_DST,
 484                 },
 485                 {
 486                         .type = RTE_ACL_FIELD_TYPE_RANGE,
 487                         .size = sizeof(uint16_t),
 488                         .field_index = RTE_ACL_IPV4VLAN_SRCP_FIELD,
 489                         .input_index = RTE_ACL_IPV4VLAN_PORTS,
 490                 },
 491                 {
 492                         .type = RTE_ACL_FIELD_TYPE_RANGE,
 493                         .size = sizeof(uint16_t),
 494                         .field_index = RTE_ACL_IPV4VLAN_DSTP_FIELD,
 495                         .input_index = RTE_ACL_IPV4VLAN_PORTS,
 496                 },
 497         };
 498
 499         memcpy(&cfg->defs, ipv4_defs, sizeof(ipv4_defs));
 500         cfg->num_fields = RTE_DIM(ipv4_defs);
 501
 502         cfg->defs[RTE_ACL_IPV4VLAN_PROTO_FIELD].offset =
 503                 layout[RTE_ACL_IPV4VLAN_PROTO];
 504         cfg->defs[RTE_ACL_IPV4VLAN_VLAN1_FIELD].offset =
 505                 layout[RTE_ACL_IPV4VLAN_VLAN];
 506         cfg->defs[RTE_ACL_IPV4VLAN_VLAN2_FIELD].offset =
 507                 layout[RTE_ACL_IPV4VLAN_VLAN] +
 508                 cfg->defs[RTE_ACL_IPV4VLAN_VLAN1_FIELD].size;
 509         cfg->defs[RTE_ACL_IPV4VLAN_SRC_FIELD].offset =
 510                 layout[RTE_ACL_IPV4VLAN_SRC];
 511         cfg->defs[RTE_ACL_IPV4VLAN_DST_FIELD].offset =
 512                 layout[RTE_ACL_IPV4VLAN_DST];
 513         cfg->defs[RTE_ACL_IPV4VLAN_SRCP_FIELD].offset =
 514                 layout[RTE_ACL_IPV4VLAN_PORTS];
 515         cfg->defs[RTE_ACL_IPV4VLAN_DSTP_FIELD].offset =
 516                 layout[RTE_ACL_IPV4VLAN_PORTS] +
 517                 cfg->defs[RTE_ACL_IPV4VLAN_SRCP_FIELD].size;
 518
 519         cfg->num_categories = num_categories;
 520 }
 521
 522 int
 523 rte_acl_ipv4vlan_build(struct rte_acl_ctx *ctx,
 524         const uint32_t layout[RTE_ACL_IPV4VLAN_NUM],
 525         uint32_t num_categories)
 526 {
 527         struct rte_acl_config cfg;
 528
 529         if (ctx == NULL || layout == NULL)
 530                 return -EINVAL;
 531
 532         memset(&cfg, 0, sizeof(cfg));
 533         acl_ipv4vlan_config(&cfg, layout, num_categories);
 534         return rte_acl_build(ctx, &cfg);
 535 }