Create MAP_SHARED RAMBlocks by mmap'ing a file descriptor rather than using
MAP_ANON, so the memory can be accessed in another process by passing and
mmap'ing the fd. This will allow CPR to support memory-backend-ram and
memory-backend-shm objects, provided the user creates them with share=on.
Use memfd_create if available because it has no constraints. If not, use
POSIX shm_open. However, this may fail if the shm mount size is too small,
even if the system has free memory, so for backwards compatibility fall
back to qemu_anon_ram_alloc/MAP_ANON on shm_open failure.
For backwards compatibility on Windows, always use MAP_ANON. share=on has
no purpose there, but the syntax is accepted, and must continue to work.
Exclude Xen. Xen ignores RAM_SHARED and does its own allocation.
Signed-off-by: Steve Sistare <steven.sist...@oracle.com>
---
system/physmem.c | 85 +++++++++++++++++++++++++++++++++++++++++++++++++----
system/trace-events | 1 +
2 files changed, 81 insertions(+), 5 deletions(-)
diff --git a/system/physmem.c b/system/physmem.c
index dc1db3a..b0c4b22 100644
--- a/system/physmem.c
+++ b/system/physmem.c
@@ -47,6 +47,7 @@
#include "qemu/qemu-print.h"
#include "qemu/log.h"
#include "qemu/memalign.h"
+#include "qemu/memfd.h"
#include "exec/memory.h"
#include "exec/ioport.h"
#include "sysemu/dma.h"
@@ -2057,6 +2058,70 @@ RAMBlock *qemu_ram_alloc_from_file(ram_addr_t size,
MemoryRegion *mr,
}
#endif
+static bool qemu_memfd_available(void)
+{
+ static int has_memfd = -1;
+
+ if (has_memfd < 0) {
+ has_memfd = qemu_memfd_check(0);
+ }
+ return has_memfd;
+}
+
+/*
+ * We want anonymous shared memory, similar to MAP_SHARED|MAP_ANON, but
+ * some users want the fd. Allocate shm explicitly to get an fd.
+ */
+static bool qemu_ram_alloc_shared(RAMBlock *new_block, Error **errp)
+{
+ size_t max_length = new_block->max_length;
+ MemoryRegion *mr = new_block->mr;
+ const char *name = memory_region_name(mr);
+ int fd;
+
+ if (qemu_memfd_available()) {
+ fd = qemu_memfd_create(name, max_length + mr->align, 0, 0, 0, errp);
+ if (fd < 0) {
+ return false;
+ }
+ } else if (!qemu_shm_available()) {
+ /*
+ * Backwards compatibility for Windows. The user may specify a
+ * memory backend with shared=on, and Windows ignores shared.
+ * Fall back to qemu_anon_ram_alloc.
+ */
+ return true;
+ } else {
+ Error *local_err = NULL;
+
+ fd = qemu_shm_alloc(max_length, &local_err);
+ if (fd < 0) {
+ /*
+ * Backwards compatibility in case the shm mount size is too small.
+ * Previous QEMU versions called qemu_anon_ram_alloc for anonymous
+ * shared memory, which could succeed.
+ */
+ error_prepend(&local_err,
+ "Retrying using MAP_ANON|MAP_SHARED because: ");
+ warn_report_err(local_err);
+ return true;
+ }
+ }
+
+ new_block->mr->align = QEMU_VMALLOC_ALIGN;
+ new_block->host = file_ram_alloc(new_block, max_length, fd, false, 0,
errp);
+
+ if (new_block->host) {
+ qemu_set_cloexec(fd);
+ new_block->fd = fd;
+ trace_qemu_ram_alloc_shared(name, max_length, fd, new_block->host);
+ return true;
+ }
+
+ close(fd);
+ return false;
+}
+
static
RAMBlock *qemu_ram_alloc_internal(ram_addr_t size, ram_addr_t max_size,
void (*resized)(const char*,
@@ -2089,13 +2154,23 @@ RAMBlock *qemu_ram_alloc_internal(ram_addr_t size,
ram_addr_t max_size,
new_block->page_size = qemu_real_host_page_size();
new_block->host = host;
new_block->flags = ram_flags;
+
+ if (!host && !xen_enabled()) {
+ if ((new_block->flags & RAM_SHARED) &&
+ !qemu_ram_alloc_shared(new_block, &local_err)) {
+ goto err;
+ }
+ }
+
ram_block_add(new_block, &local_err);
- if (local_err) {
- g_free(new_block);
- error_propagate(errp, local_err);
- return NULL;
+ if (!local_err) {
+ return new_block;
}
- return new_block;
+
+err:
+ g_free(new_block);
+ error_propagate(errp, local_err);
+ return NULL;
}
RAMBlock *qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
diff --git a/system/trace-events b/system/trace-events
index 5bbc3fb..831a60c 100644
--- a/system/trace-events
+++ b/system/trace-events
@@ -33,6 +33,7 @@ address_space_map(void *as, uint64_t addr, uint64_t len, bool
is_write, uint32_t
find_ram_offset(uint64_t size, uint64_t offset) "size: 0x%" PRIx64 " @ 0x%"
PRIx64
find_ram_offset_loop(uint64_t size, uint64_t candidate, uint64_t offset,
uint64_t next, uint64_t mingap) "trying size: 0x%" PRIx64 " @ 0x%" PRIx64 ",
offset: 0x%" PRIx64" next: 0x%" PRIx64 " mingap: 0x%" PRIx64
ram_block_discard_range(const char *rbname, void *hva, size_t length, bool
need_madvise, bool need_fallocate, int ret) "%s@%p + 0x%zx: madvise: %d
fallocate: %d ret: %d"
+qemu_ram_alloc_shared(const char *name, size_t max_length, int fd, void *host)
"%s size %zu fd %d host %p"
# cpus.c
vm_stop_flush_all(int ret) "ret %d"
--
1.8.3.1
