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>

#ifdef __cplusplus
extern "C" {
#endif

#define RTE_LPM_NAMESIZE                32

#define RTE_LPM_HEAP                    0

#define RTE_LPM_MEMZONE                 1

#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_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 0x0300

#define RTE_LPM_LOOKUP_SUCCESS          0x0100

#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN

struct rte_lpm_tbl24_entry {
        /* Stores Next hop or group index (i.e. gindex)into tbl8. */
        union {
                uint8_t next_hop;
                uint8_t tbl8_gindex;
        };
        /* Using single uint8_t to store 3 values. */
        uint8_t valid     :1; 
        uint8_t ext_entry :1; 
        uint8_t depth     :6; 
};

struct rte_lpm_tbl8_entry {
        uint8_t next_hop; 
        /* Using single uint8_t to store 3 values. */
        uint8_t valid       :1; 
        uint8_t valid_group :1; 
        uint8_t depth       :6; 
};
#else
struct rte_lpm_tbl24_entry {
        uint8_t depth       :6;
        uint8_t ext_entry   :1;
        uint8_t valid       :1;
        union {
                uint8_t tbl8_gindex;
                uint8_t next_hop;
        };
};

struct rte_lpm_tbl8_entry {
        uint8_t depth       :6;
        uint8_t valid_group :1;
        uint8_t valid       :1;
        uint8_t next_hop;
};
#endif

struct rte_lpm_rule {
        uint32_t ip; 
        uint8_t  next_hop; 
};

struct rte_lpm_rule_info {
        uint32_t used_rules; 
        uint32_t first_rule; 
};

struct rte_lpm {
        /* LPM metadata. */
        char name[RTE_LPM_NAMESIZE];        
        int mem_location; 
        uint32_t max_rules; 
        struct rte_lpm_rule_info rule_info[RTE_LPM_MAX_DEPTH]; 
        /* LPM Tables. */
        struct rte_lpm_tbl24_entry tbl24[RTE_LPM_TBL24_NUM_ENTRIES] \
                        __rte_cache_aligned; 
        struct rte_lpm_tbl8_entry tbl8[RTE_LPM_TBL8_NUM_ENTRIES] \
                        __rte_cache_aligned; 
        struct rte_lpm_rule rules_tbl[0] \
                        __rte_cache_aligned; 
};

struct rte_lpm *
rte_lpm_create(const char *name, int socket_id, int max_rules, int flags);

struct rte_lpm *
rte_lpm_find_existing(const char *name);

void
rte_lpm_free(struct rte_lpm *lpm);

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

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

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

void
rte_lpm_delete_all(struct rte_lpm *lpm);

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

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

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

        /* 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 +
                                ((uint8_t)tbl_entry * RTE_LPM_TBL8_GROUP_NUM_ENTRIES);

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

        *next_hop = (uint8_t)tbl_entry;
        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,
                uint16_t * next_hops, const unsigned n)
{
        unsigned i;
        unsigned tbl24_indexes[n];

        /* 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 */
                next_hops[i] = *(const uint16_t *)&lpm->tbl24[tbl24_indexes[i]];

                /* 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] +
                                        ((uint8_t)next_hops[i] *
                                         RTE_LPM_TBL8_GROUP_NUM_ENTRIES);

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

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

static inline void
rte_lpm_lookupx4(const struct rte_lpm *lpm, __m128i ip, uint16_t hop[4],
        uint16_t defv)
{
        __m128i i24;
        rte_xmm_t i8;
        uint16_t tbl[4];
        uint64_t idx, pt;

        const __m128i mask8 =
                _mm_set_epi32(UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX);

        /*
         * RTE_LPM_VALID_EXT_ENTRY_BITMASK for 4 LPM entries
         * as one 64-bit value (0x0300030003000300).
         */
        const uint64_t mask_xv =
                ((uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK |
                (uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK << 16 |
                (uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK << 32 |
                (uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK << 48);

        /*
         * RTE_LPM_LOOKUP_SUCCESS for 4 LPM entries
         * as one 64-bit value (0x0100010001000100).
         */
        const uint64_t mask_v =
                ((uint64_t)RTE_LPM_LOOKUP_SUCCESS |
                (uint64_t)RTE_LPM_LOOKUP_SUCCESS << 16 |
                (uint64_t)RTE_LPM_LOOKUP_SUCCESS << 32 |
                (uint64_t)RTE_LPM_LOOKUP_SUCCESS << 48);

        /* get 4 indexes for tbl24[]. */
        i24 = _mm_srli_epi32(ip, CHAR_BIT);

        /* extract values from tbl24[] */
        idx = _mm_cvtsi128_si64(i24);
        i24 = _mm_srli_si128(i24, sizeof(uint64_t));

        tbl[0] = *(const uint16_t *)&lpm->tbl24[(uint32_t)idx];
        tbl[1] = *(const uint16_t *)&lpm->tbl24[idx >> 32];

        idx = _mm_cvtsi128_si64(i24);

        tbl[2] = *(const uint16_t *)&lpm->tbl24[(uint32_t)idx];
        tbl[3] = *(const uint16_t *)&lpm->tbl24[idx >> 32];

        /* get 4 indexes for tbl8[]. */
        i8.x = _mm_and_si128(ip, mask8);

        pt = (uint64_t)tbl[0] |
                (uint64_t)tbl[1] << 16 |
                (uint64_t)tbl[2] << 32 |
                (uint64_t)tbl[3] << 48;

        /* search successfully finished for all 4 IP addresses. */
        if (likely((pt & mask_xv) == mask_v)) {
                uintptr_t ph = (uintptr_t)hop;
                *(uint64_t *)ph = pt & RTE_LPM_MASKX4_RES;
                return;
        }

        if (unlikely((pt & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
                        RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {
                i8.u32[0] = i8.u32[0] +
                        (uint8_t)tbl[0] * RTE_LPM_TBL8_GROUP_NUM_ENTRIES;
                tbl[0] = *(const uint16_t *)&lpm->tbl8[i8.u32[0]];
        }
        if (unlikely((pt >> 16 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
                        RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {
                i8.u32[1] = i8.u32[1] +
                        (uint8_t)tbl[1] * RTE_LPM_TBL8_GROUP_NUM_ENTRIES;
                tbl[1] = *(const uint16_t *)&lpm->tbl8[i8.u32[1]];
        }
        if (unlikely((pt >> 32 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
                        RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {
                i8.u32[2] = i8.u32[2] +
                        (uint8_t)tbl[2] * RTE_LPM_TBL8_GROUP_NUM_ENTRIES;
                tbl[2] = *(const uint16_t *)&lpm->tbl8[i8.u32[2]];
        }
        if (unlikely((pt >> 48 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) ==
                        RTE_LPM_VALID_EXT_ENTRY_BITMASK)) {
                i8.u32[3] = i8.u32[3] +
                        (uint8_t)tbl[3] * RTE_LPM_TBL8_GROUP_NUM_ENTRIES;
                tbl[3] = *(const uint16_t *)&lpm->tbl8[i8.u32[3]];
        }

        hop[0] = (tbl[0] & RTE_LPM_LOOKUP_SUCCESS) ? (uint8_t)tbl[0] : defv;
        hop[1] = (tbl[1] & RTE_LPM_LOOKUP_SUCCESS) ? (uint8_t)tbl[1] : defv;
        hop[2] = (tbl[2] & RTE_LPM_LOOKUP_SUCCESS) ? (uint8_t)tbl[2] : defv;
        hop[3] = (tbl[3] & RTE_LPM_LOOKUP_SUCCESS) ? (uint8_t)tbl[3] : defv;
}

#ifdef __cplusplus
}
#endif

#endif /* _RTE_LPM_H_ */