d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
e83d41f069
numam-dpdk/app/test/test_lpm.c
Jie Zhou 3c60274c09 test: skip unsupported tests on Windows 
Skip tests which are not yet supported for Windows:
- The libraries that tests depend on are not enabled on Windows yet
- The tests can compile but with issue still under investigation
    * test_func_reentrancy:
      Windows EAL has no protection against repeated calls.
    * test_lcores:
      Execution enters an infinite loops, requires investigation.
    * test_rcu_qsbr_perf:
      Execution hangs on Windows, requires investigation.

Signed-off-by: Jie Zhou <jizh@linux.microsoft.com>
Signed-off-by: Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>
Acked-by: Tyler Retzlaff <roretzla@linux.microsoft.com>
2022-02-08 14:19:40 +01:00

1601 lines
39 KiB
C
Raw Blame History

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2014 Intel Corporation
*/
#include "test.h"
#ifdef RTE_EXEC_ENV_WINDOWS
static int
test_lpm(void)
{
printf("lpm not supported on Windows, skipping test\n");
return TEST_SKIPPED;
}
#else
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <rte_ip.h>
#include <rte_lpm.h>
#include <rte_malloc.h>
#include "test_xmmt_ops.h"
#define TEST_LPM_ASSERT(cond) do { \
if (!(cond)) { \
printf("Error at line %d: \n", __LINE__); \
return -1; \
} \
} while(0)
typedef int32_t (*rte_lpm_test)(void);
static int32_t test0(void);
static int32_t test1(void);
static int32_t test2(void);
static int32_t test3(void);
static int32_t test4(void);
static int32_t test5(void);
static int32_t test6(void);
static int32_t test7(void);
static int32_t test8(void);
static int32_t test9(void);
static int32_t test10(void);
static int32_t test11(void);
static int32_t test12(void);
static int32_t test13(void);
static int32_t test14(void);
static int32_t test15(void);
static int32_t test16(void);
static int32_t test17(void);
static int32_t test18(void);
static int32_t test19(void);
static int32_t test20(void);
static int32_t test21(void);
rte_lpm_test tests[] = {
/* Test Cases */
test0,
test1,
test2,
test3,
test4,
test5,
test6,
test7,
test8,
test9,
test10,
test11,
test12,
test13,
test14,
test15,
test16,
test17,
test18,
test19,
test20,
test21
};
#define MAX_DEPTH 32
#define MAX_RULES 256
#define NUMBER_TBL8S 256
#define PASS 0
/*
* Check that rte_lpm_create fails gracefully for incorrect user input
* arguments
*/
int32_t
test0(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
/* rte_lpm_create: lpm name == NULL */
lpm = rte_lpm_create(NULL, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm == NULL);
/* rte_lpm_create: max_rules = 0 */
/* Note: __func__ inserts the function name, in this case "test0". */
config.max_rules = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm == NULL);
/* socket_id < -1 is invalid */
config.max_rules = MAX_RULES;
lpm = rte_lpm_create(__func__, -2, &config);
TEST_LPM_ASSERT(lpm == NULL);
return PASS;
}
/*
* Create lpm table then delete lpm table 100 times
* Use a slightly different rules size each time
* */
int32_t
test1(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
int32_t i;
/* rte_lpm_free: Free NULL */
for (i = 0; i < 100; i++) {
config.max_rules = MAX_RULES - i;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
rte_lpm_free(lpm);
}
/* Can not test free so return success */
return PASS;
}
/*
* Call rte_lpm_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
test2(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
rte_lpm_free(lpm);
rte_lpm_free(NULL);
return PASS;
}
/*
* Check that rte_lpm_add fails gracefully for incorrect user input arguments
*/
int32_t
test3(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop = 100;
uint8_t depth = 24;
int32_t status = 0;
/* rte_lpm_add: lpm == NULL */
status = rte_lpm_add(NULL, ip, depth, next_hop);
TEST_LPM_ASSERT(status < 0);
/*Create valid lpm to use in rest of test. */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* rte_lpm_add: depth < 1 */
status = rte_lpm_add(lpm, ip, 0, next_hop);
TEST_LPM_ASSERT(status < 0);
/* rte_lpm_add: depth > MAX_DEPTH */
status = rte_lpm_add(lpm, ip, (MAX_DEPTH + 1), next_hop);
TEST_LPM_ASSERT(status < 0);
rte_lpm_free(lpm);
return PASS;
}
/*
* Check that rte_lpm_delete fails gracefully for incorrect user input
* arguments
*/
int32_t
test4(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip = RTE_IPV4(0, 0, 0, 0);
uint8_t depth = 24;
int32_t status = 0;
/* rte_lpm_delete: lpm == NULL */
status = rte_lpm_delete(NULL, ip, depth);
TEST_LPM_ASSERT(status < 0);
/*Create valid lpm to use in rest of test. */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* rte_lpm_delete: depth < 1 */
status = rte_lpm_delete(lpm, ip, 0);
TEST_LPM_ASSERT(status < 0);
/* rte_lpm_delete: depth > MAX_DEPTH */
status = rte_lpm_delete(lpm, ip, (MAX_DEPTH + 1));
TEST_LPM_ASSERT(status < 0);
rte_lpm_free(lpm);
return PASS;
}
/*
* Check that rte_lpm_lookup fails gracefully for incorrect user input
* arguments
*/
int32_t
test5(void)
{
#if defined(RTE_LIBRTE_LPM_DEBUG)
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_return = 0;
int32_t status = 0;
/* rte_lpm_lookup: lpm == NULL */
status = rte_lpm_lookup(NULL, ip, &next_hop_return);
TEST_LPM_ASSERT(status < 0);
/*Create valid lpm to use in rest of test. */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* rte_lpm_lookup: depth < 1 */
status = rte_lpm_lookup(lpm, ip, NULL);
TEST_LPM_ASSERT(status < 0);
rte_lpm_free(lpm);
#endif
return PASS;
}
/*
* Call add, lookup and delete for a single rule with depth <= 24
*/
int32_t
test6(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_add = 100, next_hop_return = 0;
uint8_t depth = 24;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* Call add, lookup and delete for a single rule with depth > 24
*/
int32_t
test7(void)
{
xmm_t ipx4;
uint32_t hop[4];
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip = RTE_IPV4(0, 0, 0, 0), next_hop_add = 100, next_hop_return = 0;
uint8_t depth = 32;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ipx4 = vect_set_epi32(ip, ip + 0x100, ip - 0x100, ip);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX);
TEST_LPM_ASSERT(hop[0] == next_hop_add);
TEST_LPM_ASSERT(hop[1] == UINT32_MAX);
TEST_LPM_ASSERT(hop[2] == UINT32_MAX);
TEST_LPM_ASSERT(hop[3] == next_hop_add);
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* Use rte_lpm_add to add rules which effect only the second half of the lpm
* table. Use all possible depths ranging from 1..32. Set the next hop = to the
* depth. Check lookup hit for on every add and check for lookup miss on the
* first half of the lpm table after each add. Finally delete all rules going
* backwards (i.e. from depth = 32 ..1) and carry out a lookup after each
* delete. The lookup should return the next_hop_add value related to the
* previous depth value (i.e. depth -1).
*/
int32_t
test8(void)
{
xmm_t ipx4;
uint32_t hop[4];
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip1 = RTE_IPV4(127, 255, 255, 255), ip2 = RTE_IPV4(128, 0, 0, 0);
uint32_t next_hop_add, next_hop_return;
uint8_t depth;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Loop with rte_lpm_add. */
for (depth = 1; depth <= 32; depth++) {
/* Let the next_hop_add value = depth. Just for change. */
next_hop_add = depth;
status = rte_lpm_add(lpm, ip2, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
/* Check IP in first half of tbl24 which should be empty. */
status = rte_lpm_lookup(lpm, ip1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
status = rte_lpm_lookup(lpm, ip2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add));
ipx4 = vect_set_epi32(ip2, ip1, ip2, ip1);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX);
TEST_LPM_ASSERT(hop[0] == UINT32_MAX);
TEST_LPM_ASSERT(hop[1] == next_hop_add);
TEST_LPM_ASSERT(hop[2] == UINT32_MAX);
TEST_LPM_ASSERT(hop[3] == next_hop_add);
}
/* Loop with rte_lpm_delete. */
for (depth = 32; depth >= 1; depth--) {
next_hop_add = (uint8_t) (depth - 1);
status = rte_lpm_delete(lpm, ip2, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip2, &next_hop_return);
if (depth != 1) {
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add));
} else {
TEST_LPM_ASSERT(status == -ENOENT);
}
status = rte_lpm_lookup(lpm, ip1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
ipx4 = vect_set_epi32(ip1, ip1, ip2, ip2);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX);
if (depth != 1) {
TEST_LPM_ASSERT(hop[0] == next_hop_add);
TEST_LPM_ASSERT(hop[1] == next_hop_add);
} else {
TEST_LPM_ASSERT(hop[0] == UINT32_MAX);
TEST_LPM_ASSERT(hop[1] == UINT32_MAX);
}
TEST_LPM_ASSERT(hop[2] == UINT32_MAX);
TEST_LPM_ASSERT(hop[3] == UINT32_MAX);
}
rte_lpm_free(lpm);
return PASS;
}
/*
* - Add & lookup to hit invalid TBL24 entry
* - Add & lookup to hit valid TBL24 entry not extended
* - Add & lookup to hit valid extended TBL24 entry with invalid TBL8 entry
* - Add & lookup to hit valid extended TBL24 entry with valid TBL8 entry
*
*/
int32_t
test9(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip, ip_1, ip_2;
uint8_t depth, depth_1, depth_2;
uint32_t next_hop_add, next_hop_add_1, next_hop_add_2, next_hop_return;
int32_t status = 0;
/* Add & lookup to hit invalid TBL24 entry */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
next_hop_add = 100;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Add & lookup to hit valid TBL24 entry not extended */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 23;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
depth = 24;
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
depth = 24;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
depth = 23;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Add & lookup to hit valid extended TBL24 entry with invalid TBL8
* entry */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ip = RTE_IPV4(128, 0, 0, 5);
depth = 32;
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Add & lookup to hit valid extended TBL24 entry with valid TBL8
* entry */
ip_1 = RTE_IPV4(128, 0, 0, 0);
depth_1 = 25;
next_hop_add_1 = 101;
ip_2 = RTE_IPV4(128, 0, 0, 5);
depth_2 = 32;
next_hop_add_2 = 102;
next_hop_return = 0;
status = rte_lpm_add(lpm, ip_1, depth_1, next_hop_add_1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip_1, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1));
status = rte_lpm_add(lpm, ip_2, depth_2, next_hop_add_2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip_2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_2));
status = rte_lpm_delete(lpm, ip_2, depth_2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip_2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1));
status = rte_lpm_delete(lpm, ip_1, depth_1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip_1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* - Add rule that covers a TBL24 range previously invalid & lookup (& delete &
* lookup)
* - Add rule that extends a TBL24 invalid entry & lookup (& delete & lookup)
* - Add rule that extends a TBL24 valid entry & lookup for both rules (&
* delete & lookup)
* - Add rule that updates the next hop in TBL24 & lookup (& delete & lookup)
* - Add rule that updates the next hop in TBL8 & lookup (& delete & lookup)
* - Delete a rule that is not present in the TBL24 & lookup
* - Delete a rule that is not present in the TBL8 & lookup
*
*/
int32_t
test10(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip, next_hop_add, next_hop_return;
uint8_t depth;
int32_t status = 0;
/* Add rule that covers a TBL24 range previously invalid & lookup
* (& delete & lookup) */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 16;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 25;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
rte_lpm_delete_all(lpm);
/* Add rule that extends a TBL24 valid entry & lookup for both rules
* (& delete & lookup) */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
ip = RTE_IPV4(128, 0, 0, 10);
depth = 32;
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ip = RTE_IPV4(128, 0, 0, 0);
next_hop_add = 100;
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
ip = RTE_IPV4(128, 0, 0, 10);
depth = 32;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Add rule that updates the next hop in TBL24 & lookup
* (& delete & lookup) */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Add rule that updates the next hop in TBL8 & lookup
* (& delete & lookup) */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Delete a rule that is not present in the TBL24 & lookup */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status < 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_delete_all(lpm);
/* Delete a rule that is not present in the TBL8 & lookup */
ip = RTE_IPV4(128, 0, 0, 0);
depth = 32;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status < 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* Add two rules, lookup to hit the more specific one, lookup to hit the less
* specific one delete the less specific rule and lookup previous values again;
* add a more specific rule than the existing rule, lookup again
*
* */
int32_t
test11(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip, next_hop_add, next_hop_return;
uint8_t depth;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
ip = RTE_IPV4(128, 0, 0, 10);
depth = 32;
next_hop_add = 101;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ip = RTE_IPV4(128, 0, 0, 0);
next_hop_add = 100;
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
ip = RTE_IPV4(128, 0, 0, 10);
depth = 32;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* Add an extended rule (i.e. depth greater than 24, lookup (hit), delete,
* lookup (miss) in a for loop of 1000 times. This will check tbl8 extension
* and contraction.
*
* */
int32_t
test12(void)
{
xmm_t ipx4;
uint32_t hop[4];
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip, i, next_hop_add, next_hop_return;
uint8_t depth;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 32;
next_hop_add = 100;
for (i = 0; i < 1000; i++) {
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add));
ipx4 = vect_set_epi32(ip, ip + 1, ip, ip - 1);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX);
TEST_LPM_ASSERT(hop[0] == UINT32_MAX);
TEST_LPM_ASSERT(hop[1] == next_hop_add);
TEST_LPM_ASSERT(hop[2] == UINT32_MAX);
TEST_LPM_ASSERT(hop[3] == next_hop_add);
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
}
rte_lpm_free(lpm);
return PASS;
}
/*
* Add a rule to tbl24, lookup (hit), then add a rule that will extend this
* tbl24 entry, lookup (hit). delete the rule that caused the tbl24 extension,
* lookup (miss) and repeat for loop of 1000 times. This will check tbl8
* extension and contraction.
*
* */
int32_t
test13(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
uint32_t ip, i, next_hop_add_1, next_hop_add_2, next_hop_return;
uint8_t depth;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
ip = RTE_IPV4(128, 0, 0, 0);
depth = 24;
next_hop_add_1 = 100;
status = rte_lpm_add(lpm, ip, depth, next_hop_add_1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1));
depth = 32;
next_hop_add_2 = 101;
for (i = 0; i < 1000; i++) {
status = rte_lpm_add(lpm, ip, depth, next_hop_add_2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add_2));
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add_1));
}
depth = 24;
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm_free(lpm);
return PASS;
}
/*
* For TBL8 extension exhaustion. Add 512 rules that require a tbl8 extension.
* No more tbl8 extensions will be allowed. Now add one more rule that required
* a tbl8 extension and get fail.
* */
int32_t
test14(void)
{
/* We only use depth = 32 in the loop below so we must make sure
* that we have enough storage for all rules at that depth*/
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = 256 * 32;
config.number_tbl8s = 512;
config.flags = 0;
uint32_t ip, next_hop_base, next_hop_return;
uint8_t depth;
int32_t status = 0;
xmm_t ipx4;
uint32_t hop[4];
/* Add enough space for 256 rules for every depth */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
depth = 32;
next_hop_base = 100;
ip = RTE_IPV4(0, 0, 0, 0);
/* Add 256 rules that require a tbl8 extension */
for (; ip <= RTE_IPV4(0, 1, 255, 0); ip += 256) {
status = rte_lpm_add(lpm, ip, depth, next_hop_base + ip);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_base + ip));
ipx4 = vect_set_epi32(ip + 3, ip + 2, ip + 1, ip);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT32_MAX);
TEST_LPM_ASSERT(hop[0] == next_hop_base + ip);
TEST_LPM_ASSERT(hop[1] == UINT32_MAX);
TEST_LPM_ASSERT(hop[2] == UINT32_MAX);
TEST_LPM_ASSERT(hop[3] == UINT32_MAX);
}
/* All tbl8 extensions have been used above. Try to add one more and
* we get a fail */
ip = RTE_IPV4(1, 0, 0, 0);
depth = 32;
status = rte_lpm_add(lpm, ip, depth, next_hop_base + ip);
TEST_LPM_ASSERT(status < 0);
rte_lpm_free(lpm);
return PASS;
}
/*
* Sequence of operations for find existing lpm table
*
* - create table
* - find existing table: hit
* - find non-existing table: miss
*
*/
int32_t
test15(void)
{
struct rte_lpm *lpm = NULL, *result = NULL;
struct rte_lpm_config config;
config.max_rules = 256 * 32;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
/* Create lpm */
lpm = rte_lpm_create("lpm_find_existing", SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Try to find existing lpm */
result = rte_lpm_find_existing("lpm_find_existing");
TEST_LPM_ASSERT(result == lpm);
/* Try to find non-existing lpm */
result = rte_lpm_find_existing("lpm_find_non_existing");
TEST_LPM_ASSERT(result == NULL);
/* Cleanup. */
rte_lpm_delete_all(lpm);
rte_lpm_free(lpm);
return PASS;
}
/*
* test failure condition of overloading the tbl8 so no more will fit
* Check we get an error return value in that case
*/
int32_t
test16(void)
{
uint32_t ip;
struct rte_lpm_config config;
config.max_rules = 256 * 32;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
struct rte_lpm *lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
/* ip loops through all possibilities for top 24 bits of address */
for (ip = 0; ip < 0xFFFFFF; ip++) {
/* add an entry within a different tbl8 each time, since
* depth >24 and the top 24 bits are different */
if (rte_lpm_add(lpm, (ip << 8) + 0xF0, 30, 0) < 0)
break;
}
if (ip != NUMBER_TBL8S) {
printf("Error, unexpected failure with filling tbl8 groups\n");
printf("Failed after %u additions, expected after %u\n",
(unsigned)ip, (unsigned)NUMBER_TBL8S);
}
rte_lpm_free(lpm);
return 0;
}
/*
* Test for overwriting of tbl8:
* - add rule /32 and lookup
* - add new rule /24 and lookup
* - add third rule /25 and lookup
* - lookup /32 and /24 rule to ensure the table has not been overwritten.
*/
int32_t
test17(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
const uint32_t ip_10_32 = RTE_IPV4(10, 10, 10, 2);
const uint32_t ip_10_24 = RTE_IPV4(10, 10, 10, 0);
const uint32_t ip_20_25 = RTE_IPV4(10, 10, 20, 2);
const uint8_t d_ip_10_32 = 32,
d_ip_10_24 = 24,
d_ip_20_25 = 25;
const uint32_t next_hop_ip_10_32 = 100,
next_hop_ip_10_24 = 105,
next_hop_ip_20_25 = 111;
uint32_t next_hop_return = 0;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
if ((status = rte_lpm_add(lpm, ip_10_32, d_ip_10_32,
next_hop_ip_10_32)) < 0)
return -1;
status = rte_lpm_lookup(lpm, ip_10_32, &next_hop_return);
uint32_t test_hop_10_32 = next_hop_return;
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32);
if ((status = rte_lpm_add(lpm, ip_10_24, d_ip_10_24,
next_hop_ip_10_24)) < 0)
return -1;
status = rte_lpm_lookup(lpm, ip_10_24, &next_hop_return);
uint32_t test_hop_10_24 = next_hop_return;
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24);
if ((status = rte_lpm_add(lpm, ip_20_25, d_ip_20_25,
next_hop_ip_20_25)) < 0)
return -1;
status = rte_lpm_lookup(lpm, ip_20_25, &next_hop_return);
uint32_t test_hop_20_25 = next_hop_return;
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop_ip_20_25);
if (test_hop_10_32 == test_hop_10_24) {
printf("Next hop return equal\n");
return -1;
}
if (test_hop_10_24 == test_hop_20_25) {
printf("Next hop return equal\n");
return -1;
}
status = rte_lpm_lookup(lpm, ip_10_32, &next_hop_return);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_32);
status = rte_lpm_lookup(lpm, ip_10_24, &next_hop_return);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop_ip_10_24);
rte_lpm_free(lpm);
return PASS;
}
/*
* Test for recycle of tbl8
* - step 1: add a rule with depth=28 (> 24)
* - step 2: add a rule with same 24-bit prefix and depth=23 (< 24)
* - step 3: delete the first rule
* - step 4: check tbl8 is freed
* - step 5: add a rule same as the first one (depth=28)
* - step 6: check same tbl8 is allocated
* - step 7: add a rule with same 24-bit prefix and depth=24
* - step 8: delete the rule (depth=28) added in step 5
* - step 9: check tbl8 is freed
* - step 10: add a rule with same 24-bit prefix and depth = 28
* - setp 11: check same tbl8 is allocated again
*/
int32_t
test18(void)
{
#define group_idx next_hop
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
uint32_t ip, next_hop;
uint8_t depth;
uint32_t tbl8_group_index;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
ip = RTE_IPV4(192, 168, 100, 100);
depth = 28;
next_hop = 1;
rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
tbl8_group_index = lpm->tbl24[ip>>8].group_idx;
depth = 23;
next_hop = 2;
rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
depth = 28;
rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid_group);
next_hop = 3;
rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
TEST_LPM_ASSERT(tbl8_group_index == lpm->tbl24[ip>>8].group_idx);
depth = 24;
next_hop = 4;
rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
depth = 28;
rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid_group);
next_hop = 5;
rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
TEST_LPM_ASSERT(tbl8_group_index == lpm->tbl24[ip>>8].group_idx);
rte_lpm_free(lpm);
#undef group_idx
return PASS;
}
/*
* rte_lpm_rcu_qsbr_add positive and negative tests.
* - Add RCU QSBR variable to LPM
* - Add another RCU QSBR variable to LPM
* - Check returns
*/
int32_t
test19(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
size_t sz;
struct rte_rcu_qsbr *qsv;
struct rte_rcu_qsbr *qsv2;
int32_t status;
struct rte_lpm_rcu_config rcu_cfg = {0};
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
TEST_LPM_ASSERT(qsv != NULL);
status = rte_rcu_qsbr_init(qsv, RTE_MAX_LCORE);
TEST_LPM_ASSERT(status == 0);
rcu_cfg.v = qsv;
/* Invalid QSBR mode */
rcu_cfg.mode = 2;
status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg);
TEST_LPM_ASSERT(status != 0);
rcu_cfg.mode = RTE_LPM_QSBR_MODE_DQ;
/* Attach RCU QSBR to LPM table */
status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg);
TEST_LPM_ASSERT(status == 0);
/* Create and attach another RCU QSBR to LPM table */
qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
TEST_LPM_ASSERT(qsv2 != NULL);
rcu_cfg.v = qsv2;
rcu_cfg.mode = RTE_LPM_QSBR_MODE_SYNC;
status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg);
TEST_LPM_ASSERT(status != 0);
rte_lpm_free(lpm);
rte_free(qsv);
rte_free(qsv2);
return PASS;
}
/*
* rte_lpm_rcu_qsbr_add DQ mode functional test.
* Reader and writer are in the same thread in this test.
* - Create LPM which supports 1 tbl8 group at max
* - Add RCU QSBR variable to LPM
* - Add a rule with depth=28 (> 24)
* - Register a reader thread (not a real thread)
* - Reader lookup existing rule
* - Writer delete the rule
* - Reader lookup the rule
* - Writer re-add the rule (no available tbl8 group)
* - Reader report quiescent state and unregister
* - Writer re-add the rule
* - Reader lookup the rule
*/
int32_t
test20(void)
{
struct rte_lpm *lpm = NULL;
struct rte_lpm_config config;
size_t sz;
struct rte_rcu_qsbr *qsv;
int32_t status;
uint32_t ip, next_hop, next_hop_return;
uint8_t depth;
struct rte_lpm_rcu_config rcu_cfg = {0};
config.max_rules = MAX_RULES;
config.number_tbl8s = 1;
config.flags = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(1);
qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
TEST_LPM_ASSERT(qsv != NULL);
status = rte_rcu_qsbr_init(qsv, 1);
TEST_LPM_ASSERT(status == 0);
rcu_cfg.v = qsv;
rcu_cfg.mode = RTE_LPM_QSBR_MODE_DQ;
/* Attach RCU QSBR to LPM table */
status = rte_lpm_rcu_qsbr_add(lpm, &rcu_cfg);
TEST_LPM_ASSERT(status == 0);
ip = RTE_IPV4(192, 0, 2, 100);
depth = 28;
next_hop = 1;
status = rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(lpm->tbl24[ip>>8].valid_group);
/* Register pseudo reader */
status = rte_rcu_qsbr_thread_register(qsv, 0);
TEST_LPM_ASSERT(status == 0);
rte_rcu_qsbr_thread_online(qsv, 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop);
/* Writer update */
status = rte_lpm_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(!lpm->tbl24[ip>>8].valid);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status != 0);
status = rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(status != 0);
/* Reader quiescent */
rte_rcu_qsbr_quiescent(qsv, 0);
status = rte_lpm_add(lpm, ip, depth, next_hop);
TEST_LPM_ASSERT(status == 0);
rte_rcu_qsbr_thread_offline(qsv, 0);
status = rte_rcu_qsbr_thread_unregister(qsv, 0);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == 0);
TEST_LPM_ASSERT(next_hop_return == next_hop);
rte_lpm_free(lpm);
rte_free(qsv);
return PASS;
}
static struct rte_lpm *g_lpm;
static struct rte_rcu_qsbr *g_v;
static uint32_t g_ip = RTE_IPV4(192, 0, 2, 100);
static volatile uint8_t writer_done;
/* Report quiescent state interval every 1024 lookups. Larger critical
* sections in reader will result in writer polling multiple times.
*/
#define QSBR_REPORTING_INTERVAL 1024
#define WRITER_ITERATIONS 512
/*
* Reader thread using rte_lpm data structure with RCU.
*/
static int
test_lpm_rcu_qsbr_reader(void *arg)
{
int i;
uint32_t next_hop_return = 0;
RTE_SET_USED(arg);
/* Register this thread to report quiescent state */
rte_rcu_qsbr_thread_register(g_v, 0);
rte_rcu_qsbr_thread_online(g_v, 0);
do {
for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
rte_lpm_lookup(g_lpm, g_ip, &next_hop_return);
/* Update quiescent state */
rte_rcu_qsbr_quiescent(g_v, 0);
} while (!writer_done);
rte_rcu_qsbr_thread_offline(g_v, 0);
rte_rcu_qsbr_thread_unregister(g_v, 0);
return 0;
}
/*
* rte_lpm_rcu_qsbr_add sync mode functional test.
* 1 Reader and 1 writer. They cannot be in the same thread in this test.
* - Create LPM which supports 1 tbl8 group at max
* - Add RCU QSBR variable with sync mode to LPM
* - Register a reader thread. Reader keeps looking up a specific rule.
* - Writer keeps adding and deleting a specific rule with depth=28 (> 24)
*/
int32_t
test21(void)
{
struct rte_lpm_config config;
size_t sz;
int32_t status;
uint32_t i, next_hop;
uint8_t depth;
struct rte_lpm_rcu_config rcu_cfg = {0};
if (rte_lcore_count() < 2) {
printf("Not enough cores for %s, expecting at least 2\n",
__func__);
return TEST_SKIPPED;
}
config.max_rules = MAX_RULES;
config.number_tbl8s = 1;
config.flags = 0;
g_lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(g_lpm != NULL);
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(1);
g_v = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
TEST_LPM_ASSERT(g_v != NULL);
status = rte_rcu_qsbr_init(g_v, 1);
TEST_LPM_ASSERT(status == 0);
rcu_cfg.v = g_v;
rcu_cfg.mode = RTE_LPM_QSBR_MODE_SYNC;
/* Attach RCU QSBR to LPM table */
status = rte_lpm_rcu_qsbr_add(g_lpm, &rcu_cfg);
TEST_LPM_ASSERT(status == 0);
writer_done = 0;
/* Launch reader thread */
rte_eal_remote_launch(test_lpm_rcu_qsbr_reader, NULL,
rte_get_next_lcore(-1, 1, 0));
depth = 28;
next_hop = 1;
status = rte_lpm_add(g_lpm, g_ip, depth, next_hop);
if (status != 0) {
printf("%s: Failed to add rule\n", __func__);
goto error;
}
/* Writer update */
for (i = 0; i < WRITER_ITERATIONS; i++) {
status = rte_lpm_delete(g_lpm, g_ip, depth);
if (status != 0) {
printf("%s: Failed to delete rule at iteration %d\n",
__func__, i);
goto error;
}
status = rte_lpm_add(g_lpm, g_ip, depth, next_hop);
if (status != 0) {
printf("%s: Failed to add rule at iteration %d\n",
__func__, i);
goto error;
}
}
error:
writer_done = 1;
/* Wait until reader exited. */
rte_eal_mp_wait_lcore();
rte_lpm_free(g_lpm);
rte_free(g_v);
return (status == 0) ? PASS : -1;
}
/*
* Do all unit tests.
*/
static int
test_lpm(void)
{
unsigned i;
int status, global_status = 0;
for (i = 0; i < RTE_DIM(tests); i++) {
status = tests[i]();
if (status < 0) {
printf("ERROR: LPM Test %u: FAIL\n", i);
global_status = status;
}
}
return global_status;
}
#endif /* !RTE_EXEC_ENV_WINDOWS */
REGISTER_TEST_COMMAND(lpm_autotest, test_lpm);
Reference in New Issue View Git Blame Copy Permalink