/*
* 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;
uint32_t ip = IPv4(0, 0, 0, 0);
uint8_t 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 vaild lpm to use in rest of test. */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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;
}
/*
* Check that rte_lpm_delete fails gracefully for incorrect user input
* arguments
*/
int32_t
test4(void)
{
struct rte_lpm *lpm = NULL;
uint32_t ip = 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 vaild lpm to use in rest of test. */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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;
}
/*
* Call add, lookup and delete for a single rule with depth <= 24
*/
int32_t
test6(void)
{
struct rte_lpm *lpm = NULL;
uint32_t ip = IPv4(0, 0, 0, 0);
uint8_t depth = 24, next_hop_add = 100, next_hop_return = 0;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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;
}
static void
app_init_lpm_tables(void)
{
unsigned socket, lcore;
/* Init the LPM tables */
for (socket = 0; socket < APP_MAX_SOCKETS; socket ++) {
char name[32];
uint32_t rule;
if (app_is_socket_used(socket) == 0) {
continue;
}
struct rte_lpm_config lpm_config;
lpm_config.max_rules = APP_MAX_LPM_RULES;
lpm_config.number_tbl8s = 256;
lpm_config.flags = 0;
snprintf(name, sizeof(name), "lpm_table_%u", socket);
printf("Creating the LPM table for socket %u ...\n", socket);
app.lpm_tables[socket] = rte_lpm_create(
name,
socket,
&lpm_config);
if (app.lpm_tables[socket] == NULL) {
rte_panic("Unable to create LPM table on socket %u\n", socket);
}
for (rule = 0; rule < app.n_lpm_rules; rule ++) {
int ret;
ret = rte_lpm_add(app.lpm_tables[socket],
app.lpm_rules[rule].ip,
app.lpm_rules[rule].depth,
app.lpm_rules[rule].if_out);
if (ret < 0) {
rte_panic("Unable to add entry %u (%x/%u => %u) to the LPM table on socket %u (%d)\n",
(unsigned) rule,
(unsigned) app.lpm_rules[rule].ip,
(unsigned) app.lpm_rules[rule].depth,
(unsigned) app.lpm_rules[rule].if_out,
socket,
ret);
}
}
}
for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
continue;
}
socket = rte_lcore_to_socket_id(lcore);
app.lcore_params[lcore].worker.lpm_table = app.lpm_tables[socket];
}
}
static void *
rte_table_lpm_create(void *params, int socket_id, uint32_t entry_size)
{
struct rte_table_lpm_params *p = (struct rte_table_lpm_params *) params;
struct rte_table_lpm *lpm;
uint32_t total_size, nht_size;
/* Check input parameters */
if (p == NULL) {
RTE_LOG(ERR, TABLE, "%s: NULL input parameters\n", __func__);
return NULL;
}
if (p->n_rules == 0) {
RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__);
return NULL;
}
if (p->entry_unique_size == 0) {
RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
__func__);
return NULL;
}
if (p->entry_unique_size > entry_size) {
RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
__func__);
return NULL;
}
entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t));
/* Memory allocation */
nht_size = RTE_TABLE_LPM_MAX_NEXT_HOPS * entry_size;
total_size = sizeof(struct rte_table_lpm) + nht_size;
lpm = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE,
socket_id);
if (lpm == NULL) {
RTE_LOG(ERR, TABLE,
"%s: Cannot allocate %u bytes for LPM table\n",
__func__, total_size);
return NULL;
}
/* LPM low-level table creation */
lpm->lpm = rte_lpm_create("LPM", socket_id, p->n_rules, 0);
if (lpm->lpm == NULL) {
rte_free(lpm);
RTE_LOG(ERR, TABLE, "Unable to create low-level LPM table\n");
return NULL;
}
/* Memory initialization */
lpm->entry_size = entry_size;
lpm->entry_unique_size = p->entry_unique_size;
lpm->n_rules = p->n_rules;
lpm->offset = p->offset;
return lpm;
}
void
rt_init(struct socket_ctx *ctx, int socket_id, unsigned ep)
{
char name[PATH_MAX];
unsigned i;
int ret;
struct rte_lpm *lpm;
struct ipv4_route *rt;
char a, b, c, d;
unsigned nb_routes;
struct rte_lpm_config conf = { 0 };
if (ctx == NULL)
rte_exit(EXIT_FAILURE, "NULL context.\n");
if (ctx->rt_ipv4 != NULL)
rte_exit(EXIT_FAILURE, "Routing Table for socket %u already "
"initialized\n", socket_id);
printf("Creating Routing Table (RT) context with %u max routes\n",
RT_IPV4_MAX_RULES);
if (ep == 0) {
rt = rt_ipv4_ep0;
nb_routes = RTE_DIM(rt_ipv4_ep0);
} else if (ep == 1) {
rt = rt_ipv4_ep1;
nb_routes = RTE_DIM(rt_ipv4_ep1);
} else
rte_exit(EXIT_FAILURE, "Invalid EP value %u. Only 0 or 1 "
"supported.\n", ep);
/* create the LPM table */
snprintf(name, sizeof(name), "%s_%u", "rt_ipv4", socket_id);
conf.max_rules = RT_IPV4_MAX_RULES;
conf.number_tbl8s = RTE_LPM_TBL8_NUM_ENTRIES;
lpm = rte_lpm_create(name, socket_id, &conf);
if (lpm == NULL)
rte_exit(EXIT_FAILURE, "Unable to create LPM table "
"on socket %d\n", socket_id);
/* populate the LPM table */
for (i = 0; i < nb_routes; i++) {
ret = rte_lpm_add(lpm, rt[i].ip, rt[i].depth, rt[i].if_out);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Unable to add entry num %u to "
"LPM table on socket %d\n", i, socket_id);
uint32_t_to_char(rt[i].ip, &a, &b, &c, &d);
printf("LPM: Adding route %hhu.%hhu.%hhu.%hhu/%hhu (%hhu)\n",
a, b, c, d, rt[i].depth, rt[i].if_out);
}
ctx->rt_ipv4 = (struct rt_ctx *)lpm;
}
/*
* Check that rte_lpm_create fails gracefully for incorrect user input
* arguments
*/
int32_t
test0(void)
{
struct rte_lpm *lpm = NULL;
/* rte_lpm_create: lpm name == NULL */
lpm = rte_lpm_create(NULL, SOCKET_ID_ANY, MAX_RULES, 0);
TEST_LPM_ASSERT(lpm == NULL);
/* rte_lpm_create: max_rules = 0 */
/* Note: __func__ inserts the function name, in this case "test0". */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 0, 0);
TEST_LPM_ASSERT(lpm == NULL);
/* socket_id < -1 is invalid */
lpm = rte_lpm_create(__func__, -2, MAX_RULES, 0);
TEST_LPM_ASSERT(lpm == NULL);
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;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, RTE_LPM_HEAP);
TEST_LPM_ASSERT(lpm != NULL);
rte_lpm_free(lpm);
rte_lpm_free(NULL);
return PASS;
}
int ss_conf_ioc_file_parse() {
int is_ok = 1;
int rv = 0;
json_object* items = NULL;
json_object* item = NULL;
struct rte_lpm6_config lpm6_info = {
.max_rules = SS_LPM_RULE_MAX,
.number_tbl8s = SS_LPM_TBL8S_MAX,
.flags = 0,
};
ss_conf->cidr4 = rte_lpm_create("cidr4", 0, SS_LPM_RULE_MAX, 0);
ss_conf->cidr6 = rte_lpm6_create("cidr6", 0, &lpm6_info);
if (ss_conf->cidr4 == NULL) {
fprintf(stderr, "could not allocate cidr4\n");
return -1;
}
if (ss_conf->cidr6 == NULL) {
fprintf(stderr, "could not allocate cidr6\n");
return -1;
}
items = ss_json_object_get(ss_conf->json, "ioc_files");
if (!items) return 0;
is_ok = json_object_is_type(items, json_type_array);
if (!is_ok) {
fprintf(stderr, "ioc_files is not an array\n");
return -1;
}
int length = json_object_array_length(items);
if (length > SS_IOC_FILE_MAX) {
fprintf(stderr, "ioc_file_count %d greater than %d, only parsing files below limit\n", length, SS_IOC_FILE_MAX);
length = SS_IOC_FILE_MAX;
}
for (int i = 0; i < length; ++i) {
item = json_object_array_get_idx(items, i);
rv = ss_ioc_file_load(item);
if (rv) {
fprintf(stderr, "ioc_file index %d could not be loaded\n", i);
is_ok = 0;
return -1;
}
}
ss_ioc_chain_dump(20);
ss_ioc_chain_optimize();
ss_ioc_tables_dump(5);
return 0;
}
int32_t
test13(void)
{
struct rte_lpm *lpm = NULL;
uint32_t ip, i;
uint8_t depth, next_hop_add_1, next_hop_add_2, next_hop_return;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
TEST_LPM_ASSERT(lpm != NULL);
ip = 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;
}
/*
* 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;
int32_t i;
/* rte_lpm_free: Free NULL */
for (i = 0; i < 100; i++) {
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES - i, 0);
TEST_LPM_ASSERT(lpm != NULL);
rte_lpm_free(lpm);
}
/* Can not test free so return success */
return PASS;
}
int lpm_table_init(int socketid) {
char s[64];
struct rte_lpm_config config_ipv4;
/* create the LPM table */
config_ipv4.max_rules = IPV4_L3FWD_LPM_MAX_RULES;
config_ipv4.number_tbl8s = IPV4_L3FWD_LPM_NUMBER_TBL8S;
config_ipv4.flags = 0;
snprintf(s, sizeof(s), "IPV4_L3FWD_LPM_%d", socketid);
ipv4_l3fwd_lpm_lookup_struct[socketid] =
rte_lpm_create(s, socketid, &config_ipv4);
if (ipv4_l3fwd_lpm_lookup_struct[socketid] == NULL)
rte_exit(EXIT_FAILURE,
"Unable to create the l3fwd LPM table on socket %d\n",
socketid);
return 1;
}
int32_t
test12(void)
{
__m128i ipx4;
uint16_t hop[4];
struct rte_lpm *lpm = NULL;
uint32_t ip, i;
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
TEST_LPM_ASSERT(lpm != NULL);
ip = 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 = _mm_set_epi32(ip, ip + 1, ip, ip - 1);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT16_MAX);
TEST_LPM_ASSERT(hop[0] == UINT16_MAX);
TEST_LPM_ASSERT(hop[1] == next_hop_add);
TEST_LPM_ASSERT(hop[2] == UINT16_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;
}
/*
* Fore TBL8 extension exhaustion. Add 256 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;
uint32_t ip;
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
/* Add enough space for 256 rules for every depth */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 256 * 32, 0);
TEST_LPM_ASSERT(lpm != NULL);
depth = 32;
next_hop_add = 100;
ip = IPv4(0, 0, 0, 0);
/* Add 256 rules that require a tbl8 extension */
for (; ip <= IPv4(0, 0, 255, 0); ip += 256) {
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));
}
/* All tbl8 extensions have been used above. Try to add one more and
* we get a fail */
ip = IPv4(1, 0, 0, 0);
depth = 32;
status = rte_lpm_add(lpm, ip, depth, next_hop_add);
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;
/* Create lpm */
lpm = rte_lpm_create("lpm_find_existing", SOCKET_ID_ANY, 256 * 32, 0);
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 *lpm = rte_lpm_create(__func__, SOCKET_ID_ANY,
256 * 32, 0);
/* 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 != RTE_LPM_TBL8_NUM_GROUPS) {
printf("Error, unexpected failure with filling tbl8 groups\n");
printf("Failed after %u additions, expected after %u\n",
(unsigned)ip, (unsigned)RTE_LPM_TBL8_NUM_GROUPS);
}
rte_lpm_free(lpm);
return 0;
}
/*
* This function is run in the secondary instance to test that creation of
* objects fails in a secondary
*/
static int
run_object_creation_tests(void)
{
const unsigned flags = 0;
const unsigned size = 1024;
const unsigned elt_size = 64;
const unsigned cache_size = 64;
const unsigned priv_data_size = 32;
printf("### Testing object creation - expect lots of mz reserve errors!\n");
rte_errno = 0;
if ((rte_memzone_reserve("test_mz", size, rte_socket_id(),
flags) == NULL) &&
(rte_memzone_lookup("test_mz") == NULL)) {
printf("Error: unexpected return value from rte_memzone_reserve\n");
return -1;
}
printf("# Checked rte_memzone_reserve() OK\n");
rte_errno = 0;
if ((rte_ring_create(
"test_ring", size, rte_socket_id(), flags) == NULL) &&
(rte_ring_lookup("test_ring") == NULL)){
printf("Error: unexpected return value from rte_ring_create()\n");
return -1;
}
printf("# Checked rte_ring_create() OK\n");
rte_errno = 0;
if ((rte_mempool_create("test_mp", size, elt_size, cache_size,
priv_data_size, NULL, NULL, NULL, NULL,
rte_socket_id(), flags) == NULL) &&
(rte_mempool_lookup("test_mp") == NULL)){
printf("Error: unexpected return value from rte_mempool_create()\n");
return -1;
}
printf("# Checked rte_mempool_create() OK\n");
#ifdef RTE_LIBRTE_HASH
const struct rte_hash_parameters hash_params = { .name = "test_mp_hash" };
rte_errno=0;
if ((rte_hash_create(&hash_params) != NULL) &&
(rte_hash_find_existing(hash_params.name) == NULL)){
printf("Error: unexpected return value from rte_hash_create()\n");
return -1;
}
printf("# Checked rte_hash_create() OK\n");
const struct rte_fbk_hash_params fbk_params = { .name = "test_fbk_mp_hash" };
rte_errno=0;
if ((rte_fbk_hash_create(&fbk_params) != NULL) &&
(rte_fbk_hash_find_existing(fbk_params.name) == NULL)){
printf("Error: unexpected return value from rte_fbk_hash_create()\n");
return -1;
}
printf("# Checked rte_fbk_hash_create() OK\n");
#endif
#ifdef RTE_LIBRTE_LPM
rte_errno=0;
struct rte_lpm_config config;
config.max_rules = rte_socket_id();
config.number_tbl8s = 256;
config.flags = 0;
if ((rte_lpm_create("test_lpm", size, &config) != NULL) &&
(rte_lpm_find_existing("test_lpm") == NULL)){
printf("Error: unexpected return value from rte_lpm_create()\n");
return -1;
}
printf("# Checked rte_lpm_create() OK\n");
#endif
/* Run a test_pci call */
if (test_pci() != 0) {
printf("PCI scan failed in secondary\n");
if (getuid() == 0) /* pci scans can fail as non-root */
return -1;
} else
printf("PCI scan succeeded in secondary\n");
return 0;
}
/* if called in a primary process, just spawns off a secondary process to
* run validation tests - which brings us right back here again...
* if called in a secondary process, this runs a series of API tests to check
* how things run in a secondary instance.
*/
int
test_mp_secondary(void)
{
if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
if (!test_pci_run) {
printf("=== Running pre-requisite test of test_pci\n");
test_pci();
printf("=== Requisite test done\n");
}
return run_secondary_instances();
}
printf("IN SECONDARY PROCESS\n");
return run_object_creation_tests();
}
static struct test_command multiprocess_cmd = {
.command = "multiprocess_autotest",
.callback = test_mp_secondary,
};
REGISTER_TEST_COMMAND(multiprocess_cmd);
void *
mg_table_lpm_create(void *params, int socket_id, uint32_t entry_size)
{
struct rte_table_lpm_params *p = (struct rte_table_lpm_params *) params;
struct rte_table_lpm *lpm;
uint32_t total_size, nht_size;
/* Check input parameters */
if (p == NULL) {
RTE_LOG(ERR, TABLE, "%s: NULL input parameters\n", __func__);
return NULL;
}
if (p->n_rules == 0) {
RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__);
return NULL;
}
if (p->entry_unique_size == 0) {
RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
__func__);
return NULL;
}
if (p->entry_unique_size > entry_size) {
RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
__func__);
return NULL;
}
// XXX ASK: does a 32 bit aligned offset make any sense here?
// this prevents me from accessing ip address in payload
//if ((p->offset & 0x3) != 0) {
// RTE_LOG(ERR, TABLE, "%s: Invalid offset\n", __func__);
// return NULL;
//}
entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t));
/* Memory allocation */
nht_size = RTE_TABLE_LPM_MAX_NEXT_HOPS * entry_size;
total_size = sizeof(struct rte_table_lpm) + nht_size;
lpm = rte_zmalloc_socket("TABLE", total_size, CACHE_LINE_SIZE,
socket_id);
if (lpm == NULL) {
RTE_LOG(ERR, TABLE,
"%s: Cannot allocate %u bytes for LPM table\n",
__func__, total_size);
return NULL;
}
/* LPM low-level table creation */
lpm->lpm = rte_lpm_create("LPM", socket_id, p->n_rules, 0);
if (lpm->lpm == NULL) {
rte_free(lpm);
RTE_LOG(ERR, TABLE, "Unable to create low-level LPM table\n");
return NULL;
}
/* Memory initialization */
lpm->entry_size = entry_size;
lpm->entry_unique_size = p->entry_unique_size;
lpm->n_rules = p->n_rules;
lpm->offset = p->offset;
return lpm;
}
/*
* - 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;
uint32_t ip;
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
/* Add rule that covers a TBL24 range previously invalid & lookup
* (& delete & lookup) */
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, RTE_LPM_HEAP);
TEST_LPM_ASSERT(lpm != NULL);
ip = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 & 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;
uint32_t ip, ip_1, ip_2;
uint8_t depth, depth_1, depth_2, 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 = IPv4(128, 0, 0, 0);
depth = 24;
next_hop_add = 100;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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 = 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 = 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 = 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 = 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 = IPv4(128, 0, 0, 0);
depth_1 = 25;
next_hop_add_1 = 101;
ip_2 = 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;
}
/*
* 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)
{
__m128i ipx4;
uint16_t hop[4];
struct rte_lpm *lpm = NULL;
uint32_t ip1 = IPv4(127, 255, 255, 255), ip2 = IPv4(128, 0, 0, 0);
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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 = _mm_set_epi32(ip2, ip1, ip2, ip1);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT16_MAX);
TEST_LPM_ASSERT(hop[0] == UINT16_MAX);
TEST_LPM_ASSERT(hop[1] == next_hop_add);
TEST_LPM_ASSERT(hop[2] == UINT16_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 = _mm_set_epi32(ip1, ip1, ip2, ip2);
rte_lpm_lookupx4(lpm, ipx4, hop, UINT16_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] == UINT16_MAX);
TEST_LPM_ASSERT(hop[1] == UINT16_MAX);
}
TEST_LPM_ASSERT(hop[2] == UINT16_MAX);
TEST_LPM_ASSERT(hop[3] == UINT16_MAX);
}
rte_lpm_free(lpm);
return PASS;
}
/*
* 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;
const uint32_t ip_10_32 = IPv4(10, 10, 10, 2);
const uint32_t ip_10_24 = IPv4(10, 10, 10, 0);
const uint32_t ip_20_25 = IPv4(10, 10, 20, 2);
const uint8_t d_ip_10_32 = 32,
d_ip_10_24 = 24,
d_ip_20_25 = 25;
const uint8_t next_hop_ip_10_32 = 100,
next_hop_ip_10_24 = 105,
next_hop_ip_20_25 = 111;
uint8_t next_hop_return = 0;
int32_t status = 0;
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, MAX_RULES, 0);
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);
uint8_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);
uint8_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);
uint8_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;
}
int32_t
perf_test(void)
{
struct rte_lpm *lpm = NULL;
uint64_t begin, total_time, lpm_used_entries = 0;
unsigned i, j;
uint8_t next_hop_add = 0xAA, next_hop_return = 0;
int status = 0;
uint64_t cache_line_counter = 0;
int64_t count = 0;
rte_srand(rte_rdtsc());
printf("No. routes = %u\n", (unsigned) NUM_ROUTE_ENTRIES);
print_route_distribution(large_route_table, (uint32_t) NUM_ROUTE_ENTRIES);
lpm = rte_lpm_create(__func__, SOCKET_ID_ANY, 1000000, 0);
TEST_LPM_ASSERT(lpm != NULL);
/* Measue add. */
begin = rte_rdtsc();
for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
if (rte_lpm_add(lpm, large_route_table[i].ip,
large_route_table[i].depth, next_hop_add) == 0)
status++;
}
/* End Timer. */
total_time = rte_rdtsc() - begin;
printf("Unique added entries = %d\n", status);
/* Obtain add statistics. */
for (i = 0; i < RTE_LPM_TBL24_NUM_ENTRIES; i++) {
if (lpm->tbl24[i].valid)
lpm_used_entries++;
if (i % 32 == 0){
if ((uint64_t)count < lpm_used_entries) {
cache_line_counter++;
count = lpm_used_entries;
}
}
}
printf("Used table 24 entries = %u (%g%%)\n",
(unsigned) lpm_used_entries,
(lpm_used_entries * 100.0) / RTE_LPM_TBL24_NUM_ENTRIES);
printf("64 byte Cache entries used = %u (%u bytes)\n",
(unsigned) cache_line_counter, (unsigned) cache_line_counter * 64);
printf("Average LPM Add: %g cycles\n", (double)total_time / NUM_ROUTE_ENTRIES);
/* Measure single Lookup */
total_time = 0;
count = 0;
for (i = 0; i < ITERATIONS; i ++) {
static uint32_t ip_batch[BATCH_SIZE];
for (j = 0; j < BATCH_SIZE; j ++)
ip_batch[j] = rte_rand();
/* Lookup per batch */
begin = rte_rdtsc();
for (j = 0; j < BATCH_SIZE; j ++) {
if (rte_lpm_lookup(lpm, ip_batch[j], &next_hop_return) != 0)
count++;
}
total_time += rte_rdtsc() - begin;
}
printf("Average LPM Lookup: %.1f cycles (fails = %.1f%%)\n",
(double)total_time / ((double)ITERATIONS * BATCH_SIZE),
(count * 100.0) / (double)(ITERATIONS * BATCH_SIZE));
/* Measure bulk Lookup */
total_time = 0;
count = 0;
for (i = 0; i < ITERATIONS; i ++) {
static uint32_t ip_batch[BATCH_SIZE];
uint16_t next_hops[BULK_SIZE];
/* Create array of random IP addresses */
for (j = 0; j < BATCH_SIZE; j ++)
ip_batch[j] = rte_rand();
/* Lookup per batch */
begin = rte_rdtsc();
for (j = 0; j < BATCH_SIZE; j += BULK_SIZE) {
unsigned k;
rte_lpm_lookup_bulk(lpm, &ip_batch[j], next_hops, BULK_SIZE);
for (k = 0; k < BULK_SIZE; k++)
if (unlikely(!(next_hops[k] & RTE_LPM_LOOKUP_SUCCESS)))
count++;
}
total_time += rte_rdtsc() - begin;
}
printf("BULK LPM Lookup: %.1f cycles (fails = %.1f%%)\n",
(double)total_time / ((double)ITERATIONS * BATCH_SIZE),
(count * 100.0) / (double)(ITERATIONS * BATCH_SIZE));
/* Measure LookupX4 */
total_time = 0;
count = 0;
for (i = 0; i < ITERATIONS; i++) {
static uint32_t ip_batch[BATCH_SIZE];
uint16_t next_hops[4];
/* Create array of random IP addresses */
for (j = 0; j < BATCH_SIZE; j++)
ip_batch[j] = rte_rand();
/* Lookup per batch */
begin = rte_rdtsc();
for (j = 0; j < BATCH_SIZE; j += RTE_DIM(next_hops)) {
unsigned k;
__m128i ipx4;
ipx4 = _mm_loadu_si128((__m128i *)(ip_batch + j));
ipx4 = *(__m128i *)(ip_batch + j);
rte_lpm_lookupx4(lpm, ipx4, next_hops, UINT16_MAX);
for (k = 0; k < RTE_DIM(next_hops); k++)
if (unlikely(next_hops[k] == UINT16_MAX))
count++;
}
total_time += rte_rdtsc() - begin;
}
printf("LPM LookupX4: %.1f cycles (fails = %.1f%%)\n",
(double)total_time / ((double)ITERATIONS * BATCH_SIZE),
(count * 100.0) / (double)(ITERATIONS * BATCH_SIZE));
/* Delete */
status = 0;
begin = rte_rdtsc();
for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
/* rte_lpm_delete(lpm, ip, depth) */
status += rte_lpm_delete(lpm, large_route_table[i].ip,
large_route_table[i].depth);
}
total_time += rte_rdtsc() - begin;
printf("Average LPM Delete: %g cycles\n",
(double)total_time / NUM_ROUTE_ENTRIES);
rte_lpm_delete_all(lpm);
rte_lpm_free(lpm);
return PASS;
}
