/*-
* 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
* * 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
#include <string.h>
#include <errno.h>
-#include <cmdline_parse.h>
-
-#include <rte_string_fns.h>
-#include <rte_mbuf.h>
-
#include "test.h"
#ifdef RTE_LIBRTE_ACL
+#include <rte_string_fns.h>
+#include <rte_mbuf.h>
#include <rte_byteorder.h>
#include <rte_ip.h>
#include <rte_acl.h>
+#include <rte_common.h>
#include "test_acl.h"
struct rte_acl_param acl_param = {
.name = "acl_ctx",
.socket_id = SOCKET_ID_ANY,
- .rule_size = sizeof(struct rte_acl_ipv4vlan_rule),
+ .rule_size = RTE_ACL_IPV4VLAN_RULE_SZ,
.max_rule_num = 0x30000,
};
/* 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;
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);
* 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[DIM(acl_test_data) * RTE_ACL_MAX_CATEGORIES];
-
- const uint8_t * data[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,
- 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;
- }
+ uint32_t results[RTE_DIM(acl_test_data) * RTE_ACL_MAX_CATEGORIES];
+ const uint8_t *data[RTE_DIM(acl_test_data)];
/* swap all bytes in the data to network order */
- bswap_test_data(acl_test_data, DIM(acl_test_data), 1);
+ bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 1);
/* store pointers to test data */
- for (i = 0; i < (int) DIM(acl_test_data); i++)
+ for (i = 0; i < (int) RTE_DIM(acl_test_data); i++)
data[i] = (uint8_t *)&acl_test_data[i];
/**
* these will run quite a few times, it's necessary to test code paths
* from num=0 to num>8
*/
- for (count = 0; count < 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) {
/* 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);
goto err;
}
}
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);
goto err;
}
}
/* make a quick check for scalar */
ret = rte_acl_classify_scalar(acx, data, results,
- DIM(acl_test_data), RTE_ACL_MAX_CATEGORIES);
+ RTE_DIM(acl_test_data), RTE_ACL_MAX_CATEGORIES);
if (ret != 0) {
printf("Line %i: SSE classify failed!\n", __LINE__);
goto err;
}
/* check if we allow everything we should allow */
- for (i = 0; i < (int) DIM(acl_test_data); i++) {
+ for (i = 0; i < (int) RTE_DIM(acl_test_data); i++) {
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 "
}
/* check if we deny everything we should deny */
- for (i = 0; i < (int) DIM(acl_test_data); i++) {
+ for (i = 0; i < (int) RTE_DIM(acl_test_data); i++) {
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 "
}
}
- /* 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, DIM(acl_test_data), 0);
+ bswap_test_data(acl_test_data, RTE_DIM(acl_test_data), 0);
+ return ret;
+}
+
+static int
+test_classify_buid(struct rte_acl_ctx *acx)
+{
+ 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, acl_test_rules,
+ RTE_DIM(acl_test_rules));
+ 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, DIM(acl_test_data), 0);
+#define TEST_CLASSIFY_ITER 4
- rte_acl_free(acx);
+/*
+ * Test scalar and SSE ACL lookup.
+ */
+static int
+test_classify(void)
+{
+ struct rte_acl_ctx *acx;
+ int i, ret;
- return -1;
+ 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);
+ 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;
}
/*
static int
test_invalid_layout(void)
{
- struct rte_acl_ctx * acx;
+ struct rte_acl_ctx *acx;
int ret, i;
- uint32_t results[DIM(invalid_layout_data)];
- const uint8_t * data[DIM(invalid_layout_data)];
+ uint32_t results[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 */
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),
};
for (i = 0; i < 1000; i++) {
/* add rules to the context */
ret = rte_acl_ipv4vlan_add_rules(acx, invalid_layout_rules,
- DIM(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;
}
}
/* swap all bytes in the data to network order */
- bswap_test_data(invalid_layout_data, DIM(invalid_layout_data), 1);
+ bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 1);
/* prepare data */
- for (i = 0; i < (int) DIM(invalid_layout_data); i++) {
+ for (i = 0; i < (int) RTE_DIM(invalid_layout_data); i++) {
data[i] = (uint8_t *)&invalid_layout_data[i];
}
/* classify tuples */
ret = rte_acl_classify(acx, data, results,
- DIM(results), 1);
+ RTE_DIM(results), 1);
if (ret != 0) {
printf("Line %i: SSE classify failed!\n", __LINE__);
rte_acl_free(acx);
return -1;
}
- for (i = 0; i < (int) DIM(results); i++) {
+ 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,
- DIM(results), 1);
+ RTE_DIM(results), 1);
if (ret != 0) {
printf("Line %i: Scalar classify failed!\n", __LINE__);
rte_acl_free(acx);
return -1;
}
- for (i = 0; i < (int) DIM(results); i++) {
+ 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;
}
}
rte_acl_free(acx);
/* swap data back to cpu order so that next time tests don't fail */
- bswap_test_data(invalid_layout_data, DIM(invalid_layout_data), 0);
+ bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 0);
return 0;
err:
/* swap data back to cpu order so that next time tests don't fail */
- bswap_test_data(invalid_layout_data, DIM(invalid_layout_data), 0);
+ bswap_test_data(invalid_layout_data, RTE_DIM(invalid_layout_data), 0);
rte_acl_free(acx);
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 */
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;
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;
/* 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 */
static int
test_invalid_rules(void)
{
- struct rte_acl_ctx * acx;
+ struct rte_acl_ctx *acx;
int ret;
struct rte_acl_ipv4vlan_rule rule;
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;
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 */
printf("Line %i: ACL context creation with zero rule num "
"failed!\n", __LINE__);
return -1;
- }
- else
+ } else
rte_acl_free(acx);
/* invalid NUMA node */
/* 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;
}
rte_acl_free(acx);
/* set wrong rule_size so that adding any rules would fail */
- param.rule_size = sizeof(struct rte_acl_ipv4vlan_rule) + 4;
+ param.rule_size = RTE_ACL_IPV4VLAN_RULE_SZ + 4;
acx = rte_acl_create(¶m);
if (acx == NULL) {
printf("Line %i: ACL context creation failed!\n", __LINE__);
/* zero categories (should not fail) */
result = rte_acl_ipv4vlan_build(acx, layout, 0);
- if (result != 0) {
- printf("Line %i: Building with 0 categories failed!\n", __LINE__);
+ if (result == 0) {
+ printf("Line %i: Building with 0 categories should fail!\n",
+ __LINE__);
rte_acl_free(acx);
return -1;
}
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));
return 0;
}
-int
+static int
test_acl(void)
{
if (test_invalid_parameters() < 0)
return 0;
}
-#else
-
-int
-test_acl(void)
-{
- printf("This binary was not compiled with ACL support!\n");
- return 0;
-}
+static struct test_command acl_cmd = {
+ .command = "acl_autotest",
+ .callback = test_acl,
+};
+REGISTER_TEST_COMMAND(acl_cmd);
#endif /* RTE_LIBRTE_ACL */
git.droids-corp.org / dpdk.git / blobdiff