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