d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

reorder: new library

Browse Source 
This library provides reordering capability for out of order mbufs based
on a sequence number in the mbuf structure.

Signed-off-by: Reshma Pattan <reshma.pattan@intel.com>
Signed-off-by: Richardson Bruce <bruce.richardson@intel.com>
Signed-off-by: Sergio Gonzalez Monroy <sergio.gonzalez.monroy@intel.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Acked-by: Declan Doherty <declan.doherty@intel.com>
This commit is contained in:
Sergio Gonzalez Monroy 2015-02-18 14:58:13 +00:00 committed by Thomas Monjalon
parent c07691ae10
commit b70b56032b
9 changed files with 680 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
config/common_bsdapp
View File

@ -343,6 +343,11 @@ CONFIG_RTE_SCHED_PORT_N_GRINDERS=8
#
CONFIG_RTE_LIBRTE_DISTRIBUTOR=y
#
# Compile the reorder library
#
CONFIG_RTE_LIBRTE_REORDER=y
#
# Compile librte_port
#

5
config/common_linuxapp
View File

@ -351,6 +351,11 @@ CONFIG_RTE_SCHED_PORT_N_GRINDERS=8
#
CONFIG_RTE_LIBRTE_DISTRIBUTOR=y
#
# Compile the reorder library
#
CONFIG_RTE_LIBRTE_REORDER=y
#
# Compile librte_port
#

1
lib/Makefile
View File

@ -67,6 +67,7 @@ DIRS-$(CONFIG_RTE_LIBRTE_DISTRIBUTOR) += librte_distributor
DIRS-$(CONFIG_RTE_LIBRTE_PORT) += librte_port
DIRS-$(CONFIG_RTE_LIBRTE_TABLE) += librte_table
DIRS-$(CONFIG_RTE_LIBRTE_PIPELINE) += librte_pipeline
DIRS-$(CONFIG_RTE_LIBRTE_REORDER) += librte_reorder
ifeq ($(CONFIG_RTE_EXEC_ENV_LINUXAPP),y)
DIRS-$(CONFIG_RTE_LIBRTE_KNI) += librte_kni

2
lib/librte_eal/common/include/rte_tailq_elem.h
View File

@ -84,6 +84,8 @@ rte_tailq_elem(RTE_TAILQ_ACL, "RTE_ACL")
rte_tailq_elem(RTE_TAILQ_DISTRIBUTOR, "RTE_DISTRIBUTOR")
rte_tailq_elem(RTE_TAILQ_REORDER, "RTE_REORDER")
rte_tailq_end(RTE_TAILQ_NUM)
#undef rte_tailq_elem

3
lib/librte_mbuf/rte_mbuf.h
View File

@ -289,6 +289,9 @@ struct rte_mbuf {
uint32_t usr; /**< User defined tags. See @rte_distributor_process */
} hash; /**< hash information */
/* sequence number - field used in distributor and reorder library */
uint32_t seqn;
/* second cache line - fields only used in slow path or on TX */
MARKER cacheline1 __rte_cache_aligned;

54
lib/librte_reorder/Makefile Normal file
View File

@ -0,0 +1,54 @@
# 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.
include $(RTE_SDK)/mk/rte.vars.mk
# library name
LIB = librte_reorder.a
CFLAGS += -O3
CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR)
EXPORT_MAP := rte_reorder_version.map
LIBABIVER := 1
# all source are stored in SRCS-y
SRCS-$(CONFIG_RTE_LIBRTE_REORDER) := rte_reorder.c
# install this header file
SYMLINK-$(CONFIG_RTE_LIBRTE_REORDER)-include := rte_reorder.h
# this lib depends upon:
DEPDIRS-$(CONFIG_RTE_LIBRTE_REORDER) += lib/librte_mbuf
DEPDIRS-$(CONFIG_RTE_LIBRTE_REORDER) += lib/librte_eal
include $(RTE_SDK)/mk/rte.lib.mk

416
lib/librte_reorder/rte_reorder.c Normal file
View File

