rte_lpm.h

Go to the documentation of this file.

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _RTE_LPM_H_
#define _RTE_LPM_H_

#include <errno.h>
#include <sys/queue.h>
#include <stdint.h>
#include <stdlib.h>
#include <rte_branch_prediction.h>
#include <rte_byteorder.h>
#include <rte_memory.h>
#include <rte_common.h>
#include <rte_vect.h>
#include <rte_compat.h>

#ifdef __cplusplus
extern "C" {
#endif

#define RTE_LPM_NAMESIZE                32

#define RTE_LPM_MAX_DEPTH               32

#define RTE_LPM_TBL24_NUM_ENTRIES       (1 << 24)

#define RTE_LPM_TBL8_GROUP_NUM_ENTRIES  256

#define RTE_LPM_MAX_TBL8_NUM_GROUPS         (1 << 24)

#define RTE_LPM_TBL8_NUM_GROUPS         256

#define RTE_LPM_TBL8_NUM_ENTRIES        (RTE_LPM_TBL8_NUM_GROUPS * \
                    RTE_LPM_TBL8_GROUP_NUM_ENTRIES)

#if defined(RTE_LIBRTE_LPM_DEBUG)
#define RTE_LPM_RETURN_IF_TRUE(cond, retval) do { \
    if (cond) return (retval);                \
} while (0)
#else
#define RTE_LPM_RETURN_IF_TRUE(cond, retval)
#endif

#define RTE_LPM_VALID_EXT_ENTRY_BITMASK 0x03000000

#define RTE_LPM_LOOKUP_SUCCESS          0x01000000

#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN

__extension__
struct rte_lpm_tbl_entry_v20 {
    RTE_STD_C11
    union {
        uint8_t next_hop;
        uint8_t group_idx;
    };
    /* Using single uint8_t to store 3 values. */
    uint8_t valid     :1;   
    uint8_t valid_group :1;
    uint8_t depth       :6; 
};

__extension__
struct rte_lpm_tbl_entry {
    uint32_t next_hop    :24;
    /* Using single uint8_t to store 3 values. */
    uint32_t valid       :1;   
    uint32_t valid_group :1;
    uint32_t depth       :6; 
};

#else
__extension__
struct rte_lpm_tbl_entry_v20 {
    uint8_t depth       :6;
    uint8_t valid_group :1;
    uint8_t valid       :1;
    union {
        uint8_t group_idx;
        uint8_t next_hop;
    };
};

__extension__
struct rte_lpm_tbl_entry {
    uint32_t depth       :6;
    uint32_t valid_group :1;
    uint32_t valid       :1;
    uint32_t next_hop    :24;

};

#endif

struct rte_lpm_config {
    uint32_t max_rules;      
    uint32_t number_tbl8s;   
    int flags;               
};

struct rte_lpm_rule_v20 {
    uint32_t ip; 
    uint8_t  next_hop; 
};

struct rte_lpm_rule {
    uint32_t ip; 
    uint32_t next_hop; 
};

struct rte_lpm_rule_info {
    uint32_t used_rules; 
    uint32_t first_rule; 
};

struct rte_lpm_v20 {
    /* LPM metadata. */
    char name[RTE_LPM_NAMESIZE];        
    uint32_t max_rules; 
    struct rte_lpm_rule_info rule_info[RTE_LPM_MAX_DEPTH]; 
    /* LPM Tables. */
    struct rte_lpm_tbl_entry_v20 tbl24[RTE_LPM_TBL24_NUM_ENTRIES]
            __rte_cache_aligned; 
    struct rte_lpm_tbl_entry_v20 tbl8[RTE_LPM_TBL8_NUM_ENTRIES]
            __rte_cache_aligned; 
    struct rte_lpm_rule_v20 rules_tbl[]
            __rte_cache_aligned; 
};

struct rte_lpm {
    /* LPM metadata. */
    char name[RTE_LPM_NAMESIZE];        
    uint32_t max_rules; 
    uint32_t number_tbl8s; 
    struct rte_lpm_rule_info rule_info[RTE_LPM_MAX_DEPTH]; 
    /* LPM Tables. */
    struct rte_lpm_tbl_entry tbl24[RTE_LPM_TBL24_NUM_ENTRIES]
            __rte_cache_aligned; 
    struct rte_lpm_tbl_entry *tbl8; 
    struct rte_lpm_rule *rules_tbl; 
};

struct rte_lpm *
rte_lpm_create(const char *name, int socket_id,
        const struct rte_lpm_config *config);
struct rte_lpm_v20 *
rte_lpm_create_v20(const char *name, int socket_id, int max_rules, int flags);
struct rte_lpm *
rte_lpm_create_v1604(const char *name, int socket_id,
        const struct rte_lpm_config *config);

struct rte_lpm *
rte_lpm_find_existing(const char *name);
struct rte_lpm_v20 *
rte_lpm_find_existing_v20(const char *name);
struct rte_lpm *
rte_lpm_find_existing_v1604(const char *name);

