doc: remove release version from known issues
[dpdk.git] / app / test / test_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 <string.h>
35 #include <errno.h>
36
37 #include "test.h"
38
39 #include <rte_string_fns.h>
40 #include <rte_mbuf.h>
41 #include <rte_byteorder.h>
42 #include <rte_ip.h>
43 #include <rte_acl.h>
44 #include <rte_common.h>
45
46 #include "test_acl.h"
47
48 #define LEN RTE_ACL_MAX_CATEGORIES
49
50 struct rte_acl_param acl_param = {
51         .name = "acl_ctx",
52         .socket_id = SOCKET_ID_ANY,
53         .rule_size = RTE_ACL_IPV4VLAN_RULE_SZ,
54         .max_rule_num = 0x30000,
55 };
56
57 struct rte_acl_ipv4vlan_rule acl_rule = {
58                 .data = { .priority = 1, .category_mask = 0xff },
59                 .src_port_low = 0,
60                 .src_port_high = UINT16_MAX,
61                 .dst_port_low = 0,
62                 .dst_port_high = UINT16_MAX,
63 };
64
65 /* byteswap to cpu or network order */
66 static void
67 bswap_test_data(struct ipv4_7tuple *data, int len, int to_be)
68 {
69         int i;
70
71         for (i = 0; i < len; i++) {
72
73                 if (to_be) {
74                         /* swap all bytes so that they are in network order */
75                         data[i].ip_dst = rte_cpu_to_be_32(data[i].ip_dst);
76                         data[i].ip_src = rte_cpu_to_be_32(data[i].ip_src);
77                         data[i].port_dst = rte_cpu_to_be_16(data[i].port_dst);
78                         data[i].port_src = rte_cpu_to_be_16(data[i].port_src);
79                         data[i].vlan = rte_cpu_to_be_16(data[i].vlan);
80                         data[i].domain = rte_cpu_to_be_16(data[i].domain);
81                 } else {
82                         data[i].ip_dst = rte_be_to_cpu_32(data[i].ip_dst);
83                         data[i].ip_src = rte_be_to_cpu_32(data[i].ip_src);
84                         data[i].port_dst = rte_be_to_cpu_16(data[i].port_dst);
85                         data[i].port_src = rte_be_to_cpu_16(data[i].port_src);
86                         data[i].vlan = rte_be_to_cpu_16(data[i].vlan);
87                         data[i].domain = rte_be_to_cpu_16(data[i].domain);
88                 }
89         }
90 }
91
92 /*
93  * Test scalar and SSE ACL lookup.
94  */
95 static int
96 test_classify_run(struct rte_acl_ctx *acx)
97 {
98         int ret, i;
99         uint32_t result, count;
100         uint32_t results[RTE_DIM(acl_test_data) * RTE_ACL_MAX_CATEGORIES];
101         const uint8_t *data[RTE_DIM(acl_test_data)];
102
103         /* swap all bytes in the data to network order */
104         bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 1);
105
106         /* store pointers to test data */
107         for (i = 0; i < (int) RTE_DIM(acl_test_data); i++)
108                 data[i] = (uint8_t *)&acl_test_data[i];
109
110         /**
111          * these will run quite a few times, it's necessary to test code paths
112          * from num=0 to num>8
113          */
114         for (count = 0; count <= RTE_DIM(acl_test_data); count++) {
115                 ret = rte_acl_classify(acx, data, results,
116                                 count, RTE_ACL_MAX_CATEGORIES);
117                 if (ret != 0) {
118                         printf("Line %i: SSE classify failed!\n", __LINE__);
119                         goto err;
120                 }
121
122                 /* check if we allow everything we should allow */
123                 for (i = 0; i < (int) count; i++) {
124                         result =
125                                 results[i * RTE_ACL_MAX_CATEGORIES + ACL_ALLOW];
126                         if (result != acl_test_data[i].allow) {
127                                 printf("Line %i: Error in allow results at %i "
128                                         "(expected %"PRIu32" got %"PRIu32")!\n",
129                                         __LINE__, i, acl_test_data[i].allow,
130                                         result);
131                                 ret = -EINVAL;
132                                 goto err;
133                         }
134                 }
135
136                 /* check if we deny everything we should deny */
137                 for (i = 0; i < (int) count; i++) {
138                         result = results[i * RTE_ACL_MAX_CATEGORIES + ACL_DENY];
139                         if (result != acl_test_data[i].deny) {
140                                 printf("Line %i: Error in deny results at %i "
141                                         "(expected %"PRIu32" got %"PRIu32")!\n",
142                                         __LINE__, i, acl_test_data[i].deny,
143                                         result);
144                                 ret = -EINVAL;
145                                 goto err;
146                         }
147                 }
148         }
149
150         /* make a quick check for scalar */
151         ret = rte_acl_classify_alg(acx, data, results,
152                         RTE_DIM(acl_test_data), RTE_ACL_MAX_CATEGORIES,
153                         RTE_ACL_CLASSIFY_SCALAR);
154         if (ret != 0) {
155                 printf("Line %i: scalar classify failed!\n", __LINE__);
156                 goto err;
157         }
158
159         /* check if we allow everything we should allow */
160         for (i = 0; i < (int) RTE_DIM(acl_test_data); i++) {
161                 result = results[i * RTE_ACL_MAX_CATEGORIES + ACL_ALLOW];
162                 if (result != acl_test_data[i].allow) {
163                         printf("Line %i: Error in allow results at %i "
164                                         "(expected %"PRIu32" got %"PRIu32")!\n",
165                                         __LINE__, i, acl_test_data[i].allow,
166                                         result);
167                         ret = -EINVAL;
168                         goto err;
169                 }
170         }
171
172         /* check if we deny everything we should deny */
173         for (i = 0; i < (int) RTE_DIM(acl_test_data); i++) {
174                 result = results[i * RTE_ACL_MAX_CATEGORIES + ACL_DENY];
175                 if (result != acl_test_data[i].deny) {
176                         printf("Line %i: Error in deny results at %i "
177                                         "(expected %"PRIu32" got %"PRIu32")!\n",
178                                         __LINE__, i, acl_test_data[i].deny,
179                                         result);
180                         ret = -EINVAL;
181                         goto err;
182                 }
183         }
184
185         ret = 0;
186
187 err:
188         /* swap data back to cpu order so that next time tests don't fail */
189         bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 0);
190         return ret;
191 }
192
193 static int
194 test_classify_buid(struct rte_acl_ctx *acx)
195 {
196         int ret;
197         const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = {
198                         offsetof(struct ipv4_7tuple, proto),
199                         offsetof(struct ipv4_7tuple, vlan),
200                         offsetof(struct ipv4_7tuple, ip_src),
201                         offsetof(struct ipv4_7tuple, ip_dst),
202                         offsetof(struct ipv4_7tuple, port_src),
203         };
204
205         /* add rules to the context */
206         ret = rte_acl_ipv4vlan_add_rules(acx, acl_test_rules,
207                         RTE_DIM(acl_test_rules));
208         if (ret != 0) {
209                 printf("Line %i: Adding rules to ACL context failed!\n",
210                         __LINE__);
211                 return ret;
212         }
213
214         /* try building the context */
215         ret = rte_acl_ipv4vlan_build(acx, layout, RTE_ACL_MAX_CATEGORIES);
216         if (ret != 0) {
217                 printf("Line %i: Building ACL context failed!\n", __LINE__);
218                 return ret;
219         }
220
221         return 0;
222 }
223
224 #define TEST_CLASSIFY_ITER      4
225
226 /*
227  * Test scalar and SSE ACL lookup.
228  */
229 static int
230 test_classify(void)
231 {
232         struct rte_acl_ctx *acx;
233         int i, ret;
234
235         acx = rte_acl_create(&acl_param);
236         if (acx == NULL) {
237                 printf("Line %i: Error creating ACL context!\n", __LINE__);
238                 return -1;
239         }
240
241         ret = 0;
242         for (i = 0; i != TEST_CLASSIFY_ITER; i++) {
243
244                 if ((i & 1) == 0)
245                         rte_acl_reset(acx);
246                 else
247                         rte_acl_reset_rules(acx);
248
249                 ret = test_classify_buid(acx);
250                 if (ret != 0) {
251                         printf("Line %i, iter: %d: "
252                                 "Adding rules to ACL context failed!\n",
253                                 __LINE__, i);
254                         break;
255                 }
256
257                 ret = test_classify_run(acx);
258                 if (ret != 0) {
259                         printf("Line %i, iter: %d: %s failed!\n",
260                                 __LINE__, i, __func__);
261                         break;
262                 }
263
264                 /* reset rules and make sure that classify still works ok. */
265                 rte_acl_reset_rules(acx);
266                 ret = test_classify_run(acx);
267                 if (ret != 0) {
268                         printf("Line %i, iter: %d: %s failed!\n",
269                                 __LINE__, i, __func__);
270                         break;
271                 }
272         }
273
274         rte_acl_free(acx);
275         return ret;
276 }
277
278 /*
279  * Test wrong layout behavior
280  * This test supplies the ACL context with invalid layout, which results in
281  * ACL matching the wrong stuff. However, it should match the wrong stuff
282  * the right way. We switch around source and destination addresses,
283  * source and destination ports, and protocol will point to first byte of
284  * destination port.
285  */
286 static int
287 test_invalid_layout(void)
288 {
289         struct rte_acl_ctx *acx;
290         int ret, i;
291
292         uint32_t results[RTE_DIM(invalid_layout_data)];
293         const uint8_t *data[RTE_DIM(invalid_layout_data)];
294
295         const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = {
296                         /* proto points to destination port's first byte */
297                         offsetof(struct ipv4_7tuple, port_dst),
298
299                         0, /* VLAN not used */
300
301                         /* src and dst addresses are swapped */
302                         offsetof(struct ipv4_7tuple, ip_dst),
303                         offsetof(struct ipv4_7tuple, ip_src),
304
305                         /*
306                          * we can't swap ports here, so we will swap
307                          * them in the data
308                          */
309                         offsetof(struct ipv4_7tuple, port_src),
310         };
311
312         acx = rte_acl_create(&acl_param);
313         if (acx == NULL) {
314                 printf("Line %i: Error creating ACL context!\n", __LINE__);
315                 return -1;
316         }
317
318         /* putting a lot of rules into the context results in greater
319          * coverage numbers. it doesn't matter if they are identical */
320         for (i = 0; i < 1000; i++) {
321                 /* add rules to the context */
322                 ret = rte_acl_ipv4vlan_add_rules(acx, invalid_layout_rules,
323                                 RTE_DIM(invalid_layout_rules));
324                 if (ret != 0) {
325                         printf("Line %i: Adding rules to ACL context failed!\n",
326                                 __LINE__);
327                         rte_acl_free(acx);
328                         return -1;
329                 }
330         }
331
332         /* try building the context */
333         ret = rte_acl_ipv4vlan_build(acx, layout, 1);
334         if (ret != 0) {
335                 printf("Line %i: Building ACL context failed!\n", __LINE__);
336                 rte_acl_free(acx);
337                 return -1;
338         }
339
340         /* swap all bytes in the data to network order */
341         bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 1);
342
343         /* prepare data */
344         for (i = 0; i < (int) RTE_DIM(invalid_layout_data); i++) {
345                 data[i] = (uint8_t *)&invalid_layout_data[i];
346         }
347
348         /* classify tuples */
349         ret = rte_acl_classify_alg(acx, data, results,
350                         RTE_DIM(results), 1, RTE_ACL_CLASSIFY_SCALAR);
351         if (ret != 0) {
352                 printf("Line %i: SSE classify failed!\n", __LINE__);
353                 rte_acl_free(acx);
354                 return -1;
355         }
356
357         for (i = 0; i < (int) RTE_DIM(results); i++) {
358                 if (results[i] != invalid_layout_data[i].allow) {
359                         printf("Line %i: Wrong results at %i "
360                                 "(result=%u, should be %u)!\n",
361                                 __LINE__, i, results[i],
362                                 invalid_layout_data[i].allow);
363                         goto err;
364                 }
365         }
366
367         /* classify tuples (scalar) */
368         ret = rte_acl_classify_alg(acx, data, results, RTE_DIM(results), 1,
369                 RTE_ACL_CLASSIFY_SCALAR);
370
371         if (ret != 0) {
372                 printf("Line %i: Scalar classify failed!\n", __LINE__);
373                 rte_acl_free(acx);
374                 return -1;
375         }
376
377         for (i = 0; i < (int) RTE_DIM(results); i++) {
378                 if (results[i] != invalid_layout_data[i].allow) {
379                         printf("Line %i: Wrong results at %i "
380                                 "(result=%u, should be %u)!\n",
381                                 __LINE__, i, results[i],
382                                 invalid_layout_data[i].allow);
383                         goto err;
384                 }
385         }
386
387         rte_acl_free(acx);
388
389         /* swap data back to cpu order so that next time tests don't fail */
390         bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 0);
391
392         return 0;
393 err:
394
395         /* swap data back to cpu order so that next time tests don't fail */
396         bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 0);
397
398         rte_acl_free(acx);
399
400         return -1;
401 }
402
403 /*
404  * Test creating and finding ACL contexts, and adding rules
405  */
406 static int
407 test_create_find_add(void)
408 {
409         struct rte_acl_param param;
410         struct rte_acl_ctx *acx, *acx2, *tmp;
411         struct rte_acl_ipv4vlan_rule rules[LEN];
412
413         const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = {0};
414
415         const char *acx_name = "acx";
416         const char *acx2_name = "acx2";
417         int i, ret;
418
419         /* create two contexts */
420         memcpy(&param, &acl_param, sizeof(param));
421         param.max_rule_num = 2;
422
423         param.name = acx_name;
424         acx = rte_acl_create(&param);
425         if (acx == NULL) {
426                 printf("Line %i: Error creating %s!\n", __LINE__, acx_name);
427                 return -1;
428         }
429
430         param.name = acx2_name;
431         acx2 = rte_acl_create(&param);
432         if (acx2 == NULL || acx2 == acx) {
433                 printf("Line %i: Error creating %s!\n", __LINE__, acx2_name);
434                 rte_acl_free(acx);
435                 return -1;
436         }
437
438         /* try to create third one, with an existing name */
439         param.name = acx_name;
440         tmp = rte_acl_create(&param);
441         if (tmp != acx) {
442                 printf("Line %i: Creating context with existing name "
443                         "test failed!\n",
444                         __LINE__);
445                 if (tmp)
446                         rte_acl_free(tmp);
447                 goto err;
448         }
449
450         param.name = acx2_name;
451         tmp = rte_acl_create(&param);
452         if (tmp != acx2) {
453                 printf("Line %i: Creating context with existing "
454                         "name test 2 failed!\n",
455                         __LINE__);
456                 if (tmp)
457                         rte_acl_free(tmp);
458                 goto err;
459         }
460
461         /* try to find existing ACL contexts */
462         tmp = rte_acl_find_existing(acx_name);
463         if (tmp != acx) {
464                 printf("Line %i: Finding %s failed!\n", __LINE__, acx_name);
465                 if (tmp)
466                         rte_acl_free(tmp);
467                 goto err;
468         }
469
470         tmp = rte_acl_find_existing(acx2_name);
471         if (tmp != acx2) {
472                 printf("Line %i: Finding %s failed!\n", __LINE__, acx2_name);
473                 if (tmp)
474                         rte_acl_free(tmp);
475                 goto err;
476         }
477
478         /* try to find non-existing context */
479         tmp = rte_acl_find_existing("invalid");
480         if (tmp != NULL) {
481                 printf("Line %i: Non-existent ACL context found!\n", __LINE__);
482                 goto err;
483         }
484
485         /* free context */
486         rte_acl_free(acx);
487
488
489         /* create valid (but severely limited) acx */
490         memcpy(&param, &acl_param, sizeof(param));
491         param.max_rule_num = LEN;
492
493         acx = rte_acl_create(&param);
494         if (acx == NULL) {
495                 printf("Line %i: Error creating %s!\n", __LINE__, param.name);
496                 goto err;
497         }
498
499         /* create dummy acl */
500         for (i = 0; i < LEN; i++) {
501                 memcpy(&rules[i], &acl_rule,
502                         sizeof(struct rte_acl_ipv4vlan_rule));
503                 /* skip zero */
504                 rules[i].data.userdata = i + 1;
505                 /* one rule per category */
506                 rules[i].data.category_mask = 1 << i;
507         }
508
509         /* try filling up the context */
510         ret = rte_acl_ipv4vlan_add_rules(acx, rules, LEN);
511         if (ret != 0) {
512                 printf("Line %i: Adding %i rules to ACL context failed!\n",
513                                 __LINE__, LEN);
514                 goto err;
515         }
516
517         /* try adding to a (supposedly) full context */
518         ret = rte_acl_ipv4vlan_add_rules(acx, rules, 1);
519         if (ret == 0) {
520                 printf("Line %i: Adding rules to full ACL context should"
521                                 "have failed!\n", __LINE__);
522                 goto err;
523         }
524
525         /* try building the context */
526         ret = rte_acl_ipv4vlan_build(acx, layout, RTE_ACL_MAX_CATEGORIES);
527         if (ret != 0) {
528                 printf("Line %i: Building ACL context failed!\n", __LINE__);
529                 goto err;
530         }
531
532         rte_acl_free(acx);
533         rte_acl_free(acx2);
534
535         return 0;
536 err:
537         rte_acl_free(acx);
538         rte_acl_free(acx2);
539         return -1;
540 }
541
542 /*
543  * test various invalid rules
544  */
545 static int
546 test_invalid_rules(void)
547 {
548         struct rte_acl_ctx *acx;
549         int ret;
550
551         struct rte_acl_ipv4vlan_rule rule;
552
553         acx = rte_acl_create(&acl_param);
554         if (acx == NULL) {
555                 printf("Line %i: Error creating ACL context!\n", __LINE__);
556                 return -1;
557         }
558
559         /* test inverted high/low source and destination ports.
560          * originally, there was a problem with memory consumption when using
561          * such rules.
562          */
563         /* create dummy acl */
564         memcpy(&rule, &acl_rule, sizeof(struct rte_acl_ipv4vlan_rule));
565         rule.data.userdata = 1;
566         rule.dst_port_low = 0xfff0;
567         rule.dst_port_high = 0x0010;
568
569         /* add rules to context and try to build it */
570         ret = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
571         if (ret == 0) {
572                 printf("Line %i: Adding rules to ACL context "
573                                 "should have failed!\n", __LINE__);
574                 goto err;
575         }
576
577         rule.dst_port_low = 0x0;
578         rule.dst_port_high = 0xffff;
579         rule.src_port_low = 0xfff0;
580         rule.src_port_high = 0x0010;
581
582         /* add rules to context and try to build it */
583         ret = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
584         if (ret == 0) {
585                 printf("Line %i: Adding rules to ACL context "
586                                 "should have failed!\n", __LINE__);
587                 goto err;
588         }
589
590         rule.dst_port_low = 0x0;
591         rule.dst_port_high = 0xffff;
592         rule.src_port_low = 0x0;
593         rule.src_port_high = 0xffff;
594
595         rule.dst_mask_len = 33;
596
597         /* add rules to context and try to build it */
598         ret = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
599         if (ret == 0) {
600                 printf("Line %i: Adding rules to ACL context "
601                                 "should have failed!\n", __LINE__);
602                 goto err;
603         }
604
605         rule.dst_mask_len = 0;
606         rule.src_mask_len = 33;
607
608         /* add rules to context and try to build it */
609         ret = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
610         if (ret == 0) {
611                 printf("Line %i: Adding rules to ACL context "
612                                 "should have failed!\n", __LINE__);
613                 goto err;
614         }
615
616         rule.dst_mask_len = 0;
617         rule.src_mask_len = 0;
618         rule.data.userdata = 0;
619
620         /* try adding this rule (it should fail because userdata is invalid) */
621         ret = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
622         if (ret == 0) {
623                 printf("Line %i: Adding a rule with invalid user data "
624                                 "should have failed!\n", __LINE__);
625                 rte_acl_free(acx);
626                 return -1;
627         }
628
629         rte_acl_free(acx);
630
631         return 0;
632
633 err:
634         rte_acl_free(acx);
635
636         return -1;
637 }
638
639 /*
640  * test functions by passing invalid or
641  * non-workable parameters.
642  *
643  * we do very limited testing of classify functions here
644  * because those are performance-critical and
645  * thus don't do much parameter checking.
646  */
647 static int
648 test_invalid_parameters(void)
649 {
650         struct rte_acl_param param;
651         struct rte_acl_ctx *acx;
652         struct rte_acl_ipv4vlan_rule rule;
653         int result;
654
655         uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = {0};
656
657
658         /**
659          * rte_ac_create()
660          */
661
662         /* NULL param */
663         acx = rte_acl_create(NULL);
664         if (acx != NULL) {
665                 printf("Line %i: ACL context creation with NULL param "
666                                 "should have failed!\n", __LINE__);
667                 rte_acl_free(acx);
668                 return -1;
669         }
670
671         /* zero rule size */
672         memcpy(&param, &acl_param, sizeof(param));
673         param.rule_size = 0;
674
675         acx = rte_acl_create(&param);
676         if (acx == NULL) {
677                 printf("Line %i: ACL context creation with zero rule len "
678                                 "failed!\n", __LINE__);
679                 return -1;
680         } else
681                 rte_acl_free(acx);
682
683         /* zero max rule num */
684         memcpy(&param, &acl_param, sizeof(param));
685         param.max_rule_num = 0;
686
687         acx = rte_acl_create(&param);
688         if (acx == NULL) {
689                 printf("Line %i: ACL context creation with zero rule num "
690                                 "failed!\n", __LINE__);
691                 return -1;
692         } else
693                 rte_acl_free(acx);
694
695         /* invalid NUMA node */
696         memcpy(&param, &acl_param, sizeof(param));
697         param.socket_id = RTE_MAX_NUMA_NODES + 1;
698
699         acx = rte_acl_create(&param);
700         if (acx != NULL) {
701                 printf("Line %i: ACL context creation with invalid NUMA "
702                                 "should have failed!\n", __LINE__);
703                 rte_acl_free(acx);
704                 return -1;
705         }
706
707         /* NULL name */
708         memcpy(&param, &acl_param, sizeof(param));
709         param.name = NULL;
710
711         acx = rte_acl_create(&param);
712         if (acx != NULL) {
713                 printf("Line %i: ACL context creation with NULL name "
714                                 "should have failed!\n", __LINE__);
715                 rte_acl_free(acx);
716                 return -1;
717         }
718
719         /**
720          * rte_acl_find_existing
721          */
722
723         acx = rte_acl_find_existing(NULL);
724         if (acx != NULL) {
725                 printf("Line %i: NULL ACL context found!\n", __LINE__);
726                 rte_acl_free(acx);
727                 return -1;
728         }
729
730         /**
731          * rte_acl_ipv4vlan_add_rules
732          */
733
734         /* initialize everything */
735         memcpy(&param, &acl_param, sizeof(param));
736         acx = rte_acl_create(&param);
737         if (acx == NULL) {
738                 printf("Line %i: ACL context creation failed!\n", __LINE__);
739                 return -1;
740         }
741
742         memcpy(&rule, &acl_rule, sizeof(rule));
743
744         /* NULL context */
745         result = rte_acl_ipv4vlan_add_rules(NULL, &rule, 1);
746         if (result == 0) {
747                 printf("Line %i: Adding rules with NULL ACL context "
748                                 "should have failed!\n", __LINE__);
749                 rte_acl_free(acx);
750                 return -1;
751         }
752
753         /* NULL rule */
754         result = rte_acl_ipv4vlan_add_rules(acx, NULL, 1);
755         if (result == 0) {
756                 printf("Line %i: Adding NULL rule to ACL context "
757                                 "should have failed!\n", __LINE__);
758                 rte_acl_free(acx);
759                 return -1;
760         }
761
762         /* zero count (should succeed) */
763         result = rte_acl_ipv4vlan_add_rules(acx, &rule, 0);
764         if (result != 0) {
765                 printf("Line %i: Adding 0 rules to ACL context failed!\n",
766                         __LINE__);
767                 rte_acl_free(acx);
768                 return -1;
769         }
770
771         /* free ACL context */
772         rte_acl_free(acx);
773
774         /* set wrong rule_size so that adding any rules would fail */
775         param.rule_size = RTE_ACL_IPV4VLAN_RULE_SZ + 4;
776         acx = rte_acl_create(&param);
777         if (acx == NULL) {
778                 printf("Line %i: ACL context creation failed!\n", __LINE__);
779                 return -1;
780         }
781
782         /* try adding a rule with size different from context rule_size */
783         result = rte_acl_ipv4vlan_add_rules(acx, &rule, 1);
784         if (result == 0) {
785                 printf("Line %i: Adding an invalid sized rule "
786                                 "should have failed!\n", __LINE__);
787                 rte_acl_free(acx);
788                 return -1;
789         }
790
791         /* free ACL context */
792         rte_acl_free(acx);
793
794
795         /**
796          * rte_acl_ipv4vlan_build
797          */
798
799         /* reinitialize context */
800         memcpy(&param, &acl_param, sizeof(param));
801         acx = rte_acl_create(&param);
802         if (acx == NULL) {
803                 printf("Line %i: ACL context creation failed!\n", __LINE__);
804                 return -1;
805         }
806
807         /* NULL context */
808         result = rte_acl_ipv4vlan_build(NULL, layout, 1);
809         if (result == 0) {
810                 printf("Line %i: Building with NULL context "
811                                 "should have failed!\n", __LINE__);
812                 rte_acl_free(acx);
813                 return -1;
814         }
815
816         /* NULL layout */
817         result = rte_acl_ipv4vlan_build(acx, NULL, 1);
818         if (result == 0) {
819                 printf("Line %i: Building with NULL layout "
820                                 "should have failed!\n", __LINE__);
821                 rte_acl_free(acx);
822                 return -1;
823         }
824
825         /* zero categories (should not fail) */
826         result = rte_acl_ipv4vlan_build(acx, layout, 0);
827         if (result == 0) {
828                 printf("Line %i: Building with 0 categories should fail!\n",
829                         __LINE__);
830                 rte_acl_free(acx);
831                 return -1;
832         }
833
834         /* SSE classify test */
835
836         /* cover zero categories in classify (should not fail) */
837         result = rte_acl_classify(acx, NULL, NULL, 0, 0);
838         if (result != 0) {
839                 printf("Line %i: SSE classify with zero categories "
840                                 "failed!\n", __LINE__);
841                 rte_acl_free(acx);
842                 return -1;
843         }
844
845         /* cover invalid but positive categories in classify */
846         result = rte_acl_classify(acx, NULL, NULL, 0, 3);
847         if (result == 0) {
848                 printf("Line %i: SSE classify with 3 categories "
849                                 "should have failed!\n", __LINE__);
850                 rte_acl_free(acx);
851                 return -1;
852         }
853
854         /* scalar classify test */
855
856         /* cover zero categories in classify (should not fail) */
857         result = rte_acl_classify_alg(acx, NULL, NULL, 0, 0,
858                 RTE_ACL_CLASSIFY_SCALAR);
859         if (result != 0) {
860                 printf("Line %i: Scalar classify with zero categories "
861                                 "failed!\n", __LINE__);
862                 rte_acl_free(acx);
863                 return -1;
864         }
865
866         /* cover invalid but positive categories in classify */
867         result = rte_acl_classify(acx, NULL, NULL, 0, 3);
868         if (result == 0) {
869                 printf("Line %i: Scalar classify with 3 categories "
870                                 "should have failed!\n", __LINE__);
871                 rte_acl_free(acx);
872                 return -1;
873         }
874
875         /* free ACL context */
876         rte_acl_free(acx);
877
878
879         /**
880          * make sure void functions don't crash with NULL parameters
881          */
882
883         rte_acl_free(NULL);
884
885         rte_acl_dump(NULL);
886
887         return 0;
888 }
889
890 /**
891  * Various tests that don't test much but improve coverage
892  */
893 static int
894 test_misc(void)
895 {
896         struct rte_acl_param param;
897         struct rte_acl_ctx *acx;
898
899         /* create context */
900         memcpy(&param, &acl_param, sizeof(param));
901
902         acx = rte_acl_create(&param);
903         if (acx == NULL) {
904                 printf("Line %i: Error creating ACL context!\n", __LINE__);
905                 return -1;
906         }
907
908         /* dump context with rules - useful for coverage */
909         rte_acl_list_dump();
910
911         rte_acl_dump(acx);
912
913         rte_acl_free(acx);
914
915         return 0;
916 }
917
918 static int
919 test_acl(void)
920 {
921         if (test_invalid_parameters() < 0)
922                 return -1;
923         if (test_invalid_rules() < 0)
924                 return -1;
925         if (test_create_find_add() < 0)
926                 return -1;
927         if (test_invalid_layout() < 0)
928                 return -1;
929         if (test_misc() < 0)
930                 return -1;
931         if (test_classify() < 0)
932                 return -1;
933
934         return 0;
935 }
936
937 static struct test_command acl_cmd = {
938         .command = "acl_autotest",
939         .callback = test_acl,
940 };
941 REGISTER_TEST_COMMAND(acl_cmd);