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