lib/librte_eal/common/eal_common_memory.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <fcntl.h>
   6 #include <errno.h>
   7 #include <stdio.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #include <stdarg.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <inttypes.h>
  14 #include <sys/mman.h>
  15 #include <sys/queue.h>
  16
  17 #include <rte_fbarray.h>
  18 #include <rte_memory.h>
  19 #include <rte_eal.h>
  20 #include <rte_eal_memconfig.h>
  21 #include <rte_errno.h>
  22 #include <rte_log.h>
  23
  24 #include "eal_memalloc.h"
  25 #include "eal_private.h"
  26 #include "eal_internal_cfg.h"
  27 #include "malloc_heap.h"
  28
  29 /*
  30  * Try to mmap *size bytes in /dev/zero. If it is successful, return the
  31  * pointer to the mmap'd area and keep *size unmodified. Else, retry
  32  * with a smaller zone: decrease *size by hugepage_sz until it reaches
  33  * 0. In this case, return NULL. Note: this function returns an address
  34  * which is a multiple of hugepage size.
  35  */
  36
  37 #define MEMSEG_LIST_FMT "memseg-%" PRIu64 "k-%i-%i"
  38
  39 static void *next_baseaddr;
  40 static uint64_t system_page_sz;
  41
  42 #ifdef RTE_ARCH_64
  43 /*
  44  * Linux kernel uses a really high address as starting address for serving
  45  * mmaps calls. If there exists addressing limitations and IOVA mode is VA,
  46  * this starting address is likely too high for those devices. However, it
  47  * is possible to use a lower address in the process virtual address space
  48  * as with 64 bits there is a lot of available space.
  49  *
  50  * Current known limitations are 39 or 40 bits. Setting the starting address
  51  * at 4GB implies there are 508GB or 1020GB for mapping the available
  52  * hugepages. This is likely enough for most systems, although a device with
  53  * addressing limitations should call rte_mem_check_dma_mask for ensuring all
  54  * memory is within supported range.
  55  */
  56 static uint64_t baseaddr = 0x100000000;
  57 #endif
  58
  59 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
  60 void *
  61 eal_get_virtual_area(void *requested_addr, size_t *size,
  62                 size_t page_sz, int flags, int mmap_flags)
  63 {
  64         bool addr_is_hint, allow_shrink, unmap, no_align;
  65         uint64_t map_sz;
  66         void *mapped_addr, *aligned_addr;
  67         uint8_t try = 0;
  68
  69         if (system_page_sz == 0)
  70                 system_page_sz = sysconf(_SC_PAGESIZE);
  71
  72         mmap_flags |= MAP_PRIVATE | MAP_ANONYMOUS;
  73
  74         RTE_LOG(DEBUG, EAL, "Ask a virtual area of 0x%zx bytes\n", *size);
  75
  76         addr_is_hint = (flags & EAL_VIRTUAL_AREA_ADDR_IS_HINT) > 0;
  77         allow_shrink = (flags & EAL_VIRTUAL_AREA_ALLOW_SHRINK) > 0;
  78         unmap = (flags & EAL_VIRTUAL_AREA_UNMAP) > 0;
  79
  80         if (next_baseaddr == NULL && internal_config.base_virtaddr != 0 &&
  81                         rte_eal_process_type() == RTE_PROC_PRIMARY)
  82                 next_baseaddr = (void *) internal_config.base_virtaddr;
  83
  84 #ifdef RTE_ARCH_64
  85         if (next_baseaddr == NULL && internal_config.base_virtaddr == 0 &&
  86                         rte_eal_process_type() == RTE_PROC_PRIMARY)
  87                 next_baseaddr = (void *) baseaddr;
  88 #endif
  89         if (requested_addr == NULL && next_baseaddr != NULL) {
  90                 requested_addr = next_baseaddr;
  91                 requested_addr = RTE_PTR_ALIGN(requested_addr, page_sz);
  92                 addr_is_hint = true;
  93         }
  94
  95         /* we don't need alignment of resulting pointer in the following cases:
  96          *
  97          * 1. page size is equal to system size
  98          * 2. we have a requested address, and it is page-aligned, and we will
  99          *    be discarding the address if we get a different one.
 100          *
 101          * for all other cases, alignment is potentially necessary.
 102          */
 103         no_align = (requested_addr != NULL &&
 104                 requested_addr == RTE_PTR_ALIGN(requested_addr, page_sz) &&
 105                 !addr_is_hint) ||
 106                 page_sz == system_page_sz;
 107
 108         do {
 109                 map_sz = no_align ? *size : *size + page_sz;
 110                 if (map_sz > SIZE_MAX) {
 111                         RTE_LOG(ERR, EAL, "Map size too big\n");
 112                         rte_errno = E2BIG;
 113                         return NULL;
 114                 }
 115
 116                 mapped_addr = mmap(requested_addr, (size_t)map_sz, PROT_READ,
 117                                 mmap_flags, -1, 0);
 118                 if (mapped_addr == MAP_FAILED && allow_shrink)
 119                         *size -= page_sz;
 120
 121                 if (mapped_addr != MAP_FAILED && addr_is_hint &&
 122                     mapped_addr != requested_addr) {
 123                         try++;
 124                         next_baseaddr = RTE_PTR_ADD(next_baseaddr, page_sz);
 125                         if (try <= MAX_MMAP_WITH_DEFINED_ADDR_TRIES) {
 126                                 /* hint was not used. Try with another offset */
 127                                 munmap(mapped_addr, map_sz);
 128                                 mapped_addr = MAP_FAILED;
 129                                 requested_addr = next_baseaddr;
 130                         }
 131                 }
 132         } while ((allow_shrink || addr_is_hint) &&
 133                  mapped_addr == MAP_FAILED && *size > 0);
 134
 135         /* align resulting address - if map failed, we will ignore the value
 136          * anyway, so no need to add additional checks.
 137          */
 138         aligned_addr = no_align ? mapped_addr :
 139                         RTE_PTR_ALIGN(mapped_addr, page_sz);
 140
 141         if (*size == 0) {
 142                 RTE_LOG(ERR, EAL, "Cannot get a virtual area of any size: %s\n",
 143                         strerror(errno));
 144                 rte_errno = errno;
 145                 return NULL;
 146         } else if (mapped_addr == MAP_FAILED) {
 147                 RTE_LOG(ERR, EAL, "Cannot get a virtual area: %s\n",
 148                         strerror(errno));
 149                 /* pass errno up the call chain */
 150                 rte_errno = errno;
 151                 return NULL;
 152         } else if (requested_addr != NULL && !addr_is_hint &&
 153                         aligned_addr != requested_addr) {
 154                 RTE_LOG(ERR, EAL, "Cannot get a virtual area at requested address: %p (got %p)\n",
 155                         requested_addr, aligned_addr);
 156                 munmap(mapped_addr, map_sz);
 157                 rte_errno = EADDRNOTAVAIL;
 158                 return NULL;
 159         } else if (requested_addr != NULL && addr_is_hint &&
 160                         aligned_addr != requested_addr) {
 161                 RTE_LOG(WARNING, EAL, "WARNING! Base virtual address hint (%p != %p) not respected!\n",
 162                         requested_addr, aligned_addr);
 163                 RTE_LOG(WARNING, EAL, "   This may cause issues with mapping memory into secondary processes\n");
 164         } else if (next_baseaddr != NULL) {
 165                 next_baseaddr = RTE_PTR_ADD(aligned_addr, *size);
 166         }
 167
 168         RTE_LOG(DEBUG, EAL, "Virtual area found at %p (size = 0x%zx)\n",
 169                 aligned_addr, *size);
 170
 171         if (unmap) {
 172                 munmap(mapped_addr, map_sz);
 173         } else if (!no_align) {
 174                 void *map_end, *aligned_end;
 175                 size_t before_len, after_len;
 176
 177                 /* when we reserve space with alignment, we add alignment to
 178                  * mapping size. On 32-bit, if 1GB alignment was requested, this
 179                  * would waste 1GB of address space, which is a luxury we cannot
 180                  * afford. so, if alignment was performed, check if any unneeded
 181                  * address space can be unmapped back.
 182                  */
 183
 184                 map_end = RTE_PTR_ADD(mapped_addr, (size_t)map_sz);
 185                 aligned_end = RTE_PTR_ADD(aligned_addr, *size);
 186
 187                 /* unmap space before aligned mmap address */
 188                 before_len = RTE_PTR_DIFF(aligned_addr, mapped_addr);
 189                 if (before_len > 0)
 190                         munmap(mapped_addr, before_len);
 191
 192                 /* unmap space after aligned end mmap address */
 193                 after_len = RTE_PTR_DIFF(map_end, aligned_end);
 194                 if (after_len > 0)
 195                         munmap(aligned_end, after_len);
 196         }
 197
 198         return aligned_addr;
 199 }
 200
 201 static struct rte_memseg *
 202 virt2memseg(const void *addr, const struct rte_memseg_list *msl)
 203 {
 204         const struct rte_fbarray *arr;
 205         void *start, *end;
 206         int ms_idx;
 207
 208         if (msl == NULL)
 209                 return NULL;
 210
 211         /* a memseg list was specified, check if it's the right one */
 212         start = msl->base_va;
 213         end = RTE_PTR_ADD(start, msl->len);
 214
 215         if (addr < start || addr >= end)
 216                 return NULL;
 217
 218         /* now, calculate index */
 219         arr = &msl->memseg_arr;
 220         ms_idx = RTE_PTR_DIFF(addr, msl->base_va) / msl->page_sz;
 221         return rte_fbarray_get(arr, ms_idx);
 222 }
 223
 224 static struct rte_memseg_list *
 225 virt2memseg_list(const void *addr)
 226 {
 227         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 228         struct rte_memseg_list *msl;
 229         int msl_idx;
 230
 231         for (msl_idx = 0; msl_idx < RTE_MAX_MEMSEG_LISTS; msl_idx++) {
 232                 void *start, *end;
 233                 msl = &mcfg->memsegs[msl_idx];
 234
 235                 start = msl->base_va;
 236                 end = RTE_PTR_ADD(start, msl->len);
 237                 if (addr >= start && addr < end)
 238                         break;
 239         }
 240         /* if we didn't find our memseg list */
 241         if (msl_idx == RTE_MAX_MEMSEG_LISTS)
 242                 return NULL;
 243         return msl;
 244 }
 245
 246 struct rte_memseg_list *
 247 rte_mem_virt2memseg_list(const void *addr)
 248 {
 249         return virt2memseg_list(addr);
 250 }
 251
 252 struct virtiova {
 253         rte_iova_t iova;
 254         void *virt;
 255 };
 256 static int
 257 find_virt(const struct rte_memseg_list *msl __rte_unused,
 258                 const struct rte_memseg *ms, void *arg)
 259 {
 260         struct virtiova *vi = arg;
 261         if (vi->iova >= ms->iova && vi->iova < (ms->iova + ms->len)) {
 262                 size_t offset = vi->iova - ms->iova;
 263                 vi->virt = RTE_PTR_ADD(ms->addr, offset);
 264                 /* stop the walk */
 265                 return 1;
 266         }
 267         return 0;
 268 }
 269 static int
 270 find_virt_legacy(const struct rte_memseg_list *msl __rte_unused,
 271                 const struct rte_memseg *ms, size_t len, void *arg)
 272 {
 273         struct virtiova *vi = arg;
 274         if (vi->iova >= ms->iova && vi->iova < (ms->iova + len)) {
 275                 size_t offset = vi->iova - ms->iova;
 276                 vi->virt = RTE_PTR_ADD(ms->addr, offset);
 277                 /* stop the walk */
 278                 return 1;
 279         }
 280         return 0;
 281 }
 282
 283 void *
 284 rte_mem_iova2virt(rte_iova_t iova)
 285 {
 286         struct virtiova vi;
 287
 288         memset(&vi, 0, sizeof(vi));
 289
 290         vi.iova = iova;
 291         /* for legacy mem, we can get away with scanning VA-contiguous segments,
 292          * as we know they are PA-contiguous as well
 293          */
 294         if (internal_config.legacy_mem)
 295                 rte_memseg_contig_walk(find_virt_legacy, &vi);
 296         else
 297                 rte_memseg_walk(find_virt, &vi);
 298
 299         return vi.virt;
 300 }
 301
 302 struct rte_memseg *
 303 rte_mem_virt2memseg(const void *addr, const struct rte_memseg_list *msl)
 304 {
 305         return virt2memseg(addr, msl != NULL ? msl :
 306                         rte_mem_virt2memseg_list(addr));
 307 }
 308
 309 static int
 310 physmem_size(const struct rte_memseg_list *msl, void *arg)
 311 {
 312         uint64_t *total_len = arg;
 313
 314         if (msl->external)
 315                 return 0;
 316
 317         *total_len += msl->memseg_arr.count * msl->page_sz;
 318
 319         return 0;
 320 }
 321
 322 /* get the total size of memory */
 323 uint64_t
 324 rte_eal_get_physmem_size(void)
 325 {
 326         uint64_t total_len = 0;
 327
 328         rte_memseg_list_walk(physmem_size, &total_len);
 329
 330         return total_len;
 331 }
 332
 333 static int
 334 dump_memseg(const struct rte_memseg_list *msl, const struct rte_memseg *ms,
 335                 void *arg)
 336 {
 337         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 338         int msl_idx, ms_idx, fd;
 339         FILE *f = arg;
 340
 341         msl_idx = msl - mcfg->memsegs;
 342         if (msl_idx < 0 || msl_idx >= RTE_MAX_MEMSEG_LISTS)
 343                 return -1;
 344
 345         ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
 346         if (ms_idx < 0)
 347                 return -1;
 348
 349         fd = eal_memalloc_get_seg_fd(msl_idx, ms_idx);
 350         fprintf(f, "Segment %i-%i: IOVA:0x%"PRIx64", len:%zu, "
 351                         "virt:%p, socket_id:%"PRId32", "
 352                         "hugepage_sz:%"PRIu64", nchannel:%"PRIx32", "
 353                         "nrank:%"PRIx32" fd:%i\n",
 354                         msl_idx, ms_idx,
 355                         ms->iova,
 356                         ms->len,
 357                         ms->addr,
 358                         ms->socket_id,
 359                         ms->hugepage_sz,
 360                         ms->nchannel,
 361                         ms->nrank,
 362                         fd);
 363
 364         return 0;
 365 }
 366
 367 /*
 368  * Defining here because declared in rte_memory.h, but the actual implementation
 369  * is in eal_common_memalloc.c, like all other memalloc internals.
 370  */
 371 int
 372 rte_mem_event_callback_register(const char *name, rte_mem_event_callback_t clb,
 373                 void *arg)
 374 {
 375         /* FreeBSD boots with legacy mem enabled by default */
 376         if (internal_config.legacy_mem) {
 377                 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
 378                 rte_errno = ENOTSUP;
 379                 return -1;
 380         }
 381         return eal_memalloc_mem_event_callback_register(name, clb, arg);
 382 }
 383
 384 int
 385 rte_mem_event_callback_unregister(const char *name, void *arg)
 386 {
 387         /* FreeBSD boots with legacy mem enabled by default */
 388         if (internal_config.legacy_mem) {
 389                 RTE_LOG(DEBUG, EAL, "Registering mem event callbacks not supported\n");
 390                 rte_errno = ENOTSUP;
 391                 return -1;
 392         }
 393         return eal_memalloc_mem_event_callback_unregister(name, arg);
 394 }
 395
 396 int
 397 rte_mem_alloc_validator_register(const char *name,
 398                 rte_mem_alloc_validator_t clb, int socket_id, size_t limit)
 399 {
 400         /* FreeBSD boots with legacy mem enabled by default */
 401         if (internal_config.legacy_mem) {
 402                 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
 403                 rte_errno = ENOTSUP;
 404                 return -1;
 405         }
 406         return eal_memalloc_mem_alloc_validator_register(name, clb, socket_id,
 407                         limit);
 408 }
 409
 410 int
 411 rte_mem_alloc_validator_unregister(const char *name, int socket_id)
 412 {
 413         /* FreeBSD boots with legacy mem enabled by default */
 414         if (internal_config.legacy_mem) {
 415                 RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
 416                 rte_errno = ENOTSUP;
 417                 return -1;
 418         }
 419         return eal_memalloc_mem_alloc_validator_unregister(name, socket_id);
 420 }
 421
 422 /* Dump the physical memory layout on console */
 423 void
 424 rte_dump_physmem_layout(FILE *f)
 425 {
 426         rte_memseg_walk(dump_memseg, f);
 427 }
 428
 429 static int
 430 check_iova(const struct rte_memseg_list *msl __rte_unused,
 431                 const struct rte_memseg *ms, void *arg)
 432 {
 433         uint64_t *mask = arg;
 434         rte_iova_t iova;
 435
 436         /* higher address within segment */
 437         iova = (ms->iova + ms->len) - 1;
 438         if (!(iova & *mask))
 439                 return 0;
 440
 441         RTE_LOG(DEBUG, EAL, "memseg iova %"PRIx64", len %zx, out of range\n",
 442                             ms->iova, ms->len);
 443
 444         RTE_LOG(DEBUG, EAL, "\tusing dma mask %"PRIx64"\n", *mask);
 445         return 1;
 446 }
 447
 448 #define MAX_DMA_MASK_BITS 63
 449
 450 /* check memseg iovas are within the required range based on dma mask */
 451 static int
 452 check_dma_mask(uint8_t maskbits, bool thread_unsafe)
 453 {
 454         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 455         uint64_t mask;
 456         int ret;
 457
 458         /* Sanity check. We only check width can be managed with 64 bits
 459          * variables. Indeed any higher value is likely wrong. */
 460         if (maskbits > MAX_DMA_MASK_BITS) {
 461                 RTE_LOG(ERR, EAL, "wrong dma mask size %u (Max: %u)\n",
 462                                    maskbits, MAX_DMA_MASK_BITS);
 463                 return -1;
 464         }
 465
 466         /* create dma mask */
 467         mask = ~((1ULL << maskbits) - 1);
 468
 469         if (thread_unsafe)
 470                 ret = rte_memseg_walk_thread_unsafe(check_iova, &mask);
 471         else
 472                 ret = rte_memseg_walk(check_iova, &mask);
 473
 474         if (ret)
 475                 /*
 476                  * Dma mask precludes hugepage usage.
 477                  * This device can not be used and we do not need to keep
 478                  * the dma mask.
 479                  */
 480                 return 1;
 481
 482         /*
 483          * we need to keep the more restricted maskbit for checking
 484          * potential dynamic memory allocation in the future.
 485          */
 486         mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
 487                              RTE_MIN(mcfg->dma_maskbits, maskbits);
 488
 489         return 0;
 490 }
 491
 492 int
 493 rte_mem_check_dma_mask(uint8_t maskbits)
 494 {
 495         return check_dma_mask(maskbits, false);
 496 }
 497
 498 int
 499 rte_mem_check_dma_mask_thread_unsafe(uint8_t maskbits)
 500 {
 501         return check_dma_mask(maskbits, true);
 502 }
 503
 504 /*
 505  * Set dma mask to use when memory initialization is done.
 506  *
 507  * This function should ONLY be used by code executed before the memory
 508  * initialization. PMDs should use rte_mem_check_dma_mask if addressing
 509  * limitations by the device.
 510  */
 511 void
 512 rte_mem_set_dma_mask(uint8_t maskbits)
 513 {
 514         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 515
 516         mcfg->dma_maskbits = mcfg->dma_maskbits == 0 ? maskbits :
 517                              RTE_MIN(mcfg->dma_maskbits, maskbits);
 518 }
 519
 520 /* return the number of memory channels */
 521 unsigned rte_memory_get_nchannel(void)
 522 {
 523         return rte_eal_get_configuration()->mem_config->nchannel;
 524 }
 525
 526 /* return the number of memory rank */
 527 unsigned rte_memory_get_nrank(void)
 528 {
 529         return rte_eal_get_configuration()->mem_config->nrank;
 530 }
 531
 532 static int
 533 rte_eal_memdevice_init(void)
 534 {
 535         struct rte_config *config;
 536
 537         if (rte_eal_process_type() == RTE_PROC_SECONDARY)
 538                 return 0;
 539
 540         config = rte_eal_get_configuration();
 541         config->mem_config->nchannel = internal_config.force_nchannel;
 542         config->mem_config->nrank = internal_config.force_nrank;
 543
 544         return 0;
 545 }
 546
 547 /* Lock page in physical memory and prevent from swapping. */
 548 int
 549 rte_mem_lock_page(const void *virt)
 550 {
 551         unsigned long virtual = (unsigned long)virt;
 552         int page_size = getpagesize();
 553         unsigned long aligned = (virtual & ~(page_size - 1));
 554         return mlock((void *)aligned, page_size);
 555 }
 556
 557 int
 558 rte_memseg_contig_walk_thread_unsafe(rte_memseg_contig_walk_t func, void *arg)
 559 {
 560         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 561         int i, ms_idx, ret = 0;
 562
 563         for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
 564                 struct rte_memseg_list *msl = &mcfg->memsegs[i];
 565                 const struct rte_memseg *ms;
 566                 struct rte_fbarray *arr;
 567
 568                 if (msl->memseg_arr.count == 0)
 569                         continue;
 570
 571                 arr = &msl->memseg_arr;
 572
 573                 ms_idx = rte_fbarray_find_next_used(arr, 0);
 574                 while (ms_idx >= 0) {
 575                         int n_segs;
 576                         size_t len;
 577
 578                         ms = rte_fbarray_get(arr, ms_idx);
 579
 580                         /* find how many more segments there are, starting with
 581                          * this one.
 582                          */
 583                         n_segs = rte_fbarray_find_contig_used(arr, ms_idx);
 584                         len = n_segs * msl->page_sz;
 585
 586                         ret = func(msl, ms, len, arg);
 587                         if (ret)
 588                                 return ret;
 589                         ms_idx = rte_fbarray_find_next_used(arr,
 590                                         ms_idx + n_segs);
 591                 }
 592         }
 593         return 0;
 594 }
 595
 596 int
 597 rte_memseg_contig_walk(rte_memseg_contig_walk_t func, void *arg)
 598 {
 599         int ret = 0;
 600
 601         /* do not allow allocations/frees/init while we iterate */
 602         rte_mcfg_mem_read_lock();
 603         ret = rte_memseg_contig_walk_thread_unsafe(func, arg);
 604         rte_mcfg_mem_read_unlock();
 605
 606         return ret;
 607 }
 608
 609 int
 610 rte_memseg_walk_thread_unsafe(rte_memseg_walk_t func, void *arg)
 611 {
 612         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 613         int i, ms_idx, ret = 0;
 614
 615         for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
 616                 struct rte_memseg_list *msl = &mcfg->memsegs[i];
 617                 const struct rte_memseg *ms;
 618                 struct rte_fbarray *arr;
 619
 620                 if (msl->memseg_arr.count == 0)
 621                         continue;
 622
 623                 arr = &msl->memseg_arr;
 624
 625                 ms_idx = rte_fbarray_find_next_used(arr, 0);
 626                 while (ms_idx >= 0) {
 627                         ms = rte_fbarray_get(arr, ms_idx);
 628                         ret = func(msl, ms, arg);
 629                         if (ret)
 630                                 return ret;
 631                         ms_idx = rte_fbarray_find_next_used(arr, ms_idx + 1);
 632                 }
 633         }
 634         return 0;
 635 }
 636
 637 int
 638 rte_memseg_walk(rte_memseg_walk_t func, void *arg)
 639 {
 640         int ret = 0;
 641
 642         /* do not allow allocations/frees/init while we iterate */
 643         rte_mcfg_mem_read_lock();
 644         ret = rte_memseg_walk_thread_unsafe(func, arg);
 645         rte_mcfg_mem_read_unlock();
 646
 647         return ret;
 648 }
 649
 650 int
 651 rte_memseg_list_walk_thread_unsafe(rte_memseg_list_walk_t func, void *arg)
 652 {
 653         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 654         int i, ret = 0;
 655
 656         for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
 657                 struct rte_memseg_list *msl = &mcfg->memsegs[i];
 658
 659                 if (msl->base_va == NULL)
 660                         continue;
 661
 662                 ret = func(msl, arg);
 663                 if (ret)
 664                         return ret;
 665         }
 666         return 0;
 667 }
 668
 669 int
 670 rte_memseg_list_walk(rte_memseg_list_walk_t func, void *arg)
 671 {
 672         int ret = 0;
 673
 674         /* do not allow allocations/frees/init while we iterate */
 675         rte_mcfg_mem_read_lock();
 676         ret = rte_memseg_list_walk_thread_unsafe(func, arg);
 677         rte_mcfg_mem_read_unlock();
 678
 679         return ret;
 680 }
 681
 682 int
 683 rte_memseg_get_fd_thread_unsafe(const struct rte_memseg *ms)
 684 {
 685         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 686         struct rte_memseg_list *msl;
 687         struct rte_fbarray *arr;
 688         int msl_idx, seg_idx, ret;
 689
 690         if (ms == NULL) {
 691                 rte_errno = EINVAL;
 692                 return -1;
 693         }
 694
 695         msl = rte_mem_virt2memseg_list(ms->addr);
 696         if (msl == NULL) {
 697                 rte_errno = EINVAL;
 698                 return -1;
 699         }
 700         arr = &msl->memseg_arr;
 701
 702         msl_idx = msl - mcfg->memsegs;
 703         seg_idx = rte_fbarray_find_idx(arr, ms);
 704
 705         if (!rte_fbarray_is_used(arr, seg_idx)) {
 706                 rte_errno = ENOENT;
 707                 return -1;
 708         }
 709
 710         /* segment fd API is not supported for external segments */
 711         if (msl->external) {
 712                 rte_errno = ENOTSUP;
 713                 return -1;
 714         }
 715
 716         ret = eal_memalloc_get_seg_fd(msl_idx, seg_idx);
 717         if (ret < 0) {
 718                 rte_errno = -ret;
 719                 ret = -1;
 720         }
 721         return ret;
 722 }
 723
 724 int
 725 rte_memseg_get_fd(const struct rte_memseg *ms)
 726 {
 727         int ret;
 728
 729         rte_mcfg_mem_read_lock();
 730         ret = rte_memseg_get_fd_thread_unsafe(ms);
 731         rte_mcfg_mem_read_unlock();
 732
 733         return ret;
 734 }
 735
 736 int
 737 rte_memseg_get_fd_offset_thread_unsafe(const struct rte_memseg *ms,
 738                 size_t *offset)
 739 {
 740         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 741         struct rte_memseg_list *msl;
 742         struct rte_fbarray *arr;
 743         int msl_idx, seg_idx, ret;
 744
 745         if (ms == NULL || offset == NULL) {
 746                 rte_errno = EINVAL;
 747                 return -1;
 748         }
 749
 750         msl = rte_mem_virt2memseg_list(ms->addr);
 751         if (msl == NULL) {
 752                 rte_errno = EINVAL;
 753                 return -1;
 754         }
 755         arr = &msl->memseg_arr;
 756
 757         msl_idx = msl - mcfg->memsegs;
 758         seg_idx = rte_fbarray_find_idx(arr, ms);
 759
 760         if (!rte_fbarray_is_used(arr, seg_idx)) {
 761                 rte_errno = ENOENT;
 762                 return -1;
 763         }
 764
 765         /* segment fd API is not supported for external segments */
 766         if (msl->external) {
 767                 rte_errno = ENOTSUP;
 768                 return -1;
 769         }
 770
 771         ret = eal_memalloc_get_seg_fd_offset(msl_idx, seg_idx, offset);
 772         if (ret < 0) {
 773                 rte_errno = -ret;
 774                 ret = -1;
 775         }
 776         return ret;
 777 }
 778
 779 int
 780 rte_memseg_get_fd_offset(const struct rte_memseg *ms, size_t *offset)
 781 {
 782         int ret;
 783
 784         rte_mcfg_mem_read_lock();
 785         ret = rte_memseg_get_fd_offset_thread_unsafe(ms, offset);
 786         rte_mcfg_mem_read_unlock();
 787
 788         return ret;
 789 }
 790
 791 int
 792 rte_extmem_register(void *va_addr, size_t len, rte_iova_t iova_addrs[],
 793                 unsigned int n_pages, size_t page_sz)
 794 {
 795         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 796         unsigned int socket_id, n;
 797         int ret = 0;
 798
 799         if (va_addr == NULL || page_sz == 0 || len == 0 ||
 800                         !rte_is_power_of_2(page_sz) ||
 801                         RTE_ALIGN(len, page_sz) != len ||
 802                         ((len / page_sz) != n_pages && iova_addrs != NULL) ||
 803                         !rte_is_aligned(va_addr, page_sz)) {
 804                 rte_errno = EINVAL;
 805                 return -1;
 806         }
 807         rte_mcfg_mem_write_lock();
 808
 809         /* make sure the segment doesn't already exist */
 810         if (malloc_heap_find_external_seg(va_addr, len) != NULL) {
 811                 rte_errno = EEXIST;
 812                 ret = -1;
 813                 goto unlock;
 814         }
 815
 816         /* get next available socket ID */
 817         socket_id = mcfg->next_socket_id;
 818         if (socket_id > INT32_MAX) {
 819                 RTE_LOG(ERR, EAL, "Cannot assign new socket ID's\n");
 820                 rte_errno = ENOSPC;
 821                 ret = -1;
 822                 goto unlock;
 823         }
 824
 825         /* we can create a new memseg */
 826         n = len / page_sz;
 827         if (malloc_heap_create_external_seg(va_addr, iova_addrs, n,
 828                         page_sz, "extmem", socket_id) == NULL) {
 829                 ret = -1;
 830                 goto unlock;
 831         }
 832
 833         /* memseg list successfully created - increment next socket ID */
 834         mcfg->next_socket_id++;
 835 unlock:
 836         rte_mcfg_mem_write_unlock();
 837         return ret;
 838 }
 839
 840 int
 841 rte_extmem_unregister(void *va_addr, size_t len)
 842 {
 843         struct rte_memseg_list *msl;
 844         int ret = 0;
 845
 846         if (va_addr == NULL || len == 0) {
 847                 rte_errno = EINVAL;
 848                 return -1;
 849         }
 850         rte_mcfg_mem_write_lock();
 851
 852         /* find our segment */
 853         msl = malloc_heap_find_external_seg(va_addr, len);
 854         if (msl == NULL) {
 855                 rte_errno = ENOENT;
 856                 ret = -1;
 857                 goto unlock;
 858         }
 859
 860         ret = malloc_heap_destroy_external_seg(msl);
 861 unlock:
 862         rte_mcfg_mem_write_unlock();
 863         return ret;
 864 }
 865
 866 static int
 867 sync_memory(void *va_addr, size_t len, bool attach)
 868 {
 869         struct rte_memseg_list *msl;
 870         int ret = 0;
 871
 872         if (va_addr == NULL || len == 0) {
 873                 rte_errno = EINVAL;
 874                 return -1;
 875         }
 876         rte_mcfg_mem_write_lock();
 877
 878         /* find our segment */
 879         msl = malloc_heap_find_external_seg(va_addr, len);
 880         if (msl == NULL) {
 881                 rte_errno = ENOENT;
 882                 ret = -1;
 883                 goto unlock;
 884         }
 885         if (attach)
 886                 ret = rte_fbarray_attach(&msl->memseg_arr);
 887         else
 888                 ret = rte_fbarray_detach(&msl->memseg_arr);
 889
 890 unlock:
 891         rte_mcfg_mem_write_unlock();
 892         return ret;
 893 }
 894
 895 int
 896 rte_extmem_attach(void *va_addr, size_t len)
 897 {
 898         return sync_memory(va_addr, len, true);
 899 }
 900
 901 int
 902 rte_extmem_detach(void *va_addr, size_t len)
 903 {
 904         return sync_memory(va_addr, len, false);
 905 }
 906
 907 /* init memory subsystem */
 908 int
 909 rte_eal_memory_init(void)
 910 {
 911         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 912         int retval;
 913         RTE_LOG(DEBUG, EAL, "Setting up physically contiguous memory...\n");
 914
 915         if (!mcfg)
 916                 return -1;
 917
 918         /* lock mem hotplug here, to prevent races while we init */
 919         rte_mcfg_mem_read_lock();
 920
 921         if (rte_eal_memseg_init() < 0)
 922                 goto fail;
 923
 924         if (eal_memalloc_init() < 0)
 925                 goto fail;
 926
 927         retval = rte_eal_process_type() == RTE_PROC_PRIMARY ?
 928                         rte_eal_hugepage_init() :
 929                         rte_eal_hugepage_attach();
 930         if (retval < 0)
 931                 goto fail;
 932
 933         if (internal_config.no_shconf == 0 && rte_eal_memdevice_init() < 0)
 934                 goto fail;
 935
 936         return 0;
 937 fail:
 938         rte_mcfg_mem_read_unlock();
 939         return -1;
 940 }