rib: support IPv6
Extend RIB library with IPv6 support. Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com>
This commit is contained in:
Vladimir Medvedkin
Thomas Monjalon
parent
b35df4dd66
commit
f7e861e21c
@ -17,9 +17,9 @@ EXPORT_MAP := rte_rib_version.map
|
||||
LIBABIVER := 1
|
||||
|
||||
# all source are stored in SRCS-y
|
||||
SRCS-$(CONFIG_RTE_LIBRTE_RIB) := rte_rib.c
|
||||
SRCS-$(CONFIG_RTE_LIBRTE_RIB) := rte_rib.c rte_rib6.c
|
||||
|
||||
# install this header file
|
||||
SYMLINK-$(CONFIG_RTE_LIBRTE_RIB)-include := rte_rib.h
|
||||
SYMLINK-$(CONFIG_RTE_LIBRTE_RIB)-include := rte_rib.h rte_rib6.h
|
||||
|
||||
include $(RTE_SDK)/mk/rte.lib.mk
|
||||
|
||||
@ -3,6 +3,6 @@
|
||||
# Copyright(c) 2019 Intel Corporation
|
||||
|
||||
allow_experimental_apis = true
|
||||
sources = files('rte_rib.c')
|
||||
headers = files('rte_rib.h')
|
||||
sources = files('rte_rib.c', 'rte_rib6.c')
|
||||
headers = files('rte_rib.h', 'rte_rib6.h')
|
||||
deps += ['mempool']
|
||||
|
||||
598
lib/librte_rib/rte_rib6.c
Normal file
598
lib/librte_rib/rte_rib6.c
Normal file
@ -0,0 +1,598 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause
|
||||
* Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
|
||||
* Copyright(c) 2019 Intel Corporation
|
||||
*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <rte_eal.h>
|
||||
#include <rte_eal_memconfig.h>
|
||||
#include <rte_errno.h>
|
||||
#include <rte_malloc.h>
|
||||
#include <rte_mempool.h>
|
||||
#include <rte_rwlock.h>
|
||||
#include <rte_string_fns.h>
|
||||
#include <rte_tailq.h>
|
||||
|
||||
#include <rte_rib6.h>
|
||||
|
||||
#define RTE_RIB_VALID_NODE 1
|
||||
#define RIB6_MAXDEPTH 128
|
||||
/* Maximum length of a RIB6 name. */
|
||||
#define RTE_RIB6_NAMESIZE 64
|
||||
|
||||
TAILQ_HEAD(rte_rib6_list, rte_tailq_entry);
|
||||
static struct rte_tailq_elem rte_rib6_tailq = {
|
||||
.name = "RTE_RIB6",
|
||||
};
|
||||
EAL_REGISTER_TAILQ(rte_rib6_tailq)
|
||||
|
||||
struct rte_rib6_node {
|
||||
struct rte_rib6_node *left;
|
||||
struct rte_rib6_node *right;
|
||||
struct rte_rib6_node *parent;
|
||||
uint64_t nh;
|
||||
uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE];
|
||||
uint8_t depth;
|
||||
uint8_t flag;
|
||||
__extension__ uint64_t ext[0];
|
||||
};
|
||||
|
||||
struct rte_rib6 {
|
||||
char name[RTE_RIB6_NAMESIZE];
|
||||
struct rte_rib6_node *tree;
|
||||
struct rte_mempool *node_pool;
|
||||
uint32_t cur_nodes;
|
||||
uint32_t cur_routes;
|
||||
int max_nodes;
|
||||
};
|
||||
|
||||
static inline bool
|
||||
is_valid_node(struct rte_rib6_node *node)
|
||||
{
|
||||
return (node->flag & RTE_RIB_VALID_NODE) == RTE_RIB_VALID_NODE;
|
||||
}
|
||||
|
||||
static inline bool
|
||||
is_right_node(struct rte_rib6_node *node)
|
||||
{
|
||||
return node->parent->right == node;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check if ip1 is covered by ip2/depth prefix
|
||||
*/
|
||||
static inline bool
|
||||
is_covered(const uint8_t ip1[RTE_RIB6_IPV6_ADDR_SIZE],
|
||||
const uint8_t ip2[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++)
|
||||
if ((ip1[i] ^ ip2[i]) & get_msk_part(depth, i))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline int
|
||||
get_dir(const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth)
|
||||
{
|
||||
int i = 0;
|
||||
uint8_t p_depth, msk;
|
||||
|
||||
for (p_depth = depth; p_depth >= 8; p_depth -= 8)
|
||||
i++;
|
||||
|
||||
msk = 1 << (7 - p_depth);
|
||||
return (ip[i] & msk) != 0;
|
||||
}
|
||||
|
||||
static inline struct rte_rib6_node *
|
||||
get_nxt_node(struct rte_rib6_node *node,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE])
|
||||
{
|
||||
return (get_dir(ip, node->depth)) ? node->right : node->left;
|
||||
}
|
||||
|
||||
static struct rte_rib6_node *
|
||||
node_alloc(struct rte_rib6 *rib)
|
||||
{
|
||||
struct rte_rib6_node *ent;
|
||||
int ret;
|
||||
|
||||
ret = rte_mempool_get(rib->node_pool, (void *)&ent);
|
||||
if (unlikely(ret != 0))
|
||||
return NULL;
|
||||
++rib->cur_nodes;
|
||||
return ent;
|
||||
}
|
||||
|
||||
static void
|
||||
node_free(struct rte_rib6 *rib, struct rte_rib6_node *ent)
|
||||
{
|
||||
--rib->cur_nodes;
|
||||
rte_mempool_put(rib->node_pool, ent);
|
||||
}
|
||||
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE])
|
||||
{
|
||||
struct rte_rib6_node *cur;
|
||||
struct rte_rib6_node *prev = NULL;
|
||||
|
||||
if (unlikely(rib == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
cur = rib->tree;
|
||||
|
||||
while ((cur != NULL) && is_covered(ip, cur->ip, cur->depth)) {
|
||||
if (is_valid_node(cur))
|
||||
prev = cur;
|
||||
cur = get_nxt_node(cur, ip);
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup_parent(struct rte_rib6_node *ent)
|
||||
{
|
||||
struct rte_rib6_node *tmp;
|
||||
|
||||
if (ent == NULL)
|
||||
return NULL;
|
||||
|
||||
tmp = ent->parent;
|
||||
while ((tmp != NULL) && (!is_valid_node(tmp)))
|
||||
tmp = tmp->parent;
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup_exact(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth)
|
||||
{
|
||||
struct rte_rib6_node *cur;
|
||||
uint8_t tmp_ip[RTE_RIB6_IPV6_ADDR_SIZE];
|
||||
int i;
|
||||
|
||||
if ((rib == NULL) || (ip == NULL) || (depth > RIB6_MAXDEPTH)) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
cur = rib->tree;
|
||||
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++)
|
||||
tmp_ip[i] = ip[i] & get_msk_part(depth, i);
|
||||
|
||||
while (cur != NULL) {
|
||||
if (rte_rib6_is_equal(cur->ip, tmp_ip) &&
|
||||
(cur->depth == depth) &&
|
||||
is_valid_node(cur))
|
||||
return cur;
|
||||
|
||||
if (!(is_covered(tmp_ip, cur->ip, cur->depth)) ||
|
||||
(cur->depth >= depth))
|
||||
break;
|
||||
|
||||
cur = get_nxt_node(cur, tmp_ip);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Traverses on subtree and retreeves more specific routes
|
||||
* for a given in args ip/depth prefix
|
||||
* last = NULL means the first invocation
|
||||
*/
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_get_nxt(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE],
|
||||
uint8_t depth, struct rte_rib6_node *last, int flag)
|
||||
{
|
||||
struct rte_rib6_node *tmp, *prev = NULL;
|
||||
uint8_t tmp_ip[RTE_RIB6_IPV6_ADDR_SIZE];
|
||||
int i;
|
||||
|
||||
if ((rib == NULL) || (ip == NULL) || (depth > RIB6_MAXDEPTH)) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++)
|
||||
tmp_ip[i] = ip[i] & get_msk_part(depth, i);
|
||||
|
||||
if (last == NULL) {
|
||||
tmp = rib->tree;
|
||||
while ((tmp) && (tmp->depth < depth))
|
||||
tmp = get_nxt_node(tmp, tmp_ip);
|
||||
} else {
|
||||
tmp = last;
|
||||
while ((tmp->parent != NULL) && (is_right_node(tmp) ||
|
||||
(tmp->parent->right == NULL))) {
|
||||
tmp = tmp->parent;
|
||||
if (is_valid_node(tmp) &&
|
||||
(is_covered(tmp->ip, tmp_ip, depth) &&
|
||||
(tmp->depth > depth)))
|
||||
return tmp;
|
||||
}
|
||||
tmp = (tmp->parent != NULL) ? tmp->parent->right : NULL;
|
||||
}
|
||||
while (tmp) {
|
||||
if (is_valid_node(tmp) &&
|
||||
(is_covered(tmp->ip, tmp_ip, depth) &&
|
||||
(tmp->depth > depth))) {
|
||||
prev = tmp;
|
||||
if (flag == RTE_RIB6_GET_NXT_COVER)
|
||||
return prev;
|
||||
}
|
||||
tmp = (tmp->left != NULL) ? tmp->left : tmp->right;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
void
|
||||
rte_rib6_remove(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth)
|
||||
{
|
||||
struct rte_rib6_node *cur, *prev, *child;
|
||||
|
||||
cur = rte_rib6_lookup_exact(rib, ip, depth);
|
||||
if (cur == NULL)
|
||||
return;
|
||||
|
||||
--rib->cur_routes;
|
||||
cur->flag &= ~RTE_RIB_VALID_NODE;
|
||||
while (!is_valid_node(cur)) {
|
||||
if ((cur->left != NULL) && (cur->right != NULL))
|
||||
return;
|
||||
child = (cur->left == NULL) ? cur->right : cur->left;
|
||||
if (child != NULL)
|
||||
child->parent = cur->parent;
|
||||
if (cur->parent == NULL) {
|
||||
rib->tree = child;
|
||||
node_free(rib, cur);
|
||||
return;
|
||||
}
|
||||
if (cur->parent->left == cur)
|
||||
cur->parent->left = child;
|
||||
else
|
||||
cur->parent->right = child;
|
||||
prev = cur;
|
||||
cur = cur->parent;
|
||||
node_free(rib, prev);
|
||||
}
|
||||
}
|
||||
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_insert(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth)
|
||||
{
|
||||
struct rte_rib6_node **tmp;
|
||||
struct rte_rib6_node *prev = NULL;
|
||||
struct rte_rib6_node *new_node = NULL;
|
||||
struct rte_rib6_node *common_node = NULL;
|
||||
uint8_t common_prefix[RTE_RIB6_IPV6_ADDR_SIZE];
|
||||
uint8_t tmp_ip[RTE_RIB6_IPV6_ADDR_SIZE];
|
||||
int i, d;
|
||||
uint8_t common_depth, ip_xor;
|
||||
|
||||
if (unlikely((rib == NULL) || (ip == NULL) ||
|
||||
(depth > RIB6_MAXDEPTH))) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tmp = &rib->tree;
|
||||
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++)
|
||||
tmp_ip[i] = ip[i] & get_msk_part(depth, i);
|
||||
|
||||
new_node = rte_rib6_lookup_exact(rib, tmp_ip, depth);
|
||||
if (new_node != NULL) {
|
||||
rte_errno = EEXIST;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
new_node = node_alloc(rib);
|
||||
if (new_node == NULL) {
|
||||
rte_errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
new_node->left = NULL;
|
||||
new_node->right = NULL;
|
||||
new_node->parent = NULL;
|
||||
rte_rib6_copy_addr(new_node->ip, tmp_ip);
|
||||
new_node->depth = depth;
|
||||
new_node->flag = RTE_RIB_VALID_NODE;
|
||||
|
||||
/* traverse down the tree to find matching node or closest matching */
|
||||
while (1) {
|
||||
/* insert as the last node in the branch */
|
||||
if (*tmp == NULL) {
|
||||
*tmp = new_node;
|
||||
new_node->parent = prev;
|
||||
++rib->cur_routes;
|
||||
return *tmp;
|
||||
}
|
||||
/*
|
||||
* Intermediate node found.
|
||||
* Previous rte_rib6_lookup_exact() returned NULL
|
||||
* but node with proper search criteria is found.
|
||||
* Validate intermediate node and return.
|
||||
*/
|
||||
if (rte_rib6_is_equal(tmp_ip, (*tmp)->ip) &&
|
||||
(depth == (*tmp)->depth)) {
|
||||
node_free(rib, new_node);
|
||||
(*tmp)->flag |= RTE_RIB_VALID_NODE;
|
||||
++rib->cur_routes;
|
||||
return *tmp;
|
||||
}
|
||||
|
||||
if (!is_covered(tmp_ip, (*tmp)->ip, (*tmp)->depth) ||
|
||||
((*tmp)->depth >= depth)) {
|
||||
break;
|
||||
}
|
||||
prev = *tmp;
|
||||
|
||||
tmp = (get_dir(tmp_ip, (*tmp)->depth)) ? &(*tmp)->right :
|
||||
&(*tmp)->left;
|
||||
}
|
||||
|
||||
/* closest node found, new_node should be inserted in the middle */
|
||||
common_depth = RTE_MIN(depth, (*tmp)->depth);
|
||||
for (i = 0, d = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++) {
|
||||
ip_xor = tmp_ip[i] ^ (*tmp)->ip[i];
|
||||
if (ip_xor == 0)
|
||||
d += 8;
|
||||
else {
|
||||
d += __builtin_clz(ip_xor << 24);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
common_depth = RTE_MIN(d, common_depth);
|
||||
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++)
|
||||
common_prefix[i] = tmp_ip[i] & get_msk_part(common_depth, i);
|
||||
|
||||
if (rte_rib6_is_equal(common_prefix, tmp_ip) &&
|
||||
(common_depth == depth)) {
|
||||
/* insert as a parent */
|
||||
if (get_dir((*tmp)->ip, depth))
|
||||
new_node->right = *tmp;
|
||||
else
|
||||
new_node->left = *tmp;
|
||||
new_node->parent = (*tmp)->parent;
|
||||
(*tmp)->parent = new_node;
|
||||
*tmp = new_node;
|
||||
} else {
|
||||
/* create intermediate node */
|
||||
common_node = node_alloc(rib);
|
||||
if (common_node == NULL) {
|
||||
node_free(rib, new_node);
|
||||
rte_errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
rte_rib6_copy_addr(common_node->ip, common_prefix);
|
||||
common_node->depth = common_depth;
|
||||
common_node->flag = 0;
|
||||
common_node->parent = (*tmp)->parent;
|
||||
new_node->parent = common_node;
|
||||
(*tmp)->parent = common_node;
|
||||
if (get_dir((*tmp)->ip, common_depth) == 1) {
|
||||
common_node->left = new_node;
|
||||
common_node->right = *tmp;
|
||||
} else {
|
||||
common_node->left = *tmp;
|
||||
common_node->right = new_node;
|
||||
}
|
||||
*tmp = common_node;
|
||||
}
|
||||
++rib->cur_routes;
|
||||
return new_node;
|
||||
}
|
||||
|
||||
int
|
||||
rte_rib6_get_ip(struct rte_rib6_node *node, uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE])
|
||||
{
|
||||
if ((node == NULL) || (ip == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
rte_rib6_copy_addr(ip, node->ip);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
rte_rib6_get_depth(struct rte_rib6_node *node, uint8_t *depth)
|
||||
{
|
||||
if ((node == NULL) || (depth == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
*depth = node->depth;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void *
|
||||
rte_rib6_get_ext(struct rte_rib6_node *node)
|
||||
{
|
||||
return (node == NULL) ? NULL : &node->ext[0];
|
||||
}
|
||||
|
||||
int
|
||||
rte_rib6_get_nh(struct rte_rib6_node *node, uint64_t *nh)
|
||||
{
|
||||
if ((node == NULL) || (nh == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
*nh = node->nh;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
rte_rib6_set_nh(struct rte_rib6_node *node, uint64_t nh)
|
||||
{
|
||||
if (node == NULL) {
|
||||
rte_errno = EINVAL;
|
||||
return -1;
|
||||
}
|
||||
node->nh = nh;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct rte_rib6 *
|
||||
rte_rib6_create(const char *name, int socket_id, struct rte_rib6_conf *conf)
|
||||
{
|
||||
char mem_name[RTE_RIB6_NAMESIZE];
|
||||
struct rte_rib6 *rib = NULL;
|
||||
struct rte_tailq_entry *te;
|
||||
struct rte_rib6_list *rib6_list;
|
||||
struct rte_mempool *node_pool;
|
||||
|
||||
/* Check user arguments. */
|
||||
if ((name == NULL) || (conf == NULL) ||
|
||||
(conf->max_nodes == 0)) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
snprintf(mem_name, sizeof(mem_name), "MP_%s", name);
|
||||
node_pool = rte_mempool_create(mem_name, conf->max_nodes,
|
||||
sizeof(struct rte_rib6_node) + conf->ext_sz, 0, 0,
|
||||
NULL, NULL, NULL, NULL, socket_id, 0);
|
||||
|
||||
if (node_pool == NULL) {
|
||||
RTE_LOG(ERR, LPM,
|
||||
"Can not allocate mempool for RIB6 %s\n", name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
snprintf(mem_name, sizeof(mem_name), "RIB6_%s", name);
|
||||
rib6_list = RTE_TAILQ_CAST(rte_rib6_tailq.head, rte_rib6_list);
|
||||
|
||||
rte_mcfg_tailq_write_lock();
|
||||
|
||||
/* guarantee there's no existing */
|
||||
TAILQ_FOREACH(te, rib6_list, next) {
|
||||
rib = (struct rte_rib6 *)te->data;
|
||||
if (strncmp(name, rib->name, RTE_RIB6_NAMESIZE) == 0)
|
||||
break;
|
||||
}
|
||||
rib = NULL;
|
||||
if (te != NULL) {
|
||||
rte_errno = EEXIST;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* allocate tailq entry */
|
||||
te = rte_zmalloc("RIB6_TAILQ_ENTRY", sizeof(*te), 0);
|
||||
if (te == NULL) {
|
||||
RTE_LOG(ERR, LPM,
|
||||
"Can not allocate tailq entry for RIB6 %s\n", name);
|
||||
rte_errno = ENOMEM;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* Allocate memory to store the RIB6 data structures. */
|
||||
rib = rte_zmalloc_socket(mem_name,
|
||||
sizeof(struct rte_rib6), RTE_CACHE_LINE_SIZE, socket_id);
|
||||
if (rib == NULL) {
|
||||
RTE_LOG(ERR, LPM, "RIB6 %s memory allocation failed\n", name);
|
||||
rte_errno = ENOMEM;
|
||||
goto free_te;
|
||||
}
|
||||
|
||||
rte_strlcpy(rib->name, name, sizeof(rib->name));
|
||||
rib->tree = NULL;
|
||||
rib->max_nodes = conf->max_nodes;
|
||||
rib->node_pool = node_pool;
|
||||
|
||||
te->data = (void *)rib;
|
||||
TAILQ_INSERT_TAIL(rib6_list, te, next);
|
||||
|
||||
rte_mcfg_tailq_write_unlock();
|
||||
|
||||
return rib;
|
||||
|
||||
free_te:
|
||||
rte_free(te);
|
||||
exit:
|
||||
rte_mcfg_tailq_write_unlock();
|
||||
rte_mempool_free(node_pool);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct rte_rib6 *
|
||||
rte_rib6_find_existing(const char *name)
|
||||
{
|
||||
struct rte_rib6 *rib = NULL;
|
||||
struct rte_tailq_entry *te;
|
||||
struct rte_rib6_list *rib6_list;
|
||||
|
||||
if (unlikely(name == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
rib6_list = RTE_TAILQ_CAST(rte_rib6_tailq.head, rte_rib6_list);
|
||||
|
||||
rte_mcfg_tailq_read_lock();
|
||||
TAILQ_FOREACH(te, rib6_list, next) {
|
||||
rib = (struct rte_rib6 *) te->data;
|
||||
if (strncmp(name, rib->name, RTE_RIB6_NAMESIZE) == 0)
|
||||
break;
|
||||
}
|
||||
rte_mcfg_tailq_read_unlock();
|
||||
|
||||
if (te == NULL) {
|
||||
rte_errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return rib;
|
||||
}
|
||||
|
||||
void
|
||||
rte_rib6_free(struct rte_rib6 *rib)
|
||||
{
|
||||
struct rte_tailq_entry *te;
|
||||
struct rte_rib6_list *rib6_list;
|
||||
struct rte_rib6_node *tmp = NULL;
|
||||
|
||||
if (unlikely(rib == NULL)) {
|
||||
rte_errno = EINVAL;
|
||||
return;
|
||||
}
|
||||
|
||||
rib6_list = RTE_TAILQ_CAST(rte_rib6_tailq.head, rte_rib6_list);
|
||||
|
||||
rte_mcfg_tailq_write_lock();
|
||||
|
||||
/* find our tailq entry */
|
||||
TAILQ_FOREACH(te, rib6_list, next) {
|
||||
if (te->data == (void *)rib)
|
||||
break;
|
||||
}
|
||||
if (te != NULL)
|
||||
TAILQ_REMOVE(rib6_list, te, next);
|
||||
|
||||
rte_mcfg_tailq_write_unlock();
|
||||
|
||||
while ((tmp = rte_rib6_get_nxt(rib, 0, 0, tmp,
|
||||
RTE_RIB6_GET_NXT_ALL)) != NULL)
|
||||
rte_rib6_remove(rib, tmp->ip, tmp->depth);
|
||||
|
||||
rte_mempool_free(rib->node_pool);
|
||||
|
||||
rte_free(rib);
|
||||
rte_free(te);
|
||||
}
|
||||
334
lib/librte_rib/rte_rib6.h
Normal file
334
lib/librte_rib/rte_rib6.h
Normal file
@ -0,0 +1,334 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause
|
||||
* Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
|
||||
* Copyright(c) 2019 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef _RTE_RIB6_H_
|
||||
#define _RTE_RIB6_H_
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Level compressed tree implementation for IPv6 Longest Prefix Match
|
||||
*/
|
||||
|
||||
#include <rte_memcpy.h>
|
||||
#include <rte_compat.h>
|
||||
|
||||
#define RTE_RIB6_IPV6_ADDR_SIZE 16
|
||||
|
||||
/**
|
||||
* rte_rib6_get_nxt() flags
|
||||
*/
|
||||
enum {
|
||||
/** flag to get all subroutes in a RIB tree */
|
||||
RTE_RIB6_GET_NXT_ALL,
|
||||
/** flag to get first matched subroutes in a RIB tree */
|
||||
RTE_RIB6_GET_NXT_COVER
|
||||
};
|
||||
|
||||
struct rte_rib6;
|
||||
struct rte_rib6_node;
|
||||
|
||||
/** RIB configuration structure */
|
||||
struct rte_rib6_conf {
|
||||
/**
|
||||
* Size of extension block inside rte_rib_node.
|
||||
* This space could be used to store additional user
|
||||
* defined data.
|
||||
*/
|
||||
size_t ext_sz;
|
||||
/* size of rte_rib_node's pool */
|
||||
int max_nodes;
|
||||
};
|
||||
|
||||
/**
|
||||
* Copy IPv6 address from one location to another
|
||||
*
|
||||
* @param dst
|
||||
* pointer to the place to copy
|
||||
* @param src
|
||||
* pointer from where to copy
|
||||
*/
|
||||
static inline void
|
||||
rte_rib6_copy_addr(uint8_t *dst, const uint8_t *src)
|
||||
{
|
||||
if ((dst == NULL) || (src == NULL))
|
||||
return;
|
||||
rte_memcpy(dst, src, RTE_RIB6_IPV6_ADDR_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two IPv6 addresses
|
||||
*
|
||||
* @param ip1
|
||||
* pointer to the first ipv6 address
|
||||
* @param ip2
|
||||
* pointer to the second ipv6 address
|
||||
*
|
||||
* @return
|
||||
* 1 if equal
|
||||
* 0 otherwise
|
||||
*/
|
||||
static inline int
|
||||
rte_rib6_is_equal(uint8_t *ip1, uint8_t *ip2) {
|
||||
int i;
|
||||
|
||||
if ((ip1 == NULL) || (ip2 == NULL))
|
||||
return 0;
|
||||
for (i = 0; i < RTE_RIB6_IPV6_ADDR_SIZE; i++) {
|
||||
if (ip1[i] != ip2[i])
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get 8-bit part of 128-bit IPv6 mask
|
||||
*
|
||||
* @param depth
|
||||
* ipv6 prefix length
|
||||
* @param byte
|
||||
* position of a 8-bit chunk in the 128-bit mask
|
||||
*
|
||||
* @return
|
||||
* 8-bit chunk of the 128-bit IPv6 mask
|
||||
*/
|
||||
static inline uint8_t
|
||||
get_msk_part(uint8_t depth, int byte) {
|
||||
uint8_t part;
|
||||
|
||||
byte &= 0xf;
|
||||
depth = RTE_MIN(depth, 128);
|
||||
part = RTE_MAX((int16_t)depth - (byte * 8), 0);
|
||||
part = (part > 8) ? 8 : part;
|
||||
return (uint16_t)(~UINT8_MAX) >> part;
|
||||
}
|
||||
|
||||
/**
|
||||
* Lookup an IP into the RIB structure
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @param ip
|
||||
* IP to be looked up in the RIB
|
||||
* @return
|
||||
* pointer to struct rte_rib6_node on success
|
||||
* NULL otherwise
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE]);
|
||||
|
||||
/**
|
||||
* Lookup less specific route into the RIB structure
|
||||
*
|
||||
* @param ent
|
||||
* Pointer to struct rte_rib6_node that represents target route
|
||||
* @return
|
||||
* pointer to struct rte_rib6_node that represents
|
||||
* less specific route on success
|
||||
* NULL otherwise
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup_parent(struct rte_rib6_node *ent);
|
||||
|
||||
/**
|
||||
* Provides exact mach lookup of the prefix into the RIB structure
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @param ip
|
||||
* net to be looked up in the RIB
|
||||
* @param depth
|
||||
* prefix length
|
||||
* @return
|
||||
* pointer to struct rte_rib6_node on success
|
||||
* NULL otherwise
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_lookup_exact(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth);
|
||||
|
||||
/**
|
||||
* Retrieve next more specific prefix from the RIB
|
||||
* that is covered by ip/depth supernet in an ascending order
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @param ip
|
||||
* net address of supernet prefix that covers returned more specific prefixes
|
||||
* @param depth
|
||||
* supernet prefix length
|
||||
* @param last
|
||||
* pointer to the last returned prefix to get next prefix
|
||||
* or
|
||||
* NULL to get first more specific prefix
|
||||
* @param flag
|
||||
* -RTE_RIB6_GET_NXT_ALL
|
||||
* get all prefixes from subtrie
|
||||
* -RTE_RIB6_GET_NXT_COVER
|
||||
* get only first more specific prefix even if it have more specifics
|
||||
* @return
|
||||
* pointer to the next more specific prefix
|
||||
* NULL if there is no prefixes left
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_get_nxt(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE],
|
||||
uint8_t depth, struct rte_rib6_node *last, int flag);
|
||||
|
||||
/**
|
||||
* Remove prefix from the RIB
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @param ip
|
||||
* net to be removed from the RIB
|
||||
* @param depth
|
||||
* prefix length
|
||||
*/
|
||||
__rte_experimental
|
||||
void
|
||||
rte_rib6_remove(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth);
|
||||
|
||||
/**
|
||||
* Insert prefix into the RIB
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @param ip
|
||||
* net to be inserted to the RIB
|
||||
* @param depth
|
||||
* prefix length
|
||||
* @return
|
||||
* pointer to new rte_rib6_node on success
|
||||
* NULL otherwise
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6_node *
|
||||
rte_rib6_insert(struct rte_rib6 *rib,
|
||||
const uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE], uint8_t depth);
|
||||
|
||||
/**
|
||||
* Get an ip from rte_rib6_node
|
||||
*
|
||||
* @param node
|
||||
* pointer to the rib6 node
|
||||
* @param ip
|
||||
* pointer to the ipv6 to save
|
||||
* @return
|
||||
* 0 on success
|
||||
* -1 on failure with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
int
|
||||
rte_rib6_get_ip(struct rte_rib6_node *node,
|
||||
uint8_t ip[RTE_RIB6_IPV6_ADDR_SIZE]);
|
||||
|
||||
/**
|
||||
* Get a depth from rte_rib6_node
|
||||
*
|
||||
* @param node
|
||||
* pointer to the rib6 node
|
||||
* @param depth
|
||||
* pointer to the depth to save
|
||||
* @return
|
||||
* 0 on success
|
||||
* -1 on failure with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
int
|
||||
rte_rib6_get_depth(struct rte_rib6_node *node, uint8_t *depth);
|
||||
|
||||
/**
|
||||
* Get ext field from the rte_rib6_node
|
||||
* It is caller responsibility to make sure there are necessary space
|
||||
* for the ext field inside rib6 node.
|
||||
*
|
||||
* @param node
|
||||
* pointer to the rte_rib6_node
|
||||
* @return
|
||||
* pointer to the ext
|
||||
*/
|
||||
__rte_experimental
|
||||
void *
|
||||
rte_rib6_get_ext(struct rte_rib6_node *node);
|
||||
|
||||
/**
|
||||
* Get nexthop from the rte_rib6_node
|
||||
*
|
||||
* @param node
|
||||
* pointer to the rib6 node
|
||||
* @param nh
|
||||
* pointer to the nexthop to save
|
||||
* @return
|
||||
* 0 on success
|
||||
* -1 on failure, with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
int
|
||||
rte_rib6_get_nh(struct rte_rib6_node *node, uint64_t *nh);
|
||||
|
||||
/**
|
||||
* Set nexthop into the rte_rib6_node
|
||||
*
|
||||
* @param node
|
||||
* pointer to the rib6 node
|
||||
* @param nh
|
||||
* nexthop value to set to the rib6 node
|
||||
* @return
|
||||
* 0 on success
|
||||
* -1 on failure, with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
int
|
||||
rte_rib6_set_nh(struct rte_rib6_node *node, uint64_t nh);
|
||||
|
||||
/**
|
||||
* Create RIB
|
||||
*
|
||||
* @param name
|
||||
* RIB name
|
||||
* @param socket_id
|
||||
* NUMA socket ID for RIB table memory allocation
|
||||
* @param conf
|
||||
* Structure containing the configuration
|
||||
* @return
|
||||
* Pointer to RIB object on success
|
||||
* NULL otherwise with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6 *
|
||||
rte_rib6_create(const char *name, int socket_id, struct rte_rib6_conf *conf);
|
||||
|
||||
/**
|
||||
* Find an existing RIB object and return a pointer to it.
|
||||
*
|
||||
* @param name
|
||||
* Name of the rib object as passed to rte_rib_create()
|
||||
* @return
|
||||
* Pointer to RIB object on success
|
||||
* NULL otherwise with rte_errno indicating reason for failure.
|
||||
*/
|
||||
__rte_experimental
|
||||
struct rte_rib6 *
|
||||
rte_rib6_find_existing(const char *name);
|
||||
|
||||
/**
|
||||
* Free an RIB object.
|
||||
*
|
||||
* @param rib
|
||||
* RIB object handle
|
||||
* @return
|
||||
* None
|
||||
*/
|
||||
__rte_experimental
|
||||
void
|
||||
rte_rib6_free(struct rte_rib6 *rib);
|
||||
|
||||
#endif /* _RTE_RIB_H_ */
|
||||
@ -16,5 +16,20 @@ EXPERIMENTAL {
|
||||
rte_rib_set_nh;
|
||||
rte_rib_remove;
|
||||
|
||||
rte_rib6_create;
|
||||
rte_rib6_find_existing;
|
||||
rte_rib6_free;
|
||||
rte_rib6_get_depth;
|
||||
rte_rib6_get_ext;
|
||||
rte_rib6_get_ip;
|
||||
rte_rib6_get_nh;
|
||||
rte_rib6_get_nxt;
|
||||
rte_rib6_insert;
|
||||
rte_rib6_lookup;
|
||||
rte_rib6_lookup_parent;
|
||||
rte_rib6_lookup_exact;
|
||||
rte_rib6_set_nh;
|
||||
rte_rib6_remove;
|
||||
|
||||
local: *;
|
||||
};
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user