1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
14 #include <sys/queue.h>
16 #include <rte_fbarray.h>
17 #include <rte_memory.h>
19 #include <rte_eal_memconfig.h>
20 #include <rte_eal_paging.h>
21 #include <rte_errno.h>
24 #include "eal_memalloc.h"
25 #include "eal_private.h"
26 #include "eal_internal_cfg.h"
27 #include "eal_memcfg.h"
28 #include "eal_options.h"
29 #include "malloc_heap.h"
32 * Try to mmap *size bytes in /dev/zero. If it is successful, return the
33 * pointer to the mmap'd area and keep *size unmodified. Else, retry
34 * with a smaller zone: decrease *size by hugepage_sz until it reaches
35 * 0. In this case, return NULL. Note: this function returns an address
36 * which is a multiple of hugepage size.
39 #define MEMSEG_LIST_FMT "memseg-%" PRIu64 "k-%i-%i"
41 static void *next_baseaddr;
42 static uint64_t system_page_sz;
44 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
46 eal_get_virtual_area(void *requested_addr, size_t *size,
47 size_t page_sz, int flags, int reserve_flags)
49 bool addr_is_hint, allow_shrink, unmap, no_align;
51 void *mapped_addr, *aligned_addr;
53 struct internal_config *internal_conf =
54 eal_get_internal_configuration();
56 if (system_page_sz == 0)
57 system_page_sz = rte_mem_page_size();
59 RTE_LOG(DEBUG, EAL, "Ask a virtual area of 0x%zx bytes\n", *size);
61 addr_is_hint = (flags & EAL_VIRTUAL_AREA_ADDR_IS_HINT) > 0;
62 allow_shrink = (flags & EAL_VIRTUAL_AREA_ALLOW_SHRINK) > 0;
63 unmap = (flags & EAL_VIRTUAL_AREA_UNMAP) > 0;
65 if (next_baseaddr == NULL && internal_conf->base_virtaddr != 0 &&
66 rte_eal_process_type() == RTE_PROC_PRIMARY)
67 next_baseaddr = (void *) internal_conf->base_virtaddr;
70 if (next_baseaddr == NULL && internal_conf->base_virtaddr == 0 &&
71 rte_eal_process_type() == RTE_PROC_PRIMARY)
72 next_baseaddr = (void *) eal_get_baseaddr();
74 if (requested_addr == NULL && next_baseaddr != NULL) {
75 requested_addr = next_baseaddr;
76 requested_addr = RTE_PTR_ALIGN(requested_addr, page_sz);
80 /* we don't need alignment of resulting pointer in the following cases:
82 * 1. page size is equal to system size
83 * 2. we have a requested address, and it is page-aligned, and we will
84 * be discarding the address if we get a different one.
86 * for all other cases, alignment is potentially necessary.
88 no_align = (requested_addr != NULL &&
89 requested_addr == RTE_PTR_ALIGN(requested_addr, page_sz) &&
91 page_sz == system_page_sz;
94 map_sz = no_align ? *size : *size + page_sz;
95 if (map_sz > SIZE_MAX) {
96 RTE_LOG(ERR, EAL, "Map size too big\n");
101 mapped_addr = eal_mem_reserve(
102 requested_addr, (size_t)map_sz, reserve_flags);
103 if ((mapped_addr == NULL) && allow_shrink)
106 if ((mapped_addr != NULL) && addr_is_hint &&
107 (mapped_addr != requested_addr)) {
109 next_baseaddr = RTE_PTR_ADD(next_baseaddr, page_sz);
110 if (try <= MAX_MMAP_WITH_DEFINED_ADDR_TRIES) {
111 /* hint was not used. Try with another offset */
112 eal_mem_free(mapped_addr, map_sz);
114 requested_addr = next_baseaddr;
117 } while ((allow_shrink || addr_is_hint) &&
118 (mapped_addr == NULL) && (*size > 0));
120 /* align resulting address - if map failed, we will ignore the value
121 * anyway, so no need to add additional checks.
123 aligned_addr = no_align ? mapped_addr :
124 RTE_PTR_ALIGN(mapped_addr, page_sz);
127 RTE_LOG(ERR, EAL, "Cannot get a virtual area of any size: %s\n",
128 rte_strerror(rte_errno));
130 } else if (mapped_addr == NULL) {
131 RTE_LOG(ERR, EAL, "Cannot get a virtual area: %s\n",
132 rte_strerror(rte_errno));
134 } else if (requested_addr != NULL && !addr_is_hint &&
135 aligned_addr != requested_addr) {
136 RTE_LOG(ERR, EAL, "Cannot get a virtual area at requested address: %p (got %p)\n",
137 requested_addr, aligned_addr);
138 eal_mem_free(mapped_addr, map_sz);
139 rte_errno = EADDRNOTAVAIL;
141 } else if (requested_addr != NULL && addr_is_hint &&
142 aligned_addr != requested_addr) {
143 RTE_LOG(WARNING, EAL, "WARNING! Base virtual address hint (%p != %p) not respected!\n",
144 requested_addr, aligned_addr);
145 RTE_LOG(WARNING, EAL, " This may cause issues with mapping memory into secondary processes\n");
146 } else if (next_baseaddr != NULL) {
147 next_baseaddr = RTE_PTR_ADD(aligned_addr, *size);
150 RTE_LOG(DEBUG, EAL, "Virtual area found at %p (size = 0x%zx)\n",
151 aligned_addr, *size);
154 eal_mem_free(mapped_addr, map_sz);
155 } else if (!no_align) {
156 void *map_end, *aligned_end;
157 size_t before_len, after_len;
159 /* when we reserve space with alignment, we add alignment to
160 * mapping size. On 32-bit, if 1GB alignment was requested, this
161 * would waste 1GB of address space, which is a luxury we cannot
162 * afford. so, if alignment was performed, check if any unneeded
163 * address space can be unmapped back.
166 map_end = RTE_PTR_ADD(mapped_addr, (size_t)map_sz);
167 aligned_end = RTE_PTR_ADD(aligned_addr, *size);
169 /* unmap space before aligned mmap address */
170 before_len = RTE_PTR_DIFF(aligned_addr, mapped_addr);
172 eal_mem_free(mapped_addr, before_len);
174 /* unmap space after aligned end mmap address */
175 after_len = RTE_PTR_DIFF(map_end, aligned_end);
177 eal_mem_free(aligned_end, after_len);
181 /* Exclude these pages from a core dump. */
182 eal_mem_set_dump(aligned_addr, *size, false);
189 eal_memseg_list_init_named(struct rte_memseg_list *msl, const char *name,
190 uint64_t page_sz, int n_segs, int socket_id, bool heap)
192 if (rte_fbarray_init(&msl->memseg_arr, name, n_segs,
193 sizeof(struct rte_memseg))) {
194 RTE_LOG(ERR, EAL, "Cannot allocate memseg list: %s\n",
195 rte_strerror(rte_errno));
199 msl->page_sz = page_sz;
200 msl->socket_id = socket_id;
205 "Memseg list allocated at socket %i, page size 0x%"PRIx64"kB\n",
206 socket_id, page_sz >> 10);
212 eal_memseg_list_init(struct rte_memseg_list *msl, uint64_t page_sz,
213 int n_segs, int socket_id, int type_msl_idx, bool heap)
215 char name[RTE_FBARRAY_NAME_LEN];
217 snprintf(name, sizeof(name), MEMSEG_LIST_FMT, page_sz >> 10, socket_id,
220 return eal_memseg_list_init_named(
221 msl, name, page_sz, n_segs, socket_id, heap);
225 eal_memseg_list_alloc(struct rte_memseg_list *msl, int reserve_flags)
227 size_t page_sz, mem_sz;
230 page_sz = msl->page_sz;
231 mem_sz = page_sz * msl->memseg_arr.len;
233 addr = eal_get_virtual_area(
234 msl->base_va, &mem_sz, page_sz, 0, reserve_flags);
236 #ifndef RTE_EXEC_ENV_WINDOWS
237 /* The hint would be misleading on Windows, because address
238 * is by default system-selected (base VA = 0).
239 * However, this function is called from many places,
240 * including common code, so don't duplicate the message.
242 if (rte_errno == EADDRNOTAVAIL)
243 RTE_LOG(ERR, EAL, "Cannot reserve %llu bytes at [%p] - "
244 "please use '--" OPT_BASE_VIRTADDR "' option\n",
245 (unsigned long long)mem_sz, msl->base_va);
252 RTE_LOG(DEBUG, EAL, "VA reserved for memseg list at %p, size %zx\n",
259 eal_memseg_list_populate(struct rte_memseg_list *msl, void *addr, int n_segs)
261 size_t page_sz = msl->page_sz;
264 for (i = 0; i < n_segs; i++) {
265 struct rte_fbarray *arr = &msl->memseg_arr;
266 struct rte_memseg *ms = rte_fbarray_get(arr, i);
268 if (rte_eal_iova_mode() == RTE_IOVA_VA)
269 ms->iova = (uintptr_t)addr;
271 ms->iova = RTE_BAD_IOVA;
273 ms->hugepage_sz = page_sz;
277 rte_fbarray_set_used(arr, i);
279 addr = RTE_PTR_ADD(addr, page_sz);
283 static struct rte_memseg *
284 virt2memseg(const void *addr, const struct rte_memseg_list *msl)
286 const struct rte_fbarray *arr;
293 /* a memseg list was specified, check if it's the right one */
294 start = msl->base_va;
295 end = RTE_PTR_ADD(start, msl->len);
297 if (addr < start || addr >= end)
300 /* now, calculate index */
301 arr = &msl->memseg_arr;
302 ms_idx = RTE_PTR_DIFF(addr, msl->base_va) / msl->page_sz;
303 return rte_fbarray_get(arr, ms_idx);
306 static struct rte_memseg_list *
307 virt2memseg_list(const void *addr)
309 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
310 struct rte_memseg_list *msl;
313 for (msl_idx = 0; msl_idx < RTE_MAX_MEMSEG_LISTS; msl_idx++) {
315 msl = &mcfg->memsegs[msl_idx];
317 start = msl->base_va;
318 end = RTE_PTR_ADD(start, msl->len);
319 if (addr >= start && addr < end)
322 /* if we didn't find our memseg list */
323 if (msl_idx == RTE_MAX_MEMSEG_LISTS)
328 struct rte_memseg_list *
329 rte_mem_virt2memseg_list(const void *addr)
331 return virt2memseg_list(addr);
339 find_virt(const struct rte_memseg_list *msl __rte_unused,
340 const struct rte_memseg *ms, void *arg)
342 struct virtiova *vi = arg;
343 if (vi->iova >= ms->iova && vi->iova < (ms->iova + ms->len)) {
344 size_t offset = vi->iova - ms->iova;
345 vi->virt = RTE_PTR_ADD(ms->addr, offset);
352 find_virt_legacy(const struct rte_memseg_list *msl __rte_unused,
353 const struct rte_memseg *ms, size_t len, void *arg)
355 struct virtiova *vi = arg;
356 if (vi->iova >= ms->iova && vi->iova < (ms->iova + len)) {
357 size_t offset = vi->iova - ms->iova;
358 vi->virt = RTE_PTR_ADD(ms->addr, offset);
366 rte_mem_iova2virt(rte_iova_t iova)
369 const struct internal_config *internal_conf =
370 eal_get_internal_configuration();
372 memset(&vi, 0, sizeof(vi));
375 /* for legacy mem, we can get away with scanning VA-contiguous segments,
376 * as we know they are PA-contiguous as well
378 if (internal_conf->legacy_mem)
379 rte_memseg_contig_walk(find_virt_legacy, &vi);
381 rte_memseg_walk(find_virt, &vi);
387 rte_mem_virt2memseg(const void *addr, const struct rte_memseg_list *msl)
389 return virt2memseg(addr, msl != NULL ? msl :
390 rte_mem_virt2memseg_list(addr));
394 physmem_size(const struct rte_memseg_list *msl, void *arg)
396 uint64_t *total_len = arg;
401 *total_len += msl->memseg_arr.count * msl->page_sz;
406 /* get the total size of memory */
408 rte_eal_get_physmem_size(void)
410 uint64_t total_len = 0;
412 rte_memseg_list_walk(physmem_size, &total_len);
418 dump_memseg(const struct rte_memseg_list *msl, const struct rte_memseg *ms,
421 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
422 int msl_idx, ms_idx, fd;
425 msl_idx = msl - mcfg->memsegs;
426 if (msl_idx < 0 || msl_idx >= RTE_MAX_MEMSEG_LISTS)
429 ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
433 fd = eal_memalloc_get_seg_fd(msl_idx, ms_idx);
434 fprintf(f, "Segment %i-%i: IOVA:0x%"PRIx64", len:%zu, "
435 "virt:%p, socket_id:%"PRId32", "
436 "hugepage_sz:%"PRIu64", nchannel:%"PRIx32", "
437 "nrank:%"PRIx32" fd:%i\n",
452 * Defining here because declared in rte_memory.h, but the actual implementation
453 * is in eal_common_memalloc.c, like all other memalloc internals.
456 rte_mem_event_callback_register(const char *name, rte_mem_event_callback_t clb,
459 const struct internal_config *internal_conf =
460 eal_get_internal_configuration();
462 /* FreeBSD boots with legacy mem enabled by default */
463 if (internal_conf->legacy_mem) {
464 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
468 return eal_memalloc_mem_event_callback_register(name, clb, arg);
472 rte_mem_event_callback_unregister(const char *name, void *arg)
474 const struct internal_config *internal_conf =
475 eal_get_internal_configuration();
477 /* FreeBSD boots with legacy mem enabled by default */
478 if (internal_conf->legacy_mem) {
479 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
483 return eal_memalloc_mem_event_callback_unregister(name, arg);
487 rte_mem_alloc_validator_register(const char *name,
488 rte_mem_alloc_validator_t clb, int socket_id, size_t limit)
490 const struct internal_config *internal_conf =
491 eal_get_internal_configuration();
493 /* FreeBSD boots with legacy mem enabled by default */
494 if (internal_conf->legacy_mem) {
495 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
499 return eal_memalloc_mem_alloc_validator_register(name, clb, socket_id,
504 rte_mem_alloc_validator_unregister(const char *name, int socket_id)
506 const struct internal_config *internal_conf =
507 eal_get_internal_configuration();
509 /* FreeBSD boots with legacy mem enabled by default */
510 if (internal_conf->legacy_mem) {
511 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
515 return eal_memalloc_mem_alloc_validator_unregister(name, socket_id);
518 /* Dump the physical memory layout on console */
520 rte_dump_physmem_layout(FILE *f)
522 rte_memseg_walk(dump_memseg, f);
526 check_iova(const struct rte_memseg_list *msl __rte_unused,
527 const struct rte_memseg *ms, void *arg)
529 uint64_t *mask = arg;
532 /* higher address within segment */
533 iova = (ms->iova + ms->len) - 1;
537 RTE_LOG(DEBUG, EAL, "memseg iova %"PRIx64", len %zx, out of range\n",
540 RTE_LOG(DEBUG, EAL, "\tusing dma mask %"PRIx64"\n", *mask);
544 #define MAX_DMA_MASK_BITS 63
546 /* check memseg iovas are within the required range based on dma mask */
548 check_dma_mask(uint8_t maskbits, bool thread_unsafe)
550 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
554 /* Sanity check. We only check width can be managed with 64 bits
555 * variables. Indeed any higher value is likely wrong. */
556 if (maskbits > MAX_DMA_MASK_BITS) {
557 RTE_LOG(ERR, EAL, "wrong dma mask size %u (Max: %u)\n",
558 maskbits, MAX_DMA_MASK_BITS);
562 /* create dma mask */
563 mask = ~((1ULL << maskbits) - 1);
566 ret = rte_memseg_walk_thread_unsafe(check_iova, &mask);
568 ret = rte_memseg_walk(check_iova, &mask);
572 * Dma mask precludes hugepage usage.
573 * This device can not be used and we do not need to keep
579 * we need to keep the more restricted maskbit for checking
580 * potential dynamic memory allocation in the future.
582 mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
583 RTE_MIN(mcfg->dma_maskbits, maskbits);
589 rte_mem_check_dma_mask(uint8_t maskbits)
591 return check_dma_mask(maskbits, false);
595 rte_mem_check_dma_mask_thread_unsafe(uint8_t maskbits)
597 return check_dma_mask(maskbits, true);
601 * Set dma mask to use when memory initialization is done.
603 * This function should ONLY be used by code executed before the memory
604 * initialization. PMDs should use rte_mem_check_dma_mask if addressing
605 * limitations by the device.
608 rte_mem_set_dma_mask(uint8_t maskbits)
610 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
612 mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
613 RTE_MIN(mcfg->dma_maskbits, maskbits);
616 /* return the number of memory channels */
617 unsigned rte_memory_get_nchannel(void)
619 return rte_eal_get_configuration()->mem_config->nchannel;
622 /* return the number of memory rank */
623 unsigned rte_memory_get_nrank(void)
625 return rte_eal_get_configuration()->mem_config->nrank;
629 rte_eal_memdevice_init(void)
631 struct rte_config *config;
632 const struct internal_config *internal_conf;
634 if (rte_eal_process_type() == RTE_PROC_SECONDARY)
637 internal_conf = eal_get_internal_configuration();
638 config = rte_eal_get_configuration();
639 config->mem_config->nchannel = internal_conf->force_nchannel;
640 config->mem_config->nrank = internal_conf->force_nrank;
645 /* Lock page in physical memory and prevent from swapping. */
647 rte_mem_lock_page(const void *virt)
649 uintptr_t virtual = (uintptr_t)virt;
650 size_t page_size = rte_mem_page_size();
651 uintptr_t aligned = RTE_PTR_ALIGN_FLOOR(virtual, page_size);
652 return rte_mem_lock((void *)aligned, page_size);
656 rte_memseg_contig_walk_thread_unsafe(rte_memseg_contig_walk_t func, void *arg)
658 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
659 int i, ms_idx, ret = 0;
661 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
662 struct rte_memseg_list *msl = &mcfg->memsegs[i];
663 const struct rte_memseg *ms;
664 struct rte_fbarray *arr;
666 if (msl->memseg_arr.count == 0)
669 arr = &msl->memseg_arr;
671 ms_idx = rte_fbarray_find_next_used(arr, 0);
672 while (ms_idx >= 0) {
676 ms = rte_fbarray_get(arr, ms_idx);
678 /* find how many more segments there are, starting with
681 n_segs = rte_fbarray_find_contig_used(arr, ms_idx);
682 len = n_segs * msl->page_sz;
684 ret = func(msl, ms, len, arg);
687 ms_idx = rte_fbarray_find_next_used(arr,
695 rte_memseg_contig_walk(rte_memseg_contig_walk_t func, void *arg)
699 /* do not allow allocations/frees/init while we iterate */
700 rte_mcfg_mem_read_lock();
701 ret = rte_memseg_contig_walk_thread_unsafe(func, arg);
702 rte_mcfg_mem_read_unlock();
708 rte_memseg_walk_thread_unsafe(rte_memseg_walk_t func, void *arg)
710 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
711 int i, ms_idx, ret = 0;
713 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
714 struct rte_memseg_list *msl = &mcfg->memsegs[i];
715 const struct rte_memseg *ms;
716 struct rte_fbarray *arr;
718 if (msl->memseg_arr.count == 0)
721 arr = &msl->memseg_arr;
723 ms_idx = rte_fbarray_find_next_used(arr, 0);
724 while (ms_idx >= 0) {
725 ms = rte_fbarray_get(arr, ms_idx);
726 ret = func(msl, ms, arg);
729 ms_idx = rte_fbarray_find_next_used(arr, ms_idx + 1);
736 rte_memseg_walk(rte_memseg_walk_t func, void *arg)
740 /* do not allow allocations/frees/init while we iterate */
741 rte_mcfg_mem_read_lock();
742 ret = rte_memseg_walk_thread_unsafe(func, arg);
743 rte_mcfg_mem_read_unlock();
749 rte_memseg_list_walk_thread_unsafe(rte_memseg_list_walk_t func, void *arg)
751 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
754 for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
755 struct rte_memseg_list *msl = &mcfg->memsegs[i];
757 if (msl->base_va == NULL)
760 ret = func(msl, arg);
768 rte_memseg_list_walk(rte_memseg_list_walk_t func, void *arg)
772 /* do not allow allocations/frees/init while we iterate */
773 rte_mcfg_mem_read_lock();
774 ret = rte_memseg_list_walk_thread_unsafe(func, arg);
775 rte_mcfg_mem_read_unlock();
781 rte_memseg_get_fd_thread_unsafe(const struct rte_memseg *ms)
783 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
784 struct rte_memseg_list *msl;
785 struct rte_fbarray *arr;
786 int msl_idx, seg_idx, ret;
793 msl = rte_mem_virt2memseg_list(ms->addr);
798 arr = &msl->memseg_arr;
800 msl_idx = msl - mcfg->memsegs;
801 seg_idx = rte_fbarray_find_idx(arr, ms);
803 if (!rte_fbarray_is_used(arr, seg_idx)) {
808 /* segment fd API is not supported for external segments */
814 ret = eal_memalloc_get_seg_fd(msl_idx, seg_idx);
823 rte_memseg_get_fd(const struct rte_memseg *ms)
827 rte_mcfg_mem_read_lock();
828 ret = rte_memseg_get_fd_thread_unsafe(ms);
829 rte_mcfg_mem_read_unlock();
835 rte_memseg_get_fd_offset_thread_unsafe(const struct rte_memseg *ms,
838 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
839 struct rte_memseg_list *msl;
840 struct rte_fbarray *arr;
841 int msl_idx, seg_idx, ret;
843 if (ms == NULL || offset == NULL) {
848 msl = rte_mem_virt2memseg_list(ms->addr);
853 arr = &msl->memseg_arr;
855 msl_idx = msl - mcfg->memsegs;
856 seg_idx = rte_fbarray_find_idx(arr, ms);
858 if (!rte_fbarray_is_used(arr, seg_idx)) {
863 /* segment fd API is not supported for external segments */
869 ret = eal_memalloc_get_seg_fd_offset(msl_idx, seg_idx, offset);
878 rte_memseg_get_fd_offset(const struct rte_memseg *ms, size_t *offset)
882 rte_mcfg_mem_read_lock();
883 ret = rte_memseg_get_fd_offset_thread_unsafe(ms, offset);
884 rte_mcfg_mem_read_unlock();
890 rte_extmem_register(void *va_addr, size_t len, rte_iova_t iova_addrs[],
891 unsigned int n_pages, size_t page_sz)
893 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
894 unsigned int socket_id, n;
897 if (va_addr == NULL || page_sz == 0 || len == 0 ||
898 !rte_is_power_of_2(page_sz) ||
899 RTE_ALIGN(len, page_sz) != len ||
900 ((len / page_sz) != n_pages && iova_addrs != NULL) ||
901 !rte_is_aligned(va_addr, page_sz)) {
905 rte_mcfg_mem_write_lock();
907 /* make sure the segment doesn't already exist */
908 if (malloc_heap_find_external_seg(va_addr, len) != NULL) {
914 /* get next available socket ID */
915 socket_id = mcfg->next_socket_id;
916 if (socket_id > INT32_MAX) {
917 RTE_LOG(ERR, EAL, "Cannot assign new socket ID's\n");
923 /* we can create a new memseg */
925 if (malloc_heap_create_external_seg(va_addr, iova_addrs, n,
926 page_sz, "extmem", socket_id) == NULL) {
931 /* memseg list successfully created - increment next socket ID */
932 mcfg->next_socket_id++;
934 rte_mcfg_mem_write_unlock();
939 rte_extmem_unregister(void *va_addr, size_t len)
941 struct rte_memseg_list *msl;
944 if (va_addr == NULL || len == 0) {
948 rte_mcfg_mem_write_lock();
950 /* find our segment */
951 msl = malloc_heap_find_external_seg(va_addr, len);
958 ret = malloc_heap_destroy_external_seg(msl);
960 rte_mcfg_mem_write_unlock();
965 sync_memory(void *va_addr, size_t len, bool attach)
967 struct rte_memseg_list *msl;
970 if (va_addr == NULL || len == 0) {
974 rte_mcfg_mem_write_lock();
976 /* find our segment */
977 msl = malloc_heap_find_external_seg(va_addr, len);
984 ret = rte_fbarray_attach(&msl->memseg_arr);
986 ret = rte_fbarray_detach(&msl->memseg_arr);
989 rte_mcfg_mem_write_unlock();
994 rte_extmem_attach(void *va_addr, size_t len)
996 return sync_memory(va_addr, len, true);
1000 rte_extmem_detach(void *va_addr, size_t len)
1002 return sync_memory(va_addr, len, false);
1005 /* init memory subsystem */
1007 rte_eal_memory_init(void)
1009 struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
1010 const struct internal_config *internal_conf =
1011 eal_get_internal_configuration();
1014 RTE_LOG(DEBUG, EAL, "Setting up physically contiguous memory...\n");
1019 /* lock mem hotplug here, to prevent races while we init */
1020 rte_mcfg_mem_read_lock();
1022 if (rte_eal_memseg_init() < 0)
1025 if (eal_memalloc_init() < 0)
1028 retval = rte_eal_process_type() == RTE_PROC_PRIMARY ?
1029 rte_eal_hugepage_init() :
1030 rte_eal_hugepage_attach();
1034 if (internal_conf->no_shconf == 0 && rte_eal_memdevice_init() < 0)
1039 rte_mcfg_mem_read_unlock();