mempool: get memory size with unspecified page size
[dpdk.git] / lib / librte_mempool / rte_mempool.h
index 3314651..53275e4 100644 (file)
@@ -2,6 +2,7 @@
  *   BSD LICENSE
  *
  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2016 6WIND S.A.
  *   All rights reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
@@ -95,7 +96,6 @@ struct rte_mempool_debug_stats {
 } __rte_cache_aligned;
 #endif
 
-#if RTE_MEMPOOL_CACHE_MAX_SIZE > 0
 /**
  * A structure that stores a per-core object cache.
  */
@@ -107,8 +107,10 @@ struct rte_mempool_cache {
         */
        void *objs[RTE_MEMPOOL_CACHE_MAX_SIZE * 3]; /**< Cache objects */
 } __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). */
@@ -139,6 +141,74 @@ struct rte_mempool_objsz {
 /** 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 and to
+ * iterate on all objects attached to a mempool. When debug is enabled,
+ * a cookie is also added in this structure preventing corruptions and
+ * double-frees.
+ */
+struct rte_mempool_objhdr {
+       STAILQ_ENTRY(rte_mempool_objhdr) next; /**< Next in list. */
+       struct rte_mempool *mp;          /**< The mempool owning the object. */
+       phys_addr_t physaddr;            /**< Physical address of the object. */
+#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
+       uint64_t cookie;                 /**< Debug cookie. */
+#endif
+};
+
+/**
+ * A list of object headers type
+ */
+STAILQ_HEAD(rte_mempool_objhdr_list, rte_mempool_objhdr);
+
+/**
+ * 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
+};
+
+/**
+ * A list of memory where objects are stored
+ */
+STAILQ_HEAD(rte_mempool_memhdr_list, rte_mempool_memhdr);
+
+/**
+ * Callback used to free a memory chunk
+ */
+typedef void (rte_mempool_memchunk_free_cb_t)(struct rte_mempool_memhdr *memhdr,
+       void *opaque);
+
+/**
+ * Mempool objects memory header structure
+ *
+ * The memory chunks where objects are stored. Each chunk is virtually
+ * and physically contiguous.
+ */
+struct rte_mempool_memhdr {
+       STAILQ_ENTRY(rte_mempool_memhdr) next; /**< Next in list. */
+       struct rte_mempool *mp;  /**< The mempool owning the chunk */
+       void *addr;              /**< Virtual address of the chunk */
+       phys_addr_t phys_addr;   /**< Physical address of the chunk */
+       size_t len;              /**< length of the chunk */
+       rte_mempool_memchunk_free_cb_t *free_cb; /**< Free callback */
+       void *opaque;            /**< Argument passed to the free callback */
+};
+
 /**
  * The RTE mempool structure.
  */
@@ -147,7 +217,8 @@ struct rte_mempool {
        struct rte_ring *ring;           /**< Ring to store objects. */
        phys_addr_t phys_addr;           /**< Phys. addr. of mempool struct. */
        int flags;                       /**< Flags of the mempool. */
-       uint32_t size;                   /**< Size of the mempool. */
+       int socket_id;                   /**< Socket id passed at mempool creation. */
+       uint32_t size;                   /**< Max size of the mempool. */
        uint32_t cache_size;             /**< Size of per-lcore local cache. */
        uint32_t cache_flushthresh;
        /**< Threshold before we flush excess elements. */
@@ -158,38 +229,27 @@ struct rte_mempool {
 
        unsigned private_data_size;      /**< Size of private data. */
 
-#if RTE_MEMPOOL_CACHE_MAX_SIZE > 0
-       /** Per-lcore local cache. */
-       struct rte_mempool_cache local_cache[RTE_MAX_LCORE];
-#endif
+       struct rte_mempool_cache *local_cache; /**< Per-lcore local cache */
+
+       uint32_t populated_size;         /**< Number of populated objects. */
+       struct rte_mempool_objhdr_list elt_list; /**< List of objects in pool */
+       uint32_t nb_mem_chunks;          /**< Number of memory chunks */
+       struct rte_mempool_memhdr_list mem_list; /**< List of memory chunks */
 
 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
        /** Per-lcore statistics. */
        struct rte_mempool_debug_stats stats[RTE_MAX_LCORE];
 #endif
-
-       /* Address translation support, starts from next cache line. */
-
-       /** Number of elements in the elt_pa array. */
-       uint32_t    pg_num __rte_cache_aligned;
-       uint32_t    pg_shift;     /**< LOG2 of the physical pages. */
-       uintptr_t   pg_mask;      /**< physical page mask value. */
-       uintptr_t   elt_va_start;
-       /**< Virtual address of the first mempool object. */
-       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. */
-
 }  __rte_cache_aligned;
 
-#define MEMPOOL_F_NO_SPREAD      0x0001 /**< Do not spread in memory. */
+#define MEMPOOL_F_NO_SPREAD      0x0001 /**< Do not spread among memory channels. */
 #define MEMPOOL_F_NO_CACHE_ALIGN 0x0002 /**< Do not align objs on cache lines.*/
 #define MEMPOOL_F_SP_PUT         0x0004 /**< Default put is "single-producer".*/
 #define MEMPOOL_F_SC_GET         0x0008 /**< Default get is "single-consumer".*/
 
 /**
  * @internal When debug is enabled, store some statistics.
+ *
  * @param mp
  *   Pointer to the memory pool.
  * @param name
@@ -198,51 +258,34 @@ struct rte_mempool {
  *   Number to add to the object-oriented statistics.
  */
 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
-#define __MEMPOOL_STAT_ADD(mp, name, n) do {                   \
-               unsigned __lcore_id = rte_lcore_id();           \
-               mp->stats[__lcore_id].name##_objs += n;         \
-               mp->stats[__lcore_id].name##_bulk += 1;         \
+#define __MEMPOOL_STAT_ADD(mp, name, n) do {                    \
+               unsigned __lcore_id = rte_lcore_id();           \
+               if (__lcore_id < RTE_MAX_LCORE) {               \
+                       mp->stats[__lcore_id].name##_objs += n; \
+                       mp->stats[__lcore_id].name##_bulk += 1; \
+               }                                               \
        } while(0)
 #else
 #define __MEMPOOL_STAT_ADD(mp, name, n) do {} while(0)
 #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.
+ * @param cs
+ *   Size of the per-lcore cache.
  */
-#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))
+#define MEMPOOL_HEADER_SIZE(mp, cs) \
+       (sizeof(*(mp)) + (((cs) == 0) ? 0 : \
+       (sizeof(struct rte_mempool_cache) * RTE_MAX_LCORE)))
 
-/**
- * Returns TRUE if whole mempool is allocated in one contiguous block of 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;
-
-       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 (struct rte_mempool_objhdr *)RTE_PTR_SUB(obj,
+               sizeof(struct rte_mempool_objhdr));
 }
 
 /**
@@ -254,48 +297,18 @@ static inline struct rte_mempool **__mempool_from_obj(void *obj)
  * @return
  *   A pointer to the mempool structure.
  */
-static inline const struct rte_mempool *rte_mempool_from_obj(void *obj)
-{
-       struct rte_mempool * const *mpp;
-       mpp = __mempool_from_obj(obj);
-       return *mpp;
-}
-
-#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)
+static inline struct rte_mempool *rte_mempool_from_obj(void *obj)
 {
-       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;
-
+       struct rte_mempool_objhdr *hdr = __mempool_get_header(obj);
+       return hdr->mp;
 }
 
-/* write trailer cookie value */
-static inline void __mempool_write_trailer_cookie(void *obj)
+/* return the trailer of a mempool object (internal) */
+static inline struct rte_mempool_objtlr *__mempool_get_trailer(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;
+       struct rte_mempool *mp = rte_mempool_from_obj(obj);
+       return (struct rte_mempool_objtlr *)RTE_PTR_ADD(obj, mp->elt_size);
 }
-#endif /* RTE_LIBRTE_MEMPOOL_DEBUG */
 
 /**
  * @internal Check and update cookies or panic.
@@ -311,132 +324,33 @@ static inline void __mempool_write_trailer_cookie(void *obj)
  *   - 1: object is supposed to be free, mark it as allocated
  *   - 2: just check that cookie is valid (free or allocated)
  */
+void rte_mempool_check_cookies(const struct rte_mempool *mp,
+       void * const *obj_table_const, unsigned n, int free);
+
 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
-#ifndef __INTEL_COMPILER
-#pragma GCC diagnostic ignored "-Wcast-qual"
-#endif
-static inline void __mempool_check_cookies(const struct rte_mempool *mp,
-                                          void * const *obj_table_const,
-                                          unsigned n, int free)
-{
-       uint64_t cookie;
-       void *tmp;
-       void *obj;
-       void **obj_table;
-
-       /* Force to drop the "const" attribute. This is done only when
-        * DEBUG is enabled */
-       tmp = (void *) obj_table_const;
-       obj_table = (void **) tmp;
-
-       while (n--) {
-               obj = obj_table[n];
-
-               if (rte_mempool_from_obj(obj) != mp)
-                       rte_panic("MEMPOOL: object is owned by another "
-                                 "mempool\n");
-
-               cookie = __mempool_read_header_cookie(obj);
-
-               if (free == 0) {
-                       if (cookie != RTE_MEMPOOL_HEADER_COOKIE1) {
-                               rte_log_set_history(0);
-                               RTE_LOG(CRIT, MEMPOOL,
-                                       "obj=%p, mempool=%p, cookie=%"PRIx64"\n",
-                                       obj, mp, cookie);
-                               rte_panic("MEMPOOL: bad header cookie (put)\n");
-                       }
-                       __mempool_write_header_cookie(obj, 1);
-               }
-               else if (free == 1) {
-                       if (cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
-                               rte_log_set_history(0);
-                               RTE_LOG(CRIT, MEMPOOL,
-                                       "obj=%p, mempool=%p, cookie=%"PRIx64"\n",
-                                       obj, mp, cookie);
-                               rte_panic("MEMPOOL: bad header cookie (get)\n");
-                       }
-                       __mempool_write_header_cookie(obj, 0);
-               }
-               else if (free == 2) {
-                       if (cookie != RTE_MEMPOOL_HEADER_COOKIE1 &&
-                           cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
-                               rte_log_set_history(0);
-                               RTE_LOG(CRIT, MEMPOOL,
-                                       "obj=%p, mempool=%p, cookie=%"PRIx64"\n",
-                                       obj, mp, cookie);
-                               rte_panic("MEMPOOL: bad header cookie (audit)\n");
-                       }
-               }
-               cookie = __mempool_read_trailer_cookie(obj);
-               if (cookie != RTE_MEMPOOL_TRAILER_COOKIE) {
-                       rte_log_set_history(0);
-                       RTE_LOG(CRIT, MEMPOOL,
-                               "obj=%p, mempool=%p, cookie=%"PRIx64"\n",
-                               obj, mp, cookie);
-                       rte_panic("MEMPOOL: bad trailer cookie\n");
-               }
-       }
-}
-#ifndef __INTEL_COMPILER
-#pragma GCC diagnostic error "-Wcast-qual"
-#endif
+#define __mempool_check_cookies(mp, obj_table_const, n, free) \
+       rte_mempool_check_cookies(mp, obj_table_const, n, free)
 #else
 #define __mempool_check_cookies(mp, obj_table_const, n, free) do {} while(0)
 #endif /* RTE_LIBRTE_MEMPOOL_DEBUG */
 
 /**
- * An mempool's 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
- * 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.
- * @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 paddr
- *   Array of phyiscall 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.
- * @param obj_iter
- *   Object iterator callback function (could be NULL).
- * @param obj_iter_arg
- *   User defined Prameter for the object iterator callback function.
+ * An object callback function for mempool.
  *
- * @return
- *   Number of objects iterated through.
+ * Used by rte_mempool_create() and rte_mempool_obj_iter().
  */
-
-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,
-       rte_mempool_obj_iter_t obj_iter, void *obj_iter_arg);
+typedef void (rte_mempool_obj_cb_t)(struct rte_mempool *mp,
+               void *opaque, void *obj, unsigned obj_idx);
+typedef rte_mempool_obj_cb_t rte_mempool_obj_ctor_t; /* compat */
 
 /**
- * An object constructor callback function for mempool.
+ * A memory callback function for mempool.
  *
- * Arguments are the mempool, the opaque pointer given by the user in
- * rte_mempool_create(), the pointer to the element and the index of
- * the element in the pool.
+ * Used by rte_mempool_mem_iter().
  */
