lib/librte_mempool/rte_mempool.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   Copyright(c) 2016 6WIND S.A.
   6  *   All rights reserved.
   7  *
   8  *   Redistribution and use in source and binary forms, with or without
   9  *   modification, are permitted provided that the following conditions
  10  *   are met:
  11  *
  12  *     * Redistributions of source code must retain the above copyright
  13  *       notice, this list of conditions and the following disclaimer.
  14  *     * Redistributions in binary form must reproduce the above copyright
  15  *       notice, this list of conditions and the following disclaimer in
  16  *       the documentation and/or other materials provided with the
  17  *       distribution.
  18  *     * Neither the name of Intel Corporation nor the names of its
  19  *       contributors may be used to endorse or promote products derived
  20  *       from this software without specific prior written permission.
  21  *
  22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdint.h>
  38 #include <stdarg.h>
  39 #include <unistd.h>
  40 #include <inttypes.h>
  41 #include <errno.h>
  42 #include <sys/queue.h>
  43 #include <sys/mman.h>
  44
  45 #include <rte_common.h>
  46 #include <rte_log.h>
  47 #include <rte_debug.h>
  48 #include <rte_memory.h>
  49 #include <rte_memzone.h>
  50 #include <rte_malloc.h>
  51 #include <rte_atomic.h>
  52 #include <rte_launch.h>
  53 #include <rte_eal.h>
  54 #include <rte_eal_memconfig.h>
  55 #include <rte_per_lcore.h>
  56 #include <rte_lcore.h>
  57 #include <rte_branch_prediction.h>
  58 #include <rte_ring.h>
  59 #include <rte_errno.h>
  60 #include <rte_string_fns.h>
  61 #include <rte_spinlock.h>
  62
  63 #include "rte_mempool.h"
  64
  65 TAILQ_HEAD(rte_mempool_list, rte_tailq_entry);
  66
  67 static struct rte_tailq_elem rte_mempool_tailq = {
  68         .name = "RTE_MEMPOOL",
  69 };
  70 EAL_REGISTER_TAILQ(rte_mempool_tailq)
  71
  72 #define CACHE_FLUSHTHRESH_MULTIPLIER 1.5
  73 #define CALC_CACHE_FLUSHTHRESH(c)       \
  74         ((typeof(c))((c) * CACHE_FLUSHTHRESH_MULTIPLIER))
  75
  76 /*
  77  * return the greatest common divisor between a and b (fast algorithm)
  78  *
  79  */
  80 static unsigned get_gcd(unsigned a, unsigned b)
  81 {
  82         unsigned c;
  83
  84         if (0 == a)
  85                 return b;
  86         if (0 == b)
  87                 return a;
  88
  89         if (a < b) {
  90                 c = a;
  91                 a = b;
  92                 b = c;
  93         }
  94
  95         while (b != 0) {
  96                 c = a % b;
  97                 a = b;
  98                 b = c;
  99         }
 100
 101         return a;
 102 }
 103
 104 /*
 105  * Depending on memory configuration, objects addresses are spread
 106  * between channels and ranks in RAM: the pool allocator will add
 107  * padding between objects. This function return the new size of the
 108  * object.
 109  */
 110 static unsigned optimize_object_size(unsigned obj_size)
 111 {
 112         unsigned nrank, nchan;
 113         unsigned new_obj_size;
 114
 115         /* get number of channels */
 116         nchan = rte_memory_get_nchannel();
 117         if (nchan == 0)
 118                 nchan = 4;
 119
 120         nrank = rte_memory_get_nrank();
 121         if (nrank == 0)
 122                 nrank = 1;
 123
 124         /* process new object size */
 125         new_obj_size = (obj_size + RTE_MEMPOOL_ALIGN_MASK) / RTE_MEMPOOL_ALIGN;
 126         while (get_gcd(new_obj_size, nrank * nchan) != 1)
 127                 new_obj_size++;
 128         return new_obj_size * RTE_MEMPOOL_ALIGN;
 129 }
 130
 131 static void
 132 mempool_add_elem(struct rte_mempool *mp, void *obj, phys_addr_t physaddr)
 133 {
 134         struct rte_mempool_objhdr *hdr;
 135         struct rte_mempool_objtlr *tlr __rte_unused;
 136
 137         /* set mempool ptr in header */
 138         hdr = RTE_PTR_SUB(obj, sizeof(*hdr));
 139         hdr->mp = mp;
 140         hdr->physaddr = physaddr;
 141         STAILQ_INSERT_TAIL(&mp->elt_list, hdr, next);
 142         mp->populated_size++;
 143
 144 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 145         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE2;
 146         tlr = __mempool_get_trailer(obj);
 147         tlr->cookie = RTE_MEMPOOL_TRAILER_COOKIE;
 148 #endif
 149
 150         /* enqueue in ring */
 151         rte_ring_sp_enqueue(mp->ring, obj);
 152 }
 153
 154 /* call obj_cb() for each mempool element */
 155 uint32_t
 156 rte_mempool_obj_iter(struct rte_mempool *mp,
 157         rte_mempool_obj_cb_t *obj_cb, void *obj_cb_arg)
 158 {
 159         struct rte_mempool_objhdr *hdr;
 160         void *obj;
 161         unsigned n = 0;
 162
 163         STAILQ_FOREACH(hdr, &mp->elt_list, next) {
 164                 obj = (char *)hdr + sizeof(*hdr);
 165                 obj_cb(mp, obj_cb_arg, obj, n);
 166                 n++;
 167         }
 168
 169         return n;
 170 }
 171
 172 /* call mem_cb() for each mempool memory chunk */
 173 uint32_t
 174 rte_mempool_mem_iter(struct rte_mempool *mp,
 175         rte_mempool_mem_cb_t *mem_cb, void *mem_cb_arg)
 176 {
 177         struct rte_mempool_memhdr *hdr;
 178         unsigned n = 0;
 179
 180         STAILQ_FOREACH(hdr, &mp->mem_list, next) {
 181                 mem_cb(mp, mem_cb_arg, hdr, n);
 182                 n++;
 183         }
 184
 185         return n;
 186 }
 187
 188 /* get the header, trailer and total size of a mempool element. */
 189 uint32_t
 190 rte_mempool_calc_obj_size(uint32_t elt_size, uint32_t flags,
 191         struct rte_mempool_objsz *sz)
 192 {
 193         struct rte_mempool_objsz lsz;
 194
 195         sz = (sz != NULL) ? sz : &lsz;
 196
 197         sz->header_size = sizeof(struct rte_mempool_objhdr);
 198         if ((flags & MEMPOOL_F_NO_CACHE_ALIGN) == 0)
 199                 sz->header_size = RTE_ALIGN_CEIL(sz->header_size,
 200                         RTE_MEMPOOL_ALIGN);
 201
 202         sz->trailer_size = sizeof(struct rte_mempool_objtlr);
 203
 204         /* element size is 8 bytes-aligned at least */
 205         sz->elt_size = RTE_ALIGN_CEIL(elt_size, sizeof(uint64_t));
 206
 207         /* expand trailer to next cache line */
 208         if ((flags & MEMPOOL_F_NO_CACHE_ALIGN) == 0) {
 209                 sz->total_size = sz->header_size + sz->elt_size +
 210                         sz->trailer_size;
 211                 sz->trailer_size += ((RTE_MEMPOOL_ALIGN -
 212                                   (sz->total_size & RTE_MEMPOOL_ALIGN_MASK)) &
 213                                  RTE_MEMPOOL_ALIGN_MASK);
 214         }
 215
 216         /*
 217          * increase trailer to add padding between objects in order to
 218          * spread them across memory channels/ranks
 219          */
 220         if ((flags & MEMPOOL_F_NO_SPREAD) == 0) {
 221                 unsigned new_size;
 222                 new_size = optimize_object_size(sz->header_size + sz->elt_size +
 223                         sz->trailer_size);
 224                 sz->trailer_size = new_size - sz->header_size - sz->elt_size;
 225         }
 226
 227         /* this is the size of an object, including header and trailer */
 228         sz->total_size = sz->header_size + sz->elt_size + sz->trailer_size;
 229
 230         return sz->total_size;
 231 }
 232
 233
 234 /*
 235  * Calculate maximum amount of memory required to store given number of objects.
 236  */
 237 size_t
 238 rte_mempool_xmem_size(uint32_t elt_num, size_t total_elt_sz, uint32_t pg_shift)
 239 {
 240         size_t obj_per_page, pg_num, pg_sz;
 241
 242         if (pg_shift == 0)
 243                 return total_elt_sz * elt_num;
 244
 245         pg_sz = (size_t)1 << pg_shift;
 246         obj_per_page = pg_sz / total_elt_sz;
 247         if (obj_per_page == 0)
 248                 return RTE_ALIGN_CEIL(total_elt_sz, pg_sz) * elt_num;
 249
 250         pg_num = (elt_num + obj_per_page - 1) / obj_per_page;
 251         return pg_num << pg_shift;
 252 }
 253
 254 /*
 255  * Calculate how much memory would be actually required with the
 256  * given memory footprint to store required number of elements.
 257  */
 258 ssize_t
 259 rte_mempool_xmem_usage(__rte_unused void *vaddr, uint32_t elt_num,
 260         size_t total_elt_sz, const phys_addr_t paddr[], uint32_t pg_num,
 261         uint32_t pg_shift)
 262 {
 263         uint32_t elt_cnt = 0;
 264         phys_addr_t start, end;
 265         uint32_t paddr_idx;
 266         size_t pg_sz = (size_t)1 << pg_shift;
 267
 268         /* if paddr is NULL, assume contiguous memory */
 269         if (paddr == NULL) {
 270                 start = 0;
 271                 end = pg_sz * pg_num;
 272                 paddr_idx = pg_num;
 273         } else {
 274                 start = paddr[0];
 275                 end = paddr[0] + pg_sz;
 276                 paddr_idx = 1;
 277         }
 278         while (elt_cnt < elt_num) {
 279
 280                 if (end - start >= total_elt_sz) {
 281                         /* enough contiguous memory, add an object */
 282                         start += total_elt_sz;
 283                         elt_cnt++;
 284                 } else if (paddr_idx < pg_num) {
 285                         /* no room to store one obj, add a page */
 286                         if (end == paddr[paddr_idx]) {
 287                                 end += pg_sz;
 288                         } else {
 289                                 start = paddr[paddr_idx];
 290                                 end = paddr[paddr_idx] + pg_sz;
 291                         }
 292                         paddr_idx++;
 293
 294                 } else {
 295                         /* no more page, return how many elements fit */
 296                         return -(size_t)elt_cnt;
 297                 }
 298         }
 299
 300         return (size_t)paddr_idx << pg_shift;
 301 }
 302
 303 /* create the internal ring */
 304 static int
 305 rte_mempool_ring_create(struct rte_mempool *mp)
 306 {
 307         int rg_flags = 0, ret;
 308         char rg_name[RTE_RING_NAMESIZE];
 309         struct rte_ring *r;
 310
 311         ret = snprintf(rg_name, sizeof(rg_name),
 312                 RTE_MEMPOOL_MZ_FORMAT, mp->name);
 313         if (ret < 0 || ret >= (int)sizeof(rg_name))
 314                 return -ENAMETOOLONG;
 315
 316         /* ring flags */
 317         if (mp->flags & MEMPOOL_F_SP_PUT)
 318                 rg_flags |= RING_F_SP_ENQ;
 319         if (mp->flags & MEMPOOL_F_SC_GET)
 320                 rg_flags |= RING_F_SC_DEQ;
 321
 322         /* Allocate the ring that will be used to store objects.
 323          * Ring functions will return appropriate errors if we are
 324          * running as a secondary process etc., so no checks made
 325          * in this function for that condition.
 326          */
 327         r = rte_ring_create(rg_name, rte_align32pow2(mp->size + 1),
 328                 mp->socket_id, rg_flags);
 329         if (r == NULL)
 330                 return -rte_errno;
 331
 332         mp->ring = r;
 333         mp->flags |= MEMPOOL_F_RING_CREATED;
 334         return 0;
 335 }
 336
 337 /* free a memchunk allocated with rte_memzone_reserve() */
 338 static void
 339 rte_mempool_memchunk_mz_free(__rte_unused struct rte_mempool_memhdr *memhdr,
 340         void *opaque)
 341 {
 342         const struct rte_memzone *mz = opaque;
 343         rte_memzone_free(mz);
 344 }
 345
 346 /* Free memory chunks used by a mempool. Objects must be in pool */
 347 static void
 348 rte_mempool_free_memchunks(struct rte_mempool *mp)
 349 {
 350         struct rte_mempool_memhdr *memhdr;
 351         void *elt;
 352
 353         while (!STAILQ_EMPTY(&mp->elt_list)) {
 354                 rte_ring_sc_dequeue(mp->ring, &elt);
 355                 (void)elt;
 356                 STAILQ_REMOVE_HEAD(&mp->elt_list, next);
 357                 mp->populated_size--;
 358         }
 359
 360         while (!STAILQ_EMPTY(&mp->mem_list)) {
 361                 memhdr = STAILQ_FIRST(&mp->mem_list);
 362                 STAILQ_REMOVE_HEAD(&mp->mem_list, next);
 363                 if (memhdr->free_cb != NULL)
 364                         memhdr->free_cb(memhdr, memhdr->opaque);
 365                 rte_free(memhdr);
 366                 mp->nb_mem_chunks--;
 367         }
 368 }
 369
 370 /* Add objects in the pool, using a physically contiguous memory
 371  * zone. Return the number of objects added, or a negative value
 372  * on error.
 373  */
 374 int
 375 rte_mempool_populate_phys(struct rte_mempool *mp, char *vaddr,
 376         phys_addr_t paddr, size_t len, rte_mempool_memchunk_free_cb_t *free_cb,
 377         void *opaque)
 378 {
 379         unsigned total_elt_sz;
 380         unsigned i = 0;
 381         size_t off;
 382         struct rte_mempool_memhdr *memhdr;
 383         int ret;
 384
 385         /* create the internal ring if not already done */
 386         if ((mp->flags & MEMPOOL_F_RING_CREATED) == 0) {
 387                 ret = rte_mempool_ring_create(mp);
 388                 if (ret < 0)
 389                         return ret;
 390         }
 391
 392         /* mempool is already populated */
 393         if (mp->populated_size >= mp->size)
 394                 return -ENOSPC;
 395
 396         total_elt_sz = mp->header_size + mp->elt_size + mp->trailer_size;
 397
 398         memhdr = rte_zmalloc("MEMPOOL_MEMHDR", sizeof(*memhdr), 0);
 399         if (memhdr == NULL)
 400                 return -ENOMEM;
 401
 402         memhdr->mp = mp;
 403         memhdr->addr = vaddr;
 404         memhdr->phys_addr = paddr;
 405         memhdr->len = len;
 406         memhdr->free_cb = free_cb;
 407         memhdr->opaque = opaque;
 408
 409         if (mp->flags & MEMPOOL_F_NO_CACHE_ALIGN)
 410                 off = RTE_PTR_ALIGN_CEIL(vaddr, 8) - vaddr;
 411         else
 412                 off = RTE_PTR_ALIGN_CEIL(vaddr, RTE_CACHE_LINE_SIZE) - vaddr;
 413
 414         while (off + total_elt_sz <= len && mp->populated_size < mp->size) {
 415                 off += mp->header_size;
 416                 mempool_add_elem(mp, (char *)vaddr + off, paddr + off);
 417                 off += mp->elt_size + mp->trailer_size;
 418                 i++;
 419         }
 420
 421         /* not enough room to store one object */
 422         if (i == 0)
 423                 return -EINVAL;
 424
 425         STAILQ_INSERT_TAIL(&mp->mem_list, memhdr, next);
 426         mp->nb_mem_chunks++;
 427         return i;
 428 }
 429
 430 /* Add objects in the pool, using a table of physical pages. Return the
 431  * number of objects added, or a negative value on error.
 432  */
 433 int
 434 rte_mempool_populate_phys_tab(struct rte_mempool *mp, char *vaddr,
 435         const phys_addr_t paddr[], uint32_t pg_num, uint32_t pg_shift,
 436         rte_mempool_memchunk_free_cb_t *free_cb, void *opaque)
 437 {
 438         uint32_t i, n;
 439         int ret, cnt = 0;
 440         size_t pg_sz = (size_t)1 << pg_shift;
 441
 442         /* mempool must not be populated */
 443         if (mp->nb_mem_chunks != 0)
 444                 return -EEXIST;
 445
 446         for (i = 0; i < pg_num && mp->populated_size < mp->size; i += n) {
 447
 448                 /* populate with the largest group of contiguous pages */
 449                 for (n = 1; (i + n) < pg_num &&
 450                              paddr[i] + pg_sz == paddr[i+n]; n++)
 451                         ;
 452
 453                 ret = rte_mempool_populate_phys(mp, vaddr + i * pg_sz,
 454                         paddr[i], n * pg_sz, free_cb, opaque);
 455                 if (ret < 0) {
 456                         rte_mempool_free_memchunks(mp);
 457                         return ret;
 458                 }
 459                 /* no need to call the free callback for next chunks */
 460                 free_cb = NULL;
 461                 cnt += ret;
 462         }
 463         return cnt;
 464 }
 465
 466 /* Populate the mempool with a virtual area. Return the number of
 467  * objects added, or a negative value on error.
 468  */
 469 int
 470 rte_mempool_populate_virt(struct rte_mempool *mp, char *addr,
 471         size_t len, size_t pg_sz, rte_mempool_memchunk_free_cb_t *free_cb,
 472         void *opaque)
 473 {
 474         phys_addr_t paddr;
 475         size_t off, phys_len;
 476         int ret, cnt = 0;
 477
 478         /* mempool must not be populated */
 479         if (mp->nb_mem_chunks != 0)
 480                 return -EEXIST;
 481         /* address and len must be page-aligned */
 482         if (RTE_PTR_ALIGN_CEIL(addr, pg_sz) != addr)
 483                 return -EINVAL;
 484         if (RTE_ALIGN_CEIL(len, pg_sz) != len)
 485                 return -EINVAL;
 486
 487         for (off = 0; off + pg_sz <= len &&
 488                      mp->populated_size < mp->size; off += phys_len) {
 489
 490                 paddr = rte_mem_virt2phy(addr + off);
 491                 /* required for xen_dom0 to get the machine address */
 492                 paddr = rte_mem_phy2mch(-1, paddr);
 493
 494                 if (paddr == RTE_BAD_PHYS_ADDR) {
 495                         ret = -EINVAL;
 496                         goto fail;
 497                 }
 498
 499                 /* populate with the largest group of contiguous pages */
 500                 for (phys_len = pg_sz; off + phys_len < len; phys_len += pg_sz) {
 501                         phys_addr_t paddr_tmp;
 502
 503                         paddr_tmp = rte_mem_virt2phy(addr + off + phys_len);
 504                         paddr_tmp = rte_mem_phy2mch(-1, paddr_tmp);
 505
 506                         if (paddr_tmp != paddr + phys_len)
 507                                 break;
 508                 }
 509
 510                 ret = rte_mempool_populate_phys(mp, addr + off, paddr,
 511                         phys_len, free_cb, opaque);
 512                 if (ret < 0)
 513                         goto fail;
 514                 /* no need to call the free callback for next chunks */
 515                 free_cb = NULL;
 516                 cnt += ret;
 517         }
 518
 519         return cnt;
 520
 521  fail:
 522         rte_mempool_free_memchunks(mp);
 523         return ret;
 524 }
 525
 526 /* Default function to populate the mempool: allocate memory in memzones,
 527  * and populate them. Return the number of objects added, or a negative
 528  * value on error.
 529  */
 530 int
 531 rte_mempool_populate_default(struct rte_mempool *mp)
 532 {
 533         int mz_flags = RTE_MEMZONE_1GB|RTE_MEMZONE_SIZE_HINT_ONLY;
 534         char mz_name[RTE_MEMZONE_NAMESIZE];
 535         const struct rte_memzone *mz;
 536         size_t size, total_elt_sz, align, pg_sz, pg_shift;
 537         unsigned mz_id, n;
 538         int ret;
 539
 540         /* mempool must not be populated */
 541         if (mp->nb_mem_chunks != 0)
 542                 return -EEXIST;
 543
 544         if (rte_eal_has_hugepages()) {
 545                 pg_shift = 0; /* not needed, zone is physically contiguous */
 546                 pg_sz = 0;
 547                 align = RTE_CACHE_LINE_SIZE;
 548         } else {
 549                 pg_sz = getpagesize();
 550                 pg_shift = rte_bsf32(pg_sz);
 551                 align = pg_sz;
 552         }
 553
 554         total_elt_sz = mp->header_size + mp->elt_size + mp->trailer_size;
 555         for (mz_id = 0, n = mp->size; n > 0; mz_id++, n -= ret) {
 556                 size = rte_mempool_xmem_size(n, total_elt_sz, pg_shift);
 557
 558                 ret = snprintf(mz_name, sizeof(mz_name),
 559                         RTE_MEMPOOL_MZ_FORMAT "_%d", mp->name, mz_id);
 560                 if (ret < 0 || ret >= (int)sizeof(mz_name)) {
 561                         ret = -ENAMETOOLONG;
 562                         goto fail;
 563                 }
 564
 565                 mz = rte_memzone_reserve_aligned(mz_name, size,
 566                         mp->socket_id, mz_flags, align);
 567                 /* not enough memory, retry with the biggest zone we have */
 568                 if (mz == NULL)
 569                         mz = rte_memzone_reserve_aligned(mz_name, 0,
 570                                 mp->socket_id, mz_flags, align);
 571                 if (mz == NULL) {
 572                         ret = -rte_errno;
 573                         goto fail;
 574                 }
 575
 576                 /* use memzone physical address if it is valid */
 577                 if (rte_eal_has_hugepages() && !rte_xen_dom0_supported())
 578                         ret = rte_mempool_populate_phys(mp, mz->addr,
 579                                 mz->phys_addr, mz->len,
 580                                 rte_mempool_memchunk_mz_free,
 581                                 (void *)(uintptr_t)mz);
 582                 else
 583                         ret = rte_mempool_populate_virt(mp, mz->addr,
 584                                 mz->len, pg_sz,
 585                                 rte_mempool_memchunk_mz_free,
 586                                 (void *)(uintptr_t)mz);
 587                 if (ret < 0)
 588                         goto fail;
 589         }
 590
 591         return mp->size;
 592
 593  fail:
 594         rte_mempool_free_memchunks(mp);
 595         return ret;
 596 }
 597
 598 /* return the memory size required for mempool objects in anonymous mem */
 599 static size_t
 600 get_anon_size(const struct rte_mempool *mp)
 601 {
 602         size_t size, total_elt_sz, pg_sz, pg_shift;
 603
 604         pg_sz = getpagesize();
 605         pg_shift = rte_bsf32(pg_sz);
 606         total_elt_sz = mp->header_size + mp->elt_size + mp->trailer_size;
 607         size = rte_mempool_xmem_size(mp->size, total_elt_sz, pg_shift);
 608
 609         return size;
 610 }
 611
 612 /* unmap a memory zone mapped by rte_mempool_populate_anon() */
 613 static void
 614 rte_mempool_memchunk_anon_free(struct rte_mempool_memhdr *memhdr,
 615         void *opaque)
 616 {
 617         munmap(opaque, get_anon_size(memhdr->mp));
 618 }
 619
 620 /* populate the mempool with an anonymous mapping */
 621 int
 622 rte_mempool_populate_anon(struct rte_mempool *mp)
 623 {
 624         size_t size;
 625         int ret;
 626         char *addr;
 627
 628         /* mempool is already populated, error */
 629         if (!STAILQ_EMPTY(&mp->mem_list)) {
 630                 rte_errno = EINVAL;
 631                 return 0;
 632         }
 633
 634         /* get chunk of virtually continuous memory */
 635         size = get_anon_size(mp);
 636         addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
 637                 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 638         if (addr == MAP_FAILED) {
 639                 rte_errno = errno;
 640                 return 0;
 641         }
 642         /* can't use MMAP_LOCKED, it does not exist on BSD */
 643         if (mlock(addr, size) < 0) {
 644                 rte_errno = errno;
 645                 munmap(addr, size);
 646                 return 0;
 647         }
 648
 649         ret = rte_mempool_populate_virt(mp, addr, size, getpagesize(),
 650                 rte_mempool_memchunk_anon_free, addr);
 651         if (ret == 0)
 652                 goto fail;
 653
 654         return mp->populated_size;
 655
 656  fail:
 657         rte_mempool_free_memchunks(mp);
 658         return 0;
 659 }
 660
 661 /* free a mempool */
 662 void
 663 rte_mempool_free(struct rte_mempool *mp)
 664 {
 665         struct rte_mempool_list *mempool_list = NULL;
 666         struct rte_tailq_entry *te;
 667
 668         if (mp == NULL)
 669                 return;
 670
 671         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
 672         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 673         /* find out tailq entry */
 674         TAILQ_FOREACH(te, mempool_list, next) {
 675                 if (te->data == (void *)mp)
 676                         break;
 677         }
 678
 679         if (te != NULL) {
 680                 TAILQ_REMOVE(mempool_list, te, next);
 681                 rte_free(te);
 682         }
 683         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 684
 685         rte_mempool_free_memchunks(mp);
 686         rte_ring_free(mp->ring);
 687         rte_memzone_free(mp->mz);
 688 }
 689
 690 /* create an empty mempool */
 691 struct rte_mempool *
 692 rte_mempool_create_empty(const char *name, unsigned n, unsigned elt_size,
 693         unsigned cache_size, unsigned private_data_size,
 694         int socket_id, unsigned flags)
 695 {
 696         char mz_name[RTE_MEMZONE_NAMESIZE];
 697         struct rte_mempool_list *mempool_list;
 698         struct rte_mempool *mp = NULL;
 699         struct rte_tailq_entry *te = NULL;
 700         const struct rte_memzone *mz = NULL;
 701         size_t mempool_size;
 702         int mz_flags = RTE_MEMZONE_1GB|RTE_MEMZONE_SIZE_HINT_ONLY;
 703         struct rte_mempool_objsz objsz;
 704         int ret;
 705
 706         /* compilation-time checks */
 707         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool) &
 708                           RTE_CACHE_LINE_MASK) != 0);
 709         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool_cache) &
 710                           RTE_CACHE_LINE_MASK) != 0);
 711 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 712         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool_debug_stats) &
 713                           RTE_CACHE_LINE_MASK) != 0);
 714         RTE_BUILD_BUG_ON((offsetof(struct rte_mempool, stats) &
 715                           RTE_CACHE_LINE_MASK) != 0);
 716 #endif
 717
 718         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
 719
 720         /* asked cache too big */
 721         if (cache_size > RTE_MEMPOOL_CACHE_MAX_SIZE ||
 722             CALC_CACHE_FLUSHTHRESH(cache_size) > n) {
 723                 rte_errno = EINVAL;
 724                 return NULL;
 725         }
 726
 727         /* "no cache align" imply "no spread" */
 728         if (flags & MEMPOOL_F_NO_CACHE_ALIGN)
 729                 flags |= MEMPOOL_F_NO_SPREAD;
 730
 731         /* calculate mempool object sizes. */
 732         if (!rte_mempool_calc_obj_size(elt_size, flags, &objsz)) {
 733                 rte_errno = EINVAL;
 734                 return NULL;
 735         }
 736
 737         rte_rwlock_write_lock(RTE_EAL_MEMPOOL_RWLOCK);
 738
 739         /*
 740          * reserve a memory zone for this mempool: private data is
 741          * cache-aligned
 742          */
 743         private_data_size = (private_data_size +
 744                              RTE_MEMPOOL_ALIGN_MASK) & (~RTE_MEMPOOL_ALIGN_MASK);
 745
 746
 747         /* try to allocate tailq entry */
 748         te = rte_zmalloc("MEMPOOL_TAILQ_ENTRY", sizeof(*te), 0);
 749         if (te == NULL) {
 750                 RTE_LOG(ERR, MEMPOOL, "Cannot allocate tailq entry!\n");
 751                 goto exit_unlock;
 752         }
 753
 754         mempool_size = MEMPOOL_HEADER_SIZE(mp, cache_size);
 755         mempool_size += private_data_size;
 756         mempool_size = RTE_ALIGN_CEIL(mempool_size, RTE_MEMPOOL_ALIGN);
 757
 758         ret = snprintf(mz_name, sizeof(mz_name), RTE_MEMPOOL_MZ_FORMAT, name);
 759         if (ret < 0 || ret >= (int)sizeof(mz_name)) {
 760                 rte_errno = ENAMETOOLONG;
 761                 goto exit_unlock;
 762         }
 763
 764         mz = rte_memzone_reserve(mz_name, mempool_size, socket_id, mz_flags);
 765         if (mz == NULL)
 766                 goto exit_unlock;
 767
 768         /* init the mempool structure */
 769         mp = mz->addr;
 770         memset(mp, 0, sizeof(*mp));
 771         ret = snprintf(mp->name, sizeof(mp->name), "%s", name);
 772         if (ret < 0 || ret >= (int)sizeof(mp->name)) {
 773                 rte_errno = ENAMETOOLONG;
 774                 goto exit_unlock;
 775         }
 776         mp->mz = mz;
 777         mp->socket_id = socket_id;
 778         mp->size = n;
 779         mp->flags = flags;
 780         mp->socket_id = socket_id;
 781         mp->elt_size = objsz.elt_size;
 782         mp->header_size = objsz.header_size;
 783         mp->trailer_size = objsz.trailer_size;
 784         mp->cache_size = cache_size;
 785         mp->cache_flushthresh = CALC_CACHE_FLUSHTHRESH(cache_size);
 786         mp->private_data_size = private_data_size;
 787         STAILQ_INIT(&mp->elt_list);
 788         STAILQ_INIT(&mp->mem_list);
 789
 790         /*
 791          * local_cache pointer is set even if cache_size is zero.
 792          * The local_cache points to just past the elt_pa[] array.
 793          */
 794         mp->local_cache = (struct rte_mempool_cache *)
 795                 RTE_PTR_ADD(mp, MEMPOOL_HEADER_SIZE(mp, 0));
 796
 797         te->data = mp;
 798         rte_rwlock_write_lock(RTE_EAL_TAILQ_RWLOCK);
 799         TAILQ_INSERT_TAIL(mempool_list, te, next);
 800         rte_rwlock_write_unlock(RTE_EAL_TAILQ_RWLOCK);
 801         rte_rwlock_write_unlock(RTE_EAL_MEMPOOL_RWLOCK);
 802
 803         return mp;
 804
 805 exit_unlock:
 806         rte_rwlock_write_unlock(RTE_EAL_MEMPOOL_RWLOCK);
 807         rte_free(te);
 808         rte_mempool_free(mp);
 809         return NULL;
 810 }
 811
 812 /* create the mempool */
 813 struct rte_mempool *
 814 rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
 815         unsigned cache_size, unsigned private_data_size,
 816         rte_mempool_ctor_t *mp_init, void *mp_init_arg,
 817         rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
 818         int socket_id, unsigned flags)
 819 {
 820         struct rte_mempool *mp;
 821
 822         mp = rte_mempool_create_empty(name, n, elt_size, cache_size,
 823                 private_data_size, socket_id, flags);
 824         if (mp == NULL)
 825                 return NULL;
 826
 827         /* call the mempool priv initializer */
 828         if (mp_init)
 829                 mp_init(mp, mp_init_arg);
 830
 831         if (rte_mempool_populate_default(mp) < 0)
 832                 goto fail;
 833
 834         /* call the object initializers */
 835         if (obj_init)
 836                 rte_mempool_obj_iter(mp, obj_init, obj_init_arg);
 837
 838         return mp;
 839
 840  fail:
 841         rte_mempool_free(mp);
 842         return NULL;
 843 }
 844
 845 /*
 846  * Create the mempool over already allocated chunk of memory.
 847  * That external memory buffer can consists of physically disjoint pages.
 848  * Setting vaddr to NULL, makes mempool to fallback to original behaviour
 849  * and allocate space for mempool and it's elements as one big chunk of
 850  * physically continuos memory.
 851  */
 852 struct rte_mempool *
 853 rte_mempool_xmem_create(const char *name, unsigned n, unsigned elt_size,
 854                 unsigned cache_size, unsigned private_data_size,
 855                 rte_mempool_ctor_t *mp_init, void *mp_init_arg,
 856                 rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
 857                 int socket_id, unsigned flags, void *vaddr,
 858                 const phys_addr_t paddr[], uint32_t pg_num, uint32_t pg_shift)
 859 {
 860         struct rte_mempool *mp = NULL;
 861         int ret;
 862
 863         /* no virtual address supplied, use rte_mempool_create() */
 864         if (vaddr == NULL)
 865                 return rte_mempool_create(name, n, elt_size, cache_size,
 866                         private_data_size, mp_init, mp_init_arg,
 867                         obj_init, obj_init_arg, socket_id, flags);
 868
 869         /* check that we have both VA and PA */
 870         if (paddr == NULL) {
 871                 rte_errno = EINVAL;
 872                 return NULL;
 873         }
 874
 875         /* Check that pg_shift parameter is valid. */
 876         if (pg_shift > MEMPOOL_PG_SHIFT_MAX) {
 877                 rte_errno = EINVAL;
 878                 return NULL;
 879         }
 880
 881         mp = rte_mempool_create_empty(name, n, elt_size, cache_size,
 882                 private_data_size, socket_id, flags);
 883         if (mp == NULL)
 884                 return NULL;
 885
 886         /* call the mempool priv initializer */
 887         if (mp_init)
 888                 mp_init(mp, mp_init_arg);
 889
 890         ret = rte_mempool_populate_phys_tab(mp, vaddr, paddr, pg_num, pg_shift,
 891                 NULL, NULL);
 892         if (ret < 0 || ret != (int)mp->size)
 893                 goto fail;
 894
 895         /* call the object initializers */
 896         if (obj_init)
 897                 rte_mempool_obj_iter(mp, obj_init, obj_init_arg);
 898
 899         return mp;
 900
 901  fail:
 902         rte_mempool_free(mp);
 903         return NULL;
 904 }
 905
 906 /* Return the number of entries in the mempool */
 907 unsigned
 908 rte_mempool_count(const struct rte_mempool *mp)
 909 {
 910         unsigned count;
 911         unsigned lcore_id;
 912
 913         count = rte_ring_count(mp->ring);
 914
 915         if (mp->cache_size == 0)
 916                 return count;
 917
 918         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
 919                 count += mp->local_cache[lcore_id].len;
 920
 921         /*
 922          * due to race condition (access to len is not locked), the
 923          * total can be greater than size... so fix the result
 924          */
 925         if (count > mp->size)
 926                 return mp->size;
 927         return count;
 928 }
 929
 930 /* dump the cache status */
 931 static unsigned
 932 rte_mempool_dump_cache(FILE *f, const struct rte_mempool *mp)
 933 {
 934         unsigned lcore_id;
 935         unsigned count = 0;
 936         unsigned cache_count;
 937
 938         fprintf(f, "  cache infos:\n");
 939         fprintf(f, "    cache_size=%"PRIu32"\n", mp->cache_size);
 940
 941         if (mp->cache_size == 0)
 942                 return count;
 943
 944         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
 945                 cache_count = mp->local_cache[lcore_id].len;
 946                 fprintf(f, "    cache_count[%u]=%u\n", lcore_id, cache_count);
 947                 count += cache_count;
 948         }
 949         fprintf(f, "    total_cache_count=%u\n", count);
 950         return count;
 951 }
 952
 953 #ifndef __INTEL_COMPILER
 954 #pragma GCC diagnostic ignored "-Wcast-qual"
 955 #endif
 956
 957 /* check and update cookies or panic (internal) */
 958 void rte_mempool_check_cookies(const struct rte_mempool *mp,
 959         void * const *obj_table_const, unsigned n, int free)
 960 {
 961 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 962         struct rte_mempool_objhdr *hdr;
 963         struct rte_mempool_objtlr *tlr;
 964         uint64_t cookie;
 965         void *tmp;
 966         void *obj;
 967         void **obj_table;
 968
 969         /* Force to drop the "const" attribute. This is done only when
 970          * DEBUG is enabled */
 971         tmp = (void *) obj_table_const;
 972         obj_table = (void **) tmp;
 973
 974         while (n--) {
 975                 obj = obj_table[n];
 976
 977                 if (rte_mempool_from_obj(obj) != mp)
 978                         rte_panic("MEMPOOL: object is owned by another "
 979                                   "mempool\n");
 980
 981                 hdr = __mempool_get_header(obj);
 982                 cookie = hdr->cookie;
 983
 984                 if (free == 0) {
 985                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE1) {
 986                                 rte_log_set_history(0);
 987                                 RTE_LOG(CRIT, MEMPOOL,
 988                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
 989                                         obj, (const void *) mp, cookie);
 990                                 rte_panic("MEMPOOL: bad header cookie (put)\n");
 991                         }
 992                         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE2;
 993                 } else if (free == 1) {
 994                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
 995                                 rte_log_set_history(0);
 996                                 RTE_LOG(CRIT, MEMPOOL,
 997                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
 998                                         obj, (const void *) mp, cookie);
 999                                 rte_panic("MEMPOOL: bad header cookie (get)\n");
1000                         }
1001                         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE1;
1002                 } else if (free == 2) {
1003                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE1 &&
1004                             cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
1005                                 rte_log_set_history(0);
1006                                 RTE_LOG(CRIT, MEMPOOL,
1007                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1008                                         obj, (const void *) mp, cookie);
1009                                 rte_panic("MEMPOOL: bad header cookie (audit)\n");
1010                         }
1011                 }
1012                 tlr = __mempool_get_trailer(obj);
1013                 cookie = tlr->cookie;
1014                 if (cookie != RTE_MEMPOOL_TRAILER_COOKIE) {
1015                         rte_log_set_history(0);
1016                         RTE_LOG(CRIT, MEMPOOL,
1017                                 "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1018                                 obj, (const void *) mp, cookie);
1019                         rte_panic("MEMPOOL: bad trailer cookie\n");
1020                 }
1021         }
1022 #else
1023         RTE_SET_USED(mp);
1024         RTE_SET_USED(obj_table_const);
1025         RTE_SET_USED(n);
1026         RTE_SET_USED(free);
1027 #endif
1028 }
1029
1030 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1031 static void
1032 mempool_obj_audit(struct rte_mempool *mp, __rte_unused void *opaque,
1033         void *obj, __rte_unused unsigned idx)
1034 {
1035         __mempool_check_cookies(mp, &obj, 1, 2);
1036 }
1037
1038 static void
1039 mempool_audit_cookies(struct rte_mempool *mp)
1040 {
1041         unsigned num;
1042
1043         num = rte_mempool_obj_iter(mp, mempool_obj_audit, NULL);
1044         if (num != mp->size) {
1045                 rte_panic("rte_mempool_obj_iter(mempool=%p, size=%u) "
1046                         "iterated only over %u elements\n",
1047                         mp, mp->size, num);
1048         }
1049 }
1050 #else
1051 #define mempool_audit_cookies(mp) do {} while(0)
1052 #endif
1053
1054 #ifndef __INTEL_COMPILER
1055 #pragma GCC diagnostic error "-Wcast-qual"
1056 #endif
1057
1058 /* check cookies before and after objects */
1059 static void
1060 mempool_audit_cache(const struct rte_mempool *mp)
1061 {
1062         /* check cache size consistency */
1063         unsigned lcore_id;
1064
1065         if (mp->cache_size == 0)
1066                 return;
1067
1068         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1069                 if (mp->local_cache[lcore_id].len > mp->cache_flushthresh) {
1070                         RTE_LOG(CRIT, MEMPOOL, "badness on cache[%u]\n",
1071                                 lcore_id);
1072                         rte_panic("MEMPOOL: invalid cache len\n");
1073                 }
1074         }
1075 }
1076
1077 /* check the consistency of mempool (size, cookies, ...) */
1078 void
1079 rte_mempool_audit(struct rte_mempool *mp)
1080 {
1081         mempool_audit_cache(mp);
1082         mempool_audit_cookies(mp);
1083
1084         /* For case where mempool DEBUG is not set, and cache size is 0 */
1085         RTE_SET_USED(mp);
1086 }
1087
1088 /* dump the status of the mempool on the console */
1089 void
1090 rte_mempool_dump(FILE *f, struct rte_mempool *mp)
1091 {
1092 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1093         struct rte_mempool_debug_stats sum;
1094         unsigned lcore_id;
1095 #endif
1096         struct rte_mempool_memhdr *memhdr;
1097         unsigned common_count;
1098         unsigned cache_count;
1099         size_t mem_len = 0;
1100
1101         RTE_ASSERT(f != NULL);
1102         RTE_ASSERT(mp != NULL);
1103
1104         fprintf(f, "mempool <%s>@%p\n", mp->name, mp);
1105         fprintf(f, "  flags=%x\n", mp->flags);
1106         fprintf(f, "  ring=<%s>@%p\n", mp->ring->name, mp->ring);
1107         fprintf(f, "  phys_addr=0x%" PRIx64 "\n", mp->mz->phys_addr);
1108         fprintf(f, "  nb_mem_chunks=%u\n", mp->nb_mem_chunks);
1109         fprintf(f, "  size=%"PRIu32"\n", mp->size);
1110         fprintf(f, "  populated_size=%"PRIu32"\n", mp->populated_size);
1111         fprintf(f, "  header_size=%"PRIu32"\n", mp->header_size);
1112         fprintf(f, "  elt_size=%"PRIu32"\n", mp->elt_size);
1113         fprintf(f, "  trailer_size=%"PRIu32"\n", mp->trailer_size);
1114         fprintf(f, "  total_obj_size=%"PRIu32"\n",
1115                mp->header_size + mp->elt_size + mp->trailer_size);
1116
1117         fprintf(f, "  private_data_size=%"PRIu32"\n", mp->private_data_size);
1118
1119         STAILQ_FOREACH(memhdr, &mp->mem_list, next)
1120                 mem_len += memhdr->len;
1121         if (mem_len != 0) {
1122                 fprintf(f, "  avg bytes/object=%#Lf\n",
1123                         (long double)mem_len / mp->size);
1124         }
1125
1126         cache_count = rte_mempool_dump_cache(f, mp);
1127         common_count = rte_ring_count(mp->ring);
1128         if ((cache_count + common_count) > mp->size)
1129                 common_count = mp->size - cache_count;
1130         fprintf(f, "  common_pool_count=%u\n", common_count);
1131
1132         /* sum and dump statistics */
1133 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1134         memset(&sum, 0, sizeof(sum));
1135         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1136                 sum.put_bulk += mp->stats[lcore_id].put_bulk;
1137                 sum.put_objs += mp->stats[lcore_id].put_objs;
1138                 sum.get_success_bulk += mp->stats[lcore_id].get_success_bulk;
1139                 sum.get_success_objs += mp->stats[lcore_id].get_success_objs;
1140                 sum.get_fail_bulk += mp->stats[lcore_id].get_fail_bulk;
1141                 sum.get_fail_objs += mp->stats[lcore_id].get_fail_objs;
1142         }
1143         fprintf(f, "  stats:\n");
1144         fprintf(f, "    put_bulk=%"PRIu64"\n", sum.put_bulk);
1145         fprintf(f, "    put_objs=%"PRIu64"\n", sum.put_objs);
1146         fprintf(f, "    get_success_bulk=%"PRIu64"\n", sum.get_success_bulk);
1147         fprintf(f, "    get_success_objs=%"PRIu64"\n", sum.get_success_objs);
1148         fprintf(f, "    get_fail_bulk=%"PRIu64"\n", sum.get_fail_bulk);
1149         fprintf(f, "    get_fail_objs=%"PRIu64"\n", sum.get_fail_objs);
1150 #else
1151         fprintf(f, "  no statistics available\n");
1152 #endif
1153
1154         rte_mempool_audit(mp);
1155 }
1156
1157 /* dump the status of all mempools on the console */
1158 void
1159 rte_mempool_list_dump(FILE *f)
1160 {
1161         struct rte_mempool *mp = NULL;
1162         struct rte_tailq_entry *te;
1163         struct rte_mempool_list *mempool_list;
1164
1165         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1166
1167         rte_rwlock_read_lock(RTE_EAL_MEMPOOL_RWLOCK);
1168
1169         TAILQ_FOREACH(te, mempool_list, next) {
1170                 mp = (struct rte_mempool *) te->data;
1171                 rte_mempool_dump(f, mp);
1172         }
1173
1174         rte_rwlock_read_unlock(RTE_EAL_MEMPOOL_RWLOCK);
1175 }
1176
1177 /* search a mempool from its name */
1178 struct rte_mempool *
1179 rte_mempool_lookup(const char *name)
1180 {
1181         struct rte_mempool *mp = NULL;
1182         struct rte_tailq_entry *te;
1183         struct rte_mempool_list *mempool_list;
1184
1185         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1186
1187         rte_rwlock_read_lock(RTE_EAL_MEMPOOL_RWLOCK);
1188
1189         TAILQ_FOREACH(te, mempool_list, next) {
1190                 mp = (struct rte_mempool *) te->data;
1191                 if (strncmp(name, mp->name, RTE_MEMPOOL_NAMESIZE) == 0)
1192                         break;
1193         }
1194
1195         rte_rwlock_read_unlock(RTE_EAL_MEMPOOL_RWLOCK);
1196
1197         if (te == NULL) {
1198                 rte_errno = ENOENT;
1199                 return NULL;
1200         }
1201
1202         return mp;
1203 }
1204
1205 void rte_mempool_walk(void (*func)(struct rte_mempool *, void *),
1206                       void *arg)
1207 {
1208         struct rte_tailq_entry *te = NULL;
1209         struct rte_mempool_list *mempool_list;
1210
1211         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1212
1213         rte_rwlock_read_lock(RTE_EAL_MEMPOOL_RWLOCK);
1214
1215         TAILQ_FOREACH(te, mempool_list, next) {
1216                 (*func)((struct rte_mempool *) te->data, arg);
1217         }
1218
1219         rte_rwlock_read_unlock(RTE_EAL_MEMPOOL_RWLOCK);
1220 }