@ -0,0 +1,416 @@
/*-
* 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.
*/
#include <inttypes.h>
#include <string.h>
#include <rte_log.h>
#include <rte_mbuf.h>
#include <rte_memzone.h>
#include <rte_eal_memconfig.h>
#include <rte_errno.h>
#include <rte_tailq.h>
#include <rte_malloc.h>
#include "rte_reorder.h"
TAILQ_HEAD(rte_reorder_list, rte_tailq_entry);
#define NO_FLAGS 0
#define RTE_REORDER_PREFIX "RO_"
#define RTE_REORDER_NAMESIZE 32
/* Macros for printing using RTE_LOG */
#define RTE_LOGTYPE_REORDER RTE_LOGTYPE_USER1
/* A generic circular buffer */
struct cir_buffer {
unsigned int size; /**< Number of entries that can be stored */
unsigned int mask; /**< [buffer_size - 1]: used for wrap-around */
unsigned int head; /**< insertion point in buffer */
unsigned int tail; /**< extraction point in buffer */
struct rte_mbuf **entries;
} __rte_cache_aligned;
/* The reorder buffer data structure itself */
struct rte_reorder_buffer {
char name[RTE_REORDER_NAMESIZE];
uint32_t min_seqn; /**< Lowest seq. number that can be in the buffer */
unsigned int memsize; /**< memory area size of reorder buffer */
struct cir_buffer ready_buf; /**< temp buffer for dequeued entries */
struct cir_buffer order_buf; /**< buffer used to reorder entries */
} __rte_cache_aligned;
static void
rte_reorder_free_mbufs(struct rte_reorder_buffer *b);
struct rte_reorder_buffer *
rte_reorder_init(struct rte_reorder_buffer *b, unsigned int bufsize,
const char *name, unsigned int size)
{
const unsigned int min_bufsize = sizeof(*b) +
(2 * size * sizeof(struct rte_mbuf *));
if (b == NULL) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer parameter:"
" NULL\n");
rte_errno = EINVAL;
return NULL;
}
if (!rte_is_power_of_2(size)) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer size"
" - Not a power of 2\n");
rte_errno = EINVAL;
return NULL;
}
if (name == NULL) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer name ptr:"
" NULL\n");
rte_errno = EINVAL;
return NULL;
}
if (bufsize < min_bufsize) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer memory size: %u, "
"minimum required: %u\n", bufsize, min_bufsize);
rte_errno = EINVAL;
return NULL;
}
memset(b, 0, bufsize);
snprintf(b->name, sizeof(b->name), "%s", name);
b->memsize = bufsize;
b->order_buf.size = b->ready_buf.size = size;
b->order_buf.mask = b->ready_buf.mask = size - 1;
b->ready_buf.entries = (void *)&b[1];
b->order_buf.entries = RTE_PTR_ADD(&b[1],
size * sizeof(b->ready_buf.entries[0]));
return b;
}
struct rte_reorder_buffer*
rte_reorder_create(const char *name, unsigned socket_id, unsigned int size)
{
struct rte_reorder_buffer *b = NULL;
struct rte_tailq_entry *te;
struct rte_reorder_list *reorder_list;
const unsigned int bufsize = sizeof(struct rte_reorder_buffer) +
(2 * size * sizeof(struct rte_mbuf *));
/* check that we have an initialised tail queue */
reorder_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_REORDER, rte_reorder_list);
if (!reorder_list) {
rte_errno = E_RTE_NO_TAILQ;
return NULL;
}
/* Check user arguments. */
if (!rte_is_power_of_2(size)) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer size"
" - Not a power of 2\n");
rte_errno = EINVAL;
return NULL;
}
if (name == NULL) {
RTE_LOG(ERR, REORDER, "Invalid reorder buffer name ptr:"
" NULL\n");
rte_errno = EINVAL;
return NULL;
}
rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
/* guarantee there's no existing */
TAILQ_FOREACH(te, reorder_list, next) {
b = (struct rte_reorder_buffer *) te->data;
if (strncmp(name, b->name, RTE_REORDER_NAMESIZE) == 0)
break;
}
if (te != NULL)
goto exit;
/* allocate tailq entry */
te = rte_zmalloc("REORDER_TAILQ_ENTRY", sizeof(*te), 0);
if (te == NULL) {
RTE_LOG(ERR, REORDER, "Failed to allocate tailq entry\n");
rte_errno = ENOMEM;
b = NULL;
goto exit;
}
/* Allocate memory to store the reorder buffer structure. */
b = rte_zmalloc_socket("REORDER_BUFFER", bufsize, 0, socket_id);
if (b == NULL) {
RTE_LOG(ERR, REORDER, "Memzone allocation failed\n");
rte_errno = ENOMEM;
rte_free(te);
} else {
rte_reorder_init(b, bufsize, name, size);
te->data = (void *)b;
TAILQ_INSERT_TAIL(reorder_list, te, next);
}
exit:
rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
return b;
}
void
rte_reorder_reset(struct rte_reorder_buffer *b)
{
char name[RTE_REORDER_NAMESIZE];
rte_reorder_free_mbufs(b);
snprintf(name, sizeof(name), "%s", b->name);
/* No error checking as current values should be valid */
rte_reorder_init(b, b->memsize, name, b->order_buf.size);
}
static void
rte_reorder_free_mbufs(struct rte_reorder_buffer *b)
{
unsigned i;
/* Free up the mbufs of order buffer & ready buffer */
for (i = 0; i < b->order_buf.size; i++) {
if (b->order_buf.entries[i])
rte_pktmbuf_free(b->order_buf.entries[i]);
if (b->ready_buf.entries[i])
rte_pktmbuf_free(b->ready_buf.entries[i]);
}
}
void
rte_reorder_free(struct rte_reorder_buffer *b)
{
struct rte_reorder_list *reorder_list;
struct rte_tailq_entry *te;
/* Check user arguments. */
if (b == NULL)
return;
/* check that we have an initialised tail queue */
reorder_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_REORDER, rte_reorder_list);
if (!reorder_list) {
rte_errno = E_RTE_NO_TAILQ;
return;
}
rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
/* find our tailq entry */
TAILQ_FOREACH(te, reorder_list, next) {
if (te->data == (void *) b)
break;
}
if (te == NULL) {
rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
return;
}
TAILQ_REMOVE(reorder_list, te, next);
rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
rte_reorder_free_mbufs(b);
rte_free(b);
rte_free(te);
}
struct rte_reorder_buffer *
rte_reorder_find_existing(const char *name)
{
struct rte_reorder_buffer *b = NULL;
struct rte_tailq_entry *te;
struct rte_reorder_list *reorder_list;
/* check that we have an initialised tail queue */
reorder_list = RTE_TAILQ_LOOKUP_BY_IDX(RTE_TAILQ_REORDER, rte_reorder_list);
if (!reorder_list) {
rte_errno = E_RTE_NO_TAILQ;
return NULL;
}
rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK);
TAILQ_FOREACH(te, reorder_list, next) {
b = (struct rte_reorder_buffer *) te->data;
if (strncmp(name, b->name, RTE_REORDER_NAMESIZE) == 0)
break;
}
rte_rwlock_read_unlock(RTE_EAL_TAILQ_RWLOCK);
if (te == NULL) {
rte_errno = ENOENT;
return NULL;
}
return b;
}
static unsigned
rte_reorder_fill_overflow(struct rte_reorder_buffer *b, unsigned n)
{
/*
* 1. Move all ready entries that fit to the ready_buf
* 2. check if we meet the minimum needed (n).
* 3. If not, then skip any gaps and keep moving.
* 4. If at any point the ready buffer is full, stop
* 5. Return the number of positions the order_buf head has moved
*/
struct cir_buffer *order_buf = &b->order_buf,
*ready_buf = &b->ready_buf;
unsigned int order_head_adv = 0;
/*
* move at least n packets to ready buffer, assuming ready buffer
* has room for those packets.
*/
while (order_head_adv < n &&
((ready_buf->head + 1) & ready_buf->mask) != ready_buf->tail) {
/* if we are blocked waiting on a packet, skip it */
if (order_buf->entries[order_buf->head] == NULL) {
order_buf->head = (order_buf->head + 1) & order_buf->mask;
order_head_adv++;
}
/* Move all ready entries that fit to the ready_buf */
while (order_buf->entries[order_buf->head] != NULL) {
ready_buf->entries[ready_buf->head] =
order_buf->entries[order_buf->head];
order_buf->entries[order_buf->head] = NULL;
order_head_adv++;
order_buf->head = (order_buf->head + 1) & order_buf->mask;
if (((ready_buf->head + 1) & ready_buf->mask) == ready_buf->tail)
break;
ready_buf->head = (ready_buf->head + 1) & ready_buf->mask;
}
}
b->min_seqn += order_head_adv;
/* Return the number of positions the order_buf head has moved */
return order_head_adv;
}
int
rte_reorder_insert(struct rte_reorder_buffer *b, struct rte_mbuf *mbuf)
{
uint32_t offset, position;
struct cir_buffer *order_buf = &b->order_buf;
/*
* calculate the offset from the head pointer we need to go.
* The subtraction takes care of the sequence number wrapping.
* For example (using 16-bit for brevity):
* min_seqn = 0xFFFD
* mbuf_seqn = 0x0010
* offset = 0x0010 - 0xFFFD = 0x13
*/
offset = mbuf->seqn - b->min_seqn;
/*
* action to take depends on offset.
* offset < buffer->size: the mbuf fits within the current window of
* sequence numbers we can reorder. EXPECTED CASE.
* offset > buffer->size: the mbuf is outside the current window. There
* are a number of cases to consider:
* 1. The packet sequence is just outside the window, then we need
* to see about shifting the head pointer and taking any ready
* to return packets out of the ring. If there was a delayed
* or dropped packet preventing drains from shifting the window
* this case will skip over the dropped packet instead, and any
* packets dequeued here will be returned on the next drain call.
* 2. The packet sequence number is vastly outside our window, taken
* here as having offset greater than twice the buffer size. In
* this case, the packet is probably an old or late packet that
* was previously skipped, so just enqueue the packet for
* immediate return on the next drain call, or else return error.
*/
if (offset < b->order_buf.size) {
position = (order_buf->head + offset) & order_buf->mask;
order_buf->entries[position] = mbuf;
} else if (offset < 2 * b->order_buf.size) {
if (rte_reorder_fill_overflow(b, offset + 1 - order_buf->size)
< (offset + 1 - order_buf->size)) {
/* Put in handling for enqueue straight to output */
rte_errno = ENOSPC;
return -1;
}
offset = mbuf->seqn - b->min_seqn;
position = (order_buf->head + offset) & order_buf->mask;
order_buf->entries[position] = mbuf;
} else {
/* Put in handling for enqueue straight to output */
rte_errno = ERANGE;
return -1;
}
return 0;
}
unsigned int
rte_reorder_drain(struct rte_reorder_buffer *b, struct rte_mbuf **mbufs,
unsigned max_mbufs)
{
unsigned int drain_cnt = 0;
struct cir_buffer *order_buf = &b->order_buf,
*ready_buf = &b->ready_buf;
/* Try to fetch requested number of mbufs from ready buffer */
while ((drain_cnt < max_mbufs) && (ready_buf->tail != ready_buf->head)) {
mbufs[drain_cnt++] = ready_buf->entries[ready_buf->tail];
ready_buf->tail = (ready_buf->tail + 1) & ready_buf->mask;
}
/*
* If requested number of buffers not fetched from ready buffer, fetch
* remaining buffers from order buffer
*/
while ((drain_cnt < max_mbufs) &&
(order_buf->entries[order_buf->head] != NULL)) {
mbufs[drain_cnt++] = order_buf->entries[order_buf->head];
order_buf->entries[order_buf->head] = NULL;
b->min_seqn++;
order_buf->head = (order_buf->head + 1) & order_buf->mask;
}
return drain_cnt;
}

