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