lib/librte_mempool/rte_mempool.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright(c) 2016 6WIND S.A.
   4  */
   5
   6 #include <stdbool.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <stdint.h>
  10 #include <stdarg.h>
  11 #include <unistd.h>
  12 #include <inttypes.h>
  13 #include <errno.h>
  14 #include <sys/queue.h>
  15 #include <sys/mman.h>
  16
  17 #include <rte_common.h>
  18 #include <rte_log.h>
  19 #include <rte_debug.h>
  20 #include <rte_memory.h>
  21 #include <rte_memzone.h>
  22 #include <rte_malloc.h>
  23 #include <rte_atomic.h>
  24 #include <rte_launch.h>
  25 #include <rte_eal.h>
  26 #include <rte_eal_memconfig.h>
  27 #include <rte_per_lcore.h>
  28 #include <rte_lcore.h>
  29 #include <rte_branch_prediction.h>
  30 #include <rte_errno.h>
  31 #include <rte_string_fns.h>
  32 #include <rte_spinlock.h>
  33 #include <rte_tailq.h>
  34
  35 #include "rte_mempool.h"
  36
  37 TAILQ_HEAD(rte_mempool_list, rte_tailq_entry);
  38
  39 static struct rte_tailq_elem rte_mempool_tailq = {
  40         .name = "RTE_MEMPOOL",
  41 };
  42 EAL_REGISTER_TAILQ(rte_mempool_tailq)
  43
  44 #define CACHE_FLUSHTHRESH_MULTIPLIER 1.5
  45 #define CALC_CACHE_FLUSHTHRESH(c)       \
  46         ((typeof(c))((c) * CACHE_FLUSHTHRESH_MULTIPLIER))
  47
  48 #if defined(RTE_ARCH_X86)
  49 /*
  50  * return the greatest common divisor between a and b (fast algorithm)
  51  *
  52  */
  53 static unsigned get_gcd(unsigned a, unsigned b)
  54 {
  55         unsigned c;
  56
  57         if (0 == a)
  58                 return b;
  59         if (0 == b)
  60                 return a;
  61
  62         if (a < b) {
  63                 c = a;
  64                 a = b;
  65                 b = c;
  66         }
  67
  68         while (b != 0) {
  69                 c = a % b;
  70                 a = b;
  71                 b = c;
  72         }
  73
  74         return a;
  75 }
  76
  77 /*
  78  * Depending on memory configuration on x86 arch, objects addresses are spread
  79  * between channels and ranks in RAM: the pool allocator will add
  80  * padding between objects. This function return the new size of the
  81  * object.
  82  */
  83 static unsigned int
  84 arch_mem_object_align(unsigned int obj_size)
  85 {
  86         unsigned nrank, nchan;
  87         unsigned new_obj_size;
  88
  89         /* get number of channels */
  90         nchan = rte_memory_get_nchannel();
  91         if (nchan == 0)
  92                 nchan = 4;
  93
  94         nrank = rte_memory_get_nrank();
  95         if (nrank == 0)
  96                 nrank = 1;
  97
  98         /* process new object size */
  99         new_obj_size = (obj_size + RTE_MEMPOOL_ALIGN_MASK) / RTE_MEMPOOL_ALIGN;
 100         while (get_gcd(new_obj_size, nrank * nchan) != 1)
 101                 new_obj_size++;
 102         return new_obj_size * RTE_MEMPOOL_ALIGN;
 103 }
 104 #else
 105 static unsigned int
 106 arch_mem_object_align(unsigned int obj_size)
 107 {
 108         return obj_size;
 109 }
 110 #endif
 111
 112 struct pagesz_walk_arg {
 113         int socket_id;
 114         size_t min;
 115 };
 116
 117 static int
 118 find_min_pagesz(const struct rte_memseg_list *msl, void *arg)
 119 {
 120         struct pagesz_walk_arg *wa = arg;
 121         bool valid;
 122
 123         /*
 124          * we need to only look at page sizes available for a particular socket
 125          * ID.  so, we either need an exact match on socket ID (can match both
 126          * native and external memory), or, if SOCKET_ID_ANY was specified as a
 127          * socket ID argument, we must only look at native memory and ignore any
 128          * page sizes associated with external memory.
 129          */
 130         valid = msl->socket_id == wa->socket_id;
 131         valid |= wa->socket_id == SOCKET_ID_ANY && msl->external == 0;
 132
 133         if (valid && msl->page_sz < wa->min)
 134                 wa->min = msl->page_sz;
 135
 136         return 0;
 137 }
 138
 139 static size_t
 140 get_min_page_size(int socket_id)
 141 {
 142         struct pagesz_walk_arg wa;
 143
 144         wa.min = SIZE_MAX;
 145         wa.socket_id = socket_id;
 146
 147         rte_memseg_list_walk(find_min_pagesz, &wa);
 148
 149         return wa.min == SIZE_MAX ? (size_t) getpagesize() : wa.min;
 150 }
 151
 152
 153 static void
 154 mempool_add_elem(struct rte_mempool *mp, __rte_unused void *opaque,
 155                  void *obj, rte_iova_t iova)
 156 {
 157         struct rte_mempool_objhdr *hdr;
 158         struct rte_mempool_objtlr *tlr __rte_unused;
 159
 160         /* set mempool ptr in header */
 161         hdr = RTE_PTR_SUB(obj, sizeof(*hdr));
 162         hdr->mp = mp;
 163         hdr->iova = iova;
 164         STAILQ_INSERT_TAIL(&mp->elt_list, hdr, next);
 165         mp->populated_size++;
 166
 167 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 168         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE2;
 169         tlr = __mempool_get_trailer(obj);
 170         tlr->cookie = RTE_MEMPOOL_TRAILER_COOKIE;
 171 #endif
 172 }
 173
 174 /* call obj_cb() for each mempool element */
 175 uint32_t
 176 rte_mempool_obj_iter(struct rte_mempool *mp,
 177         rte_mempool_obj_cb_t *obj_cb, void *obj_cb_arg)
 178 {
 179         struct rte_mempool_objhdr *hdr;
 180         void *obj;
 181         unsigned n = 0;
 182
 183         STAILQ_FOREACH(hdr, &mp->elt_list, next) {
 184                 obj = (char *)hdr + sizeof(*hdr);
 185                 obj_cb(mp, obj_cb_arg, obj, n);
 186                 n++;
 187         }
 188
 189         return n;
 190 }
 191
 192 /* call mem_cb() for each mempool memory chunk */
 193 uint32_t
 194 rte_mempool_mem_iter(struct rte_mempool *mp,
 195         rte_mempool_mem_cb_t *mem_cb, void *mem_cb_arg)
 196 {
 197         struct rte_mempool_memhdr *hdr;
 198         unsigned n = 0;
 199
 200         STAILQ_FOREACH(hdr, &mp->mem_list, next) {
 201                 mem_cb(mp, mem_cb_arg, hdr, n);
 202                 n++;
 203         }
 204
 205         return n;
 206 }
 207
 208 /* get the header, trailer and total size of a mempool element. */
 209 uint32_t
 210 rte_mempool_calc_obj_size(uint32_t elt_size, uint32_t flags,
 211         struct rte_mempool_objsz *sz)
 212 {
 213         struct rte_mempool_objsz lsz;
 214
 215         sz = (sz != NULL) ? sz : &lsz;
 216
 217         sz->header_size = sizeof(struct rte_mempool_objhdr);
 218         if ((flags & MEMPOOL_F_NO_CACHE_ALIGN) == 0)
 219                 sz->header_size = RTE_ALIGN_CEIL(sz->header_size,
 220                         RTE_MEMPOOL_ALIGN);
 221
 222 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 223         sz->trailer_size = sizeof(struct rte_mempool_objtlr);
 224 #else
 225         sz->trailer_size = 0;
 226 #endif
 227
 228         /* element size is 8 bytes-aligned at least */
 229         sz->elt_size = RTE_ALIGN_CEIL(elt_size, sizeof(uint64_t));
 230
 231         /* expand trailer to next cache line */
 232         if ((flags & MEMPOOL_F_NO_CACHE_ALIGN) == 0) {
 233                 sz->total_size = sz->header_size + sz->elt_size +
 234                         sz->trailer_size;
 235                 sz->trailer_size += ((RTE_MEMPOOL_ALIGN -
 236                                   (sz->total_size & RTE_MEMPOOL_ALIGN_MASK)) &
 237                                  RTE_MEMPOOL_ALIGN_MASK);
 238         }
 239
 240         /*
 241          * increase trailer to add padding between objects in order to
 242          * spread them across memory channels/ranks
 243          */
 244         if ((flags & MEMPOOL_F_NO_SPREAD) == 0) {
 245                 unsigned new_size;
 246                 new_size = arch_mem_object_align
 247                             (sz->header_size + sz->elt_size + sz->trailer_size);
 248                 sz->trailer_size = new_size - sz->header_size - sz->elt_size;
 249         }
 250
 251         /* this is the size of an object, including header and trailer */
 252         sz->total_size = sz->header_size + sz->elt_size + sz->trailer_size;
 253
 254         return sz->total_size;
 255 }
 256
 257 /* free a memchunk allocated with rte_memzone_reserve() */
 258 static void
 259 rte_mempool_memchunk_mz_free(__rte_unused struct rte_mempool_memhdr *memhdr,
 260         void *opaque)
 261 {
 262         const struct rte_memzone *mz = opaque;
 263         rte_memzone_free(mz);
 264 }
 265
 266 /* Free memory chunks used by a mempool. Objects must be in pool */
 267 static void
 268 rte_mempool_free_memchunks(struct rte_mempool *mp)
 269 {
 270         struct rte_mempool_memhdr *memhdr;
 271         void *elt;
 272
 273         while (!STAILQ_EMPTY(&mp->elt_list)) {
 274                 rte_mempool_ops_dequeue_bulk(mp, &elt, 1);
 275                 (void)elt;
 276                 STAILQ_REMOVE_HEAD(&mp->elt_list, next);
 277                 mp->populated_size--;
 278         }
 279
 280         while (!STAILQ_EMPTY(&mp->mem_list)) {
 281                 memhdr = STAILQ_FIRST(&mp->mem_list);
 282                 STAILQ_REMOVE_HEAD(&mp->mem_list, next);
 283                 if (memhdr->free_cb != NULL)
 284                         memhdr->free_cb(memhdr, memhdr->opaque);
 285                 rte_free(memhdr);
 286                 mp->nb_mem_chunks--;
 287         }
 288 }
 289
 290 static int
 291 mempool_ops_alloc_once(struct rte_mempool *mp)
 292 {
 293         int ret;
 294
 295         /* create the internal ring if not already done */
 296         if ((mp->flags & MEMPOOL_F_POOL_CREATED) == 0) {
 297                 ret = rte_mempool_ops_alloc(mp);
 298                 if (ret != 0)
 299                         return ret;
 300                 mp->flags |= MEMPOOL_F_POOL_CREATED;
 301         }
 302         return 0;
 303 }
 304
 305 /* Add objects in the pool, using a physically contiguous memory
 306  * zone. Return the number of objects added, or a negative value
 307  * on error.
 308  */
 309 static int
 310 __rte_mempool_populate_iova(struct rte_mempool *mp, char *vaddr,
 311         rte_iova_t iova, size_t len, rte_mempool_memchunk_free_cb_t *free_cb,
 312         void *opaque)
 313 {
 314         unsigned i = 0;
 315         size_t off;
 316         struct rte_mempool_memhdr *memhdr;
 317         int ret;
 318
 319         ret = mempool_ops_alloc_once(mp);
 320         if (ret != 0)
 321                 return ret;
 322
 323         /* mempool is already populated */
 324         if (mp->populated_size >= mp->size)
 325                 return -ENOSPC;
 326
 327         memhdr = rte_zmalloc("MEMPOOL_MEMHDR", sizeof(*memhdr), 0);
 328         if (memhdr == NULL)
 329                 return -ENOMEM;
 330
 331         memhdr->mp = mp;
 332         memhdr->addr = vaddr;
 333         memhdr->iova = iova;
 334         memhdr->len = len;
 335         memhdr->free_cb = free_cb;
 336         memhdr->opaque = opaque;
 337
 338         if (mp->flags & MEMPOOL_F_NO_CACHE_ALIGN)
 339                 off = RTE_PTR_ALIGN_CEIL(vaddr, 8) - vaddr;
 340         else
 341                 off = RTE_PTR_ALIGN_CEIL(vaddr, RTE_MEMPOOL_ALIGN) - vaddr;
 342
 343         if (off > len) {
 344                 ret = 0;
 345                 goto fail;
 346         }
 347
 348         i = rte_mempool_ops_populate(mp, mp->size - mp->populated_size,
 349                 (char *)vaddr + off,
 350                 (iova == RTE_BAD_IOVA) ? RTE_BAD_IOVA : (iova + off),
 351                 len - off, mempool_add_elem, NULL);
 352
 353         /* not enough room to store one object */
 354         if (i == 0) {
 355                 ret = 0;
 356                 goto fail;
 357         }
 358
 359         STAILQ_INSERT_TAIL(&mp->mem_list, memhdr, next);
 360         mp->nb_mem_chunks++;
 361         return i;
 362
 363 fail:
 364         rte_free(memhdr);
 365         return ret;
 366 }
 367
 368 int
 369 rte_mempool_populate_iova(struct rte_mempool *mp, char *vaddr,
 370         rte_iova_t iova, size_t len, rte_mempool_memchunk_free_cb_t *free_cb,
 371         void *opaque)
 372 {
 373         int ret;
 374
 375         ret = __rte_mempool_populate_iova(mp, vaddr, iova, len, free_cb,
 376                                         opaque);
 377         if (ret == 0)
 378                 ret = -EINVAL;
 379
 380         return ret;
 381 }
 382
 383 static rte_iova_t
 384 get_iova(void *addr)
 385 {
 386         struct rte_memseg *ms;
 387
 388         /* try registered memory first */
 389         ms = rte_mem_virt2memseg(addr, NULL);
 390         if (ms == NULL || ms->iova == RTE_BAD_IOVA)
 391                 /* fall back to actual physical address */
 392                 return rte_mem_virt2iova(addr);
 393         return ms->iova + RTE_PTR_DIFF(addr, ms->addr);
 394 }
 395
 396 /* Populate the mempool with a virtual area. Return the number of
 397  * objects added, or a negative value on error.
 398  */
 399 int
 400 rte_mempool_populate_virt(struct rte_mempool *mp, char *addr,
 401         size_t len, size_t pg_sz, rte_mempool_memchunk_free_cb_t *free_cb,
 402         void *opaque)
 403 {
 404         rte_iova_t iova;
 405         size_t off, phys_len;
 406         int ret, cnt = 0;
 407
 408         if (mp->flags & MEMPOOL_F_NO_IOVA_CONTIG)
 409                 return rte_mempool_populate_iova(mp, addr, RTE_BAD_IOVA,
 410                         len, free_cb, opaque);
 411
 412         for (off = 0; off < len &&
 413                      mp->populated_size < mp->size; off += phys_len) {
 414
 415                 iova = get_iova(addr + off);
 416
 417                 /* populate with the largest group of contiguous pages */
 418                 for (phys_len = RTE_MIN(
 419                         (size_t)(RTE_PTR_ALIGN_CEIL(addr + off + 1, pg_sz) -
 420                                 (addr + off)),
 421                         len - off);
 422                      off + phys_len < len;
 423                      phys_len = RTE_MIN(phys_len + pg_sz, len - off)) {
 424                         rte_iova_t iova_tmp;
 425
 426                         iova_tmp = get_iova(addr + off + phys_len);
 427
 428                         if (iova_tmp == RTE_BAD_IOVA ||
 429                                         iova_tmp != iova + phys_len)
 430                                 break;
 431                 }
 432
 433                 ret = __rte_mempool_populate_iova(mp, addr + off, iova,
 434                         phys_len, free_cb, opaque);
 435                 if (ret == 0)
 436                         continue;
 437                 if (ret < 0)
 438                         goto fail;
 439                 /* no need to call the free callback for next chunks */
 440                 free_cb = NULL;
 441                 cnt += ret;
 442         }
 443
 444         if (cnt == 0)
 445                 return -EINVAL;
 446
 447         return cnt;
 448
 449  fail:
 450         rte_mempool_free_memchunks(mp);
 451         return ret;
 452 }
 453
 454 /* Get the minimal page size used in a mempool before populating it. */
 455 int
 456 rte_mempool_get_page_size(struct rte_mempool *mp, size_t *pg_sz)
 457 {
 458         bool need_iova_contig_obj;
 459         bool alloc_in_ext_mem;
 460         int ret;
 461
 462         /* check if we can retrieve a valid socket ID */
 463         ret = rte_malloc_heap_socket_is_external(mp->socket_id);
 464         if (ret < 0)
 465                 return -EINVAL;
 466         alloc_in_ext_mem = (ret == 1);
 467         need_iova_contig_obj = !(mp->flags & MEMPOOL_F_NO_IOVA_CONTIG);
 468
 469         if (!need_iova_contig_obj)
 470                 *pg_sz = 0;
 471         else if (rte_eal_has_hugepages() || alloc_in_ext_mem)
 472                 *pg_sz = get_min_page_size(mp->socket_id);
 473         else
 474                 *pg_sz = getpagesize();
 475
 476         return 0;
 477 }
 478
 479 /* Default function to populate the mempool: allocate memory in memzones,
 480  * and populate them. Return the number of objects added, or a negative
 481  * value on error.
 482  */
 483 int
 484 rte_mempool_populate_default(struct rte_mempool *mp)
 485 {
 486         unsigned int mz_flags = RTE_MEMZONE_1GB|RTE_MEMZONE_SIZE_HINT_ONLY;
 487         char mz_name[RTE_MEMZONE_NAMESIZE];
 488         const struct rte_memzone *mz;
 489         ssize_t mem_size;
 490         size_t align, pg_sz, pg_shift = 0;
 491         rte_iova_t iova;
 492         unsigned mz_id, n;
 493         int ret;
 494         bool need_iova_contig_obj;
 495         size_t max_alloc_size = SIZE_MAX;
 496
 497         ret = mempool_ops_alloc_once(mp);
 498         if (ret != 0)
 499                 return ret;
 500
 501         /* mempool must not be populated */
 502         if (mp->nb_mem_chunks != 0)
 503                 return -EEXIST;
 504
 505         /*
 506          * the following section calculates page shift and page size values.
 507          *
 508          * these values impact the result of calc_mem_size operation, which
 509          * returns the amount of memory that should be allocated to store the
 510          * desired number of objects. when not zero, it allocates more memory
 511          * for the padding between objects, to ensure that an object does not
 512          * cross a page boundary. in other words, page size/shift are to be set
 513          * to zero if mempool elements won't care about page boundaries.
 514          * there are several considerations for page size and page shift here.
 515          *
 516          * if we don't need our mempools to have physically contiguous objects,
 517          * then just set page shift and page size to 0, because the user has
 518          * indicated that there's no need to care about anything.
 519          *
 520          * if we do need contiguous objects (if a mempool driver has its
 521          * own calc_size() method returning min_chunk_size = mem_size),
 522          * there is also an option to reserve the entire mempool memory
 523          * as one contiguous block of memory.
 524          *
 525          * if we require contiguous objects, but not necessarily the entire
 526          * mempool reserved space to be contiguous, pg_sz will be != 0,
 527          * and the default ops->populate() will take care of not placing
 528          * objects across pages.
 529          *
 530          * if our IO addresses are physical, we may get memory from bigger
 531          * pages, or we might get memory from smaller pages, and how much of it
 532          * we require depends on whether we want bigger or smaller pages.
 533          * However, requesting each and every memory size is too much work, so
 534          * what we'll do instead is walk through the page sizes available, pick
 535          * the smallest one and set up page shift to match that one. We will be
 536          * wasting some space this way, but it's much nicer than looping around
 537          * trying to reserve each and every page size.
 538          *
 539          * If we fail to get enough contiguous memory, then we'll go and
 540          * reserve space in smaller chunks.
 541          */
 542
 543         need_iova_contig_obj = !(mp->flags & MEMPOOL_F_NO_IOVA_CONTIG);
 544         ret = rte_mempool_get_page_size(mp, &pg_sz);
 545         if (ret < 0)
 546                 return ret;
 547
 548         if (pg_sz != 0)
 549                 pg_shift = rte_bsf32(pg_sz);
 550
 551         for (mz_id = 0, n = mp->size; n > 0; mz_id++, n -= ret) {
 552                 size_t min_chunk_size;
 553
 554                 mem_size = rte_mempool_ops_calc_mem_size(
 555                         mp, n, pg_shift, &min_chunk_size, &align);
 556
 557                 if (mem_size < 0) {
 558                         ret = mem_size;
 559                         goto fail;
 560                 }
 561
 562                 ret = snprintf(mz_name, sizeof(mz_name),
 563                         RTE_MEMPOOL_MZ_FORMAT "_%d", mp->name, mz_id);
 564                 if (ret < 0 || ret >= (int)sizeof(mz_name)) {
 565                         ret = -ENAMETOOLONG;
 566                         goto fail;
 567                 }
 568
 569                 /* if we're trying to reserve contiguous memory, add appropriate
 570                  * memzone flag.
 571                  */
 572                 if (min_chunk_size == (size_t)mem_size)
 573                         mz_flags |= RTE_MEMZONE_IOVA_CONTIG;
 574
 575                 /* Allocate a memzone, retrying with a smaller area on ENOMEM */
 576                 do {
 577                         mz = rte_memzone_reserve_aligned(mz_name,
 578                                 RTE_MIN((size_t)mem_size, max_alloc_size),
 579                                 mp->socket_id, mz_flags, align);
 580
 581                         if (mz == NULL && rte_errno != ENOMEM)
 582                                 break;
 583
 584                         max_alloc_size = RTE_MIN(max_alloc_size,
 585                                                 (size_t)mem_size) / 2;
 586                 } while (mz == NULL && max_alloc_size >= min_chunk_size);
 587
 588                 if (mz == NULL) {
 589                         ret = -rte_errno;
 590                         goto fail;
 591                 }
 592
 593                 if (need_iova_contig_obj)
 594                         iova = mz->iova;
 595                 else
 596                         iova = RTE_BAD_IOVA;
 597
 598                 if (pg_sz == 0 || (mz_flags & RTE_MEMZONE_IOVA_CONTIG))
 599                         ret = rte_mempool_populate_iova(mp, mz->addr,
 600                                 iova, mz->len,
 601                                 rte_mempool_memchunk_mz_free,
 602                                 (void *)(uintptr_t)mz);
 603                 else
 604                         ret = rte_mempool_populate_virt(mp, mz->addr,
 605                                 mz->len, pg_sz,
 606                                 rte_mempool_memchunk_mz_free,
 607                                 (void *)(uintptr_t)mz);
 608                 if (ret < 0) {
 609                         rte_memzone_free(mz);
 610                         goto fail;
 611                 }
 612         }
 613
 614         return mp->size;
 615
 616  fail:
 617         rte_mempool_free_memchunks(mp);
 618         return ret;
 619 }
 620
 621 /* return the memory size required for mempool objects in anonymous mem */
 622 static ssize_t
 623 get_anon_size(const struct rte_mempool *mp)
 624 {
 625         ssize_t size;
 626         size_t pg_sz, pg_shift;
 627         size_t min_chunk_size;
 628         size_t align;
 629
 630         pg_sz = getpagesize();
 631         pg_shift = rte_bsf32(pg_sz);
 632         size = rte_mempool_ops_calc_mem_size(mp, mp->size, pg_shift,
 633                                              &min_chunk_size, &align);
 634
 635         return size;
 636 }
 637
 638 /* unmap a memory zone mapped by rte_mempool_populate_anon() */
 639 static void
 640 rte_mempool_memchunk_anon_free(struct rte_mempool_memhdr *memhdr,
 641         void *opaque)
 642 {
 643         ssize_t size;
 644
 645         /*
 646          * Calculate size since memhdr->len has contiguous chunk length
 647          * which may be smaller if anon map is split into many contiguous
 648          * chunks. Result must be the same as we calculated on populate.
 649          */
 650         size = get_anon_size(memhdr->mp);
 651         if (size < 0)
 652                 return;
 653
 654         munmap(opaque, size);
 655 }
 656
 657 /* populate the mempool with an anonymous mapping */
 658 int
 659 rte_mempool_populate_anon(struct rte_mempool *mp)
 660 {
 661         ssize_t size;
 662         int ret;
 663         char *addr;
 664
 665         /* mempool is already populated, error */
 666         if ((!STAILQ_EMPTY(&mp->mem_list)) || mp->nb_mem_chunks != 0) {
 667                 rte_errno = EINVAL;
 668                 return 0;
 669         }
 670
 671         ret = mempool_ops_alloc_once(mp);
 672         if (ret < 0) {
 673                 rte_errno = -ret;
 674                 return 0;
 675         }
 676
 677         size = get_anon_size(mp);
 678         if (size < 0) {
 679                 rte_errno = -size;
 680                 return 0;
 681         }
 682
 683         /* get chunk of virtually continuous memory */
 684         addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
 685                 MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 686         if (addr == MAP_FAILED) {
 687                 rte_errno = errno;
 688                 return 0;
 689         }
 690         /* can't use MMAP_LOCKED, it does not exist on BSD */
 691         if (mlock(addr, size) < 0) {
 692                 rte_errno = errno;
 693                 munmap(addr, size);
 694                 return 0;
 695         }
 696
 697         ret = rte_mempool_populate_virt(mp, addr, size, getpagesize(),
 698                 rte_mempool_memchunk_anon_free, addr);
 699         if (ret < 0) {
 700                 rte_errno = -ret;
 701                 goto fail;
 702         }
 703
 704         return mp->populated_size;
 705
 706  fail:
 707         rte_mempool_free_memchunks(mp);
 708         return 0;
 709 }
 710
 711 /* free a mempool */
 712 void
 713 rte_mempool_free(struct rte_mempool *mp)
 714 {
 715         struct rte_mempool_list *mempool_list = NULL;
 716         struct rte_tailq_entry *te;
 717
 718         if (mp == NULL)
 719                 return;
 720
 721         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
 722         rte_mcfg_tailq_write_lock();
 723         /* find out tailq entry */
 724         TAILQ_FOREACH(te, mempool_list, next) {
 725                 if (te->data == (void *)mp)
 726                         break;
 727         }
 728
 729         if (te != NULL) {
 730                 TAILQ_REMOVE(mempool_list, te, next);
 731                 rte_free(te);
 732         }
 733         rte_mcfg_tailq_write_unlock();
 734
 735         rte_mempool_free_memchunks(mp);
 736         rte_mempool_ops_free(mp);
 737         rte_memzone_free(mp->mz);
 738 }
 739
 740 static void
 741 mempool_cache_init(struct rte_mempool_cache *cache, uint32_t size)
 742 {
 743         cache->size = size;
 744         cache->flushthresh = CALC_CACHE_FLUSHTHRESH(size);
 745         cache->len = 0;
 746 }
 747
 748 /*
 749  * Create and initialize a cache for objects that are retrieved from and
 750  * returned to an underlying mempool. This structure is identical to the
 751  * local_cache[lcore_id] pointed to by the mempool structure.
 752  */
 753 struct rte_mempool_cache *
 754 rte_mempool_cache_create(uint32_t size, int socket_id)
 755 {
 756         struct rte_mempool_cache *cache;
 757
 758         if (size == 0 || size > RTE_MEMPOOL_CACHE_MAX_SIZE) {
 759                 rte_errno = EINVAL;
 760                 return NULL;
 761         }
 762
 763         cache = rte_zmalloc_socket("MEMPOOL_CACHE", sizeof(*cache),
 764                                   RTE_CACHE_LINE_SIZE, socket_id);
 765         if (cache == NULL) {
 766                 RTE_LOG(ERR, MEMPOOL, "Cannot allocate mempool cache.\n");
 767                 rte_errno = ENOMEM;
 768                 return NULL;
 769         }
 770
 771         mempool_cache_init(cache, size);
 772
 773         return cache;
 774 }
 775
 776 /*
 777  * Free a cache. It's the responsibility of the user to make sure that any
 778  * remaining objects in the cache are flushed to the corresponding
 779  * mempool.
 780  */
 781 void
 782 rte_mempool_cache_free(struct rte_mempool_cache *cache)
 783 {
 784         rte_free(cache);
 785 }
 786
 787 /* create an empty mempool */
 788 struct rte_mempool *
 789 rte_mempool_create_empty(const char *name, unsigned n, unsigned elt_size,
 790         unsigned cache_size, unsigned private_data_size,
 791         int socket_id, unsigned flags)
 792 {
 793         char mz_name[RTE_MEMZONE_NAMESIZE];
 794         struct rte_mempool_list *mempool_list;
 795         struct rte_mempool *mp = NULL;
 796         struct rte_tailq_entry *te = NULL;
 797         const struct rte_memzone *mz = NULL;
 798         size_t mempool_size;
 799         unsigned int mz_flags = RTE_MEMZONE_1GB|RTE_MEMZONE_SIZE_HINT_ONLY;
 800         struct rte_mempool_objsz objsz;
 801         unsigned lcore_id;
 802         int ret;
 803
 804         /* compilation-time checks */
 805         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool) &
 806                           RTE_CACHE_LINE_MASK) != 0);
 807         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool_cache) &
 808                           RTE_CACHE_LINE_MASK) != 0);
 809 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
 810         RTE_BUILD_BUG_ON((sizeof(struct rte_mempool_debug_stats) &
 811                           RTE_CACHE_LINE_MASK) != 0);
 812         RTE_BUILD_BUG_ON((offsetof(struct rte_mempool, stats) &
 813                           RTE_CACHE_LINE_MASK) != 0);
 814 #endif
 815
 816         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
 817
 818         /* asked for zero items */
 819         if (n == 0) {
 820                 rte_errno = EINVAL;
 821                 return NULL;
 822         }
 823
 824         /* asked cache too big */
 825         if (cache_size > RTE_MEMPOOL_CACHE_MAX_SIZE ||
 826             CALC_CACHE_FLUSHTHRESH(cache_size) > n) {
 827                 rte_errno = EINVAL;
 828                 return NULL;
 829         }
 830
 831         /* "no cache align" imply "no spread" */
 832         if (flags & MEMPOOL_F_NO_CACHE_ALIGN)
 833                 flags |= MEMPOOL_F_NO_SPREAD;
 834
 835         /* calculate mempool object sizes. */
 836         if (!rte_mempool_calc_obj_size(elt_size, flags, &objsz)) {
 837                 rte_errno = EINVAL;
 838                 return NULL;
 839         }
 840
 841         rte_mcfg_mempool_write_lock();
 842
 843         /*
 844          * reserve a memory zone for this mempool: private data is
 845          * cache-aligned
 846          */
 847         private_data_size = (private_data_size +
 848                              RTE_MEMPOOL_ALIGN_MASK) & (~RTE_MEMPOOL_ALIGN_MASK);
 849
 850
 851         /* try to allocate tailq entry */
 852         te = rte_zmalloc("MEMPOOL_TAILQ_ENTRY", sizeof(*te), 0);
 853         if (te == NULL) {
 854                 RTE_LOG(ERR, MEMPOOL, "Cannot allocate tailq entry!\n");
 855                 goto exit_unlock;
 856         }
 857
 858         mempool_size = MEMPOOL_HEADER_SIZE(mp, cache_size);
 859         mempool_size += private_data_size;
 860         mempool_size = RTE_ALIGN_CEIL(mempool_size, RTE_MEMPOOL_ALIGN);
 861
 862         ret = snprintf(mz_name, sizeof(mz_name), RTE_MEMPOOL_MZ_FORMAT, name);
 863         if (ret < 0 || ret >= (int)sizeof(mz_name)) {
 864                 rte_errno = ENAMETOOLONG;
 865                 goto exit_unlock;
 866         }
 867
 868         mz = rte_memzone_reserve(mz_name, mempool_size, socket_id, mz_flags);
 869         if (mz == NULL)
 870                 goto exit_unlock;
 871
 872         /* init the mempool structure */
 873         mp = mz->addr;
 874         memset(mp, 0, MEMPOOL_HEADER_SIZE(mp, cache_size));
 875         ret = strlcpy(mp->name, name, sizeof(mp->name));
 876         if (ret < 0 || ret >= (int)sizeof(mp->name)) {
 877                 rte_errno = ENAMETOOLONG;
 878                 goto exit_unlock;
 879         }
 880         mp->mz = mz;
 881         mp->size = n;
 882         mp->flags = flags;
 883         mp->socket_id = socket_id;
 884         mp->elt_size = objsz.elt_size;
 885         mp->header_size = objsz.header_size;
 886         mp->trailer_size = objsz.trailer_size;
 887         /* Size of default caches, zero means disabled. */
 888         mp->cache_size = cache_size;
 889         mp->private_data_size = private_data_size;
 890         STAILQ_INIT(&mp->elt_list);
 891         STAILQ_INIT(&mp->mem_list);
 892
 893         /*
 894          * local_cache pointer is set even if cache_size is zero.
 895          * The local_cache points to just past the elt_pa[] array.
 896          */
 897         mp->local_cache = (struct rte_mempool_cache *)
 898                 RTE_PTR_ADD(mp, MEMPOOL_HEADER_SIZE(mp, 0));
 899
 900         /* Init all default caches. */
 901         if (cache_size != 0) {
 902                 for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
 903                         mempool_cache_init(&mp->local_cache[lcore_id],
 904                                            cache_size);
 905         }
 906
 907         te->data = mp;
 908
 909         rte_mcfg_tailq_write_lock();
 910         TAILQ_INSERT_TAIL(mempool_list, te, next);
 911         rte_mcfg_tailq_write_unlock();
 912         rte_mcfg_mempool_write_unlock();
 913
 914         return mp;
 915
 916 exit_unlock:
 917         rte_mcfg_mempool_write_unlock();
 918         rte_free(te);
 919         rte_mempool_free(mp);
 920         return NULL;
 921 }
 922
 923 /* create the mempool */
 924 struct rte_mempool *
 925 rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
 926         unsigned cache_size, unsigned private_data_size,
 927         rte_mempool_ctor_t *mp_init, void *mp_init_arg,
 928         rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
 929         int socket_id, unsigned flags)
 930 {
 931         int ret;
 932         struct rte_mempool *mp;
 933
 934         mp = rte_mempool_create_empty(name, n, elt_size, cache_size,
 935                 private_data_size, socket_id, flags);
 936         if (mp == NULL)
 937                 return NULL;
 938
 939         /*
 940          * Since we have 4 combinations of the SP/SC/MP/MC examine the flags to
 941          * set the correct index into the table of ops structs.
 942          */
 943         if ((flags & MEMPOOL_F_SP_PUT) && (flags & MEMPOOL_F_SC_GET))
 944                 ret = rte_mempool_set_ops_byname(mp, "ring_sp_sc", NULL);
 945         else if (flags & MEMPOOL_F_SP_PUT)
 946                 ret = rte_mempool_set_ops_byname(mp, "ring_sp_mc", NULL);
 947         else if (flags & MEMPOOL_F_SC_GET)
 948                 ret = rte_mempool_set_ops_byname(mp, "ring_mp_sc", NULL);
 949         else
 950                 ret = rte_mempool_set_ops_byname(mp, "ring_mp_mc", NULL);
 951
 952         if (ret)
 953                 goto fail;
 954
 955         /* call the mempool priv initializer */
 956         if (mp_init)
 957                 mp_init(mp, mp_init_arg);
 958
 959         if (rte_mempool_populate_default(mp) < 0)
 960                 goto fail;
 961
 962         /* call the object initializers */
 963         if (obj_init)
 964                 rte_mempool_obj_iter(mp, obj_init, obj_init_arg);
 965
 966         return mp;
 967
 968  fail:
 969         rte_mempool_free(mp);
 970         return NULL;
 971 }
 972
 973 /* Return the number of entries in the mempool */
 974 unsigned int
 975 rte_mempool_avail_count(const struct rte_mempool *mp)
 976 {
 977         unsigned count;
 978         unsigned lcore_id;
 979
 980         count = rte_mempool_ops_get_count(mp);
 981
 982         if (mp->cache_size == 0)
 983                 return count;
 984
 985         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++)
 986                 count += mp->local_cache[lcore_id].len;
 987
 988         /*
 989          * due to race condition (access to len is not locked), the
 990          * total can be greater than size... so fix the result
 991          */
 992         if (count > mp->size)
 993                 return mp->size;
 994         return count;
 995 }
 996
 997 /* return the number of entries allocated from the mempool */
 998 unsigned int
 999 rte_mempool_in_use_count(const struct rte_mempool *mp)
