/*
* Check that rte_lpm6_add fails gracefully for incorrect user input arguments
*/
int32_t
test4(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth = 24, next_hop = 100;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
/* rte_lpm6_add: lpm == NULL */
status = rte_lpm6_add(NULL, ip, depth, next_hop);
TEST_LPM_ASSERT(status < 0);
/*Create vaild lpm to use in rest of test. */
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* rte_lpm6_add: depth < 1 */
status = rte_lpm6_add(lpm, ip, 0, next_hop);
TEST_LPM_ASSERT(status < 0);
/* rte_lpm6_add: depth > MAX_DEPTH */
status = rte_lpm6_add(lpm, ip, (MAX_DEPTH + 1), next_hop);
TEST_LPM_ASSERT(status < 0);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Creates an LPM table with a small number of tbl8s and exhaust them in the
* middle of the process of adding a rule when there is already an existing rule
* in that position and needs to be extended.
*/
int32_t
test12(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth, next_hop_add = 100;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = 16;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
depth = 128;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
ip[0] = 1;
depth = 41;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
depth = 49;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == -ENOSPC);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Adds 3 rules and look them up through the lookup_bulk function.
* Includes in the lookup a fourth IP address that won't match
* and checks that the result is as expected.
*/
int32_t
test21(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip_batch[4][16];
uint8_t depth, next_hop_add;
int16_t next_hop_return[4];
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
IPv6(ip_batch[0], 128, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 48;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip_batch[0], depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[1], 128, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 48;
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip_batch[1], depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[2], 128, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 48;
next_hop_add = 102;
status = rte_lpm6_add(lpm, ip_batch[2], depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[3], 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 4);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == 100
&& next_hop_return[1] == 101 && next_hop_return[2] == 102
&& next_hop_return[3] == -1);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Add 2^16 routes with different first 16 bits and depth 25.
* Add one more route with the same depth and check that results in a failure.
* After that delete the last rule and create the one that was attempted to be
* created. This checks tbl8 exhaustion.
*/
int32_t
test14(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth = 25, next_hop_add = 100;
int32_t status = 0;
int i, j;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
for (i = 0; i < 256; i++) {
ip[0] = (uint8_t)i;
for (j = 0; j < 256; j++) {
ip[1] = (uint8_t)j;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
}
}
ip[0] = 255;
ip[1] = 255;
ip[2] = 1;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == -ENOSPC);
ip[0] = 255;
ip[1] = 255;
ip[2] = 0;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
ip[0] = 255;
ip[1] = 255;
ip[2] = 1;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
rte_lpm6_free(lpm);
return PASS;
}
int
control_add_ipv6_local_entry(struct in6_addr *nexthop, struct in6_addr *saddr,
uint8_t depth, uint32_t port_id, int32_t socket_id)
{
int s;
uint8_t nexthop_id;
s = neighbor6_lookup_nexthop(neighbor6_struct[socket_id], nexthop,
&nexthop_id);
if (s < 0) {
s = neighbor6_add_nexthop(neighbor6_struct[socket_id], nexthop,
&nexthop_id, NEI_ACTION_KNI);
if (s < 0) {
RTE_LOG(
ERR, PKTJ_CTRL1,
"failed to add a nexthop during route adding...\n");
return -1;
}
// apply rate limit rule if next hop neighbor is in the table
apply_rate_limit_ipv6(nexthop, nexthop_id, socket_id);
}
neighbor6_set_port(neighbor6_struct[socket_id], nexthop_id, port_id);
s = rte_lpm6_add(ipv6_pktj_lookup_struct[socket_id], saddr->s6_addr,
depth, nexthop_id);
if (s < 0) {
RTE_LOG(
ERR, PKTJ_CTRL1,
"failed to add a route in lpm during route adding...\n");
return -1;
}
neighbor6_refcount_incr(neighbor6_struct[socket_id], nexthop_id);
return nexthop_id;
}
/*
* Call add, lookup and delete for a single rule with depth > 24
*/
int32_t
test16(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {12,12,1,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth = 128, next_hop_add = 100, next_hop_return = 0;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Use rte_lpm6_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
test17(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip1[] = {127,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255};
uint8_t ip2[] = {128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Loop with rte_lpm6_add. */
for (depth = 1; depth <= 128; depth++) {
/* Let the next_hop_add value = depth. Just for change. */
next_hop_add = depth;
status = rte_lpm6_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_lpm6_lookup(lpm, ip1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
status = rte_lpm6_lookup(lpm, ip2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_add));
}
/* Loop with rte_lpm6_delete. */
for (depth = 128; depth >= 1; depth--) {
next_hop_add = (uint8_t) (depth - 1);
status = rte_lpm6_delete(lpm, ip2, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_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_lpm6_lookup(lpm, ip1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
}
rte_lpm6_free(lpm);
return PASS;
}
/*
* Add a rule that reaches the end of the tree.
* Add a rule that is more generic than the first one.
* Check every possible combination that produces a match for the second rule.
* This tests tbl expansion.
*/
int32_t
test27(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,0,0};
uint8_t depth = 128, next_hop_add = 100, next_hop_return;
int32_t status = 0;
int i, j;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
depth = 128;
next_hop_add = 128;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
depth = 112;
next_hop_add = 112;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
for (i = 0; i < 256; i++) {
ip[14] = (uint8_t)i;
for (j = 0; j < 256; j++) {
ip[15] = (uint8_t)j;
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
if (i == 0 && j == 0)
TEST_LPM_ASSERT(status == 0 && next_hop_return == 128);
else
TEST_LPM_ASSERT(status == 0 && next_hop_return == 112);
}
}
rte_lpm6_free(lpm);
return PASS;
}
/*
* Creates an LPM table with max_rules = 2 and tries to add 3 rules.
* Delete one of the rules and tries to add the third one again.
*/
int32_t
test13(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint8_t depth, next_hop_add = 100;
int32_t status = 0;
config.max_rules = 2;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
depth = 1;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
depth = 2;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
depth = 3;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == -ENOSPC);
depth = 2;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
depth = 3;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Add a set of random routes with random depths.
* Lookup different IP addresses that match the routes previously added.
* Checks that the next hop is the expected one.
* The routes, IP addresses and expected result for every case have been
* precalculated by using a python script and stored in a .h file.
*/
int32_t
test25(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[16];
uint32_t i;
uint8_t depth, next_hop_add, next_hop_return, next_hop_expected;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
for (i = 0; i < 1000; i++) {
memcpy(ip, large_route_table[i].ip, 16);
depth = large_route_table[i].depth;
next_hop_add = large_route_table[i].next_hop;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
}
for (i = 0; i < 100000; i++) {
memcpy(ip, large_ips_table[i].ip, 16);
next_hop_expected = large_ips_table[i].next_hop;
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) &&
(next_hop_return == next_hop_expected));
}
rte_lpm6_free(lpm);
return PASS;
}
/**< Usage: ./exe <use_random_prefixes> */
int main(int argc, char **argv)
{
int i, j;
assert(argc == 2);
int use_random_prefixes = atoi(argv[1]);
assert(use_random_prefixes == 1 || use_random_prefixes == 0);
/**< Create the lmp6 struct */
struct rte_lpm6_config ipv6_config;
ipv6_config.max_rules = 1000000;
ipv6_config.number_tbl8s = 1024 * 1024;
struct rte_lpm6 *lpm = rte_lpm6_create(0, &ipv6_config);
/**< Read the prefixes from a prefixes file */
struct ipv6_prefix *prefix_arr;
int num_prefixes;
if(use_random_prefixes == 0) {
/**< Generate prefixes at random: Real prefixes have great cache
* behavior. */
prefix_arr = ipv6_read_prefixes(PREFIX_FILE, &num_prefixes);
printf("main: Read %d prefixes. Amplifying by %d.\n",
num_prefixes, AMP_FACTOR);
prefix_arr = ipv6_amp_prefixes(prefix_arr, num_prefixes, AMP_FACTOR);
num_prefixes *= AMP_FACTOR;
} else {
num_prefixes = NUM_RAND_PREFIXES;
prefix_arr = ipv6_gen_rand_prefixes(num_prefixes);
}
assert(num_prefixes < ipv6_config.max_rules);
for(i = 0; i < num_prefixes; i ++) {
int add_status = rte_lpm6_add(lpm,
prefix_arr[i].bytes, prefix_arr[i].depth, prefix_arr[i].dst_port);
if(add_status < 0) {
printf("main: Failed to add IPv6 prefix %d. Status = %d\n",
i, add_status);
exit(-1);
}
if(i % 1000 == 0) {
printf("main: Added prefixes = %d, total = %d\n", i, num_prefixes);
}
}
printf("\tmain: Done inserting prefixes\n");
/**< Generate probe IPv6 addresses from inserted prefixes */
printf("main: Generating %d IPv6 addresses\n", NUM_IPS);
struct ipv6_addr *addr_arr = ipv6_gen_addrs(NUM_IPS,
prefix_arr, num_prefixes);
printf("main: Starting lookups\n");
/**< Variables for PAPI */
float real_time, proc_time, ipc;
long long ins;
int retval;
/**< Init PAPI_TOT_INS and PAPI_TOT_CYC counters */
if((retval = PAPI_ipc(&real_time, &proc_time, &ins, &ipc)) < PAPI_OK) {
printf("PAPI error: retval: %d\n", retval);
exit(1);
}
int16_t dst_port[BATCH_SIZE];
int dst_port_sum = 0;
for(i = 0; i < NUM_IPS; i += BATCH_SIZE) {
rte_lpm6_lookup_handopt(lpm, (void *) addr_arr[i].bytes, dst_port, BATCH_SIZE);
for(j = 0; j < BATCH_SIZE; j ++) {
dst_port_sum += dst_port[j];
}
}
if((retval = PAPI_ipc(&real_time, &proc_time, &ins, &ipc)) < PAPI_OK) {
printf("PAPI error: retval: %d\n", retval);
exit(1);
}
printf("Time = %.4f s, Lookup rate = %.2f M/s | dst_port_sum = %d\n"
"Instructions = %lld, IPC = %f\n",
real_time, NUM_IPS / (real_time * 1000000), dst_port_sum, ins, ipc);
return 0;
}
static int
neighbor6(neighbor_action_t action,
int32_t port_id,
struct in6_addr* addr,
struct ether_addr* lladdr,
uint8_t flags,
__rte_unused uint16_t vlan_id,
void* args)
{
// if port_id is not handled
// ignore, return immediatly
// if neighbor add
// lookup neighbor
// if exists
// update lladdr, set flag as REACHABLE/STALE/DELAY
// else
// // This should not happen
// insert new nexthop
// set insert date=now, refcount = 0, flag=REACHABLE/STALE/DELAY
// if neighbor delete
// lookup neighbor
// if exists
// if refcount != 0
// set nexthop as invalid
// else
// set flag empty
// else
// do nothing
// // this should not happen
struct control_handle* handle = args;
assert(handle != NULL);
int s;
uint16_t nexthop_id, find_id;
int32_t socket_id = handle->socket_id;
char ipbuf[INET6_ADDRSTRLEN];
assert(neighbor6_struct != NULL);
if (addr == NULL)
return -1;
inet_ntop(AF_INET6, addr, ipbuf, INET6_ADDRSTRLEN);
if (action == NEIGHBOR_ADD) {
if (lladdr == NULL)
return -1;
char ibuf[IFNAMSIZ];
unsigned kni_vlan;
if_indextoname(port_id, ibuf);
s = sscanf(ibuf, "dpdk%10u.%10u", &port_id, &kni_vlan);
if (s <= 0) {
RTE_LOG(ERR, PKTJ_CTRL1,
"received a neighbor "
"announce for an unmanaged "
"iface %s\n",
ibuf);
return -1;
}
s = neighbor6_lookup_nexthop(neighbor6_struct[socket_id], addr,
&nexthop_id);
if (s < 0) {
if (flags != NUD_NONE && flags != NUD_NOARP &&
flags != NUD_STALE) {
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to change state in neighbor6 "
"table (state %d, %s)...\n",
flags, ipbuf);
return -1;
}
{
RTE_LOG(
DEBUG, PKTJ_CTRL1,
"adding ipv6 neighbor %s with port_id %d "
"vlan_id %d...\n",
ipbuf, port_id, kni_vlan);
}
s = neighbor6_add_nexthop(neighbor6_struct[socket_id],
addr, &nexthop_id,
NEI_ACTION_FWD);
if (s < 0) {
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to add a "
"nexthop in neighbor "
"table...\n");
return -1;
}
// apply rate limit rule if next hop neighbor is in the
// table
apply_rate_limit_ipv6(addr, nexthop_id, socket_id);
if (rte_lpm6_lookup(ipv6_pktj_lookup_struct[socket_id],
addr->s6_addr, &find_id) == 0) {
s = rte_lpm6_add(
ipv6_pktj_lookup_struct[socket_id],
addr->s6_addr, 128, nexthop_id);
if (s < 0) {
lpm6_stats[socket_id].nb_add_ko++;
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to add a route in "
"lpm during neighbor "
"adding...\n");
return -1;
}
lpm6_stats[socket_id].nb_add_ok++;
}
}
if (flags == NUD_FAILED) {
neighbor6_set_action(neighbor6_struct[socket_id],
nexthop_id, NEI_ACTION_KNI);
} else {
neighbor6_set_action(neighbor6_struct[socket_id],
nexthop_id, NEI_ACTION_FWD);
}
RTE_LOG(DEBUG, PKTJ_CTRL1,
"set neighbor6 with port_id %d state %d \n", port_id,
flags);
neighbor6_set_lladdr_port(neighbor6_struct[socket_id],
nexthop_id, &ports_eth_addr[port_id],
lladdr, port_id, kni_vlan);
neighbor6_set_state(neighbor6_struct[socket_id], nexthop_id,
flags);
}
if (action == NEIGHBOR_DELETE) {
if (flags != NUD_FAILED && flags != NUD_STALE) {
RTE_LOG(
DEBUG, PKTJ_CTRL1,
"neighbor6 delete ope failed, bad NUD state: %d \n",
flags);
return -1;
}
RTE_LOG(DEBUG, PKTJ_CTRL1, "deleting ipv6 neighbor...\n");
s = neighbor6_lookup_nexthop(neighbor6_struct[socket_id], addr,
&nexthop_id);
if (s < 0) {
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to find a nexthop to "
"delete in neighbor "
"table...\n");
return 0;
}
neighbor6_delete(neighbor6_struct[socket_id], nexthop_id);
// FIXME not thread safe
if (neighbor6_struct[socket_id]
->entries.t6[nexthop_id]
.neighbor.refcnt == 0) {
s = rte_lpm6_delete(ipv6_pktj_lookup_struct[socket_id],
addr->s6_addr, 128);
if (s < 0) {
lpm6_stats[socket_id].nb_del_ko++;
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to delete route...\n");
return -1;
}
// reset rate limit for this id
rlimit6_max[socket_id][nexthop_id] = UINT32_MAX;
lpm6_stats[socket_id].nb_del_ok++;
}
}
RTE_LOG(DEBUG, PKTJ_CTRL1, "neigh %s ope success\n", ipbuf);
return 0;
}
static int
route6(__rte_unused struct rtmsg* route,
route_action_t action,
struct in6_addr* addr,
uint8_t depth,
struct in6_addr* nexthop,
uint8_t type,
void* args)
{
// If route add
// lookup next hop in neighbor table ipv4
// if not lookup
// create next hop, with flag invalid and addr = nexthop
// nexthopid = last id
//
// register new route in lpm, with nexthop id
// increment refcount in neighbor
// If route delete
// lookup next hop in neighbor table ipv4
// if not lookup
// then WTF TABLE CORRUPTED
// remove route from lpm
// decrement refcount in neighbor
// if refcount reached 0
// then flag entry empty
struct control_handle* handle = args;
assert(handle != NULL);
uint16_t nexthop_id;
int s;
int32_t socket_id = handle->socket_id;
static struct in6_addr blackhole_addr6 = IN6ADDR_ANY_INIT;
if (type == RTN_BLACKHOLE) {
nexthop = &blackhole_addr6;
}
if (action == ROUTE_ADD) {
RTE_LOG(DEBUG, PKTJ_CTRL1, "adding an ipv6 route...\n");
// lookup nexthop
s = neighbor6_lookup_nexthop(neighbor6_struct[socket_id],
nexthop, &nexthop_id);
if (s < 0) {
s = neighbor6_add_nexthop(neighbor6_struct[socket_id],
nexthop, &nexthop_id,
NEI_ACTION_FWD);
if (s < 0) {
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to add a "
"nexthop during "
"route adding...\n");
return -1;
}
// apply rate limit rule if next hop neighbor is in the
// table
apply_rate_limit_ipv6(nexthop, nexthop_id, socket_id);
}
s = rte_lpm6_add(ipv6_pktj_lookup_struct[socket_id],
addr->s6_addr, depth, nexthop_id);
if (s < 0) {
lpm6_stats[socket_id].nb_add_ko++;
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to add a route in "
"lpm during route "
"adding...\n");
return -1;
}
neighbor6_refcount_incr(neighbor6_struct[socket_id],
nexthop_id);
lpm6_stats[socket_id].nb_add_ok++;
}
if (action == ROUTE_DELETE) {
RTE_LOG(DEBUG, PKTJ_CTRL1, "deleting an ipv6 route...\n");
// lookup nexthop
s = neighbor6_lookup_nexthop(neighbor6_struct[socket_id],
nexthop, &nexthop_id);
if (s < 0) {
RTE_LOG(ERR, PKTJ_CTRL1,
"failed to find nexthop "
"during route deletion...\n");
return -1;
}
s = rte_lpm6_delete(ipv6_pktj_lookup_struct[socket_id],
addr->s6_addr, depth);
if (s < 0) {
lpm6_stats[socket_id].nb_del_ko++;
RTE_LOG(ERR, PKTJ_CTRL1, "failed to delete route...\n");
return -1;
}
neighbor6_refcount_decr(neighbor6_struct[socket_id],
nexthop_id);
lpm6_stats[socket_id].nb_del_ok++;
}
RTE_LOG(DEBUG, PKTJ_CTRL1, "route ope success\n");
return 0;
}
static int
rte_table_lpm_ipv6_entry_add(
void *table,
void *key,
void *entry,
int *key_found,
void **entry_ptr)
{
struct rte_table_lpm_ipv6 *lpm = (struct rte_table_lpm_ipv6 *) table;
struct rte_table_lpm_ipv6_key *ip_prefix =
(struct rte_table_lpm_ipv6_key *) key;
uint32_t nht_pos, nht_pos0_valid;
int status;
uint8_t nht_pos0;
/* Check input parameters */
if (lpm == NULL) {
RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
return -EINVAL;
}
if (ip_prefix == NULL) {
RTE_LOG(ERR, TABLE, "%s: ip_prefix parameter is NULL\n",
__func__);
return -EINVAL;
}
if (entry == NULL) {
RTE_LOG(ERR, TABLE, "%s: entry parameter is NULL\n", __func__);
return -EINVAL;
}
if ((ip_prefix->depth == 0) || (ip_prefix->depth > 128)) {
RTE_LOG(ERR, TABLE, "%s: invalid depth (%d)\n", __func__,
ip_prefix->depth);
return -EINVAL;
}
/* Check if rule is already present in the table */
status = rte_lpm6_is_rule_present(lpm->lpm, ip_prefix->ip,
ip_prefix->depth, &nht_pos0);
nht_pos0_valid = status > 0;
/* Find existing or free NHT entry */
if (nht_find_existing(lpm, entry, &nht_pos) == 0) {
uint8_t *nht_entry;
if (nht_find_free(lpm, &nht_pos) == 0) {
RTE_LOG(ERR, TABLE, "%s: NHT full\n", __func__);
return -1;
}
nht_entry = &lpm->nht[nht_pos * lpm->entry_size];
memcpy(nht_entry, entry, lpm->entry_size);
}
/* Add rule to low level LPM table */
if (rte_lpm6_add(lpm->lpm, ip_prefix->ip, ip_prefix->depth,
(uint8_t) nht_pos) < 0) {
RTE_LOG(ERR, TABLE, "%s: LPM IPv6 rule add failed\n", __func__);
return -1;
}
/* Commit NHT changes */
lpm->nht_users[nht_pos]++;
lpm->nht_users[nht_pos0] -= nht_pos0_valid;
*key_found = nht_pos0_valid;
*entry_ptr = (void *) &lpm->nht[nht_pos * lpm->entry_size];
return 0;
}
/*
* - 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
test18(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[16], ip_1[16], ip_2[16];
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;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
/* Add & lookup to hit invalid TBL24 entry */
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 24;
next_hop_add = 100;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/* Add & lookup to hit valid TBL24 entry not extended */
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 23;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_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_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
depth = 24;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
depth = 23;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/* Add & lookup to hit valid extended TBL24 entry with invalid TBL8
* entry.
*/
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
IPv6(ip, 128, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/* Add & lookup to hit valid extended TBL24 entry with valid TBL8
* entry
*/
IPv6(ip_1, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth_1 = 25;
next_hop_add_1 = 101;
IPv6(ip_2, 128, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth_2 = 32;
next_hop_add_2 = 102;
next_hop_return = 0;
status = rte_lpm6_add(lpm, ip_1, depth_1, next_hop_add_1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip_1, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1));
status = rte_lpm6_add(lpm, ip_2, depth_2, next_hop_add_2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip_2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_2));
status = rte_lpm6_delete(lpm, ip_2, depth_2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip_2, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add_1));
status = rte_lpm6_delete(lpm, ip_1, depth_1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip_1, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_free(lpm);
return PASS;
}
/*
* Adds 5 rules and look them up.
* Use the delete_bulk function to delete two of them. Lookup again.
* Use the delete_bulk function to delete one more. Lookup again.
* Use the delete_bulk function to delete two more, one invalid. Lookup again.
* Use the delete_bulk function to delete the remaining one. Lookup again.
*/
int32_t
test22(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip_batch[5][16];
uint8_t depth[5], next_hop_add;
int16_t next_hop_return[5];
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Adds 5 rules and look them up */
IPv6(ip_batch[0], 128, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth[0] = 48;
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip_batch[0], depth[0], next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[1], 128, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth[1] = 48;
next_hop_add = 102;
status = rte_lpm6_add(lpm, ip_batch[1], depth[1], next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[2], 128, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth[2] = 48;
next_hop_add = 103;
status = rte_lpm6_add(lpm, ip_batch[2], depth[2], next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[3], 128, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth[3] = 48;
next_hop_add = 104;
status = rte_lpm6_add(lpm, ip_batch[3], depth[3], next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[4], 128, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth[4] = 48;
next_hop_add = 105;
status = rte_lpm6_add(lpm, ip_batch[4], depth[4], next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 5);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == 101
&& next_hop_return[1] == 102 && next_hop_return[2] == 103
&& next_hop_return[3] == 104 && next_hop_return[4] == 105);
/* Use the delete_bulk function to delete two of them. Lookup again */
status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[0], depth, 2);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 5);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1
&& next_hop_return[1] == -1 && next_hop_return[2] == 103
&& next_hop_return[3] == 104 && next_hop_return[4] == 105);
/* Use the delete_bulk function to delete one more. Lookup again */
status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[2], depth, 1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 5);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1
&& next_hop_return[1] == -1 && next_hop_return[2] == -1
&& next_hop_return[3] == 104 && next_hop_return[4] == 105);
/* Use the delete_bulk function to delete two, one invalid. Lookup again */
IPv6(ip_batch[4], 128, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[3], depth, 2);
TEST_LPM_ASSERT(status == 0);
IPv6(ip_batch[4], 128, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 5);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1
&& next_hop_return[1] == -1 && next_hop_return[2] == -1
&& next_hop_return[3] == -1 && next_hop_return[4] == 105);
/* Use the delete_bulk function to delete the remaining one. Lookup again */
status = rte_lpm6_delete_bulk_func(lpm, &ip_batch[4], depth, 1);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup_bulk_func(lpm, ip_batch,
next_hop_return, 5);
TEST_LPM_ASSERT(status == 0 && next_hop_return[0] == -1
&& next_hop_return[1] == -1 && next_hop_return[2] == -1
&& next_hop_return[3] == -1 && next_hop_return[4] == -1);
rte_lpm6_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
test19(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip[16];
uint8_t depth, next_hop_add, next_hop_return;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
/* Add rule that covers a TBL24 range previously invalid & lookup
* (& delete & lookup)
*/
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 16;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 25;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
rte_lpm6_delete_all(lpm);
/*
* Add rule that extends a TBL24 valid entry & lookup for both rules
* (& delete & lookup)
*/
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
IPv6(ip, 128, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
next_hop_add = 100;
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 24;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
IPv6(ip, 128, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/*
* Add rule that updates the next hop in TBL24 & lookup
* (& delete & lookup)
*/
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/*
* Add rule that updates the next hop in TBL8 & lookup
* (& delete & lookup)
*/
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
next_hop_add = 101;
status = rte_lpm6_add(lpm, ip, depth, next_hop_add);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT((status == 0) && (next_hop_return == next_hop_add));
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status == 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/* Delete a rule that is not present in the TBL24 & lookup */
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 24;
next_hop_add = 100;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status < 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_delete_all(lpm);
/* Delete a rule that is not present in the TBL8 & lookup */
IPv6(ip, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
depth = 32;
next_hop_add = 100;
status = rte_lpm6_delete(lpm, ip, depth);
TEST_LPM_ASSERT(status < 0);
status = rte_lpm6_lookup(lpm, ip, &next_hop_return);
TEST_LPM_ASSERT(status == -ENOENT);
rte_lpm6_free(lpm);
return PASS;
}
int32_t
perf_test(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint64_t begin, total_time;
unsigned i, j;
uint8_t next_hop_add = 0xAA, next_hop_return = 0;
int status = 0;
int64_t count = 0;
config.max_rules = 1000000;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 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_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
/* Measure add. */
begin = rte_rdtsc();
for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
if (rte_lpm6_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);
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 ++) {
begin = rte_rdtsc();
for (j = 0; j < NUM_IPS_ENTRIES; j ++) {
if (rte_lpm6_lookup(lpm, large_ips_table[j].ip,
&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;
uint8_t ip_batch[NUM_IPS_ENTRIES][16];
int16_t next_hops[NUM_IPS_ENTRIES];
for (i = 0; i < NUM_IPS_ENTRIES; i++)
memcpy(ip_batch[i], large_ips_table[i].ip, 16);
for (i = 0; i < ITERATIONS; i ++) {
/* Lookup per batch */
begin = rte_rdtsc();
rte_lpm6_lookup_bulk_func(lpm, ip_batch, next_hops, NUM_IPS_ENTRIES);
total_time += rte_rdtsc() - begin;
for (j = 0; j < NUM_IPS_ENTRIES; j++)
if (next_hops[j] < 0)
count++;
}
printf("BULK LPM Lookup: %.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_lpm6_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_lpm6_delete_all(lpm);
rte_lpm6_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
test26(void)
{
struct rte_lpm6 *lpm = NULL;
struct rte_lpm6_config config;
uint8_t ip_10_32[] = {10, 10, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t ip_10_24[] = {10, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t ip_20_25[] = {10, 10, 20, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t d_ip_10_32 = 32;
uint8_t d_ip_10_24 = 24;
uint8_t d_ip_20_25 = 25;
uint8_t next_hop_ip_10_32 = 100;
uint8_t next_hop_ip_10_24 = 105;
uint8_t next_hop_ip_20_25 = 111;
uint8_t next_hop_return = 0;
int32_t status = 0;
config.max_rules = MAX_RULES;
config.number_tbl8s = NUMBER_TBL8S;
config.flags = 0;
lpm = rte_lpm6_create(__func__, SOCKET_ID_ANY, &config);
TEST_LPM_ASSERT(lpm != NULL);
if ((status = rte_lpm6_add(lpm, ip_10_32, d_ip_10_32,
next_hop_ip_10_32)) < 0)
return -1;
status = rte_lpm6_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_lpm6_add(lpm, ip_10_24, d_ip_10_24,
next_hop_ip_10_24)) < 0)
return -1;
status = rte_lpm6_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_lpm6_add(lpm, ip_20_25, d_ip_20_25,
next_hop_ip_20_25)) < 0)
return -1;
status = rte_lpm6_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_lpm6_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_lpm6_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_lpm6_free(lpm);
return PASS;
}
