[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v1 8/9] util/mmap-alloc: support RAM_NORESERVE via MAP_NORESERVE
From: |
David Hildenbrand |
Subject: |
[PATCH v1 8/9] util/mmap-alloc: support RAM_NORESERVE via MAP_NORESERVE |
Date: |
Tue, 9 Feb 2021 14:49:38 +0100 |
Let's support RAM_NORESERVE via MAP_NORESERVE. At least on Linux,
the flag has no effect on shared mappings - except for anonymous memory
and hugetlbfs.
Linux man page:
"MAP_NORESERVE: Do not reserve swap space for this mapping. When swap
space is reserved, one has the guarantee that it is possible to modify
the mapping. When swap space is not reserved one might get SIGSEGV
upon a write if no physical memory is available. See also the discussion
of the file /proc/sys/vm/overcommit_memory in proc(5). In kernels before
2.6, this flag had effect only for private writable mappings."
Note that the "guarantee" part is wrong with memory overcommit in Linux.
Also, in Linux hugetlbfs is treated differently - we configure reservation
of huge pages from the pool, not reservation of swap space (huge pages
cannot be swapped).
The rough behavior is [1]:
a) !Hugetlbfs:
1) Without MAP_NORESERVE *or* with memory overcommit under Linux
disabled ("/proc/sys/vm/overcommit_memory == 2"), the following
accounting/reservation happens:
For a file backed map
SHARED or READ-only - 0 cost (the file is the map not swap)
PRIVATE WRITABLE - size of mapping per instance
For an anonymous or /dev/zero map
SHARED - size of mapping
PRIVATE READ-only - 0 cost (but of little use)
PRIVATE WRITABLE - size of mapping per instance
2) With MAP_NORESERVE, no accounting/reservation happens.
b) Hugetlbfs:
1) Without MAP_NORESERVE, huge pages are reserved.
2) With MAP_NORESERVE, no huge pages are reserved.
Note: With "/proc/sys/vm/overcommit_memory == 0", we were already able
to configure it for !hugetlbfs globally; this toggle now allows
configuring it more fine-grained, not for the whole system.
The target use case is virtio-mem, which dynamically exposes memory
inside a large, sparse memory area to the VM.
[1] https://www.kernel.org/doc/Documentation/vm/overcommit-accounting
Signed-off-by: David Hildenbrand <david@redhat.com>
---
softmmu/physmem.c | 1 +
util/mmap-alloc.c | 47 +++++++++++++++++++++++++++++++++++++++++++----
2 files changed, 44 insertions(+), 4 deletions(-)
diff --git a/softmmu/physmem.c b/softmmu/physmem.c
index 9820d845c0..f45a85add1 100644
--- a/softmmu/physmem.c
+++ b/softmmu/physmem.c
@@ -2248,6 +2248,7 @@ void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
abort();
} else {
flags = MAP_FIXED;
+ flags |= (block->flags & RAM_NORESERVE) ? MAP_NORESERVE : 0;
if (block->fd >= 0) {
flags |= (block->flags & RAM_SHARED ?
MAP_SHARED : MAP_PRIVATE);
diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
index bb99843106..f77d9ca574 100644
--- a/util/mmap-alloc.c
+++ b/util/mmap-alloc.c
@@ -20,6 +20,7 @@
#include "qemu/osdep.h"
#include "qemu/mmap-alloc.h"
#include "qemu/host-utils.h"
+#include "qemu/cutils.h"
#include "qemu/error-report.h"
#define HUGETLBFS_MAGIC 0x958458f6
@@ -120,7 +121,7 @@ static void *mmap_reserve(size_t size, int fd)
* it accessible.
*/
static void *mmap_activate(void *ptr, size_t size, int fd, bool readonly,
- bool shared, bool is_pmem)
+ bool shared, bool is_pmem, bool noreserve)
{
const int prot = PROT_READ | (readonly ? 0 : PROT_WRITE);
int map_sync_flags = 0;
@@ -129,6 +130,7 @@ static void *mmap_activate(void *ptr, size_t size, int fd,
bool readonly,
flags |= fd == -1 ? MAP_ANONYMOUS : 0;
flags |= shared ? MAP_SHARED : MAP_PRIVATE;
+ flags |= noreserve ? MAP_NORESERVE : 0;
if (shared && is_pmem) {
map_sync_flags = MAP_SYNC | MAP_SHARED_VALIDATE;
}
@@ -170,6 +172,43 @@ static inline size_t mmap_guard_pagesize(int fd)
#endif
}
+#define OVERCOMMIT_MEMORY_PATH "/proc/sys/vm/overcommit_memory"
+static bool map_noreserve_effective(int fd, bool shared)
+{
+#if defined(__linux__)
+ gchar *content = NULL;
+ const char *endptr;
+ unsigned int tmp;
+
+ /* hugetlbfs behaves differently */
+ if (qemu_fd_getpagesize(fd) != qemu_real_host_page_size) {
+ return true;
+ }
+
+ /* only private shared mappings are accounted (ignoring /dev/zero) */
+ if (fd != -1 && shared) {
+ return true;
+ }
+
+ if (g_file_get_contents(OVERCOMMIT_MEMORY_PATH, &content, NULL, NULL) &&
+ !qemu_strtoui(content, &endptr, 0, &tmp) &&
+ (!endptr || *endptr == '\n')) {
+ if (tmp == 2) {
+ error_report("Skipping reservation of swap space is not supported:
"
+ " \"" OVERCOMMIT_MEMORY_PATH "\" is \"2\"");
+ return false;
+ }
+ return true;
+ }
+ /* this interface has been around since Linux 2.6 */
+ error_report("Skipping reservation of swap space is not supported: "
+ " Could not read: \"" OVERCOMMIT_MEMORY_PATH "\"");
+ return false;
+#else
+ return true;
+#endif
+}
+
void *qemu_ram_mmap(int fd,
size_t size,
size_t align,
@@ -182,8 +221,7 @@ void *qemu_ram_mmap(int fd,
size_t offset, total;
void *ptr, *guardptr;
- if (noreserve) {
- error_report("Skipping reservation of swap space is not supported");
+ if (noreserve && !map_noreserve_effective(fd, shared)) {
return MAP_FAILED;
}
@@ -204,7 +242,8 @@ void *qemu_ram_mmap(int fd,
offset = QEMU_ALIGN_UP((uintptr_t)guardptr, align) - (uintptr_t)guardptr;
- ptr = mmap_activate(guardptr + offset, size, fd, readonly, shared,
is_pmem);
+ ptr = mmap_activate(guardptr + offset, size, fd, readonly, shared, is_pmem,
+ noreserve);
if (ptr == MAP_FAILED) {
munmap(guardptr, total);
return MAP_FAILED;
--
2.29.2
- [PATCH v1 0/9] RAM_NORESERVE, MAP_NORESERVE and hostmem "reserve" property, David Hildenbrand, 2021/02/09
- [PATCH v1 1/9] softmmu/physmem: drop "shared" parameter from ram_block_add(), David Hildenbrand, 2021/02/09
- [PATCH v1 2/9] util/mmap-alloc: factor out calculation of the pagesize for the guard page, David Hildenbrand, 2021/02/09
- [PATCH v1 3/9] util/mmap-alloc: factor out reserving of a memory region to mmap_reserve(), David Hildenbrand, 2021/02/09
- [PATCH v1 4/9] util/mmap-alloc: factor out activating of memory to mmap_activate(), David Hildenbrand, 2021/02/09
- [PATCH v1 5/9] softmmu/memory: pass ram_flags into qemu_ram_alloc_from_fd(), David Hildenbrand, 2021/02/09
- [PATCH v1 6/9] softmmu/memory: pass ram_flags into memory_region_init_ram_shared_nomigrate(), David Hildenbrand, 2021/02/09
- [PATCH v1 8/9] util/mmap-alloc: support RAM_NORESERVE via MAP_NORESERVE,
David Hildenbrand <=
- [PATCH v1 7/9] memory: introduce RAM_NORESERVE and wire it up in qemu_ram_mmap(), David Hildenbrand, 2021/02/09
- [PATCH v1 9/9] hostmem: wire up RAM_NORESERVE via "reserve" property, David Hildenbrand, 2021/02/09