X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_reorder%2Frte_reorder.c;h=9445853b79cc7bba919cb615d4a88f577025478d;hb=039b769f7c018351fbadf240f7dd692d3b02518f;hp=dc0e8062527d05f605af02e572629cb14995e4d2;hpb=a2348166ea186506d45b61d5073d16ad974e79bb;p=dpdk.git diff --git a/lib/librte_reorder/rte_reorder.c b/lib/librte_reorder/rte_reorder.c index dc0e806252..9445853b79 100644 --- a/lib/librte_reorder/rte_reorder.c +++ b/lib/librte_reorder/rte_reorder.c @@ -1,45 +1,18 @@ -/*- - * 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. +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation */ #include #include +#include #include #include -#include +#include #include #include #include +#include #include "rte_reorder.h" @@ -57,6 +30,9 @@ EAL_REGISTER_TAILQ(rte_reorder_tailq) /* Macros for printing using RTE_LOG */ #define RTE_LOGTYPE_REORDER RTE_LOGTYPE_USER1 +#define RTE_REORDER_SEQN_DYNFIELD_NAME "rte_reorder_seqn_dynfield" +int rte_reorder_seqn_dynfield_offset = -1; + /* A generic circular buffer */ struct cir_buffer { unsigned int size; /**< Number of entries that can be stored */ @@ -73,6 +49,7 @@ struct rte_reorder_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 */ + int is_initialized; } __rte_cache_aligned; static void @@ -111,7 +88,7 @@ rte_reorder_init(struct rte_reorder_buffer *b, unsigned int bufsize, } memset(b, 0, bufsize); - snprintf(b->name, sizeof(b->name), "%s", name); + strlcpy(b->name, name, sizeof(b->name)); b->memsize = bufsize; b->order_buf.size = b->ready_buf.size = size; b->order_buf.mask = b->ready_buf.mask = size - 1; @@ -130,6 +107,11 @@ rte_reorder_create(const char *name, unsigned socket_id, unsigned int size) struct rte_reorder_list *reorder_list; const unsigned int bufsize = sizeof(struct rte_reorder_buffer) + (2 * size * sizeof(struct rte_mbuf *)); + static const struct rte_mbuf_dynfield reorder_seqn_dynfield_desc = { + .name = RTE_REORDER_SEQN_DYNFIELD_NAME, + .size = sizeof(rte_reorder_seqn_t), + .align = __alignof__(rte_reorder_seqn_t), + }; reorder_list = RTE_TAILQ_CAST(rte_reorder_tailq.head, rte_reorder_list); @@ -147,7 +129,15 @@ rte_reorder_create(const char *name, unsigned socket_id, unsigned int size) return NULL; } - rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); + rte_reorder_seqn_dynfield_offset = + rte_mbuf_dynfield_register(&reorder_seqn_dynfield_desc); + if (rte_reorder_seqn_dynfield_offset < 0) { + RTE_LOG(ERR, REORDER, "Failed to register mbuf field for reorder sequence number\n"); + rte_errno = ENOMEM; + return NULL; + } + + rte_mcfg_tailq_write_lock(); /* guarantee there's no existing */ TAILQ_FOREACH(te, reorder_list, next) { @@ -180,7 +170,7 @@ rte_reorder_create(const char *name, unsigned socket_id, unsigned int size) } exit: - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); return b; } @@ -190,7 +180,7 @@ 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); + strlcpy(name, b->name, sizeof(name)); /* No error checking as current values should be valid */ rte_reorder_init(b, b->memsize, name, b->order_buf.size); } @@ -221,7 +211,7 @@ rte_reorder_free(struct rte_reorder_buffer *b) reorder_list = RTE_TAILQ_CAST(rte_reorder_tailq.head, rte_reorder_list); - rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_lock(); /* find our tailq entry */ TAILQ_FOREACH(te, reorder_list, next) { @@ -229,13 +219,13 @@ rte_reorder_free(struct rte_reorder_buffer *b) break; } if (te == NULL) { - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); return; } TAILQ_REMOVE(reorder_list, te, next); - rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_write_unlock(); rte_reorder_free_mbufs(b); @@ -250,15 +240,20 @@ rte_reorder_find_existing(const char *name) struct rte_tailq_entry *te; struct rte_reorder_list *reorder_list; + if (name == NULL) { + rte_errno = EINVAL; + return NULL; + } + reorder_list = RTE_TAILQ_CAST(rte_reorder_tailq.head, rte_reorder_list); - rte_rwlock_read_lock(RTE_EAL_TAILQ_RWLOCK); + rte_mcfg_tailq_read_lock(); 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); + rte_mcfg_tailq_read_unlock(); if (te == NULL) { rte_errno = ENOENT; @@ -323,7 +318,18 @@ 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; + struct cir_buffer *order_buf; + + if (b == NULL || mbuf == NULL) { + rte_errno = EINVAL; + return -1; + } + + order_buf = &b->order_buf; + if (!b->is_initialized) { + b->min_seqn = *rte_reorder_seqn(mbuf); + b->is_initialized = 1; + } /* * calculate the offset from the head pointer we need to go. @@ -333,7 +339,7 @@ rte_reorder_insert(struct rte_reorder_buffer *b, struct rte_mbuf *mbuf) * mbuf_seqn = 0x0010 * offset = 0x0010 - 0xFFFD = 0x13 */ - offset = mbuf->seqn - b->min_seqn; + offset = *rte_reorder_seqn(mbuf) - b->min_seqn; /* * action to take depends on offset. @@ -363,7 +369,7 @@ rte_reorder_insert(struct rte_reorder_buffer *b, struct rte_mbuf *mbuf) rte_errno = ENOSPC; return -1; } - offset = mbuf->seqn - b->min_seqn; + offset = *rte_reorder_seqn(mbuf) - b->min_seqn; position = (order_buf->head + offset) & order_buf->mask; order_buf->entries[position] = mbuf; } else {