1000 {
1001         return mp->size - rte_mempool_avail_count(mp);
1002 }
1003
1004 /* dump the cache status */
1005 static unsigned
1006 rte_mempool_dump_cache(FILE *f, const struct rte_mempool *mp)
1007 {
1008         unsigned lcore_id;
1009         unsigned count = 0;
1010         unsigned cache_count;
1011
1012         fprintf(f, "  internal cache infos:\n");
1013         fprintf(f, "    cache_size=%"PRIu32"\n", mp->cache_size);
1014
1015         if (mp->cache_size == 0)
1016                 return count;
1017
1018         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1019                 cache_count = mp->local_cache[lcore_id].len;
1020                 fprintf(f, "    cache_count[%u]=%"PRIu32"\n",
1021                         lcore_id, cache_count);
1022                 count += cache_count;
1023         }
1024         fprintf(f, "    total_cache_count=%u\n", count);
1025         return count;
1026 }
1027
1028 #ifndef __INTEL_COMPILER
1029 #pragma GCC diagnostic ignored "-Wcast-qual"
1030 #endif
1031
1032 /* check and update cookies or panic (internal) */
1033 void rte_mempool_check_cookies(const struct rte_mempool *mp,
1034         void * const *obj_table_const, unsigned n, int free)
1035 {
1036 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1037         struct rte_mempool_objhdr *hdr;
1038         struct rte_mempool_objtlr *tlr;
1039         uint64_t cookie;
1040         void *tmp;
1041         void *obj;
1042         void **obj_table;
1043
1044         /* Force to drop the "const" attribute. This is done only when
1045          * DEBUG is enabled */
1046         tmp = (void *) obj_table_const;
1047         obj_table = tmp;
1048
1049         while (n--) {
1050                 obj = obj_table[n];
1051
1052                 if (rte_mempool_from_obj(obj) != mp)
1053                         rte_panic("MEMPOOL: object is owned by another "
1054                                   "mempool\n");
1055
1056                 hdr = __mempool_get_header(obj);
1057                 cookie = hdr->cookie;
1058
1059                 if (free == 0) {
1060                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE1) {
1061                                 RTE_LOG(CRIT, MEMPOOL,
1062                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1063                                         obj, (const void *) mp, cookie);
1064                                 rte_panic("MEMPOOL: bad header cookie (put)\n");
1065                         }
1066                         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE2;
1067                 } else if (free == 1) {
1068                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
1069                                 RTE_LOG(CRIT, MEMPOOL,
1070                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1071                                         obj, (const void *) mp, cookie);
1072                                 rte_panic("MEMPOOL: bad header cookie (get)\n");
1073                         }
1074                         hdr->cookie = RTE_MEMPOOL_HEADER_COOKIE1;
1075                 } else if (free == 2) {
1076                         if (cookie != RTE_MEMPOOL_HEADER_COOKIE1 &&
1077                             cookie != RTE_MEMPOOL_HEADER_COOKIE2) {
1078                                 RTE_LOG(CRIT, MEMPOOL,
1079                                         "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1080                                         obj, (const void *) mp, cookie);
1081                                 rte_panic("MEMPOOL: bad header cookie (audit)\n");
1082                         }
1083                 }
1084                 tlr = __mempool_get_trailer(obj);
1085                 cookie = tlr->cookie;
1086                 if (cookie != RTE_MEMPOOL_TRAILER_COOKIE) {
1087                         RTE_LOG(CRIT, MEMPOOL,
1088                                 "obj=%p, mempool=%p, cookie=%" PRIx64 "\n",
1089                                 obj, (const void *) mp, cookie);
1090                         rte_panic("MEMPOOL: bad trailer cookie\n");
1091                 }
1092         }
1093 #else
1094         RTE_SET_USED(mp);
1095         RTE_SET_USED(obj_table_const);
1096         RTE_SET_USED(n);
1097         RTE_SET_USED(free);
1098 #endif
1099 }
1100
1101 void
1102 rte_mempool_contig_blocks_check_cookies(const struct rte_mempool *mp,
1103         void * const *first_obj_table_const, unsigned int n, int free)
1104 {
1105 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1106         struct rte_mempool_info info;
1107         const size_t total_elt_sz =
1108                 mp->header_size + mp->elt_size + mp->trailer_size;
1109         unsigned int i, j;
1110
1111         rte_mempool_ops_get_info(mp, &info);
1112
1113         for (i = 0; i < n; ++i) {
1114                 void *first_obj = first_obj_table_const[i];
1115
1116                 for (j = 0; j < info.contig_block_size; ++j) {
1117                         void *obj;
1118
1119                         obj = (void *)((uintptr_t)first_obj + j * total_elt_sz);
1120                         rte_mempool_check_cookies(mp, &obj, 1, free);
1121                 }
1122         }
1123 #else
1124         RTE_SET_USED(mp);
1125         RTE_SET_USED(first_obj_table_const);
1126         RTE_SET_USED(n);
1127         RTE_SET_USED(free);
1128 #endif
1129 }
1130
1131 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1132 static void
1133 mempool_obj_audit(struct rte_mempool *mp, __rte_unused void *opaque,
1134         void *obj, __rte_unused unsigned idx)
1135 {
1136         __mempool_check_cookies(mp, &obj, 1, 2);
1137 }
1138
1139 static void
1140 mempool_audit_cookies(struct rte_mempool *mp)
1141 {
1142         unsigned num;
1143
1144         num = rte_mempool_obj_iter(mp, mempool_obj_audit, NULL);
1145         if (num != mp->size) {
1146                 rte_panic("rte_mempool_obj_iter(mempool=%p, size=%u) "
1147                         "iterated only over %u elements\n",
1148                         mp, mp->size, num);
1149         }
1150 }
1151 #else
1152 #define mempool_audit_cookies(mp) do {} while(0)
1153 #endif
1154
1155 #ifndef __INTEL_COMPILER
1156 #pragma GCC diagnostic error "-Wcast-qual"
1157 #endif
1158
1159 /* check cookies before and after objects */
1160 static void
1161 mempool_audit_cache(const struct rte_mempool *mp)
1162 {
1163         /* check cache size consistency */
1164         unsigned lcore_id;
1165
1166         if (mp->cache_size == 0)
1167                 return;
1168
1169         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1170                 const struct rte_mempool_cache *cache;
1171                 cache = &mp->local_cache[lcore_id];
1172                 if (cache->len > cache->flushthresh) {
1173                         RTE_LOG(CRIT, MEMPOOL, "badness on cache[%u]\n",
1174                                 lcore_id);
1175                         rte_panic("MEMPOOL: invalid cache len\n");
1176                 }
1177         }
1178 }
1179
1180 /* check the consistency of mempool (size, cookies, ...) */
1181 void
1182 rte_mempool_audit(struct rte_mempool *mp)
1183 {
1184         mempool_audit_cache(mp);
1185         mempool_audit_cookies(mp);
1186
1187         /* For case where mempool DEBUG is not set, and cache size is 0 */
1188         RTE_SET_USED(mp);
1189 }
1190
1191 /* dump the status of the mempool on the console */
1192 void
1193 rte_mempool_dump(FILE *f, struct rte_mempool *mp)
1194 {
1195 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1196         struct rte_mempool_info info;
1197         struct rte_mempool_debug_stats sum;
1198         unsigned lcore_id;
1199 #endif
1200         struct rte_mempool_memhdr *memhdr;
1201         unsigned common_count;
1202         unsigned cache_count;
1203         size_t mem_len = 0;
1204
1205         RTE_ASSERT(f != NULL);
1206         RTE_ASSERT(mp != NULL);
1207
1208         fprintf(f, "mempool <%s>@%p\n", mp->name, mp);
1209         fprintf(f, "  flags=%x\n", mp->flags);
1210         fprintf(f, "  pool=%p\n", mp->pool_data);
1211         fprintf(f, "  iova=0x%" PRIx64 "\n", mp->mz->iova);
1212         fprintf(f, "  nb_mem_chunks=%u\n", mp->nb_mem_chunks);
1213         fprintf(f, "  size=%"PRIu32"\n", mp->size);
1214         fprintf(f, "  populated_size=%"PRIu32"\n", mp->populated_size);
1215         fprintf(f, "  header_size=%"PRIu32"\n", mp->header_size);
1216         fprintf(f, "  elt_size=%"PRIu32"\n", mp->elt_size);
1217         fprintf(f, "  trailer_size=%"PRIu32"\n", mp->trailer_size);
1218         fprintf(f, "  total_obj_size=%"PRIu32"\n",
1219                mp->header_size + mp->elt_size + mp->trailer_size);
1220
1221         fprintf(f, "  private_data_size=%"PRIu32"\n", mp->private_data_size);
1222
1223         STAILQ_FOREACH(memhdr, &mp->mem_list, next)
1224                 mem_len += memhdr->len;
1225         if (mem_len != 0) {
1226                 fprintf(f, "  avg bytes/object=%#Lf\n",
1227                         (long double)mem_len / mp->size);
1228         }
1229
1230         cache_count = rte_mempool_dump_cache(f, mp);
1231         common_count = rte_mempool_ops_get_count(mp);
1232         if ((cache_count + common_count) > mp->size)
1233                 common_count = mp->size - cache_count;
1234         fprintf(f, "  common_pool_count=%u\n", common_count);
1235
1236         /* sum and dump statistics */
1237 #ifdef RTE_LIBRTE_MEMPOOL_DEBUG
1238         rte_mempool_ops_get_info(mp, &info);
1239         memset(&sum, 0, sizeof(sum));
1240         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1241                 sum.put_bulk += mp->stats[lcore_id].put_bulk;
1242                 sum.put_objs += mp->stats[lcore_id].put_objs;
1243                 sum.get_success_bulk += mp->stats[lcore_id].get_success_bulk;
1244                 sum.get_success_objs += mp->stats[lcore_id].get_success_objs;
1245                 sum.get_fail_bulk += mp->stats[lcore_id].get_fail_bulk;
1246                 sum.get_fail_objs += mp->stats[lcore_id].get_fail_objs;
1247                 sum.get_success_blks += mp->stats[lcore_id].get_success_blks;
1248                 sum.get_fail_blks += mp->stats[lcore_id].get_fail_blks;
1249         }
1250         fprintf(f, "  stats:\n");
1251         fprintf(f, "    put_bulk=%"PRIu64"\n", sum.put_bulk);
1252         fprintf(f, "    put_objs=%"PRIu64"\n", sum.put_objs);
1253         fprintf(f, "    get_success_bulk=%"PRIu64"\n", sum.get_success_bulk);
1254         fprintf(f, "    get_success_objs=%"PRIu64"\n", sum.get_success_objs);
1255         fprintf(f, "    get_fail_bulk=%"PRIu64"\n", sum.get_fail_bulk);
1256         fprintf(f, "    get_fail_objs=%"PRIu64"\n", sum.get_fail_objs);
1257         if (info.contig_block_size > 0) {
1258                 fprintf(f, "    get_success_blks=%"PRIu64"\n",
1259                         sum.get_success_blks);
1260                 fprintf(f, "    get_fail_blks=%"PRIu64"\n", sum.get_fail_blks);
1261         }
1262 #else
1263         fprintf(f, "  no statistics available\n");
1264 #endif
1265
1266         rte_mempool_audit(mp);
1267 }
1268
1269 /* dump the status of all mempools on the console */
1270 void
1271 rte_mempool_list_dump(FILE *f)
1272 {
1273         struct rte_mempool *mp = NULL;
1274         struct rte_tailq_entry *te;
1275         struct rte_mempool_list *mempool_list;
1276
1277         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1278
1279         rte_mcfg_mempool_read_lock();
1280
1281         TAILQ_FOREACH(te, mempool_list, next) {
1282                 mp = (struct rte_mempool *) te->data;
1283                 rte_mempool_dump(f, mp);
1284         }
1285
1286         rte_mcfg_mempool_read_unlock();
1287 }
1288
1289 /* search a mempool from its name */
1290 struct rte_mempool *
1291 rte_mempool_lookup(const char *name)
1292 {
1293         struct rte_mempool *mp = NULL;
1294         struct rte_tailq_entry *te;
1295         struct rte_mempool_list *mempool_list;
1296
1297         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1298
1299         rte_mcfg_mempool_read_lock();
1300
1301         TAILQ_FOREACH(te, mempool_list, next) {
1302                 mp = (struct rte_mempool *) te->data;
1303                 if (strncmp(name, mp->name, RTE_MEMPOOL_NAMESIZE) == 0)
1304                         break;
1305         }
1306
1307         rte_mcfg_mempool_read_unlock();
1308
1309         if (te == NULL) {
1310                 rte_errno = ENOENT;
1311                 return NULL;
1312         }
1313
1314         return mp;
1315 }
1316
1317 void rte_mempool_walk(void (*func)(struct rte_mempool *, void *),
1318                       void *arg)
1319 {
1320         struct rte_tailq_entry *te = NULL;
1321         struct rte_mempool_list *mempool_list;
1322         void *tmp_te;
1323
1324         mempool_list = RTE_TAILQ_CAST(rte_mempool_tailq.head, rte_mempool_list);
1325
1326         rte_mcfg_mempool_read_lock();
1327
1328         TAILQ_FOREACH_SAFE(te, mempool_list, next, tmp_te) {
1329                 (*func)((struct rte_mempool *) te->data, arg);
1330         }
1331
1332         rte_mcfg_mempool_read_unlock();
1333 }