140 lines
4.6 KiB
Diff
140 lines
4.6 KiB
Diff
From 6b3478bb8b5718d86cb04f41043a8e0cce4df24c Mon Sep 17 00:00:00 2001
|
|
From: "plai@redhat.com" <plai@redhat.com>
|
|
Date: Tue, 20 Aug 2019 16:12:49 +0100
|
|
Subject: [PATCH 02/11] mmap-alloc: unfold qemu_ram_mmap()
|
|
MIME-Version: 1.0
|
|
Content-Type: text/plain; charset=UTF-8
|
|
Content-Transfer-Encoding: 8bit
|
|
|
|
RH-Author: plai@redhat.com
|
|
Message-id: <1566317571-5697-3-git-send-email-plai@redhat.com>
|
|
Patchwork-id: 90083
|
|
O-Subject: [RHEL8.2 qemu-kvm PATCH 2/4] mmap-alloc: unfold qemu_ram_mmap()
|
|
Bugzilla: 1539282
|
|
RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
|
|
RH-Acked-by: Philippe Mathieu-Daudé <philmd@redhat.com>
|
|
RH-Acked-by: Pankaj Gupta <pagupta@redhat.com>
|
|
RH-Acked-by: Eduardo Habkost <ehabkost@redhat.com>
|
|
|
|
From: Murilo Opsfelder Araujo <muriloo@linux.ibm.com>
|
|
|
|
Unfold parts of qemu_ram_mmap() for the sake of understanding, moving
|
|
declarations to the top, and keeping architecture-specifics in the
|
|
ifdef-else blocks. No changes in the function behaviour.
|
|
|
|
Give ptr and ptr1 meaningful names:
|
|
ptr -> guardptr : pointer to the PROT_NONE guard region
|
|
ptr1 -> ptr : pointer to the mapped memory returned to caller
|
|
|
|
Signed-off-by: Murilo Opsfelder Araujo <muriloo@linux.ibm.com>
|
|
Reviewed-by: Greg Kurz <groug@kaod.org>
|
|
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
|
|
(cherry picked from commit 2044c3e7116eeac0449dcb4a4130cc8f8b9310da)
|
|
Signed-off-by: Paul Lai <plai@redhat.com>
|
|
Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>
|
|
---
|
|
util/mmap-alloc.c | 53 ++++++++++++++++++++++++++++++++++-------------------
|
|
1 file changed, 34 insertions(+), 19 deletions(-)
|
|
|
|
diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
|
|
index 55d1890..b29fcee 100644
|
|
--- a/util/mmap-alloc.c
|
|
+++ b/util/mmap-alloc.c
|
|
@@ -79,11 +79,19 @@ void *qemu_ram_mmap(int fd,
|
|
bool shared,
|
|
bool is_pmem)
|
|
{
|
|
+ int flags;
|
|
+ int guardfd;
|
|
+ size_t offset;
|
|
+ size_t total;
|
|
+ void *guardptr;
|
|
+ void *ptr;
|
|
+
|
|
/*
|
|
* Note: this always allocates at least one extra page of virtual address
|
|
* space, even if size is already aligned.
|
|
*/
|
|
- size_t total = size + align;
|
|
+ total = size + align;
|
|
+
|
|
#if defined(__powerpc64__) && defined(__linux__)
|
|
/* On ppc64 mappings in the same segment (aka slice) must share the same
|
|
* page size. Since we will be re-allocating part of this segment
|
|
@@ -93,16 +101,22 @@ void *qemu_ram_mmap(int fd,
|
|
* We do this unless we are using the system page size, in which case
|
|
* anonymous memory is OK.
|
|
*/
|
|
- int anonfd = fd == -1 || qemu_fd_getpagesize(fd) == getpagesize() ? -1 : fd;
|
|
- int flags = anonfd == -1 ? MAP_ANONYMOUS : MAP_NORESERVE;
|
|
- void *ptr = mmap(0, total, PROT_NONE, flags | MAP_PRIVATE, anonfd, 0);
|
|
+ flags = MAP_PRIVATE;
|
|
+ if (fd == -1 || qemu_fd_getpagesize(fd) == getpagesize()) {
|
|
+ guardfd = -1;
|
|
+ flags |= MAP_ANONYMOUS;
|
|
+ } else {
|
|
+ guardfd = fd;
|
|
+ flags |= MAP_NORESERVE;
|
|
+ }
|
|
#else
|
|
- void *ptr = mmap(0, total, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
|
|
+ guardfd = -1;
|
|
+ flags = MAP_PRIVATE | MAP_ANONYMOUS;
|
|
#endif
|
|
- size_t offset;
|
|
- void *ptr1;
|
|
|
|
- if (ptr == MAP_FAILED) {
|
|
+ guardptr = mmap(0, total, PROT_NONE, flags, guardfd, 0);
|
|
+
|
|
+ if (guardptr == MAP_FAILED) {
|
|
return MAP_FAILED;
|
|
}
|
|
|
|
@@ -110,19 +124,20 @@ void *qemu_ram_mmap(int fd,
|
|
/* Always align to host page size */
|
|
assert(align >= getpagesize());
|
|
|
|
- offset = QEMU_ALIGN_UP((uintptr_t)ptr, align) - (uintptr_t)ptr;
|
|
- ptr1 = mmap(ptr + offset, size, PROT_READ | PROT_WRITE,
|
|
- MAP_FIXED |
|
|
- (fd == -1 ? MAP_ANONYMOUS : 0) |
|
|
- (shared ? MAP_SHARED : MAP_PRIVATE),
|
|
- fd, 0);
|
|
- if (ptr1 == MAP_FAILED) {
|
|
- munmap(ptr, total);
|
|
+ flags = MAP_FIXED;
|
|
+ flags |= fd == -1 ? MAP_ANONYMOUS : 0;
|
|
+ flags |= shared ? MAP_SHARED : MAP_PRIVATE;
|
|
+ offset = QEMU_ALIGN_UP((uintptr_t)guardptr, align) - (uintptr_t)guardptr;
|
|
+
|
|
+ ptr = mmap(guardptr + offset, size, PROT_READ | PROT_WRITE, flags, fd, 0);
|
|
+
|
|
+ if (ptr == MAP_FAILED) {
|
|
+ munmap(guardptr, total);
|
|
return MAP_FAILED;
|
|
}
|
|
|
|
if (offset > 0) {
|
|
- munmap(ptr, offset);
|
|
+ munmap(guardptr, offset);
|
|
}
|
|
|
|
/*
|
|
@@ -131,10 +146,10 @@ void *qemu_ram_mmap(int fd,
|
|
*/
|
|
total -= offset;
|
|
if (total > size + getpagesize()) {
|
|
- munmap(ptr1 + size + getpagesize(), total - size - getpagesize());
|
|
+ munmap(ptr + size + getpagesize(), total - size - getpagesize());
|
|
}
|
|
|
|
- return ptr1;
|
|
+ return ptr;
|
|
}
|
|
|
|
void qemu_ram_munmap(void *ptr, size_t size)
|
|
--
|
|
1.8.3.1
|
|
|