181
lib/librte_reorder/rte_reorder.h Normal file
View File

@ -0,0 +1,181 @@
/*-
* 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_REORDER_H_
#define _RTE_REORDER_H_
/**
* @file
* RTE reorder
*
* Reorder library is a component which is designed to
* provide ordering of out of ordered packets based on
* sequence number present in mbuf.
*
*/
#ifdef __cplusplus
extern "C" {
#endif
struct rte_reorder_buffer;
/**
* Create a new reorder buffer instance
*
* Allocate memory and initialize a new reorder buffer in that
* memory, returning the reorder buffer pointer to the user
*
* @param name
* The name to be given to the reorder buffer instance.
* @param socket_id
* The NUMA node on which the memory for the reorder buffer
* instance is to be reserved.
* @param size
* Max number of elements that can be stored in the reorder buffer
* @return
* The initialized reorder buffer instance, or NULL on error
* On error case, rte_errno will be set appropriately:
* - ENOMEM - no appropriate memory area found in which to create memzone
* - EINVAL - invalid parameters
*/
struct rte_reorder_buffer *
rte_reorder_create(const char *name, unsigned socket_id, unsigned int size);
/**
* Initializes given reorder buffer instance
*
* @param b
* Reorder buffer instance to initialize
* @param bufsize
* Size of the reorder buffer
* @param name
* The name to be given to the reorder buffer
* @param size
* Number of elements that can be stored in reorder buffer
* @return
* The initialized reorder buffer instance, or NULL on error
* On error case, rte_errno will be set appropriately:
* - EINVAL - invalid parameters
*/
struct rte_reorder_buffer *
rte_reorder_init(struct rte_reorder_buffer *b, unsigned int bufsize,
const char *name, unsigned int size);
/**
* Find an existing reorder buffer instance
* and return a pointer to it.
*
* @param name
* Name of the reorder buffer instacne as passed to rte_reorder_create()
* @return
* Pointer to reorder buffer instance or NULL if object not found with rte_errno
* set appropriately. Possible rte_errno values include:
* - ENOENT - required entry not available to return.
* - E_RTE_NO_TAILQ - no tailq list could be got for the
* reorder instance list
*/
struct rte_reorder_buffer *
rte_reorder_find_existing(const char *name);
/**
* Reset the given reorder buffer instance with initial values.
*
* @param b
* Reorder buffer instance which has to be reset
*/
void
rte_reorder_reset(struct rte_reorder_buffer *b);
/**
* Free reorder buffer instance.
*
* @param b
* reorder buffer instance
* @return
* None
*/
void
rte_reorder_free(struct rte_reorder_buffer *b);
/**
* Insert given mbuf in reorder buffer in its correct position
*
* The given mbuf is to be reordered relative to other mbufs in the system.
* The mbuf must contain a sequence number which is then used to place
* the buffer in the correct position in the reorder buffer. Reordered
* packets can later be taken from the buffer using the rte_reorder_drain()
* API.
*
* @param b
* Reorder buffer where the mbuf has to be inserted.
* @param mbuf
* mbuf of packet that needs to be inserted in reorder buffer.
* @return
* 0 on success
* -1 on error
* On error case, rte_errno will be set appropriately:
* - ENOSPC - Cannot move existing mbufs from reorder buffer to accommodate
* ealry mbuf, but it can be accomodated by performing drain and then insert.
* - ERANGE - Too early or late mbuf which is vastly out of range of expected
* window should be ingnored without any handling.
*/
int
rte_reorder_insert(struct rte_reorder_buffer *b, struct rte_mbuf *mbuf);
/**
* Fetch reordered buffers
*
* Returns a set of in-order buffers from the reorder buffer structure. Gaps
* may be present in the sequence numbers of the mbuf if packets have been
* delayed too long before reaching the reorder window, or have been previously
* dropped by the system.
*
* @param b
* Reorder buffer instance from which packets are to be drained
* @param mbufs
* array of mbufs where reordered packets will be inserted from reorder buffer
* @param max_mbufs
* the number of elements in the mbufs array.
* @return
* number of mbuf pointers written to mbufs. 0 <= N < max_mbufs.
*/
unsigned int
rte_reorder_drain(struct rte_reorder_buffer *b, struct rte_mbuf **mbufs,
unsigned max_mbufs);
#ifdef __cplusplus
}
#endif
#endif /* _RTE_REORDER_H_ */

13
lib/librte_reorder/rte_reorder_version.map Normal file
View File

@ -0,0 +1,13 @@
DPDK_2.0 {
global:
rte_reorder_create;
rte_reorder_init;
rte_reorder_find_existing;
rte_reorder_reset;
rte_reorder_free;
rte_reorder_insert;
rte_reorder_drain;
local: *;
};