doc: move FAQ
[dpdk.git] / 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 }