} __rte_cache_aligned;
#endif /* RTE_MEMPOOL_CACHE_MAX_SIZE > 0 */
+/**
+ * A structure that stores the size of mempool elements.
+ */
struct rte_mempool_objsz {
uint32_t elt_size; /**< Size of an element. */
uint32_t header_size; /**< Size of header (before elt). */
/** Mempool over one chunk of physically continuous memory */
#define MEMPOOL_PG_NUM_DEFAULT 1
+#ifndef RTE_MEMPOOL_ALIGN
+#define RTE_MEMPOOL_ALIGN RTE_CACHE_LINE_SIZE
+#endif
+
+#define RTE_MEMPOOL_ALIGN_MASK (RTE_MEMPOOL_ALIGN - 1)
+
+/**
+ * Mempool object header structure
+ *
+ * Each object stored in mempools are prefixed by this header structure,
+ * it allows to retrieve the mempool pointer from the object. When debug
+ * is enabled, a cookie is also added in this structure preventing
+ * corruptions and double-frees.
+ */
+struct rte_mempool_objhdr {
+ struct rte_mempool *mp; /**< The mempool owning the object. */
+#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
+ uint64_t cookie; /**< Debug cookie. */
+#endif
+};
+
+/**
+ * Mempool object trailer structure
+ *
+ * In debug mode, each object stored in mempools are suffixed by this
+ * trailer structure containing a cookie preventing memory corruptions.
+ */
+struct rte_mempool_objtlr {
+#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
+ uint64_t cookie; /**< Debug cookie. */
+#endif
+};
+
/**
* The RTE mempool structure.
*/
uintptr_t elt_va_end;
/**< Virtual address of the <size + 1> mempool object. */
phys_addr_t elt_pa[MEMPOOL_PG_NUM_DEFAULT];
- /**< Array of physical pages addresses for the mempool objects buffer. */
+ /**< Array of physical page addresses for the mempool objects buffer. */
} __rte_cache_aligned;
/**
* @internal When debug is enabled, store some statistics.
+ *
* @param mp
* Pointer to the memory pool.
* @param name
#endif
/**
- * Calculates size of the mempool header.
+ * Calculate the size of the mempool header.
+ *
* @param mp
* Pointer to the memory pool.
* @param pgn
- * Number of page used to store mempool objects.
+ * Number of pages used to store mempool objects.
*/
#define MEMPOOL_HEADER_SIZE(mp, pgn) (sizeof(*(mp)) + \
RTE_ALIGN_CEIL(((pgn) - RTE_DIM((mp)->elt_pa)) * \
sizeof ((mp)->elt_pa[0]), RTE_CACHE_LINE_SIZE))
/**
- * Returns TRUE if whole mempool is allocated in one contiguous block of memory.
+ * Return true if the whole mempool is in contiguous memory.
*/
#define MEMPOOL_IS_CONTIG(mp) \
((mp)->pg_num == MEMPOOL_PG_NUM_DEFAULT && \
(mp)->phys_addr == (mp)->elt_pa[0])
-/**
- * @internal Get a pointer to a mempool pointer in the object header.
- * @param obj
- * Pointer to object.
- * @return
- * The pointer to the mempool from which the object was allocated.
- */
-static inline struct rte_mempool **__mempool_from_obj(void *obj)
+/* return the header of a mempool object (internal) */
+static inline struct rte_mempool_objhdr *__mempool_get_header(void *obj)
{
- struct rte_mempool **mpp;
- unsigned off;
+ return RTE_PTR_SUB(obj, sizeof(struct rte_mempool_objhdr));
+}
- off = sizeof(struct rte_mempool *);
-#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
- off += sizeof(uint64_t);
-#endif
- mpp = (struct rte_mempool **)((char *)obj - off);
- return mpp;
+/* return the trailer of a mempool object (internal) */
+static inline struct rte_mempool_objtlr *__mempool_get_trailer(void *obj)
+{
+ return RTE_PTR_SUB(obj, sizeof(struct rte_mempool_objtlr));
}
/**
* @return
* A pointer to the mempool structure.
*/
-static inline const struct rte_mempool *rte_mempool_from_obj(void *obj)
+static inline struct rte_mempool *rte_mempool_from_obj(void *obj)
{
- struct rte_mempool * const *mpp;
- mpp = __mempool_from_obj(obj);
- return *mpp;
+ struct rte_mempool_objhdr *hdr = __mempool_get_header(obj);
+ return hdr->mp;
}
-#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
-/* get header cookie value */
-static inline uint64_t __mempool_read_header_cookie(const void *obj)
-{
- return *(const uint64_t *)((const char *)obj - sizeof(uint64_t));
-}
-
-/* get trailer cookie value */
-static inline uint64_t __mempool_read_trailer_cookie(void *obj)
-{
- struct rte_mempool **mpp = __mempool_from_obj(obj);
- return *(uint64_t *)((char *)obj + (*mpp)->elt_size);
-}
-
-/* write header cookie value */
-static inline void __mempool_write_header_cookie(void *obj, int free)
-{
- uint64_t *cookie_p;
- cookie_p = (uint64_t *)((char *)obj - sizeof(uint64_t));
- if (free == 0)
- *cookie_p = RTE_MEMPOOL_HEADER_COOKIE1;
- else
- *cookie_p = RTE_MEMPOOL_HEADER_COOKIE2;
-
-}
-
-/* write trailer cookie value */
-static inline void __mempool_write_trailer_cookie(void *obj)
-{
- uint64_t *cookie_p;
- struct rte_mempool **mpp = __mempool_from_obj(obj);
- cookie_p = (uint64_t *)((char *)obj + (*mpp)->elt_size);
- *cookie_p = RTE_MEMPOOL_TRAILER_COOKIE;
-}
-#endif /* RTE_LIBRTE_MEMPOOL_DEBUG */
-
/**
* @internal Check and update cookies or panic.
*
void * const *obj_table_const,
unsigned n, int free)
{
+ struct rte_mempool_objhdr *hdr;
+ struct rte_mempool_objtlr *tlr;
uint64_t cookie;
void *tmp;
void *obj;
rte_panic("MEMPOOL: object is owned by another "
"mempool\n");
- cookie = __mempool_read_header_cookie(obj);
+ hdr = __mempool_get_header(obj);
+ cookie = hdr->cookie;
if (free == 0) {
if (cookie != RTE_MEMPOOL_HEADER_COOKIE1) {
obj, (const void *) mp, cookie);
rte_panic("MEMPOOL: bad header cookie (put)\n");
}
- __mempool_write_header_cookie(obj, 1);
+ hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE2;
}
else if (free == 1) {
if (cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
obj, (const void *) mp, cookie);
rte_panic("MEMPOOL: bad header cookie (get)\n");
}
- __mempool_write_header_cookie(obj, 0);
+ hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE1;
}
else if (free == 2) {
if (cookie != RTE_MEMPOOL_HEADER_COOKIE1 &&
rte_panic("MEMPOOL: bad header cookie (audit)\n");
}
}
- cookie = __mempool_read_trailer_cookie(obj);
+ tlr = __mempool_get_trailer(obj);
+ cookie = tlr->cookie;
if (cookie != RTE_MEMPOOL_TRAILER_COOKIE) {
rte_log_set_history(0);
RTE_LOG(CRIT, MEMPOOL,
#endif /* RTE_LIBRTE_MEMPOOL_DEBUG */
/**
- * An mempool's object iterator callback function.
+ * A mempool object iterator callback function.
*/
typedef void (*rte_mempool_obj_iter_t)(void * /*obj_iter_arg*/,
void * /*obj_start*/,
void * /*obj_end*/,
uint32_t /*obj_index */);
-/*
- * Iterates across objects of the given size and alignment in the
+/**
+ * Call a function for each mempool object in a memory chunk
+ *
+ * Iterate across objects of the given size and alignment in the
* provided chunk of memory. The given memory buffer can consist of
- * disjoint physical pages.
- * For each object calls the provided callback (if any).
- * Used to populate mempool, walk through all elements of the mempool,
- * estimate how many elements of the given size could be created in the given
- * memory buffer.
+ * disjointed physical pages.
+ *
+ * For each object, call the provided callback (if any). This function
+ * is used to populate a mempool, or walk through all the elements of a
+ * mempool, or estimate how many elements of the given size could be
+ * created in the given memory buffer.
+ *
* @param vaddr
* Virtual address of the memory buffer.
* @param elt_num
* Maximum number of objects to iterate through.
* @param elt_sz
* Size of each object.
+ * @param align
+ * Alignment of each object.
* @param paddr
- * Array of phyiscall addresses of the pages that comprises given memory
+ * Array of physical addresses of the pages that comprises given memory
* buffer.
* @param pg_num
* Number of elements in the paddr array.
* @param obj_iter
* Object iterator callback function (could be NULL).
* @param obj_iter_arg
- * User defined Prameter for the object iterator callback function.
+ * User defined parameter for the object iterator callback function.
*
* @return
* Number of objects iterated through.
*/
-
uint32_t rte_mempool_obj_iter(void *vaddr,
uint32_t elt_num, size_t elt_sz, size_t align,
const phys_addr_t paddr[], uint32_t pg_num, uint32_t pg_shift,
typedef void (rte_mempool_ctor_t)(struct rte_mempool *, void *);
/**
- * Creates a new mempool named *name* in memory.
+ * Create a new mempool named *name* in memory.
*
* This function uses ``memzone_reserve()`` to allocate memory. The
* pool contains n elements of elt_size. Its size is set to n.
* If cache_size is non-zero, the rte_mempool library will try to
* limit the accesses to the common lockless pool, by maintaining a
* per-lcore object cache. This argument must be lower or equal to
- * CONFIG_RTE_MEMPOOL_CACHE_MAX_SIZE. It is advised to choose
+ * CONFIG_RTE_MEMPOOL_CACHE_MAX_SIZE and n / 1.5. It is advised to choose
* cache_size to have "n modulo cache_size == 0": if this is
* not the case, some elements will always stay in the pool and will
* never be used. The access to the per-lcore table is of course
int socket_id, unsigned flags);
/**
- * Creates a new mempool named *name* in memory.
+ * Create a new mempool named *name* in memory.
*
* This function uses ``memzone_reserve()`` to allocate memory. The
* pool contains n elements of elt_size. Its size is set to n.
* Depending on the input parameters, mempool elements can be either allocated
* together with the mempool header, or an externally provided memory buffer
* could be used to store mempool objects. In later case, that external
- * memory buffer can consist of set of disjoint phyiscal pages.
+ * memory buffer can consist of set of disjoint physical pages.
*
* @param name
* The name of the mempool.
* Virtual address of the externally allocated memory buffer.
* Will be used to store mempool objects.
* @param paddr
- * Array of phyiscall addresses of the pages that comprises given memory
+ * Array of physical addresses of the pages that comprises given memory
* buffer.
* @param pg_num
* Number of elements in the paddr array.
#ifdef RTE_LIBRTE_XEN_DOM0
/**
- * Creates a new mempool named *name* in memory on Xen Dom0.
+ * Create a new mempool named *name* in memory on Xen Dom0.
*
* This function uses ``rte_mempool_xmem_create()`` to allocate memory. The
* pool contains n elements of elt_size. Its size is set to n.
* All elements of the mempool are allocated together with the mempool header,
- * and memory buffer can consist of set of disjoint phyiscal pages.
+ * and memory buffer can consist of set of disjoint physical pages.
*
* @param name
* The name of the mempool.
struct rte_mempool *rte_mempool_lookup(const char *name);
/**
+ * Get the header, trailer and total size of a mempool element.
+ *
* Given a desired size of the mempool element and mempool flags,
- * caluclates header, trailer, body and total sizes of the mempool object.
+ * calculates header, trailer, body and total sizes of the mempool object.
+ *
* @param elt_size
* The size of each element.
* @param flags
* The flags used for the mempool creation.
* Consult rte_mempool_create() for more information about possible values.
* The size of each element.
+ * @param sz
+ * The calculated detailed size the mempool object. May be NULL.
* @return
* Total size of the mempool object.
*/
struct rte_mempool_objsz *sz);
/**
- * Calculate maximum amount of memory required to store given number of objects.
- * Assumes that the memory buffer will be aligned at page boundary.
- * Note, that if object size is bigger then page size, then it assumes that
- * we have a subsets of physically continuous pages big enough to store
- * at least one object.
+ * Get the size of memory required to store mempool elements.
+ *
+ * Calculate the maximum amount of memory required to store given number
+ * of objects. Assume that the memory buffer will be aligned at page
+ * boundary.
+ *
+ * Note that if object size is bigger then page size, then it assumes
+ * that pages are grouped in subsets of physically continuous pages big
+ * enough to store at least one object.
+ *
* @param elt_num
* Number of elements.
* @param elt_sz
uint32_t pg_shift);
/**
+ * Get the size of memory required to store mempool elements.
+ *
* Calculate how much memory would be actually required with the given
* memory footprint to store required number of objects.
+ *
* @param vaddr
* Virtual address of the externally allocated memory buffer.
* Will be used to store mempool objects.
* @param elt_sz
* The size of each element.
* @param paddr
- * Array of phyiscall addresses of the pages that comprises given memory
+ * Array of physical addresses of the pages that comprises given memory
* buffer.
* @param pg_num
* Number of elements in the paddr array.
* @param pg_shift
* LOG2 of the physical pages size.
* @return
- * Number of bytes needed to store given number of objects,
- * aligned to the given page size.
- * If provided memory buffer is not big enough:
- * (-1) * actual number of elemnts that can be stored in that buffer.
+ * On success, the number of bytes needed to store given number of
+ * objects, aligned to the given page size. If the provided memory
+ * buffer is too small, return a negative value whose absolute value
+ * is the actual number of elements that can be stored in that buffer.
*/
ssize_t rte_mempool_xmem_usage(void *vaddr, uint32_t elt_num, size_t elt_sz,
const phys_addr_t paddr[], uint32_t pg_num, uint32_t pg_shift);