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