From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 71E55A2EEB for ; Wed, 11 Sep 2019 19:11:01 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 00C741E8F5; Wed, 11 Sep 2019 19:10:30 +0200 (CEST) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by dpdk.org (Postfix) with ESMTP id 06D0C1E88C for ; Wed, 11 Sep 2019 19:10:23 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Sep 2019 10:10:23 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,492,1559545200"; d="scan'208";a="196952208" Received: from silpixa00400072.ir.intel.com ([10.237.222.213]) by orsmga002.jf.intel.com with ESMTP; 11 Sep 2019 10:10:22 -0700 From: Vladimir Medvedkin To: dev@dpdk.org Cc: bruce.richardson@intel.com Date: Wed, 11 Sep 2019 18:09:44 +0100 Message-Id: <22cceeaa7b83e79beb01fa106929b8746684efb4.1568221363.git.vladimir.medvedkin@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: References: In-Reply-To: References: <1524780214-23196-1-git-send-email-medvedkinv@gmail.com> Subject: [dpdk-dev] [PATCH v5 04/12] test/rib: add ipv6 support for RIB autotests X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Functional tests for RIB6. Signed-off-by: Vladimir Medvedkin --- app/test/Makefile | 1 + app/test/autotest_data.py | 6 + app/test/meson.build | 2 + app/test/test_rib6.c | 357 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 366 insertions(+) create mode 100644 app/test/test_rib6.c diff --git a/app/test/Makefile b/app/test/Makefile index 5bd8487..4638426 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -125,6 +125,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_readwrite.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_readwrite_lf.c SRCS-$(CONFIG_RTE_LIBRTE_RIB) += test_rib.c +SRCS-$(CONFIG_RTE_LIBRTE_RIB) += test_rib6.c SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm.c SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm_perf.c diff --git a/app/test/autotest_data.py b/app/test/autotest_data.py index 3c3b806..f35b3cc 100644 --- a/app/test/autotest_data.py +++ b/app/test/autotest_data.py @@ -117,6 +117,12 @@ "Report": None, }, { + "Name": "RIB6 autotest", + "Command": "rib6_autotest", + "Func": default_autotest, + "Report": None, + }, + { "Name": "Memcpy autotest", "Command": "memcpy_autotest", "Func": default_autotest, diff --git a/app/test/meson.build b/app/test/meson.build index 98524e1..49c1de0 100644 --- a/app/test/meson.build +++ b/app/test/meson.build @@ -100,6 +100,7 @@ test_sources = files('commands.c', 'test_red.c', 'test_reorder.c', 'test_rib.c', + 'test_rib6.c', 'test_ring.c', 'test_ring_perf.c', 'test_rwlock.c', @@ -200,6 +201,7 @@ fast_test_names = [ 'rcu_qsbr_autotest', 'red_autotest', 'rib_autotest', + 'rib6_autotest', 'ring_autotest', 'ring_pmd_autotest', 'rwlock_test1_autotest', diff --git a/app/test/test_rib6.c b/app/test/test_rib6.c new file mode 100644 index 0000000..638ba68 --- /dev/null +++ b/app/test/test_rib6.c @@ -0,0 +1,357 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Vladimir Medvedkin + * Copyright(c) 2019 Intel Corporation + */ + +#include +#include +#include + +#include +#include + +#include "test.h" + +typedef int32_t (*rte_rib6_test)(void); + +static int32_t test_create_invalid(void); +static int32_t test_multiple_create(void); +static int32_t test_free_null(void); +static int32_t test_insert_invalid(void); +static int32_t test_get_fn(void); +static int32_t test_basic(void); +static int32_t test_tree_traversal(void); + +#define MAX_DEPTH 128 +#define MAX_RULES (1 << 22) + +/* + * Check that rte_rib6_create fails gracefully for incorrect user input + * arguments + */ +int32_t +test_create_invalid(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_conf config; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + /* rte_rib6_create: rib name == NULL */ + rib = rte_rib6_create(NULL, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib == NULL, + "Call succeeded with invalid parameters\n"); + + /* rte_rib6_create: config == NULL */ + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, NULL); + RTE_TEST_ASSERT(rib == NULL, + "Call succeeded with invalid parameters\n"); + + /* socket_id < -1 is invalid */ + rib = rte_rib6_create(__func__, -2, &config); + RTE_TEST_ASSERT(rib == NULL, + "Call succeeded with invalid parameters\n"); + + /* rte_rib6_create: max_nodes = 0 */ + config.max_nodes = 0; + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib == NULL, + "Call succeeded with invalid parameters\n"); + config.max_nodes = MAX_RULES; + + return TEST_SUCCESS; +} + +/* + * Create rib table then delete rib table 10 times + * Use a slightly different rules size each time + */ +int32_t +test_multiple_create(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_conf config; + int32_t i; + + config.ext_sz = 0; + + for (i = 0; i < 10; i++) { + config.max_nodes = MAX_RULES - i; + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + rte_rib6_free(rib); + } + /* Can not test free so return success */ + return TEST_SUCCESS; +} + +/* + * Call rte_rib6_free for NULL pointer user input. Note: free has no return and + * therefore it is impossible to check for failure but this test is added to + * increase function coverage metrics and to validate that freeing null does + * not crash. + */ +int32_t +test_free_null(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_conf config; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + + rte_rib6_free(rib); + rte_rib6_free(NULL); + return TEST_SUCCESS; +} + +/* + * Check that rte_rib6_insert fails gracefully + * for incorrect user input arguments + */ +int32_t +test_insert_invalid(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_node *node, *node1; + struct rte_rib6_conf config; + uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE] = {0}; + uint8_t depth = 24; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + /* rte_rib6_insert: rib == NULL */ + node = rte_rib6_insert(NULL, ip, depth); + RTE_TEST_ASSERT(node == NULL, + "Call succeeded with invalid parameters\n"); + + /*Create valid rib to use in rest of test. */ + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + + /* rte_rib6_insert: depth > MAX_DEPTH */ + node = rte_rib6_insert(rib, ip, MAX_DEPTH + 1); + RTE_TEST_ASSERT(node == NULL, + "Call succeeded with invalid parameters\n"); + + /* insert the same ip/depth twice*/ + node = rte_rib6_insert(rib, ip, depth); + RTE_TEST_ASSERT(node != NULL, "Failed to insert rule\n"); + node1 = rte_rib6_insert(rib, ip, depth); + RTE_TEST_ASSERT(node1 == NULL, + "Call succeeded with invalid parameters\n"); + + rte_rib6_free(rib); + + return TEST_SUCCESS; +} + +/* + * Call rte_rib6_node access functions with incorrect input. + * After call rte_rib6_node access functions with correct args + * and check the return values for correctness + */ +int32_t +test_get_fn(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_node *node; + struct rte_rib6_conf config; + void *ext; + uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE] = {192, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; + uint8_t ip_ret[RTE_RIB6_IPV6_ADDR_SIZE]; + uint64_t nh_set = 10; + uint64_t nh_ret; + uint8_t depth = 24; + uint8_t depth_ret; + int ret; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + + node = rte_rib6_insert(rib, ip, depth); + RTE_TEST_ASSERT(node != NULL, "Failed to insert rule\n"); + + /* test rte_rib6_get_ip() with incorrect args */ + ret = rte_rib6_get_ip(NULL, ip_ret); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + ret = rte_rib6_get_ip(node, NULL); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + + /* test rte_rib6_get_depth() with incorrect args */ + ret = rte_rib6_get_depth(NULL, &depth_ret); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + ret = rte_rib6_get_depth(node, NULL); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + + /* test rte_rib6_set_nh() with incorrect args */ + ret = rte_rib6_set_nh(NULL, nh_set); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + + /* test rte_rib6_get_nh() with incorrect args */ + ret = rte_rib6_get_nh(NULL, &nh_ret); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + ret = rte_rib6_get_nh(node, NULL); + RTE_TEST_ASSERT(ret < 0, + "Call succeeded with invalid parameters\n"); + + /* test rte_rib6_get_ext() with incorrect args */ + ext = rte_rib6_get_ext(NULL); + RTE_TEST_ASSERT(ext == NULL, + "Call succeeded with invalid parameters\n"); + + /* check the return values */ + ret = rte_rib6_get_ip(node, ip_ret); + RTE_TEST_ASSERT((ret == 0) && (rte_rib6_is_equal(ip_ret, ip)), + "Failed to get proper node ip\n"); + ret = rte_rib6_get_depth(node, &depth_ret); + RTE_TEST_ASSERT((ret == 0) && (depth_ret == depth), + "Failed to get proper node depth\n"); + ret = rte_rib6_set_nh(node, nh_set); + RTE_TEST_ASSERT(ret == 0, + "Failed to set rte_rib_node nexthop\n"); + ret = rte_rib6_get_nh(node, &nh_ret); + RTE_TEST_ASSERT((ret == 0) && (nh_ret == nh_set), + "Failed to get proper nexthop\n"); + + rte_rib6_free(rib); + + return TEST_SUCCESS; +} + +/* + * Call insert, lookup/lookup_exact and delete for a single rule + */ +int32_t +test_basic(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_node *node; + struct rte_rib6_conf config; + + uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE] = {192, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; + uint64_t next_hop_add = 10; + uint64_t next_hop_return; + uint8_t depth = 24; + uint32_t status = 0; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + + node = rte_rib6_insert(rib, ip, depth); + RTE_TEST_ASSERT(node != NULL, "Failed to insert rule\n"); + + status = rte_rib6_set_nh(node, next_hop_add); + RTE_TEST_ASSERT(status == 0, + "Failed to set rte_rib_node field\n"); + + node = rte_rib6_lookup(rib, ip); + RTE_TEST_ASSERT(node != NULL, "Failed to lookup\n"); + + status = rte_rib6_get_nh(node, &next_hop_return); + RTE_TEST_ASSERT((status == 0) && (next_hop_add == next_hop_return), + "Failed to get proper nexthop\n"); + + node = rte_rib6_lookup_exact(rib, ip, depth); + RTE_TEST_ASSERT(node != NULL, + "Failed to lookup\n"); + + status = rte_rib6_get_nh(node, &next_hop_return); + RTE_TEST_ASSERT((status == 0) && (next_hop_add == next_hop_return), + "Failed to get proper nexthop\n"); + + rte_rib6_remove(rib, ip, depth); + + node = rte_rib6_lookup(rib, ip); + RTE_TEST_ASSERT(node == NULL, + "Lookup returns non existent rule\n"); + node = rte_rib6_lookup_exact(rib, ip, depth); + RTE_TEST_ASSERT(node == NULL, + "Lookup returns non existent rule\n"); + + rte_rib6_free(rib); + + return TEST_SUCCESS; +} + +int32_t +test_tree_traversal(void) +{ + struct rte_rib6 *rib = NULL; + struct rte_rib6_node *node; + struct rte_rib6_conf config; + + uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE] = {10, 0, 2, 130, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; + uint8_t ip1[RTE_RIB6_IPV6_ADDR_SIZE] = {10, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; + uint8_t ip2[RTE_RIB6_IPV6_ADDR_SIZE] = {10, 0, 2, 130, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 80}; + uint8_t depth = 126; + + config.max_nodes = MAX_RULES; + config.ext_sz = 0; + + rib = rte_rib6_create(__func__, SOCKET_ID_ANY, &config); + RTE_TEST_ASSERT(rib != NULL, "Failed to create RIB\n"); + + node = rte_rib6_insert(rib, ip1, depth); + RTE_TEST_ASSERT(node != NULL, "Failed to insert rule\n"); + node = rte_rib6_insert(rib, ip2, depth); + RTE_TEST_ASSERT(node != NULL, "Failed to insert rule\n"); + + node = NULL; + node = rte_rib6_get_nxt(rib, ip, 32, node, RTE_RIB6_GET_NXT_ALL); + RTE_TEST_ASSERT(node != NULL, "Failed to get rib_node\n"); + + rte_rib6_free(rib); + + return TEST_SUCCESS; +} + +static struct unit_test_suite rib6_tests = { + .suite_name = "rib6 autotest", + .setup = NULL, + .teardown = NULL, + .unit_test_cases = { + TEST_CASE(test_create_invalid), + TEST_CASE(test_multiple_create), + TEST_CASE(test_free_null), + TEST_CASE(test_insert_invalid), + TEST_CASE(test_get_fn), + TEST_CASE(test_basic), + TEST_CASE(test_tree_traversal), + TEST_CASES_END() + } +}; + +/* + * Do all unit tests. + */ +static int +test_rib6(void) +{ + return unit_test_suite_runner(&rib6_tests); +} + +REGISTER_TEST_COMMAND(rib6_autotest, test_rib6); + -- 2.7.4