From 4438710f7aa42f55d189d1b6adb09b1c0471495e Mon Sep 17 00:00:00 2001

From: "plai@redhat.com" <plai@redhat.com>

Date: Tue, 20 Aug 2019 16:12:51 +0100

Subject: [PATCH 04/11] util/mmap-alloc: support MAP_SYNC in qemu_ram_mmap()

RH-Author: plai@redhat.com

Message-id: <1566317571-5697-5-git-send-email-plai@redhat.com>

Patchwork-id: 90085

O-Subject: [RHEL8.2 qemu-kvm PATCH 4/4] util/mmap-alloc: support MAP_SYNC in qemu_ram_mmap()

Bugzilla: 1539282

RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

RH-Acked-by: Pankaj Gupta <pagupta@redhat.com>

RH-Acked-by: Eduardo Habkost <ehabkost@redhat.com>

From: Zhang Yi <yi.z.zhang@linux.intel.com>

When a file supporting DAX is used as vNVDIMM backend, mmap it with

MAP_SYNC flag in addition which can ensure file system metadata

synced in each guest writes to the backend file, without other QEMU

actions (e.g., periodic fsync() by QEMU).

Current, We have below different possible use cases:

1. pmem=on is set, shared=on is set, MAP_SYNC supported:

   a: backend is a dax supporting file.

    - MAP_SYNC will active.

   b: backend is not a dax supporting file.

    - mmap will trigger a warning. then MAP_SYNC flag will be ignored

2. The rest of cases:

   - we will never pass the MAP_SYNC to mmap2

Signed-off-by: Haozhong Zhang <haozhong.zhang@intel.com>

Signed-off-by: Zhang Yi <yi.z.zhang@linux.intel.com>

[ehabkost: Rebased patch to latest code on master]

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>

Signed-off-by: Wei Yang <richardw.yang@linux.intel.com>

Tested-by: Wei Yang <richardw.yang@linux.intel.com>

Message-Id: <20190422004849.26463-2-richardw.yang@linux.intel.com>

[ehabkost: squashed documentation patch]

Message-Id: <20190422004849.26463-3-richardw.yang@linux.intel.com>

[ehabkost: documentation fixup]

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>

Reviewed-by: Pankaj Gupta <pagupta@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>

(cherry picked from commit 119906afa5ca610adb87c55ab0d8e53c9104bfc3)

Signed-off-by: Paul Lai <plai@redhat.com>

Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>

---

 docs/nvdimm.txt   | 22 +++++++++++++++++++---

 qemu-options.hx   |  5 +++++

 util/mmap-alloc.c | 41 ++++++++++++++++++++++++++++++++++++++++-

 3 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/docs/nvdimm.txt b/docs/nvdimm.txt

index 5f158a6..33ce9aa 100644

--- a/docs/nvdimm.txt

+++ b/docs/nvdimm.txt

@@ -143,9 +143,25 @@ Guest Data Persistence

 ----------------------

 Though QEMU supports multiple types of vNVDIMM backends on Linux,

-currently the only one that can guarantee the guest write persistence

-is the device DAX on the real NVDIMM device (e.g., /dev/dax0.0), to

-which all guest access do not involve any host-side kernel cache.

+the only backend that can guarantee the guest write persistence is:

+

+A. DAX device (e.g., /dev/dax0.0, ) or

+B. DAX file(mounted with dax option)

+

+When using B (A file supporting direct mapping of persistent memory)

+as a backend, write persistence is guaranteed if the host kernel has

+support for the MAP_SYNC flag in the mmap system call (available

+since Linux 4.15 and on certain distro kernels) and additionally

+both 'pmem' and 'share' flags are set to 'on' on the backend.

+

+If these conditions are not satisfied i.e. if either 'pmem' or 'share'

+are not set, if the backend file does not support DAX or if MAP_SYNC

+is not supported by the host kernel, write persistence is not

+guaranteed after a system crash. For compatibility reasons, these

+conditions are ignored if not satisfied. Currently, no way is

+provided to test for them.

