1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
15 #include <sys/queue.h>
17 #include <rte_fbarray.h>
18 #include <rte_memory.h>
20 #include <rte_eal_memconfig.h>
21 #include <rte_errno.h>
24 #include "eal_memalloc.h"
25 #include "eal_private.h"
26 #include "eal_internal_cfg.h"
29 * Try to mmap *size bytes in /dev/zero. If it is successful, return the
30 * pointer to the mmap'd area and keep *size unmodified. Else, retry
31 * with a smaller zone: decrease *size by hugepage_sz until it reaches
32 * 0. In this case, return NULL. Note: this function returns an address
33 * which is a multiple of hugepage size.
36 #define MEMSEG_LIST_FMT "memseg-%" PRIu64 "k-%i-%i"
38 static void *next_baseaddr;
39 static uint64_t system_page_sz;
43 * Linux kernel uses a really high address as starting address for serving
44 * mmaps calls. If there exists addressing limitations and IOVA mode is VA,
45 * this starting address is likely too high for those devices. However, it
46 * is possible to use a lower address in the process virtual address space
47 * as with 64 bits there is a lot of available space.
49 * Current known limitations are 39 or 40 bits. Setting the starting address
50 * at 4GB implies there are 508GB or 1020GB for mapping the available
51 * hugepages. This is likely enough for most systems, although a device with
52 * addressing limitations should call rte_mem_check_dma_mask for ensuring all
53 * memory is within supported range.
55 static uint64_t baseaddr = 0x100000000;
59 eal_get_virtual_area(void *requested_addr, size_t *size,
60 size_t page_sz, int flags, int mmap_flags)
62 bool addr_is_hint, allow_shrink, unmap, no_align;
64 void *mapped_addr, *aligned_addr;
66 if (system_page_sz == 0)
67 system_page_sz = sysconf(_SC_PAGESIZE);
69 mmap_flags |= MAP_PRIVATE | MAP_ANONYMOUS;
71 RTE_LOG(DEBUG, EAL, "Ask a virtual area of 0x%zx bytes\n", *size);
73 addr_is_hint = (flags & EAL_VIRTUAL_AREA_ADDR_IS_HINT) > 0;
74 allow_shrink = (flags & EAL_VIRTUAL_AREA_ALLOW_SHRINK) > 0;
75 unmap = (flags & EAL_VIRTUAL_AREA_UNMAP) > 0;
77 if (next_baseaddr == NULL && internal_config.base_virtaddr != 0 &&
78 rte_eal_process_type() == RTE_PROC_PRIMARY)
79 next_baseaddr = (void *) internal_config.base_virtaddr;
82 if (next_baseaddr == NULL && internal_config.base_virtaddr == 0 &&
83 rte_eal_process_type() == RTE_PROC_PRIMARY)
84 next_baseaddr = (void *) baseaddr;
86 if (requested_addr == NULL && next_baseaddr != NULL) {
87 requested_addr = next_baseaddr;
88 requested_addr = RTE_PTR_ALIGN(requested_addr, page_sz);
92 /* we don't need alignment of resulting pointer in the following cases:
94 * 1. page size is equal to system size
95 * 2. we have a requested address, and it is page-aligned, and we will
96 * be discarding the address if we get a different one.
98 * for all other cases, alignment is potentially necessary.
100 no_align = (requested_addr != NULL &&
101 requested_addr == RTE_PTR_ALIGN(requested_addr, page_sz) &&
103 page_sz == system_page_sz;
106 map_sz = no_align ? *size : *size + page_sz;
107 if (map_sz > SIZE_MAX) {
108 RTE_LOG(ERR, EAL, "Map size too big\n");
113 mapped_addr = mmap(requested_addr, (size_t)map_sz, PROT_READ,
115 if (mapped_addr == MAP_FAILED && allow_shrink)
118 if (mapped_addr != MAP_FAILED && addr_is_hint &&
119 mapped_addr != requested_addr) {
120 /* hint was not used. Try with another offset */
121 munmap(mapped_addr, map_sz);
122 mapped_addr = MAP_FAILED;
123 next_baseaddr = RTE_PTR_ADD(next_baseaddr, page_sz);
124 requested_addr = next_baseaddr;
126 } while ((allow_shrink || addr_is_hint) &&
127 mapped_addr == MAP_FAILED && *size > 0);
129 /* align resulting address - if map failed, we will ignore the value
130 * anyway, so no need to add additional checks.
132 aligned_addr = no_align ? mapped_addr :
133 RTE_PTR_ALIGN(mapped_addr, page_sz);
136 RTE_LOG(ERR, EAL, "Cannot get a virtual area of any size: %s\n",
140 } else if (mapped_addr == MAP_FAILED) {
141 RTE_LOG(ERR, EAL, "Cannot get a virtual area: %s\n",
143 /* pass errno up the call chain */
146 } else if (requested_addr != NULL && !addr_is_hint &&
147 aligned_addr != requested_addr) {
148 RTE_LOG(ERR, EAL, "Cannot get a virtual area at requested address: %p (got %p)\n",
149 requested_addr, aligned_addr);
150 munmap(mapped_addr, map_sz);
151 rte_errno = EADDRNOTAVAIL;
153 } else if (requested_addr != NULL && addr_is_hint &&
154 aligned_addr != requested_addr) {
155 RTE_LOG(WARNING, EAL, "WARNING! Base virtual address hint (%p != %p) not respected!\n",
156 requested_addr, aligned_addr);
157 RTE_LOG(WARNING, EAL, " This may cause issues with mapping memory into secondary processes\n");
158 } else if (next_baseaddr != NULL) {
159 next_baseaddr = RTE_PTR_ADD(aligned_addr, *size);
162 RTE_LOG(DEBUG, EAL, "Virtual area found at %p (size = 0x%zx)\n",
163 aligned_addr, *size);
166 munmap(mapped_addr, map_sz);
167 } else if (!no_align) {
168 void *map_end, *aligned_end;
169 size_t before_len, after_len;
171 /* when we reserve space with alignment, we add alignment to
172 * mapping size. On 32-bit, if 1GB alignment was requested, this
173 * would waste 1GB of address space, which is a luxury we cannot
174 * afford. so, if alignment was performed, check if any unneeded
175 * address space can be unmapped back.
178 map_end = RTE_PTR_ADD(mapped_addr, (size_t)map_sz);
179 aligned_end = RTE_PTR_ADD(aligned_addr, *size);
181 /* unmap space before aligned mmap address */
182 before_len = RTE_PTR_DIFF(aligned_addr, mapped_addr);
184 munmap(mapped_addr, before_len);
186 /* unmap space after aligned end mmap address */
187 after_len = RTE_PTR_DIFF(map_end, aligned_end);
189 munmap(aligned_end, after_len);
195 static struct rte_memseg *
196 virt2memseg(const void *addr, const struct rte_memseg_list *msl)
198 const struct rte_fbarray *arr;
205 /* a memseg list was specified, check if it's the right one */
206 start = msl->base_va;
207 end = RTE_PTR_ADD(start, msl->len);
209 if (addr < start || addr >= end)
212 /* now, calculate index */
213 arr = &msl->memseg_arr;
214 ms_idx = RTE_PTR_DIFF(addr, msl->base_va) / msl->page_sz;
215 return rte_fbarray_get(arr, ms_idx);
218 static struct rte_memseg_list *
219 virt2memseg_list(const void *addr)
221 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
222 struct rte_memseg_list *msl;
225 for (msl_idx = 0; msl_idx < RTE_MAX_MEMSEG_LISTS; msl_idx++) {
227 msl = &mcfg->memsegs[msl_idx];
229 start = msl->base_va;
230 end = RTE_PTR_ADD(start, msl->len);
231 if (addr >= start && addr < end)
234 /* if we didn't find our memseg list */
235 if (msl_idx == RTE_MAX_MEMSEG_LISTS)
240 __rte_experimental struct rte_memseg_list *
241 rte_mem_virt2memseg_list(const void *addr)
243 return virt2memseg_list(addr);
251 find_virt(const struct rte_memseg_list *msl __rte_unused,
252 const struct rte_memseg *ms, void *arg)
254 struct virtiova *vi = arg;
255 if (vi->iova >= ms->iova && vi->iova < (ms->iova + ms->len)) {
256 size_t offset = vi->iova - ms->iova;
257 vi->virt = RTE_PTR_ADD(ms->addr, offset);
264 find_virt_legacy(const struct rte_memseg_list *msl __rte_unused,
265 const struct rte_memseg *ms, size_t len, void *arg)
267 struct virtiova *vi = arg;
268 if (vi->iova >= ms->iova && vi->iova < (ms->iova + len)) {
269 size_t offset = vi->iova - ms->iova;
270 vi->virt = RTE_PTR_ADD(ms->addr, offset);
277 __rte_experimental void *
278 rte_mem_iova2virt(rte_iova_t iova)
282 memset(&vi, 0, sizeof(vi));
285 /* for legacy mem, we can get away with scanning VA-contiguous segments,
286 * as we know they are PA-contiguous as well
288 if (internal_config.legacy_mem)
289 rte_memseg_contig_walk(find_virt_legacy, &vi);
291 rte_memseg_walk(find_virt, &vi);
296 __rte_experimental struct rte_memseg *
297 rte_mem_virt2memseg(const void *addr, const struct rte_memseg_list *msl)
299 return virt2memseg(addr, msl != NULL ? msl :
300 rte_mem_virt2memseg_list(addr));
304 physmem_size(const struct rte_memseg_list *msl, void *arg)
306 uint64_t *total_len = arg;
311 *total_len += msl->memseg_arr.count * msl->page_sz;
316 /* get the total size of memory */
318 rte_eal_get_physmem_size(void)
320 uint64_t total_len = 0;
322 rte_memseg_list_walk(physmem_size, &total_len);
328 dump_memseg(const struct rte_memseg_list *msl, const struct rte_memseg *ms,
331 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
332 int msl_idx, ms_idx, fd;
335 msl_idx = msl - mcfg->memsegs;
336 if (msl_idx < 0 || msl_idx >= RTE_MAX_MEMSEG_LISTS)
339 ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
343 fd = eal_memalloc_get_seg_fd(msl_idx, ms_idx);
344 fprintf(f, "Segment %i-%i: IOVA:0x%"PRIx64", len:%zu, "
345 "virt:%p, socket_id:%"PRId32", "
346 "hugepage_sz:%"PRIu64", nchannel:%"PRIx32", "
347 "nrank:%"PRIx32" fd:%i\n",
362 * Defining here because declared in rte_memory.h, but the actual implementation
363 * is in eal_common_memalloc.c, like all other memalloc internals.
365 int __rte_experimental
366 rte_mem_event_callback_register(const char *name, rte_mem_event_callback_t clb,
369 /* FreeBSD boots with legacy mem enabled by default */
370 if (internal_config.legacy_mem) {
371 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
375 return eal_memalloc_mem_event_callback_register(name, clb, arg);
378 int __rte_experimental
379 rte_mem_event_callback_unregister(const char *name, void *arg)
381 /* FreeBSD boots with legacy mem enabled by default */
382 if (internal_config.legacy_mem) {
383 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
387 return eal_memalloc_mem_event_callback_unregister(name, arg);
390 int __rte_experimental
391 rte_mem_alloc_validator_register(const char *name,
392 rte_mem_alloc_validator_t clb, int socket_id, size_t limit)
394 /* FreeBSD boots with legacy mem enabled by default */
395 if (internal_config.legacy_mem) {
396 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
400 return eal_memalloc_mem_alloc_validator_register(name, clb, socket_id,
404 int __rte_experimental
405 rte_mem_alloc_validator_unregister(const char *name, int socket_id)
407 /* FreeBSD boots with legacy mem enabled by default */
408 if (internal_config.legacy_mem) {
409 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
413 return eal_memalloc_mem_alloc_validator_unregister(name, socket_id);
416 /* Dump the physical memory layout on console */
418 rte_dump_physmem_layout(FILE *f)
420 rte_memseg_walk(dump_memseg, f);
424 check_iova(const struct rte_memseg_list *msl __rte_unused,
425 const struct rte_memseg *ms, void *arg)
427 uint64_t *mask = arg;
430 /* higher address within segment */
431 iova = (ms->iova + ms->len) - 1;
435 RTE_LOG(DEBUG, EAL, "memseg iova %"PRIx64", len %zx, out of range\n",
438 RTE_LOG(DEBUG, EAL, "\tusing dma mask %"PRIx64"\n", *mask);
442 #define MAX_DMA_MASK_BITS 63
444 /* check memseg iovas are within the required range based on dma mask */
445 static int __rte_experimental
446 check_dma_mask(uint8_t maskbits, bool thread_unsafe)
448 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
452 /* Sanity check. We only check width can be managed with 64 bits
453 * variables. Indeed any higher value is likely wrong. */
454 if (maskbits > MAX_DMA_MASK_BITS) {
455 RTE_LOG(ERR, EAL, "wrong dma mask size %u (Max: %u)\n",
456 maskbits, MAX_DMA_MASK_BITS);
460 /* create dma mask */
461 mask = ~((1ULL << maskbits) - 1);
464 ret = rte_memseg_walk_thread_unsafe(check_iova, &mask);
466 ret = rte_memseg_walk(check_iova, &mask);
470 * Dma mask precludes hugepage usage.
471 * This device can not be used and we do not need to keep
477 * we need to keep the more restricted maskbit for checking
478 * potential dynamic memory allocation in the future.
480 mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
481 RTE_MIN(mcfg->dma_maskbits, maskbits);
486 int __rte_experimental
487 rte_mem_check_dma_mask(uint8_t maskbits)
489 return check_dma_mask(maskbits, false);
492 int __rte_experimental
493 rte_mem_check_dma_mask_thread_unsafe(uint8_t maskbits)
495 return check_dma_mask(maskbits, true);
499 * Set dma mask to use when memory initialization is done.
501 * This function should ONLY be used by code executed before the memory
502 * initialization. PMDs should use rte_mem_check_dma_mask if addressing
503 * limitations by the device.
505 void __rte_experimental
506 rte_mem_set_dma_mask(uint8_t maskbits)
508 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
510 mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
511 RTE_MIN(mcfg->dma_maskbits, maskbits);
514 /* return the number of memory channels */
515 unsigned rte_memory_get_nchannel(void)
517 return rte_eal_get_configuration()->mem_config->nchannel;
520 /* return the number of memory rank */
521 unsigned rte_memory_get_nrank(void)
523 return rte_eal_get_configuration()->mem_config->nrank;
527 rte_eal_memdevice_init(void)
529 struct rte_config *config;
531 if (rte_eal_process_type() == RTE_PROC_SECONDARY)
534 config = rte_eal_get_configuration();
535 config->mem_config->nchannel = internal_config.force_nchannel;
536 config->mem_config->nrank = internal_config.force_nrank;
541 /* Lock page in physical memory and prevent from swapping. */
543 rte_mem_lock_page(const void *virt)
545 unsigned long virtual = (unsigned long)virt;
546 int page_size = getpagesize();
547 unsigned long aligned = (virtual & ~(page_size - 1));
548 return mlock((void *)aligned, page_size);
551 int __rte_experimental
552 rte_memseg_contig_walk_thread_unsafe(rte_memseg_contig_walk_t func, void *arg)
554 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
555 int i, ms_idx, ret = 0;
557 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
558 struct rte_memseg_list *msl = &mcfg->memsegs[i];
559 const struct rte_memseg *ms;
560 struct rte_fbarray *arr;
562 if (msl->memseg_arr.count == 0)
565 arr = &msl->memseg_arr;
567 ms_idx = rte_fbarray_find_next_used(arr, 0);
568 while (ms_idx >= 0) {
572 ms = rte_fbarray_get(arr, ms_idx);
574 /* find how many more segments there are, starting with
577 n_segs = rte_fbarray_find_contig_used(arr, ms_idx);
578 len = n_segs * msl->page_sz;
580 ret = func(msl, ms, len, arg);
583 ms_idx = rte_fbarray_find_next_used(arr,
590 int __rte_experimental
591 rte_memseg_contig_walk(rte_memseg_contig_walk_t func, void *arg)
593 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
596 /* do not allow allocations/frees/init while we iterate */
597 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
598 ret = rte_memseg_contig_walk_thread_unsafe(func, arg);
599 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
604 int __rte_experimental
605 rte_memseg_walk_thread_unsafe(rte_memseg_walk_t func, void *arg)
607 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
608 int i, ms_idx, ret = 0;
610 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
611 struct rte_memseg_list *msl = &mcfg->memsegs[i];
612 const struct rte_memseg *ms;
613 struct rte_fbarray *arr;
615 if (msl->memseg_arr.count == 0)
618 arr = &msl->memseg_arr;
620 ms_idx = rte_fbarray_find_next_used(arr, 0);
621 while (ms_idx >= 0) {
622 ms = rte_fbarray_get(arr, ms_idx);
623 ret = func(msl, ms, arg);
626 ms_idx = rte_fbarray_find_next_used(arr, ms_idx + 1);
632 int __rte_experimental
633 rte_memseg_walk(rte_memseg_walk_t func, void *arg)
635 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
638 /* do not allow allocations/frees/init while we iterate */
639 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
640 ret = rte_memseg_walk_thread_unsafe(func, arg);
641 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
646 int __rte_experimental
647 rte_memseg_list_walk_thread_unsafe(rte_memseg_list_walk_t func, void *arg)
649 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
652 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
653 struct rte_memseg_list *msl = &mcfg->memsegs[i];
655 if (msl->base_va == NULL)
658 ret = func(msl, arg);
665 int __rte_experimental
666 rte_memseg_list_walk(rte_memseg_list_walk_t func, void *arg)
668 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
671 /* do not allow allocations/frees/init while we iterate */
672 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
673 ret = rte_memseg_list_walk_thread_unsafe(func, arg);
674 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
679 int __rte_experimental
680 rte_memseg_get_fd_thread_unsafe(const struct rte_memseg *ms)
682 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
683 struct rte_memseg_list *msl;
684 struct rte_fbarray *arr;
685 int msl_idx, seg_idx, ret;
692 msl = rte_mem_virt2memseg_list(ms->addr);
697 arr = &msl->memseg_arr;
699 msl_idx = msl - mcfg->memsegs;
700 seg_idx = rte_fbarray_find_idx(arr, ms);
702 if (!rte_fbarray_is_used(arr, seg_idx)) {
707 ret = eal_memalloc_get_seg_fd(msl_idx, seg_idx);
715 int __rte_experimental
716 rte_memseg_get_fd(const struct rte_memseg *ms)
718 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
721 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
722 ret = rte_memseg_get_fd_thread_unsafe(ms);
723 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
728 int __rte_experimental
729 rte_memseg_get_fd_offset_thread_unsafe(const struct rte_memseg *ms,
732 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
733 struct rte_memseg_list *msl;
734 struct rte_fbarray *arr;
735 int msl_idx, seg_idx, ret;
737 if (ms == NULL || offset == NULL) {
742 msl = rte_mem_virt2memseg_list(ms->addr);
747 arr = &msl->memseg_arr;
749 msl_idx = msl - mcfg->memsegs;
750 seg_idx = rte_fbarray_find_idx(arr, ms);
752 if (!rte_fbarray_is_used(arr, seg_idx)) {
757 ret = eal_memalloc_get_seg_fd_offset(msl_idx, seg_idx, offset);
765 int __rte_experimental
766 rte_memseg_get_fd_offset(const struct rte_memseg *ms, size_t *offset)
768 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
771 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
772 ret = rte_memseg_get_fd_offset_thread_unsafe(ms, offset);
773 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
778 /* init memory subsystem */
780 rte_eal_memory_init(void)
782 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
784 RTE_LOG(DEBUG, EAL, "Setting up physically contiguous memory...\n");
789 /* lock mem hotplug here, to prevent races while we init */
790 rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
792 if (rte_eal_memseg_init() < 0)
795 if (eal_memalloc_init() < 0)
798 retval = rte_eal_process_type() == RTE_PROC_PRIMARY ?
799 rte_eal_hugepage_init() :
800 rte_eal_hugepage_attach();
804 if (internal_config.no_shconf == 0 && rte_eal_memdevice_init() < 0)
809 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);