void
rte_lpm_free(struct rte_lpm *lpm);
void
rte_lpm_free_v20(struct rte_lpm_v20 *lpm);
void
rte_lpm_free_v1604(struct rte_lpm *lpm);

int
rte_lpm_add(struct rte_lpm *lpm, uint32_t ip, uint8_t depth, uint32_t next_hop);
int
rte_lpm_add_v20(struct rte_lpm_v20 *lpm, uint32_t ip, uint8_t depth,
        uint8_t next_hop);
int
rte_lpm_add_v1604(struct rte_lpm *lpm, uint32_t ip, uint8_t depth,
        uint32_t next_hop);

int
rte_lpm_is_rule_present(struct rte_lpm *lpm, uint32_t ip, uint8_t depth,
uint32_t *next_hop);
int
rte_lpm_is_rule_present_v20(struct rte_lpm_v20 *lpm, uint32_t ip, uint8_t depth,
uint8_t *next_hop);
int
rte_lpm_is_rule_present_v1604(struct rte_lpm *lpm, uint32_t ip, uint8_t depth,
uint32_t *next_hop);

int
rte_lpm_delete(struct rte_lpm *lpm, uint32_t ip, uint8_t depth);
int
rte_lpm_delete_v20(struct rte_lpm_v20 *lpm, uint32_t ip, uint8_t depth);
int
rte_lpm_delete_v1604(struct rte_lpm *lpm, uint32_t ip, uint8_t depth);

void
rte_lpm_delete_all(struct rte_lpm *lpm);
void
rte_lpm_delete_all_v20(struct rte_lpm_v20 *lpm);
void
rte_lpm_delete_all_v1604(struct rte_lpm *lpm);

static inline int
rte_lpm_lookup(struct rte_lpm *lpm, uint32_t ip, uint32_t *next_hop)
{
    unsigned tbl24_index = (ip >> 8);
    uint32_t tbl_entry;
    const uint32_t *ptbl;

    /* DEBUG: Check user input arguments. */
    RTE_LPM_RETURN_IF_TRUE(((lpm == NULL) || (next_hop == NULL)), -EINVAL);

    /* Copy tbl24 entry */
    ptbl = (const uint32_t *)(&lpm->tbl24[tbl24_index]);
    tbl_entry = *ptbl;

    /* Copy tbl8 entry (only if needed) */
    if (unlikely((tbl_entry & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
            RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {

        unsigned tbl8_index = (uint8_t)ip +
                (((uint32_t)tbl_entry & 0x00FFFFFF) *
                        RTE_LPM_TBL8_GROUP_NUM_ENTRIES);

        ptbl = (const uint32_t *)&lpm->tbl8[tbl8_index];
        tbl_entry = *ptbl;
    }

    *next_hop = ((uint32_t)tbl_entry & 0x00FFFFFF);
    return (tbl_entry & RTE_LPM_LOOKUP_SUCCESS) ? 0 : -ENOENT;
}

#define rte_lpm_lookup_bulk(lpm, ips, next_hops, n) \
        rte_lpm_lookup_bulk_func(lpm, ips, next_hops, n)

static inline int
rte_lpm_lookup_bulk_func(const struct rte_lpm *lpm, const uint32_t *ips,
        uint32_t *next_hops, const unsigned n)
{
    unsigned i;
    unsigned tbl24_indexes[n];
    const uint32_t *ptbl;

    /* DEBUG: Check user input arguments. */
    RTE_LPM_RETURN_IF_TRUE(((lpm == NULL) || (ips == NULL) ||
            (next_hops == NULL)), -EINVAL);

    for (i = 0; i < n; i++) {
        tbl24_indexes[i] = ips[i] >> 8;
    }

    for (i = 0; i < n; i++) {
        /* Simply copy tbl24 entry to output */
        ptbl = (const uint32_t *)&lpm->tbl24[tbl24_indexes[i]];
        next_hops[i] = *ptbl;

        /* Overwrite output with tbl8 entry if needed */
        if (unlikely((next_hops[i] & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
                RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {

            unsigned tbl8_index = (uint8_t)ips[i] +
                    (((uint32_t)next_hops[i] & 0x00FFFFFF) *
                     RTE_LPM_TBL8_GROUP_NUM_ENTRIES);

            ptbl = (const uint32_t *)&lpm->tbl8[tbl8_index];
            next_hops[i] = *ptbl;
        }
    }
    return 0;
}

/* Mask four results. */
#define  RTE_LPM_MASKX4_RES UINT64_C(0x00ffffff00ffffff)

static inline void
rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],
    uint32_t defv);

#if defined(RTE_ARCH_ARM) || defined(RTE_ARCH_ARM64)
#include "rte_lpm_neon.h"
#elif defined(RTE_ARCH_PPC_64)
#include "rte_lpm_altivec.h"
#else
#include "rte_lpm_sse.h"
#endif

#ifdef __cplusplus
}
#endif

#endif /* _RTE_LPM_H_ */