X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_acl.c;h=6a032f9c03b7d449c00ae4d44342a8fd3a1bf17c;hb=cd1fd93090cdc085ef306d0935c000b30ff7032a;hp=2c84329f362a982dc1d76bb08e46d3ba4cc0628f;hpb=c1090bdee151a463a56899a450023d77b1e4a5f7;p=dpdk.git diff --git a/app/test/test_acl.c b/app/test/test_acl.c index 2c84329f36..6a032f9c03 100644 --- a/app/test/test_acl.c +++ b/app/test/test_acl.c @@ -1,13 +1,13 @@ /*- * BSD LICENSE - * + * * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. * All rights reserved. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: - * + * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright @@ -17,7 +17,7 @@ * * Neither the name of Intel Corporation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR @@ -34,12 +34,8 @@ #include #include -#include - #include "test.h" -#ifdef RTE_LIBRTE_ACL - #include #include #include @@ -68,7 +64,7 @@ struct rte_acl_ipv4vlan_rule acl_rule = { /* byteswap to cpu or network order */ static void -bswap_test_data(struct ipv4_7tuple * data, int len, int to_be) +bswap_test_data(struct ipv4_7tuple *data, int len, int to_be) { int i; @@ -82,8 +78,7 @@ bswap_test_data(struct ipv4_7tuple * data, int len, int to_be) data[i].port_src = rte_cpu_to_be_16(data[i].port_src); data[i].vlan = rte_cpu_to_be_16(data[i].vlan); data[i].domain = rte_cpu_to_be_16(data[i].domain); - } - else { + } else { data[i].ip_dst = rte_be_to_cpu_32(data[i].ip_dst); data[i].ip_src = rte_be_to_cpu_32(data[i].ip_src); data[i].port_dst = rte_be_to_cpu_16(data[i].port_dst); @@ -98,46 +93,12 @@ bswap_test_data(struct ipv4_7tuple * data, int len, int to_be) * Test scalar and SSE ACL lookup. */ static int -test_classify(void) +test_classify_run(struct rte_acl_ctx *acx) { - struct rte_acl_ctx * acx; int ret, i; uint32_t result, count; - uint32_t results[RTE_DIM(acl_test_data) * RTE_ACL_MAX_CATEGORIES]; - - const uint8_t * data[RTE_DIM(acl_test_data)]; - - const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = { - offsetof(struct ipv4_7tuple, proto), - offsetof(struct ipv4_7tuple, vlan), - offsetof(struct ipv4_7tuple, ip_src), - offsetof(struct ipv4_7tuple, ip_dst), - offsetof(struct ipv4_7tuple, port_src), - }; - - acx = rte_acl_create(&acl_param); - if (acx == NULL) { - printf("Line %i: Error creating ACL context!\n", __LINE__); - return -1; - } - - /* add rules to the context */ - ret = rte_acl_ipv4vlan_add_rules(acx, acl_test_rules, - RTE_DIM(acl_test_rules)); - if (ret != 0) { - printf("Line %i: Adding rules to ACL context failed!\n", __LINE__); - rte_acl_free(acx); - return -1; - } - - /* try building the context */ - ret = rte_acl_ipv4vlan_build(acx, layout, RTE_ACL_MAX_CATEGORIES); - if (ret != 0) { - printf("Line %i: Building ACL context failed!\n", __LINE__); - rte_acl_free(acx); - return -1; - } + const uint8_t *data[RTE_DIM(acl_test_data)]; /* swap all bytes in the data to network order */ bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 1); @@ -150,7 +111,7 @@ test_classify(void) * these will run quite a few times, it's necessary to test code paths * from num=0 to num>8 */ - for (count = 0; count < RTE_DIM(acl_test_data); count++) { + for (count = 0; count <= RTE_DIM(acl_test_data); count++) { ret = rte_acl_classify(acx, data, results, count, RTE_ACL_MAX_CATEGORIES); if (ret != 0) { @@ -160,12 +121,14 @@ test_classify(void) /* check if we allow everything we should allow */ for (i = 0; i < (int) count; i++) { - result = results[i * RTE_ACL_MAX_CATEGORIES + ACL_ALLOW]; + result = + results[i * RTE_ACL_MAX_CATEGORIES + ACL_ALLOW]; if (result != acl_test_data[i].allow) { printf("Line %i: Error in allow results at %i " - "(expected %"PRIu32" got %"PRIu32")!\n", - __LINE__, i, acl_test_data[i].allow, - result); + "(expected %"PRIu32" got %"PRIu32")!\n", + __LINE__, i, acl_test_data[i].allow, + result); + ret = -EINVAL; goto err; } } @@ -175,19 +138,21 @@ test_classify(void) result = results[i * RTE_ACL_MAX_CATEGORIES + ACL_DENY]; if (result != acl_test_data[i].deny) { printf("Line %i: Error in deny results at %i " - "(expected %"PRIu32" got %"PRIu32")!\n", - __LINE__, i, acl_test_data[i].deny, - result); + "(expected %"PRIu32" got %"PRIu32")!\n", + __LINE__, i, acl_test_data[i].deny, + result); + ret = -EINVAL; goto err; } } } /* make a quick check for scalar */ - ret = rte_acl_classify_scalar(acx, data, results, - RTE_DIM(acl_test_data), RTE_ACL_MAX_CATEGORIES); + ret = rte_acl_classify_alg(acx, data, results, + RTE_DIM(acl_test_data), RTE_ACL_MAX_CATEGORIES, + RTE_ACL_CLASSIFY_SCALAR); if (ret != 0) { - printf("Line %i: SSE classify failed!\n", __LINE__); + printf("Line %i: scalar classify failed!\n", __LINE__); goto err; } @@ -199,6 +164,7 @@ test_classify(void) "(expected %"PRIu32" got %"PRIu32")!\n", __LINE__, i, acl_test_data[i].allow, result); + ret = -EINVAL; goto err; } } @@ -211,25 +177,239 @@ test_classify(void) "(expected %"PRIu32" got %"PRIu32")!\n", __LINE__, i, acl_test_data[i].deny, result); + ret = -EINVAL; goto err; } } - /* free ACL context */ - rte_acl_free(acx); + ret = 0; +err: /* swap data back to cpu order so that next time tests don't fail */ bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 0); + return ret; +} + +static int +test_classify_buid(struct rte_acl_ctx *acx, + const struct rte_acl_ipv4vlan_rule *rules, uint32_t num) +{ + int ret; + const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = { + offsetof(struct ipv4_7tuple, proto), + offsetof(struct ipv4_7tuple, vlan), + offsetof(struct ipv4_7tuple, ip_src), + offsetof(struct ipv4_7tuple, ip_dst), + offsetof(struct ipv4_7tuple, port_src), + }; + + /* add rules to the context */ + ret = rte_acl_ipv4vlan_add_rules(acx, rules, num); + if (ret != 0) { + printf("Line %i: Adding rules to ACL context failed!\n", + __LINE__); + return ret; + } + + /* try building the context */ + ret = rte_acl_ipv4vlan_build(acx, layout, RTE_ACL_MAX_CATEGORIES); + if (ret != 0) { + printf("Line %i: Building ACL context failed!\n", __LINE__); + return ret; + } return 0; -err: +} - /* swap data back to cpu order so that next time tests don't fail */ - bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 0); +#define TEST_CLASSIFY_ITER 4 + +/* + * Test scalar and SSE ACL lookup. + */ +static int +test_classify(void) +{ + struct rte_acl_ctx *acx; + int i, ret; + + acx = rte_acl_create(&acl_param); + if (acx == NULL) { + printf("Line %i: Error creating ACL context!\n", __LINE__); + return -1; + } + + ret = 0; + for (i = 0; i != TEST_CLASSIFY_ITER; i++) { + + if ((i & 1) == 0) + rte_acl_reset(acx); + else + rte_acl_reset_rules(acx); + + ret = test_classify_buid(acx, acl_test_rules, + RTE_DIM(acl_test_rules)); + if (ret != 0) { + printf("Line %i, iter: %d: " + "Adding rules to ACL context failed!\n", + __LINE__, i); + break; + } + + ret = test_classify_run(acx); + if (ret != 0) { + printf("Line %i, iter: %d: %s failed!\n", + __LINE__, i, __func__); + break; + } + + /* reset rules and make sure that classify still works ok. */ + rte_acl_reset_rules(acx); + ret = test_classify_run(acx); + if (ret != 0) { + printf("Line %i, iter: %d: %s failed!\n", + __LINE__, i, __func__); + break; + } + } rte_acl_free(acx); + return ret; +} - return -1; +static int +test_build_ports_range(void) +{ + static const struct rte_acl_ipv4vlan_rule test_rules[] = { + { + /* match all packets. */ + .data = { + .userdata = 1, + .category_mask = ACL_ALLOW_MASK, + .priority = 101, + }, + .src_port_low = 0, + .src_port_high = UINT16_MAX, + .dst_port_low = 0, + .dst_port_high = UINT16_MAX, + }, + { + /* match all packets with dst ports [54-65280]. */ + .data = { + .userdata = 2, + .category_mask = ACL_ALLOW_MASK, + .priority = 102, + }, + .src_port_low = 0, + .src_port_high = UINT16_MAX, + .dst_port_low = 54, + .dst_port_high = 65280, + }, + { + /* match all packets with dst ports [0-52]. */ + .data = { + .userdata = 3, + .category_mask = ACL_ALLOW_MASK, + .priority = 103, + }, + .src_port_low = 0, + .src_port_high = UINT16_MAX, + .dst_port_low = 0, + .dst_port_high = 52, + }, + { + /* match all packets with dst ports [53]. */ + .data = { + .userdata = 4, + .category_mask = ACL_ALLOW_MASK, + .priority = 99, + }, + .src_port_low = 0, + .src_port_high = UINT16_MAX, + .dst_port_low = 53, + .dst_port_high = 53, + }, + { + /* match all packets with dst ports [65279-65535]. */ + .data = { + .userdata = 5, + .category_mask = ACL_ALLOW_MASK, + .priority = 98, + }, + .src_port_low = 0, + .src_port_high = UINT16_MAX, + .dst_port_low = 65279, + .dst_port_high = UINT16_MAX, + }, + }; + + static struct ipv4_7tuple test_data[] = { + { + .proto = 6, + .ip_src = IPv4(10, 1, 1, 1), + .ip_dst = IPv4(192, 168, 0, 33), + .port_dst = 53, + .allow = 1, + }, + { + .proto = 6, + .ip_src = IPv4(127, 84, 33, 1), + .ip_dst = IPv4(1, 2, 3, 4), + .port_dst = 65281, + .allow = 1, + }, + }; + + struct rte_acl_ctx *acx; + int32_t ret, i, j; + uint32_t results[RTE_DIM(test_data)]; + const uint8_t *data[RTE_DIM(test_data)]; + + acx = rte_acl_create(&acl_param); + if (acx == NULL) { + printf("Line %i: Error creating ACL context!\n", __LINE__); + return -1; + } + + /* swap all bytes in the data to network order */ + bswap_test_data(test_data, RTE_DIM(test_data), 1); + + /* store pointers to test data */ + for (i = 0; i != RTE_DIM(test_data); i++) + data[i] = (uint8_t *)&test_data[i]; + + for (i = 0; i != RTE_DIM(test_rules); i++) { + rte_acl_reset(acx); + ret = test_classify_buid(acx, test_rules, i + 1); + if (ret != 0) { + printf("Line %i, iter: %d: " + "Adding rules to ACL context failed!\n", + __LINE__, i); + break; + } + ret = rte_acl_classify(acx, data, results, + RTE_DIM(data), 1); + if (ret != 0) { + printf("Line %i, iter: %d: classify failed!\n", + __LINE__, i); + break; + } + + /* check results */ + for (j = 0; j != RTE_DIM(results); j++) { + if (results[j] != test_data[j].allow) { + printf("Line %i: Error in allow results at %i " + "(expected %"PRIu32" got %"PRIu32")!\n", + __LINE__, j, test_data[j].allow, + results[j]); + ret = -EINVAL; + } + } + } + + bswap_test_data(test_data, RTE_DIM(test_data), 0); + + rte_acl_free(acx); + return ret; } /* @@ -243,11 +423,11 @@ err: static int test_invalid_layout(void) { - struct rte_acl_ctx * acx; + struct rte_acl_ctx *acx; int ret, i; uint32_t results[RTE_DIM(invalid_layout_data)]; - const uint8_t * data[RTE_DIM(invalid_layout_data)]; + const uint8_t *data[RTE_DIM(invalid_layout_data)]; const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = { /* proto points to destination port's first byte */ @@ -259,7 +439,10 @@ test_invalid_layout(void) offsetof(struct ipv4_7tuple, ip_dst), offsetof(struct ipv4_7tuple, ip_src), - /* we can't swap ports here, so we will swap them in the data */ + /* + * we can't swap ports here, so we will swap + * them in the data + */ offsetof(struct ipv4_7tuple, port_src), }; @@ -276,7 +459,8 @@ test_invalid_layout(void) ret = rte_acl_ipv4vlan_add_rules(acx, invalid_layout_rules, RTE_DIM(invalid_layout_rules)); if (ret != 0) { - printf("Line %i: Adding rules to ACL context failed!\n", __LINE__); + printf("Line %i: Adding rules to ACL context failed!\n", + __LINE__); rte_acl_free(acx); return -1; } @@ -299,8 +483,8 @@ test_invalid_layout(void) } /* classify tuples */ - ret = rte_acl_classify(acx, data, results, - RTE_DIM(results), 1); + ret = rte_acl_classify_alg(acx, data, results, + RTE_DIM(results), 1, RTE_ACL_CLASSIFY_SCALAR); if (ret != 0) { printf("Line %i: SSE classify failed!\n", __LINE__); rte_acl_free(acx); @@ -309,15 +493,18 @@ test_invalid_layout(void) for (i = 0; i < (int) RTE_DIM(results); i++) { if (results[i] != invalid_layout_data[i].allow) { - printf("Line %i: Wrong results at %i (result=%u, should be %u)!\n", - __LINE__, i, results[i], invalid_layout_data[i].allow); + printf("Line %i: Wrong results at %i " + "(result=%u, should be %u)!\n", + __LINE__, i, results[i], + invalid_layout_data[i].allow); goto err; } } /* classify tuples (scalar) */ - ret = rte_acl_classify_scalar(acx, data, results, - RTE_DIM(results), 1); + ret = rte_acl_classify_alg(acx, data, results, RTE_DIM(results), 1, + RTE_ACL_CLASSIFY_SCALAR); + if (ret != 0) { printf("Line %i: Scalar classify failed!\n", __LINE__); rte_acl_free(acx); @@ -326,8 +513,10 @@ test_invalid_layout(void) for (i = 0; i < (int) RTE_DIM(results); i++) { if (results[i] != invalid_layout_data[i].allow) { - printf("Line %i: Wrong results at %i (result=%u, should be %u)!\n", - __LINE__, i, results[i], invalid_layout_data[i].allow); + printf("Line %i: Wrong results at %i " + "(result=%u, should be %u)!\n", + __LINE__, i, results[i], + invalid_layout_data[i].allow); goto err; } } @@ -355,13 +544,13 @@ static int test_create_find_add(void) { struct rte_acl_param param; - struct rte_acl_ctx * acx, *acx2, *tmp; + struct rte_acl_ctx *acx, *acx2, *tmp; struct rte_acl_ipv4vlan_rule rules[LEN]; const uint32_t layout[RTE_ACL_IPV4VLAN_NUM] = {0}; - const char * acx_name = "acx"; - const char * acx2_name = "acx2"; + const char *acx_name = "acx"; + const char *acx2_name = "acx2"; int i, ret; /* create two contexts */ @@ -387,8 +576,9 @@ test_create_find_add(void) param.name = acx_name; tmp = rte_acl_create(¶m); if (tmp != acx) { - printf("Line %i: Creating context with existing name test failed!\n", - __LINE__); + printf("Line %i: Creating context with existing name " + "test failed!\n", + __LINE__); if (tmp) rte_acl_free(tmp); goto err; @@ -397,8 +587,9 @@ test_create_find_add(void) param.name = acx2_name; tmp = rte_acl_create(¶m); if (tmp != acx2) { - printf("Line %i: Creating context with existing name test 2 failed!\n", - __LINE__); + printf("Line %i: Creating context with existing " + "name test 2 failed!\n", + __LINE__); if (tmp) rte_acl_free(tmp); goto err; @@ -444,9 +635,12 @@ test_create_find_add(void) /* create dummy acl */ for (i = 0; i < LEN; i++) { - memcpy(&rules[i], &acl_rule, sizeof(struct rte_acl_ipv4vlan_rule)); - rules[i].data.userdata = i + 1; /* skip zero */ - rules[i].data.category_mask = 1 << i; /* one rule per category */ + memcpy(&rules[i], &acl_rule, + sizeof(struct rte_acl_ipv4vlan_rule)); + /* skip zero */ + rules[i].data.userdata = i + 1; + /* one rule per category */ + rules[i].data.category_mask = 1 << i; } /* try filling up the context */ @@ -488,7 +682,7 @@ err: static int test_invalid_rules(void) { - struct rte_acl_ctx * acx; + struct rte_acl_ctx *acx; int ret; struct rte_acl_ipv4vlan_rule rule; @@ -591,7 +785,7 @@ static int test_invalid_parameters(void) { struct rte_acl_param param; - struct rte_acl_ctx * acx; + struct rte_acl_ctx *acx; struct rte_acl_ipv4vlan_rule rule; int result; @@ -620,8 +814,7 @@ test_invalid_parameters(void) printf("Line %i: ACL context creation with zero rule len " "failed!\n", __LINE__); return -1; - } - else + } else rte_acl_free(acx); /* zero max rule num */ @@ -633,8 +826,7 @@ test_invalid_parameters(void) printf("Line %i: ACL context creation with zero rule num " "failed!\n", __LINE__); return -1; - } - else + } else rte_acl_free(acx); /* invalid NUMA node */ @@ -707,7 +899,8 @@ test_invalid_parameters(void) /* zero count (should succeed) */ result = rte_acl_ipv4vlan_add_rules(acx, &rule, 0); if (result != 0) { - printf("Line %i: Adding 0 rules to ACL context failed!\n", __LINE__); + printf("Line %i: Adding 0 rules to ACL context failed!\n", + __LINE__); rte_acl_free(acx); return -1; } @@ -798,7 +991,8 @@ test_invalid_parameters(void) /* scalar classify test */ /* cover zero categories in classify (should not fail) */ - result = rte_acl_classify_scalar(acx, NULL, NULL, 0, 0); + result = rte_acl_classify_alg(acx, NULL, NULL, 0, 0, + RTE_ACL_CLASSIFY_SCALAR); if (result != 0) { printf("Line %i: Scalar classify with zero categories " "failed!\n", __LINE__); @@ -807,7 +1001,7 @@ test_invalid_parameters(void) } /* cover invalid but positive categories in classify */ - result = rte_acl_classify_scalar(acx, NULL, NULL, 0, 3); + result = rte_acl_classify(acx, NULL, NULL, 0, 3); if (result == 0) { printf("Line %i: Scalar classify with 3 categories " "should have failed!\n", __LINE__); @@ -837,7 +1031,7 @@ static int test_misc(void) { struct rte_acl_param param; - struct rte_acl_ctx * acx; + struct rte_acl_ctx *acx; /* create context */ memcpy(¶m, &acl_param, sizeof(param)); @@ -858,7 +1052,7 @@ test_misc(void) return 0; } -int +static int test_acl(void) { if (test_invalid_parameters() < 0) @@ -873,16 +1067,14 @@ test_acl(void) return -1; if (test_classify() < 0) return -1; + if (test_build_ports_range() < 0) + return -1; return 0; } -#else - -int -test_acl(void) -{ - printf("This binary was not compiled with ACL support!\n"); - return 0; -} -#endif /* RTE_LIBRTE_ACL */ +static struct test_command acl_cmd = { + .command = "acl_autotest", + .callback = test_acl, +}; +REGISTER_TEST_COMMAND(acl_cmd);