From: Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>
To: dev@dpdk.org
Cc: Dmitry Malloy <dmitrym@microsoft.com>,
Narcisa Ana Maria Vasile <Narcisa.Vasile@microsoft.com>,
Fady Bader <fady@mellanox.com>,
Tal Shnaiderman <talshn@mellanox.com>,
Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>,
Anatoly Burakov <anatoly.burakov@intel.com>,
Bruce Richardson <bruce.richardson@intel.com>,
Ray Kinsella <mdr@ashroe.eu>, Neil Horman <nhorman@tuxdriver.com>
Subject: [dpdk-dev] [PATCH v5 03/11] eal: introduce memory management wrappers
Date: Mon, 25 May 2020 03:37:12 +0300 [thread overview]
Message-ID: <20200525003720.6410-4-dmitry.kozliuk@gmail.com> (raw)
In-Reply-To: <20200525003720.6410-1-dmitry.kozliuk@gmail.com>
Introduce OS-independent wrappers for memory management operations used
across DPDK and specifically in common code of EAL:
* rte_mem_map()
* rte_mem_unmap()
* rte_get_page_size()
* rte_mem_lock()
Windows uses different APIs for memory mapping and reservation, while
Unices reserve memory by mapping it. Introduce EAL private functions to
support memory reservation in common code:
* eal_mem_reserve()
* eal_mem_free()
* eal_mem_set_dump()
Wrappers follow POSIX semantics limited to DPDK tasks, but their
signatures deliberately differ from POSIX ones to be more safe and
expressive.
Signed-off-by: Dmitry Kozlyuk <dmitry.kozliuk@gmail.com>
---
lib/librte_eal/common/eal_common_fbarray.c | 37 +++--
lib/librte_eal/common/eal_common_memory.c | 60 +++-----
lib/librte_eal/common/eal_private.h | 78 ++++++++++-
lib/librte_eal/freebsd/Makefile | 1 +
lib/librte_eal/include/rte_memory.h | 88 ++++++++++++
lib/librte_eal/linux/Makefile | 1 +
lib/librte_eal/linux/eal_memalloc.c | 5 +-
lib/librte_eal/rte_eal_version.map | 6 +
lib/librte_eal/unix/eal_unix_memory.c | 152 +++++++++++++++++++++
lib/librte_eal/unix/meson.build | 1 +
10 files changed, 365 insertions(+), 64 deletions(-)
create mode 100644 lib/librte_eal/unix/eal_unix_memory.c
diff --git a/lib/librte_eal/common/eal_common_fbarray.c b/lib/librte_eal/common/eal_common_fbarray.c
index cfcab63e9..a41e8ce5f 100644
--- a/lib/librte_eal/common/eal_common_fbarray.c
+++ b/lib/librte_eal/common/eal_common_fbarray.c
@@ -5,15 +5,15 @@
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
-#include <sys/mman.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <rte_common.h>
-#include <rte_log.h>
#include <rte_errno.h>
+#include <rte_log.h>
+#include <rte_memory.h>
#include <rte_spinlock.h>
#include <rte_tailq.h>
@@ -90,12 +90,9 @@ resize_and_map(int fd, void *addr, size_t len)
return -1;
}
- map_addr = mmap(addr, len, PROT_READ | PROT_WRITE,
- MAP_SHARED | MAP_FIXED, fd, 0);
+ map_addr = rte_mem_map(addr, len, RTE_PROT_READ | RTE_PROT_WRITE,
+ RTE_MAP_SHARED | RTE_MAP_FORCE_ADDRESS, fd, 0);
if (map_addr != addr) {
- RTE_LOG(ERR, EAL, "mmap() failed: %s\n", strerror(errno));
- /* pass errno up the chain */
- rte_errno = errno;
return -1;
}
return 0;
@@ -733,7 +730,7 @@ rte_fbarray_init(struct rte_fbarray *arr, const char *name, unsigned int len,
return -1;
}
- page_sz = sysconf(_SC_PAGESIZE);
+ page_sz = rte_get_page_size();
if (page_sz == (size_t)-1) {
free(ma);
return -1;
@@ -754,9 +751,11 @@ rte_fbarray_init(struct rte_fbarray *arr, const char *name, unsigned int len,
if (internal_config.no_shconf) {
/* remap virtual area as writable */
- void *new_data = mmap(data, mmap_len, PROT_READ | PROT_WRITE,
- MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, fd, 0);
- if (new_data == MAP_FAILED) {
+ static const int flags = RTE_MAP_FORCE_ADDRESS |
+ RTE_MAP_PRIVATE | RTE_MAP_ANONYMOUS;
+ void *new_data = rte_mem_map(data, mmap_len,
+ RTE_PROT_READ | RTE_PROT_WRITE, flags, fd, 0);
+ if (new_data == NULL) {
RTE_LOG(DEBUG, EAL, "%s(): couldn't remap anonymous memory: %s\n",
__func__, strerror(errno));
goto fail;
@@ -821,7 +820,7 @@ rte_fbarray_init(struct rte_fbarray *arr, const char *name, unsigned int len,
return 0;
fail:
if (data)
- munmap(data, mmap_len);
+ rte_mem_unmap(data, mmap_len);
if (fd >= 0)
close(fd);
free(ma);
@@ -859,7 +858,7 @@ rte_fbarray_attach(struct rte_fbarray *arr)
return -1;
}
- page_sz = sysconf(_SC_PAGESIZE);
+ page_sz = rte_get_page_size();
if (page_sz == (size_t)-1) {
free(ma);
return -1;
@@ -911,7 +910,7 @@ rte_fbarray_attach(struct rte_fbarray *arr)
return 0;
fail:
if (data)
- munmap(data, mmap_len);
+ rte_mem_unmap(data, mmap_len);
if (fd >= 0)
close(fd);
free(ma);
@@ -939,8 +938,7 @@ rte_fbarray_detach(struct rte_fbarray *arr)
* really do anything about it, things will blow up either way.
*/
- size_t page_sz = sysconf(_SC_PAGESIZE);
-
+ size_t page_sz = rte_get_page_size();
if (page_sz == (size_t)-1)
return -1;
@@ -959,7 +957,7 @@ rte_fbarray_detach(struct rte_fbarray *arr)
goto out;
}
- munmap(arr->data, mmap_len);
+ rte_mem_unmap(arr->data, mmap_len);
/* area is unmapped, close fd and remove the tailq entry */
if (tmp->fd >= 0)
@@ -994,8 +992,7 @@ rte_fbarray_destroy(struct rte_fbarray *arr)
* really do anything about it, things will blow up either way.
*/
- size_t page_sz = sysconf(_SC_PAGESIZE);
-
+ size_t page_sz = rte_get_page_size();
if (page_sz == (size_t)-1)
return -1;
@@ -1044,7 +1041,7 @@ rte_fbarray_destroy(struct rte_fbarray *arr)
}
close(fd);
}
- munmap(arr->data, mmap_len);
+ rte_mem_unmap(arr->data, mmap_len);
/* area is unmapped, remove the tailq entry */
TAILQ_REMOVE(&mem_area_tailq, tmp, next);
diff --git a/lib/librte_eal/common/eal_common_memory.c b/lib/librte_eal/common/eal_common_memory.c
index 4c897a13f..c6243aca1 100644
--- a/lib/librte_eal/common/eal_common_memory.c
+++ b/lib/librte_eal/common/eal_common_memory.c
@@ -11,7 +11,6 @@
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
-#include <sys/mman.h>
#include <sys/queue.h>
#include <rte_fbarray.h>
@@ -40,18 +39,10 @@
static void *next_baseaddr;
static uint64_t system_page_sz;
-#ifdef RTE_EXEC_ENV_LINUX
-#define RTE_DONTDUMP MADV_DONTDUMP
-#elif defined RTE_EXEC_ENV_FREEBSD
-#define RTE_DONTDUMP MADV_NOCORE
-#else
-#error "madvise doesn't support this OS"
-#endif
-
#define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
void *
eal_get_virtual_area(void *requested_addr, size_t *size,
- size_t page_sz, int flags, int mmap_flags)
+ size_t page_sz, int flags, int reserve_flags)
{
bool addr_is_hint, allow_shrink, unmap, no_align;
uint64_t map_sz;
@@ -59,9 +50,7 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
uint8_t try = 0;
if (system_page_sz == 0)
- system_page_sz = sysconf(_SC_PAGESIZE);
-
- mmap_flags |= MAP_PRIVATE | MAP_ANONYMOUS;
+ system_page_sz = rte_get_page_size();
RTE_LOG(DEBUG, EAL, "Ask a virtual area of 0x%zx bytes\n", *size);
@@ -105,24 +94,24 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
return NULL;
}
- mapped_addr = mmap(requested_addr, (size_t)map_sz, PROT_NONE,
- mmap_flags, -1, 0);
- if (mapped_addr == MAP_FAILED && allow_shrink)
+ mapped_addr = eal_mem_reserve(
+ requested_addr, (size_t)map_sz, reserve_flags);
+ if ((mapped_addr == NULL) && allow_shrink)
*size -= page_sz;
- if (mapped_addr != MAP_FAILED && addr_is_hint &&
- mapped_addr != requested_addr) {
+ if ((mapped_addr != NULL) && addr_is_hint &&
+ (mapped_addr != requested_addr)) {
try++;
next_baseaddr = RTE_PTR_ADD(next_baseaddr, page_sz);
if (try <= MAX_MMAP_WITH_DEFINED_ADDR_TRIES) {
/* hint was not used. Try with another offset */
- munmap(mapped_addr, map_sz);
- mapped_addr = MAP_FAILED;
+ eal_mem_free(mapped_addr, map_sz);
+ mapped_addr = NULL;
requested_addr = next_baseaddr;
}
}
} while ((allow_shrink || addr_is_hint) &&
- mapped_addr == MAP_FAILED && *size > 0);
+ (mapped_addr == NULL) && (*size > 0));
/* align resulting address - if map failed, we will ignore the value
* anyway, so no need to add additional checks.
@@ -132,20 +121,17 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
if (*size == 0) {
RTE_LOG(ERR, EAL, "Cannot get a virtual area of any size: %s\n",
- strerror(errno));
- rte_errno = errno;
+ strerror(rte_errno));
return NULL;
- } else if (mapped_addr == MAP_FAILED) {
+ } else if (mapped_addr == NULL) {
RTE_LOG(ERR, EAL, "Cannot get a virtual area: %s\n",
- strerror(errno));
- /* pass errno up the call chain */
- rte_errno = errno;
+ strerror(rte_errno));
return NULL;
} else if (requested_addr != NULL && !addr_is_hint &&
aligned_addr != requested_addr) {
RTE_LOG(ERR, EAL, "Cannot get a virtual area at requested address: %p (got %p)\n",
requested_addr, aligned_addr);
- munmap(mapped_addr, map_sz);
+ eal_mem_free(mapped_addr, map_sz);
rte_errno = EADDRNOTAVAIL;
return NULL;
} else if (requested_addr != NULL && addr_is_hint &&
@@ -161,7 +147,7 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
aligned_addr, *size);
if (unmap) {
- munmap(mapped_addr, map_sz);
+ eal_mem_free(mapped_addr, map_sz);
} else if (!no_align) {
void *map_end, *aligned_end;
size_t before_len, after_len;
@@ -179,19 +165,17 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
/* unmap space before aligned mmap address */
before_len = RTE_PTR_DIFF(aligned_addr, mapped_addr);
if (before_len > 0)
- munmap(mapped_addr, before_len);
+ eal_mem_free(mapped_addr, before_len);
/* unmap space after aligned end mmap address */
after_len = RTE_PTR_DIFF(map_end, aligned_end);
if (after_len > 0)
- munmap(aligned_end, after_len);
+ eal_mem_free(aligned_end, after_len);
}
if (!unmap) {
/* Exclude these pages from a core dump. */
- if (madvise(aligned_addr, *size, RTE_DONTDUMP) != 0)
- RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
- strerror(errno));
+ eal_mem_set_dump(aligned_addr, *size, false);
}
return aligned_addr;
@@ -547,10 +531,10 @@ rte_eal_memdevice_init(void)
int
rte_mem_lock_page(const void *virt)
{
- unsigned long virtual = (unsigned long)virt;
- int page_size = getpagesize();
- unsigned long aligned = (virtual & ~(page_size - 1));
- return mlock((void *)aligned, page_size);
+ uintptr_t virtual = (uintptr_t)virt;
+ size_t page_size = rte_get_page_size();
+ uintptr_t aligned = RTE_PTR_ALIGN_FLOOR(virtual, page_size);
+ return rte_mem_lock((void *)aligned, page_size);
}
int
diff --git a/lib/librte_eal/common/eal_private.h b/lib/librte_eal/common/eal_private.h
index cef73d6fe..a93850c09 100644
--- a/lib/librte_eal/common/eal_private.h
+++ b/lib/librte_eal/common/eal_private.h
@@ -11,6 +11,7 @@
#include <rte_dev.h>
#include <rte_lcore.h>
+#include <rte_memory.h>
/**
* Structure storing internal configuration (per-lcore)
@@ -202,6 +203,24 @@ int rte_eal_alarm_init(void);
*/
int rte_eal_check_module(const char *module_name);
+/**
+ * Memory reservation flags.
+ */
+enum eal_mem_reserve_flags {
+ /**
+ * Reserve hugepages. May be unsupported by some platforms.
+ */
+ EAL_RESERVE_HUGEPAGES = 1 << 0,
+ /**
+ * Force reserving memory at the requested address.
+ * This can be a destructive action depending on the implementation.
+ *
+ * @see RTE_MAP_FORCE_ADDRESS for description of possible consequences
+ * (although implementations are not required to use it).
+ */
+ EAL_RESERVE_FORCE_ADDRESS = 1 << 1
+};
+
/**
* Get virtual area of specified size from the OS.
*
@@ -215,8 +234,8 @@ int rte_eal_check_module(const char *module_name);
* Page size on which to align requested virtual area.
* @param flags
* EAL_VIRTUAL_AREA_* flags.
- * @param mmap_flags
- * Extra flags passed directly to mmap().
+ * @param reserve_flags
+ * Extra flags passed directly to rte_mem_reserve().
*
* @return
* Virtual area address if successful.
@@ -233,7 +252,7 @@ int rte_eal_check_module(const char *module_name);
/**< immediately unmap reserved virtual area. */
void *
eal_get_virtual_area(void *requested_addr, size_t *size,
- size_t page_sz, int flags, int mmap_flags);
+ size_t page_sz, int flags, int reserve_flags);
/**
* Get cpu core_id.
@@ -467,4 +486,57 @@ eal_file_lock(int fd, enum eal_flock_op op, enum eal_flock_mode mode);
int
eal_file_truncate(int fd, ssize_t size);
+/**
+ * Reserve a region of virtual memory.
+ *
+ * Use eal_mem_free() to free reserved memory.
+ *
+ * @param requested_addr
+ * A desired reservation addressm which must be page-aligned.
+ * The system might not respect it.
+ * NULL means the address will be chosen by the system.
+ * @param size
+ * Reservation size. Must be a multiple of system page size.
+ * @param flags
+ * Reservation options, a combination of eal_mem_reserve_flags.
+ * @returns
+ * Starting address of the reserved area on success, NULL on failure.
+ * Callers must not access this memory until remapping it.
+ */
+void *
+eal_mem_reserve(void *requested_addr, size_t size, int flags);
+
+/**
+ * Free memory obtained by eal_mem_reserve() or eal_mem_alloc().
+ *
+ * If *virt* and *size* describe a part of the reserved region,
+ * only this part of the region is freed (accurately up to the system
+ * page size). If *virt* points to allocated memory, *size* must match
+ * the one specified on allocation. The behavior is undefined
+ * if the memory pointed by *virt* is obtained from another source
+ * than listed above.
+ *
+ * @param virt
+ * A virtual address in a region previously reserved.
+ * @param size
+ * Number of bytes to unreserve.
+ */
+void
+eal_mem_free(void *virt, size_t size);
+
+/**
+ * Configure memory region inclusion into core dumps.
+ *
+ * @param virt
+ * Starting address of the region.
+ * @param size
+ * Size of the region.
+ * @param dump
+ * True to include memory into core dumps, false to exclude.
+ * @return
+ * 0 on success, (-1) on failure and rte_errno is set.
+ */
+int
+eal_mem_set_dump(void *virt, size_t size, bool dump);
+
#endif /* _EAL_PRIVATE_H_ */
diff --git a/lib/librte_eal/freebsd/Makefile b/lib/librte_eal/freebsd/Makefile
index 4654ca2b3..f64a3994c 100644
--- a/lib/librte_eal/freebsd/Makefile
+++ b/lib/librte_eal/freebsd/Makefile
@@ -77,6 +77,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += rte_reciprocal.c
# from unix dir
SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_unix.c
+SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_unix_memory.c
# from arch dir
SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += rte_cpuflags.c
diff --git a/lib/librte_eal/include/rte_memory.h b/lib/librte_eal/include/rte_memory.h
index 65374d53a..63ff0773d 100644
--- a/lib/librte_eal/include/rte_memory.h
+++ b/lib/librte_eal/include/rte_memory.h
@@ -82,6 +82,94 @@ struct rte_memseg_list {
struct rte_fbarray memseg_arr;
};
+/**
+ * Memory protection flags.
+ */
+enum rte_mem_prot {
+ RTE_PROT_READ = 1 << 0, /**< Read access. */
+ RTE_PROT_WRITE = 1 << 1, /**< Write access. */
+ RTE_PROT_EXECUTE = 1 << 2 /**< Code execution. */
+};
+
+/**
+ * Additional flags for memory mapping.
+ */
+enum rte_map_flags {
+ /** Changes to the mapped memory are visible to other processes. */
+ RTE_MAP_SHARED = 1 << 0,
+ /** Mapping is not backed by a regular file. */
+ RTE_MAP_ANONYMOUS = 1 << 1,
+ /** Copy-on-write mapping, changes are invisible to other processes. */
+ RTE_MAP_PRIVATE = 1 << 2,
+ /**
+ * Force mapping to the requested address. This flag should be used
+ * with caution, because to fulfill the request implementation
+ * may remove all other mappings in the requested region. However,
+ * it is not required to do so, thus mapping with this flag may fail.
+ */
+ RTE_MAP_FORCE_ADDRESS = 1 << 3
+};
+
+/**
+ * Map a portion of an opened file or the page file into memory.
+ *
+ * This function is similar to POSIX mmap(3) with common MAP_ANONYMOUS
+ * extension, except for the return value.
+ *
+ * @param requested_addr
+ * Desired virtual address for mapping. Can be NULL to let OS choose.
+ * @param size
+ * Size of the mapping in bytes.
+ * @param prot
+ * Protection flags, a combination of rte_mem_prot values.
+ * @param flags
+ * Addtional mapping flags, a combination of rte_map_flags.
+ * @param fd
+ * Mapped file descriptor. Can be negative for anonymous mapping.
+ * @param offset
+ * Offset of the mapped region in fd. Must be 0 for anonymous mappings.
+ * @return
+ * Mapped address or NULL on failure and rte_errno is set to OS error.
+ */
+__rte_experimental
+void *
+rte_mem_map(void *requested_addr, size_t size, int prot, int flags,
+ int fd, size_t offset);
+
+/**
+ * OS-independent implementation of POSIX munmap(3).
+ */
+__rte_experimental
+int
+rte_mem_unmap(void *virt, size_t size);
+
+/**
+ * Get system page size. This function never fails.
+ *
+ * @return
+ * Page size in bytes.
+ */
+__rte_experimental
+size_t
+rte_get_page_size(void);
+
+/**
+ * Lock in physical memory all pages crossed by the address region.
+ *
+ * @param virt
+ * Base virtual address of the region.
+ * @param size
+ * Size of the region.
+ * @return
+ * 0 on success, negative on error.
+ *
+ * @see rte_get_page_size() to retrieve the page size.
+ * @see rte_mem_lock_page() to lock an entire single page.
+ */
+__rte_experimental
+int
+rte_mem_lock(const void *virt, size_t size);
+
/**
* Lock page in physical memory and prevent from swapping.
*
diff --git a/lib/librte_eal/linux/Makefile b/lib/librte_eal/linux/Makefile
index 4f39d462c..d314648cb 100644
--- a/lib/librte_eal/linux/Makefile
+++ b/lib/librte_eal/linux/Makefile
@@ -84,6 +84,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += rte_reciprocal.c
# from unix dir
SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_unix.c
+SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_unix_memory.c
# from arch dir
SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += rte_cpuflags.c
diff --git a/lib/librte_eal/linux/eal_memalloc.c b/lib/librte_eal/linux/eal_memalloc.c
index 2c717f8bd..bf29b83c6 100644
--- a/lib/librte_eal/linux/eal_memalloc.c
+++ b/lib/librte_eal/linux/eal_memalloc.c
@@ -630,7 +630,7 @@ alloc_seg(struct rte_memseg *ms, void *addr, int socket_id,
mapped:
munmap(addr, alloc_sz);
unmapped:
- flags = MAP_FIXED;
+ flags = EAL_RESERVE_FORCE_ADDRESS;
new_addr = eal_get_virtual_area(addr, &alloc_sz, alloc_sz, 0, flags);
if (new_addr != addr) {
if (new_addr != NULL)
@@ -687,8 +687,7 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
return -1;
}
- if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
- RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+ eal_mem_set_dump(ms->addr, ms->len, false);
exit_early = false;
diff --git a/lib/librte_eal/rte_eal_version.map b/lib/librte_eal/rte_eal_version.map
index d8038749a..dff51b13d 100644
--- a/lib/librte_eal/rte_eal_version.map
+++ b/lib/librte_eal/rte_eal_version.map
@@ -386,4 +386,10 @@ EXPERIMENTAL {
rte_trace_point_lookup;
rte_trace_regexp;
rte_trace_save;
+
+ # added in 20.08
+ rte_get_page_size;
+ rte_mem_lock;
+ rte_mem_map;
+ rte_mem_unmap;
};
diff --git a/lib/librte_eal/unix/eal_unix_memory.c b/lib/librte_eal/unix/eal_unix_memory.c
new file mode 100644
index 000000000..658595b6e
--- /dev/null
+++ b/lib/librte_eal/unix/eal_unix_memory.c
@@ -0,0 +1,152 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Dmitry Kozlyuk
+ */
+
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <rte_errno.h>
+#include <rte_log.h>
+#include <rte_memory.h>
+
+#include "eal_private.h"
+
+#ifdef RTE_EXEC_ENV_LINUX
+#define EAL_DONTDUMP MADV_DONTDUMP
+#define EAL_DODUMP MADV_DODUMP
+#elif defined RTE_EXEC_ENV_FREEBSD
+#define EAL_DONTDUMP MADV_NOCORE
+#define EAL_DODUMP MADV_CORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+
+static void *
+mem_map(void *requested_addr, size_t size, int prot, int flags,
+ int fd, size_t offset)
+{
+ void *virt = mmap(requested_addr, size, prot, flags, fd, offset);
+ if (virt == MAP_FAILED) {
+ RTE_LOG(DEBUG, EAL,
+ "Cannot mmap(%p, 0x%zx, 0x%x, 0x%x, %d, 0x%zx): %s\n",
+ requested_addr, size, prot, flags, fd, offset,
+ strerror(errno));
+ rte_errno = errno;
+ return NULL;
+ }
+ return virt;
+}
+
+static int
+mem_unmap(void *virt, size_t size)
+{
+ int ret = munmap(virt, size);
+ if (ret < 0) {
+ RTE_LOG(DEBUG, EAL, "Cannot munmap(%p, 0x%zx): %s\n",
+ virt, size, strerror(errno));
+ rte_errno = errno;
+ }
+ return ret;
+}
+
+void *
+eal_mem_reserve(void *requested_addr, size_t size, int flags)
+{
+ int sys_flags = MAP_PRIVATE | MAP_ANONYMOUS;
+
+ if (flags & EAL_RESERVE_HUGEPAGES) {
+#ifdef MAP_HUGETLB
+ sys_flags |= MAP_HUGETLB;
+#else
+ rte_errno = ENOTSUP;
+ return NULL;
+#endif
+ }
+
+ if (flags & EAL_RESERVE_FORCE_ADDRESS)
+ sys_flags |= MAP_FIXED;
+
+ return mem_map(requested_addr, size, PROT_NONE, sys_flags, -1, 0);
+}
+
+void
+eal_mem_free(void *virt, size_t size)
+{
+ mem_unmap(virt, size);
+}
+
+int
+eal_mem_set_dump(void *virt, size_t size, bool dump)
+{
+ int flags = dump ? EAL_DODUMP : EAL_DONTDUMP;
+ int ret = madvise(virt, size, flags);
+ if (ret) {
+ RTE_LOG(DEBUG, EAL, "madvise(%p, %#zx, %d) failed: %s\n",
+ virt, size, flags, strerror(rte_errno));
+ rte_errno = errno;
+ }
+ return ret;
+}
+
+static int
+mem_rte_to_sys_prot(int prot)
+{
+ int sys_prot = PROT_NONE;
+
+ if (prot & RTE_PROT_READ)
+ sys_prot |= PROT_READ;
+ if (prot & RTE_PROT_WRITE)
+ sys_prot |= PROT_WRITE;
+ if (prot & RTE_PROT_EXECUTE)
+ sys_prot |= PROT_EXEC;
+
+ return sys_prot;
+}
+
+void *
+rte_mem_map(void *requested_addr, size_t size, int prot, int flags,
+ int fd, size_t offset)
+{
+ int sys_flags = 0;
+ int sys_prot;
+
+ sys_prot = mem_rte_to_sys_prot(prot);
+
+ if (flags & RTE_MAP_SHARED)
+ sys_flags |= MAP_SHARED;
+ if (flags & RTE_MAP_ANONYMOUS)
+ sys_flags |= MAP_ANONYMOUS;
+ if (flags & RTE_MAP_PRIVATE)
+ sys_flags |= MAP_PRIVATE;
+ if (flags & RTE_MAP_FORCE_ADDRESS)
+ sys_flags |= MAP_FIXED;
+
+ return mem_map(requested_addr, size, sys_prot, sys_flags, fd, offset);
+}
+
+int
+rte_mem_unmap(void *virt, size_t size)
+{
+ return mem_unmap(virt, size);
+}
+
+size_t
+rte_get_page_size(void)
+{
+ static size_t page_size;
+
+ if (!page_size)
+ page_size = sysconf(_SC_PAGESIZE);
+
+ return page_size;
+}
+
+int
+rte_mem_lock(const void *virt, size_t size)
+{
+ int ret = mlock(virt, size);
+ if (ret)
+ rte_errno = errno;
+ return ret;
+}
diff --git a/lib/librte_eal/unix/meson.build b/lib/librte_eal/unix/meson.build
index cfa1b4ef9..5734f26ad 100644
--- a/lib/librte_eal/unix/meson.build
+++ b/lib/librte_eal/unix/meson.build
@@ -3,4 +3,5 @@
sources += files(
'eal_unix.c',
+ 'eal_unix_memory.c',
)
--
2.25.4
next prev parent reply other threads:[~2020-05-25 0:38 UTC|newest]
Thread overview: 218+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-03-30 4:10 [dpdk-dev] [RFC PATCH 0/9] Windows basic memory management Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [PATCH 1/1] virt2phys: virtual to physical address translator for Windows Dmitry Kozlyuk
2020-03-30 6:58 ` Jerin Jacob
2020-03-30 13:41 ` Dmitry Kozlyuk
2020-04-10 1:45 ` Ranjit Menon
2020-04-10 2:50 ` Dmitry Kozlyuk
2020-04-10 2:59 ` Dmitry Kozlyuk
2020-04-10 19:39 ` Ranjit Menon
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 2/9] eal/windows: do not expose private EAL facilities Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 3/9] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 4/9] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 5/9] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-03-30 7:04 ` Jerin Jacob
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 6/9] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-03-30 7:31 ` Thomas Monjalon
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 7/9] eal/windows: fix rte_page_sizes with Clang on Windows Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 8/9] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-03-30 4:10 ` [dpdk-dev] [RFC PATCH 9/9] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 00/10] eal: Windows " Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 1/1] virt2phys: virtual to physical address translator for Windows Dmitry Kozlyuk
2020-04-13 5:32 ` Ranjit Menon
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 02/10] eal/windows: do not expose private EAL facilities Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 03/10] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 04/10] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 05/10] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 06/10] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-04-13 7:50 ` Tal Shnaiderman
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 07/10] eal: extract common code for memseg list initialization Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 08/10] eal/windows: fix rte_page_sizes with Clang on Windows Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 09/10] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-04-10 16:43 ` [dpdk-dev] [PATCH v2 10/10] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-04-10 22:04 ` Narcisa Ana Maria Vasile
2020-04-11 1:16 ` Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 00/10] Windows " Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 1/1] virt2phys: virtual to physical address translator for Windows Dmitry Kozlyuk
2020-04-14 23:35 ` Ranjit Menon
2020-04-15 15:19 ` Thomas Monjalon
2020-04-21 6:23 ` Ophir Munk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 02/10] eal/windows: do not expose private EAL facilities Dmitry Kozlyuk
2020-04-21 22:40 ` Thomas Monjalon
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 03/10] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 04/10] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 05/10] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-04-15 21:48 ` Thomas Monjalon
2020-04-17 12:24 ` Burakov, Anatoly
2020-04-28 23:50 ` Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 06/10] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-04-15 22:17 ` Thomas Monjalon
2020-04-15 23:32 ` Dmitry Kozlyuk
2020-04-17 12:43 ` Burakov, Anatoly
2020-04-20 5:59 ` Tal Shnaiderman
2020-04-21 23:36 ` Dmitry Kozlyuk
2020-04-22 0:55 ` Ranjit Menon
2020-04-22 2:07 ` Ranjit Menon
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 07/10] eal: extract common code for memseg list initialization Dmitry Kozlyuk
2020-04-15 22:19 ` Thomas Monjalon
2020-04-17 13:04 ` Burakov, Anatoly
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 08/10] eal/windows: fix rte_page_sizes with Clang on Windows Dmitry Kozlyuk
2020-04-15 9:34 ` Jerin Jacob
2020-04-15 10:32 ` Dmitry Kozlyuk
2020-04-15 10:57 ` Jerin Jacob
2020-04-15 11:09 ` Dmitry Kozlyuk
2020-04-15 11:17 ` Jerin Jacob
2020-05-06 5:41 ` Ray Kinsella
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 09/10] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-04-14 19:44 ` [dpdk-dev] [PATCH v3 10/10] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-04-15 9:42 ` Jerin Jacob
2020-04-16 18:34 ` Ranjit Menon
2020-04-23 1:00 ` Dmitry Kozlyuk
2020-04-14 23:37 ` [dpdk-dev] [PATCH v3 00/10] Windows " Kadam, Pallavi
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 0/8] " Dmitry Kozlyuk
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 1/8] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 2/8] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-04-29 16:41 ` Burakov, Anatoly
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 3/8] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-04-29 17:13 ` Burakov, Anatoly
2020-04-30 13:59 ` Burakov, Anatoly
2020-05-01 19:00 ` Dmitry Kozlyuk
2020-05-05 14:43 ` Burakov, Anatoly
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 4/8] eal: extract common code for memseg list initialization Dmitry Kozlyuk
2020-05-05 16:08 ` Burakov, Anatoly
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 5/8] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 6/8] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 7/8] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-04-28 23:50 ` [dpdk-dev] [PATCH v4 8/8] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-04-29 1:18 ` Ranjit Menon
2020-05-01 19:19 ` Dmitry Kozlyuk
2020-05-05 16:24 ` Burakov, Anatoly
2020-05-05 23:20 ` Dmitry Kozlyuk
2020-05-06 9:46 ` Burakov, Anatoly
2020-05-06 21:53 ` Dmitry Kozlyuk
2020-05-07 11:57 ` Burakov, Anatoly
2020-05-13 8:24 ` Fady Bader
2020-05-13 8:42 ` Dmitry Kozlyuk
2020-05-13 9:09 ` Fady Bader
2020-05-13 9:22 ` Fady Bader
2020-05-13 9:38 ` Dmitry Kozlyuk
2020-05-13 12:25 ` Fady Bader
2020-05-18 0:17 ` Dmitry Kozlyuk
2020-05-18 22:25 ` Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 0/8] Windows " Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 01/11] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 02/11] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-05-28 7:59 ` Thomas Monjalon
2020-05-28 10:09 ` Dmitry Kozlyuk
2020-05-28 11:29 ` Thomas Monjalon
2020-05-25 0:37 ` Dmitry Kozlyuk [this message]
2020-05-27 6:33 ` [dpdk-dev] [PATCH v5 03/11] eal: introduce memory management wrappers Ray Kinsella
2020-05-27 16:34 ` Dmitry Kozlyuk
2020-05-28 11:26 ` Burakov, Anatoly
2020-06-01 21:08 ` Thomas Monjalon
2020-05-28 11:52 ` Burakov, Anatoly
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 04/11] eal/mem: extract common code for memseg list initialization Dmitry Kozlyuk
2020-05-28 7:31 ` Thomas Monjalon
2020-05-28 10:04 ` Dmitry Kozlyuk
2020-05-28 11:46 ` Burakov, Anatoly
2020-05-28 14:41 ` Dmitry Kozlyuk
2020-05-29 8:49 ` Burakov, Anatoly
2020-05-28 12:19 ` Burakov, Anatoly
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 05/11] eal/mem: extract common code for dynamic memory allocation Dmitry Kozlyuk
2020-05-28 8:34 ` Thomas Monjalon
2020-05-28 12:21 ` Burakov, Anatoly
2020-05-28 13:24 ` Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 06/11] trace: add size_t field emitter Dmitry Kozlyuk
2020-05-25 5:53 ` Jerin Jacob
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 07/11] eal/windows: add tracing support stubs Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 08/11] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 09/11] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 10/11] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-05-25 0:37 ` [dpdk-dev] [PATCH v5 11/11] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 00/11] Windows " Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 01/11] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-06-03 1:59 ` Stephen Hemminger
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 02/11] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-06-03 12:07 ` Neil Horman
2020-06-03 12:34 ` Dmitry Kozlyuk
2020-06-04 21:07 ` Neil Horman
2020-06-05 0:16 ` Dmitry Kozlyuk
2020-06-05 11:19 ` Neil Horman
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 03/11] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 04/11] eal/mem: extract common code for memseg list initialization Dmitry Kozlyuk
2020-06-09 13:36 ` Burakov, Anatoly
2020-06-09 14:17 ` Dmitry Kozlyuk
2020-06-10 10:26 ` Burakov, Anatoly
2020-06-10 14:31 ` Dmitry Kozlyuk
2020-06-10 15:48 ` Burakov, Anatoly
2020-06-10 16:39 ` Dmitry Kozlyuk
2020-06-11 8:59 ` Burakov, Anatoly
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 05/11] eal/mem: extract common code for dynamic memory allocation Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 06/11] trace: add size_t field emitter Dmitry Kozlyuk
2020-06-03 3:29 ` Jerin Jacob
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 07/11] eal/windows: add tracing support stubs Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 08/11] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 09/11] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 10/11] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-06-02 23:03 ` [dpdk-dev] [PATCH v6 11/11] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v6 00/11] Windows " Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 01/11] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 02/11] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 03/11] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 04/11] eal/mem: extract common code for memseg list initialization Dmitry Kozlyuk
2020-06-09 11:14 ` Tal Shnaiderman
2020-06-09 13:49 ` Burakov, Anatoly
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 05/11] eal/mem: extract common code for dynamic memory allocation Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 06/11] trace: add size_t field emitter Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 07/11] eal/windows: add tracing support stubs Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 08/11] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 09/11] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 10/11] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-06-08 7:41 ` [dpdk-dev] [PATCH v7 11/11] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 00/11] Windows " Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 01/11] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 02/11] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-06-11 17:13 ` Thomas Monjalon
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 03/11] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-06-12 10:47 ` Thomas Monjalon
2020-06-12 13:44 ` Dmitry Kozliuk
2020-06-12 13:54 ` Thomas Monjalon
2020-06-12 20:24 ` Dmitry Kozliuk
2020-06-12 21:37 ` Thomas Monjalon
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 04/11] eal/mem: extract common code for memseg list initialization Dmitry Kozlyuk
2020-06-12 15:39 ` Thomas Monjalon
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 05/11] eal/mem: extract common code for dynamic memory allocation Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 06/11] trace: add size_t field emitter Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 07/11] eal/windows: add tracing support stubs Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 08/11] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 09/11] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-06-12 21:45 ` Thomas Monjalon
2020-06-12 22:09 ` Thomas Monjalon
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 10/11] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-06-12 21:55 ` Thomas Monjalon
2020-06-10 14:27 ` [dpdk-dev] [PATCH v8 11/11] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-06-12 22:12 ` Thomas Monjalon
2020-06-11 17:29 ` [dpdk-dev] [PATCH v8 00/11] Windows " Thomas Monjalon
2020-06-12 22:00 ` Thomas Monjalon
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 00/12] " Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 01/12] eal: replace rte_page_sizes with a set of constants Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 02/12] eal: introduce internal wrappers for file operations Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 03/12] eal: introduce memory management wrappers Dmitry Kozlyuk
2020-06-15 6:03 ` Kinsella, Ray
2020-06-15 7:41 ` Dmitry Kozlyuk
2020-06-15 7:41 ` Kinsella, Ray
2020-06-15 10:53 ` Neil Horman
2020-06-15 11:10 ` Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 04/12] eal/mem: extract common code for memseg list initialization Dmitry Kozlyuk
2020-06-15 13:13 ` Thomas Monjalon
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 05/12] eal/mem: extract common code for dynamic memory allocation Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 06/12] trace: add size_t field emitter Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 07/12] eal/windows: add tracing support stubs Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 08/12] eal/windows: replace sys/queue.h with a complete one from FreeBSD Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 09/12] eal/windows: improve CPU and NUMA node detection Dmitry Kozlyuk
2020-06-15 15:21 ` Thomas Monjalon
2020-06-15 15:39 ` Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 10/12] doc/windows: split build and run instructions Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 11/12] eal/windows: initialize hugepage info Dmitry Kozlyuk
2020-06-15 0:43 ` [dpdk-dev] [PATCH v9 12/12] eal/windows: implement basic memory management Dmitry Kozlyuk
2020-06-15 17:34 ` [dpdk-dev] [PATCH v9 00/12] Windows " Thomas Monjalon
2020-06-16 1:52 ` Ranjit Menon
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200525003720.6410-4-dmitry.kozliuk@gmail.com \
--to=dmitry.kozliuk@gmail.com \
--cc=Narcisa.Vasile@microsoft.com \
--cc=anatoly.burakov@intel.com \
--cc=bruce.richardson@intel.com \
--cc=dev@dpdk.org \
--cc=dmitrym@microsoft.com \
--cc=fady@mellanox.com \
--cc=mdr@ashroe.eu \
--cc=nhorman@tuxdriver.com \
--cc=talshn@mellanox.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).