-typedef void (rte_mempool_obj_ctor_t)(struct rte_mempool *, void *,
-                                     void *, unsigned);
+typedef void (rte_mempool_mem_cb_t)(struct rte_mempool *mp,
+               void *opaque, struct rte_mempool_memhdr *memhdr,
+               unsigned mem_idx);
 
 /**
  * A mempool constructor callback function.
@@ -447,7 +361,7 @@ typedef void (rte_mempool_obj_ctor_t)(struct rte_mempool *, void *,
 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.
@@ -466,7 +380,7 @@ typedef void (rte_mempool_ctor_t)(struct rte_mempool *, void *);
  *   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
@@ -522,7 +436,6 @@ typedef void (rte_mempool_ctor_t)(struct rte_mempool *, void *);
  *   with rte_errno set appropriately. Possible rte_errno values include:
  *    - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
  *    - E_RTE_SECONDARY - function was called from a secondary process instance
- *    - E_RTE_NO_TAILQ - no tailq list could be got for the ring or mempool list
  *    - EINVAL - cache size provided is too large
  *    - ENOSPC - the maximum number of memzones has already been allocated
  *    - EEXIST - a memzone with the same name already exists
@@ -532,18 +445,19 @@ struct rte_mempool *
 rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
                   unsigned cache_size, unsigned private_data_size,
                   rte_mempool_ctor_t *mp_init, void *mp_init_arg,
-                  rte_mempool_obj_ctor_t *obj_init, void *obj_init_arg,
+                  rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
                   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.
+ * The pool contains n elements of elt_size. Its size is set to n.
+ * This function uses ``memzone_reserve()`` to allocate the mempool header
+ * (and the objects if vaddr is NULL).
  * 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.
@@ -554,18 +468,7 @@ rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
  * @param elt_size
  *   The size of each element.
  * @param cache_size
- *   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
- *   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
- *   faster than the multi-producer/consumer pool. The cache can be
- *   disabled if the cache_size argument is set to 0; it can be useful to
- *   avoid losing objects in cache. Note that even if not used, the
- *   memory space for cache is always reserved in a mempool structure,
- *   except if CONFIG_RTE_MEMPOOL_CACHE_MAX_SIZE is set to 0.
+ *   Size of the cache. See rte_mempool_create() for details.
  * @param private_data_size
  *   The size of the private data appended after the mempool
  *   structure. This is useful for storing some private data after the
@@ -579,40 +482,22 @@ rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
  *   An opaque pointer to data that can be used in the mempool
  *   constructor function.
  * @param obj_init
- *   A function pointer that is called for each object at
- *   initialization of the pool. The user can set some meta data in
- *   objects if needed. This parameter can be NULL if not needed.
- *   The obj_init() function takes the mempool pointer, the init_arg,
- *   the object pointer and the object number as parameters.
+ *   A function called for each object at initialization of the pool.
+ *   See rte_mempool_create() for details.
  * @param obj_init_arg
- *   An opaque pointer to data that can be used as an argument for
- *   each call to the object constructor function.
+ *   An opaque pointer passed to the object constructor function.
  * @param socket_id
  *   The *socket_id* argument is the socket identifier in the case of
  *   NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA
  *   constraint for the reserved zone.
  * @param flags
- *   The *flags* arguments is an OR of following flags:
- *   - MEMPOOL_F_NO_SPREAD: By default, objects addresses are spread
- *     between channels in RAM: the pool allocator will add padding
- *     between objects depending on the hardware configuration. See
- *     Memory alignment constraints for details. If this flag is set,
- *     the allocator will just align them to a cache line.
- *   - MEMPOOL_F_NO_CACHE_ALIGN: By default, the returned objects are
- *     cache-aligned. This flag removes this constraint, and no
- *     padding will be present between objects. This flag implies
- *     MEMPOOL_F_NO_SPREAD.
- *   - MEMPOOL_F_SP_PUT: If this flag is set, the default behavior
- *     when using rte_mempool_put() or rte_mempool_put_bulk() is
- *     "single-producer". Otherwise, it is "multi-producers".
- *   - MEMPOOL_F_SC_GET: If this flag is set, the default behavior
- *     when using rte_mempool_get() or rte_mempool_get_bulk() is
- *     "single-consumer". Otherwise, it is "multi-consumers".
+ *   Flags controlling the behavior of the mempool. See
+ *   rte_mempool_create() for details.
  * @param vaddr
  *   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.
@@ -620,31 +505,23 @@ rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
  *   LOG2 of the physical pages size.
  * @return
  *   The pointer to the new allocated mempool, on success. NULL on error
- *   with rte_errno set appropriately. Possible rte_errno values include:
- *    - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
- *    - E_RTE_SECONDARY - function was called from a secondary process instance
- *    - E_RTE_NO_TAILQ - no tailq list could be got for the ring or mempool list
- *    - EINVAL - cache size provided is too large
- *    - ENOSPC - the maximum number of memzones has already been allocated
- *    - EEXIST - a memzone with the same name already exists
- *    - ENOMEM - no appropriate memory area found in which to create memzone
+ *   with rte_errno set appropriately. See rte_mempool_create() for details.
  */
 struct rte_mempool *
 rte_mempool_xmem_create(const char *name, unsigned n, unsigned elt_size,
                unsigned cache_size, unsigned private_data_size,
                rte_mempool_ctor_t *mp_init, void *mp_init_arg,
-               rte_mempool_obj_ctor_t *obj_init, void *obj_init_arg,
+               rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
                int socket_id, unsigned flags, void *vaddr,
                const phys_addr_t paddr[], uint32_t pg_num, uint32_t pg_shift);
 