+For more details, please reference mmap(2) man page:

+http://man7.org/linux/man-pages/man2/mmap.2.html.

 When using other types of backends, it's suggested to set 'unarmed'

 option of '-device nvdimm' to 'on', which sets the unarmed flag of the

diff --git a/qemu-options.hx b/qemu-options.hx

index 1b6786b..1243057 100644

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -4057,6 +4057,11 @@ using the SNIA NVM programming model (e.g. Intel NVDIMM).

 If @option{pmem} is set to 'on', QEMU will take necessary operations to

 guarantee the persistence of its own writes to @option{mem-path}

 (e.g. in vNVDIMM label emulation and live migration).

+Also, we will map the backend-file with MAP_SYNC flag, which ensures the

+file metadata is in sync for @option{mem-path} in case of host crash

+or a power failure. MAP_SYNC requires support from both the host kernel

+(since Linux kernel 4.15) and the filesystem of @option{mem-path} mounted

+with DAX option.

 @item -object memory-backend-ram,id=@var{id},merge=@var{on|off},dump=@var{on|off},share=@var{on|off},prealloc=@var{on|off},size=@var{size},host-nodes=@var{host-nodes},policy=@var{default|preferred|bind|interleave}

diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c

index bbd9077..4873984 100644

--- a/util/mmap-alloc.c

+++ b/util/mmap-alloc.c

@@ -10,6 +10,13 @@

  * later.  See the COPYING file in the top-level directory.

  */

+#ifdef CONFIG_LINUX

+#include <linux/mman.h>

+#else  /* !CONFIG_LINUX */

+#define MAP_SYNC              0x0

+#define MAP_SHARED_VALIDATE   0x0

+#endif /* CONFIG_LINUX */

+

 #include "qemu/osdep.h"

 #include "qemu/mmap-alloc.h"

 #include "qemu/host-utils.h"

@@ -80,6 +87,7 @@ void *qemu_ram_mmap(int fd,

                     bool is_pmem)

 {

     int flags;

+    int map_sync_flags = 0;

     int guardfd;

     size_t offset;

     size_t pagesize;

@@ -130,9 +138,40 @@ void *qemu_ram_mmap(int fd,

     flags = MAP_FIXED;

     flags |= fd == -1 ? MAP_ANONYMOUS : 0;

     flags |= shared ? MAP_SHARED : MAP_PRIVATE;

+    if (shared && is_pmem) {

+        map_sync_flags = MAP_SYNC | MAP_SHARED_VALIDATE;

+    }

+

     offset = QEMU_ALIGN_UP((uintptr_t)guardptr, align) - (uintptr_t)guardptr;

-    ptr = mmap(guardptr + offset, size, PROT_READ | PROT_WRITE, flags, fd, 0);

+    ptr = mmap(guardptr + offset, size, PROT_READ | PROT_WRITE,

+               flags | map_sync_flags, fd, 0);

+

+    if (ptr == MAP_FAILED && map_sync_flags) {

+        if (errno == ENOTSUP) {

+            char *proc_link, *file_name;

+            int len;

+            proc_link = g_strdup_printf("/proc/self/fd/%d", fd);

+            file_name = g_malloc0(PATH_MAX);

+            len = readlink(proc_link, file_name, PATH_MAX - 1);

+            if (len < 0) {

+                len = 0;

+            }

+            file_name[len] = '\0';

+            fprintf(stderr, "Warning: requesting persistence across crashes "

+                    "for backend file %s failed. Proceeding without "

+                    "persistence, data might become corrupted in case of host "

+                    "crash.\n", file_name);

+            g_free(proc_link);

+            g_free(file_name);

+        }

+        /*

+         * if map failed with MAP_SHARED_VALIDATE | MAP_SYNC,

+         * we will remove these flags to handle compatibility.

+         */

+        ptr = mmap(guardptr + offset, size, PROT_READ | PROT_WRITE,

+                   flags, fd, 0);

+    }

     if (ptr == MAP_FAILED) {

         munmap(guardptr, total);

-- 

1.8.3.1