-#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.
@@ -714,7 +591,6 @@ rte_mempool_xmem_create(const char *name, unsigned n, unsigned elt_size,
  *   with rte_errno set appropriately. Possible rte_errno values include:
  *    - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
  *    - E_RTE_SECONDARY - function was called from a secondary process instance
- *    - E_RTE_NO_TAILQ - no tailq list could be got for the ring or mempool list
  *    - EINVAL - cache size provided is too large
  *    - ENOSPC - the maximum number of memzones has already been allocated
  *    - EEXIST - a memzone with the same name already exists
@@ -724,9 +600,45 @@ struct rte_mempool *
 rte_dom0_mempool_create(const char *name, unsigned n, unsigned elt_size,
                unsigned cache_size, unsigned private_data_size,
                rte_mempool_ctor_t *mp_init, void *mp_init_arg,
-               rte_mempool_obj_ctor_t *obj_init, void *obj_init_arg,
+               rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
                int socket_id, unsigned flags);
-#endif
+
+
+/**
+ * Call a function for each mempool element
+ *
+ * Iterate across all objects attached to a rte_mempool and call the
+ * callback function on it.
+ *
+ * @param mp
+ *   A pointer to an initialized mempool.
+ * @param obj_cb
+ *   A function pointer that is called for each object.
+ * @param obj_cb_arg
+ *   An opaque pointer passed to the callback function.
+ * @return
+ *   Number of objects iterated.
+ */
+uint32_t rte_mempool_obj_iter(struct rte_mempool *mp,
+       rte_mempool_obj_cb_t *obj_cb, void *obj_cb_arg);
+
+/**
+ * Call a function for each mempool memory chunk
+ *
+ * Iterate across all memory chunks attached to a rte_mempool and call
+ * the callback function on it.
+ *
+ * @param mp
+ *   A pointer to an initialized mempool.
+ * @param mem_cb
+ *   A function pointer that is called for each memory chunk.
+ * @param mem_cb_arg
+ *   An opaque pointer passed to the callback function.
+ * @return
+ *   Number of memory chunks iterated.
+ */
+uint32_t rte_mempool_mem_iter(struct rte_mempool *mp,
+       rte_mempool_mem_cb_t *mem_cb, void *mem_cb_arg);
 
 /**
  * Dump the status of the mempool to the console.
@@ -736,7 +648,7 @@ rte_dom0_mempool_create(const char *name, unsigned n, unsigned elt_size,
  * @param mp
  *   A pointer to the mempool structure.
  */
-void rte_mempool_dump(FILE *f, const struct rte_mempool *mp);
+void rte_mempool_dump(FILE *f, struct rte_mempool *mp);
 
 /**
  * @internal Put several objects back in the mempool; used internally.
@@ -754,21 +666,19 @@ static inline void __attribute__((always_inline))
 __mempool_put_bulk(struct rte_mempool *mp, void * const *obj_table,
                    unsigned n, int is_mp)
 {
-#if RTE_MEMPOOL_CACHE_MAX_SIZE > 0
        struct rte_mempool_cache *cache;
        uint32_t index;
        void **cache_objs;
        unsigned lcore_id = rte_lcore_id();
        uint32_t cache_size = mp->cache_size;
        uint32_t flushthresh = mp->cache_flushthresh;
-#endif /* RTE_MEMPOOL_CACHE_MAX_SIZE > 0 */
 
        /* increment stat now, adding in mempool always success */
        __MEMPOOL_STAT_ADD(mp, put, n);
 
-#if RTE_MEMPOOL_CACHE_MAX_SIZE > 0
-       /* cache is not enabled or single producer */
-       if (unlikely(cache_size == 0 || is_mp == 0))
+       /* cache is not enabled or single producer or non-EAL thread */
+       if (unlikely(cache_size == 0 || is_mp == 0 ||
+                    lcore_id >= RTE_MAX_LCORE))
                goto ring_enqueue;
 
        /* Go straight to ring if put would overflow mem allocated for cache */
@@ -800,7 +710,6 @@ __mempool_put_bulk(struct rte_mempool *mp, void * const *obj_table,
        return;
 
 ring_enqueue:
-#endif /* RTE_MEMPOOL_CACHE_MAX_SIZE > 0 */
 
        /* push remaining objects in ring */
 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
@@ -944,7 +853,6 @@ __mempool_get_bulk(struct rte_mempool *mp, void **obj_table,
                   unsigned n, int is_mc)
 {
        int ret;
-#if RTE_MEMPOOL_CACHE_MAX_SIZE > 0
        struct rte_mempool_cache *cache;
        uint32_t index, len;
        void **cache_objs;
@@ -952,7 +860,8 @@ __mempool_get_bulk(struct rte_mempool *mp, void **obj_table,
        uint32_t cache_size = mp->cache_size;
 
        /* cache is not enabled or single consumer */
-       if (unlikely(cache_size == 0 || is_mc == 0 || n >= cache_size))
+       if (unlikely(cache_size == 0 || is_mc == 0 ||
+                    n >= cache_size || lcore_id >= RTE_MAX_LCORE))
                goto ring_dequeue;
 
        cache = &mp->local_cache[lcore_id];
@@ -989,7 +898,6 @@ __mempool_get_bulk(struct rte_mempool *mp, void **obj_table,
        return 0;
 
 ring_dequeue:
-#endif /* RTE_MEMPOOL_CACHE_MAX_SIZE > 0 */
 
        /* get remaining objects from ring */
        if (is_mc)
@@ -1251,13 +1159,13 @@ rte_mempool_empty(const struct rte_mempool *mp)
  *   The physical address of the elt element.
  */
 static inline phys_addr_t
-rte_mempool_virt2phy(const struct rte_mempool *mp, const void *elt)
+rte_mempool_virt2phy(__rte_unused const struct rte_mempool *mp, const void *elt)
 {
        if (rte_eal_has_hugepages()) {
-               uintptr_t off;
-
-               off = (const char *)elt - (const char *)mp->elt_va_start;
-               return (mp->elt_pa[off >> mp->pg_shift] + (off & mp->pg_mask));
+               const struct rte_mempool_objhdr *hdr;
+               hdr = (const struct rte_mempool_objhdr *)RTE_PTR_SUB(elt,
+                       sizeof(*hdr));
+               return hdr->physaddr;
        } else {
                /*
                 * If huge pages are disabled, we cannot assume the
@@ -1278,7 +1186,7 @@ rte_mempool_virt2phy(const struct rte_mempool *mp, const void *elt)
  * @param mp
  *   A pointer to the mempool structure.
  */
-void rte_mempool_audit(const struct rte_mempool *mp);
+void rte_mempool_audit(struct rte_mempool *mp);
 
 /**
  * Return a pointer to the private data in an mempool structure.
@@ -1290,7 +1198,8 @@ void rte_mempool_audit(const struct rte_mempool *mp);
  */
 static inline void *rte_mempool_get_priv(struct rte_mempool *mp)
 {
-       return (char *)mp + MEMPOOL_HEADER_SIZE(mp, mp->pg_num);
+       return (char *)mp +
+               MEMPOOL_HEADER_SIZE(mp, mp->cache_size);
 }
 
 /**
@@ -1316,14 +1225,19 @@ void rte_mempool_list_dump(FILE *f);
 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.
+ *   The size of each element, without header and trailer.
  * @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.
  */
@@ -1331,48 +1245,59 @@ uint32_t rte_mempool_calc_obj_size(uint32_t elt_size, uint32_t flags,
        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
- *   The size of each element.
+ * @param total_elt_sz
+ *   The size of each element, including header and trailer, as returned
+ *   by rte_mempool_calc_obj_size().
  * @param pg_shift
- *   LOG2 of the physical pages size.
+ *   LOG2 of the physical pages size. If set to 0, ignore page boundaries.
  * @return
  *   Required memory size aligned at page boundary.
  */
-size_t rte_mempool_xmem_size(uint32_t elt_num, size_t elt_sz,
+size_t rte_mempool_xmem_size(uint32_t elt_num, size_t total_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_num
  *   Number of elements.
- * @param elt_sz
- *   The size of each element.
+ * @param total_elt_sz
+ *   The size of each element, including header and trailer, as returned
+ *   by rte_mempool_calc_obj_size().
  * @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);
+ssize_t rte_mempool_xmem_usage(void *vaddr, uint32_t elt_num,
+       size_t total_elt_sz, const phys_addr_t paddr[], uint32_t pg_num,
+       uint32_t pg_shift);
 
 /**
  * Walk list of all memory pools
@@ -1382,7 +1307,7 @@ ssize_t rte_mempool_xmem_usage(void *vaddr, uint32_t elt_num, size_t elt_sz,
  * @param arg
  *   Argument passed to iterator
  */
-void rte_mempool_walk(void (*func)(const struct rte_mempool *, void *arg),
+void rte_mempool_walk(void (*func)(struct rte_mempool *, void *arg),
                      void *arg);
 
 #ifdef __cplusplus