Make utils_mmap_file() detect DAX using MAP_SYNC flag

ldorau · ldorau · commit cace4ecca54a · 2024-11-13T12:40:56.000+01:00
Make utils_mmap_file() detect DAX using MAP_SYNC flag.
Add bool *map_sync argument to utils_mmap_file().
map_sync is set to true only if memory was mapped with MAP_SYNC,
what means it is a DAX file/device.

Signed-off-by: Lukasz Dorau &lt;lukasz.dorau@intel.com&gt;
diff --git a/src/provider/provider_devdax_memory.c b/src/provider/provider_devdax_memory.c
@@ -143,9 +143,9 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
     utils_translate_mem_visibility_flag(UMF_MEM_MAP_SYNC, &map_sync_flag);
 
     // mmap /dev/dax with the MAP_SYNC xor MAP_SHARED flag (if MAP_SYNC fails)
-    devdax_provider->base = utils_mmap_file(NULL, devdax_provider->size,
-                                            devdax_provider->protection,
-                                            map_sync_flag, fd, 0 /* offset */);
+    devdax_provider->base = utils_mmap_file(
+        NULL, devdax_provider->size, devdax_provider->protection, map_sync_flag,
+        fd, 0 /* offset */, NULL);
     utils_close_fd(fd);
     if (devdax_provider->base == NULL) {
         LOG_PDEBUG("devdax memory mapping failed (path=%s, size=%zu)",
@@ -455,7 +455,7 @@ static umf_result_t devdax_open_ipc_handle(void *provider,
     // mmap /dev/dax with the MAP_SYNC xor MAP_SHARED flag (if MAP_SYNC fails)
     char *addr =
         utils_mmap_file(NULL, length_aligned, devdax_ipc_data->protection,
-                        map_sync_flag, fd, offset_aligned);
+                        map_sync_flag, fd, offset_aligned, NULL);
     if (addr == NULL) {
         devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED,
                                        errno);
diff --git a/src/provider/provider_file_memory.c b/src/provider/provider_file_memory.c
@@ -293,8 +293,8 @@ static umf_result_t file_mmap_aligned(file_memory_provider_t *file_provider,
     ASSERT_IS_ALIGNED(extended_size, page_size);
     ASSERT_IS_ALIGNED(aligned_offset_fd, page_size);
 
-    void *ptr =
-        utils_mmap_file(NULL, extended_size, prot, flag, fd, aligned_offset_fd);
+    void *ptr = utils_mmap_file(NULL, extended_size, prot, flag, fd,
+                                aligned_offset_fd, NULL);
     if (ptr == NULL) {
         LOG_PERR("memory mapping failed");
         return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
@@ -683,7 +683,7 @@ static umf_result_t file_open_ipc_handle(void *provider, void *providerIpcData,
 
     char *addr = utils_mmap_file(
         NULL, file_ipc_data->size, file_ipc_data->protection,
-        file_ipc_data->visibility, fd, file_ipc_data->offset_fd);
+        file_ipc_data->visibility, fd, file_ipc_data->offset_fd, NULL);
     (void)utils_close_fd(fd);
     if (addr == NULL) {
         file_store_last_native_error(UMF_FILE_RESULT_ERROR_ALLOC_FAILED, errno);
diff --git a/src/utils/utils_common.h b/src/utils/utils_common.h
@@ -11,6 +11,7 @@
 #define UMF_COMMON_H 1
 
 #include <assert.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -136,7 +137,7 @@ void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
                  size_t fd_offset);
 
 void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
-                      int fd, size_t fd_offset);
+                      int fd, size_t fd_offset, bool *map_sync);
 
 int utils_munmap(void *addr, size_t length);
 
diff --git a/src/utils/utils_linux_common.c b/src/utils/utils_linux_common.c
@@ -9,6 +9,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <stdbool.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ -40,69 +41,72 @@ utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
 
 /*
  * Map given file into memory.
- * If (flags & MAP_PRIVATE) it uses just mmap. Otherwise, if (flags & MAP_SYNC)
- * it tries to mmap with (flags | MAP_SHARED_VALIDATE | MAP_SYNC)
- * which allows flushing from the user-space. If MAP_SYNC fails and the user
- * did not specify it by himself it tries to mmap with (flags | MAP_SHARED).
+ * If (flags & MAP_PRIVATE) it uses just mmap. Otherwise, it tries to mmap
+ * with (flags | MAP_SHARED_VALIDATE | MAP_SYNC) which allows flushing
+ * from the user-space. If MAP_SYNC fails and if the user did not specify
+ * this flag by himself, it falls back to the mmap with (flags | MAP_SHARED).
  */
 void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
-                      int fd, size_t fd_offset) {
+                      int fd, size_t fd_offset, bool *map_sync) {
     void *addr;
 
+    if (map_sync) {
+        *map_sync = false;
+    }
+
     /*
      * MAP_PRIVATE and MAP_SHARED are mutually exclusive,
      * therefore mmap with MAP_PRIVATE is executed separately.
      */
     if (flags & MAP_PRIVATE) {
         addr = utils_mmap(hint_addr, length, prot, flags, fd, fd_offset);
-        if (addr == MAP_FAILED) {
+        if (addr == NULL) {
             LOG_PERR("mapping file with the MAP_PRIVATE flag failed (fd=%i, "
-                     "offset=%zu, length=%zu)",
-                     fd, fd_offset, length);
+                     "offset=%zu, length=%zu, flags=%i)",
+                     fd, fd_offset, length, flags);
             return NULL;
         }
 
         LOG_DEBUG("file mapped with the MAP_PRIVATE flag (fd=%i, offset=%zu, "
-                  "length=%zu)",
-                  fd, fd_offset, length);
+                  "length=%zu, flags=%i)",
+                  fd, fd_offset, length, flags);
 
         return addr;
     }
 
     errno = 0;
 
-    if (flags & MAP_SYNC) {
-        /* try to mmap with MAP_SYNC flag */
-        const int sync_flags = MAP_SHARED_VALIDATE | MAP_SYNC;
-        addr = utils_mmap(hint_addr, length, prot, flags | sync_flags, fd,
-                          fd_offset);
-        if (addr) {
-            LOG_DEBUG("file mapped with the MAP_SYNC flag (fd=%i, offset=%zu, "
-                      "length=%zu)",
-                      fd, fd_offset, length);
-            return addr;
+    /* try to mmap with MAP_SYNC flag */
+    const int sync_flags = flags | MAP_SHARED_VALIDATE | MAP_SYNC;
+    addr = utils_mmap(hint_addr, length, prot, sync_flags, fd, fd_offset);
+    if (addr) {
+        LOG_DEBUG("file mapped with the MAP_SYNC flag (fd=%i, offset=%zu, "
+                  "length=%zu, flags=%i)",
+                  fd, fd_offset, length, sync_flags);
+        if (map_sync) {
+            *map_sync = true;
         }
-
-        LOG_PERR("mapping file with the MAP_SYNC flag failed (fd=%i, "
-                 "offset=%zu, length=%zu)",
-                 fd, fd_offset, length);
+        return addr;
     }
 
-    if ((!(flags & MAP_SYNC)) || errno == EINVAL || errno == ENOTSUP ||
-        errno == EOPNOTSUPP) {
-        /* try to mmap with MAP_SHARED flag (without MAP_SYNC) */
+    LOG_PERR("mapping file with the MAP_SYNC flag failed (fd=%i, offset=%zu, "
+             "length=%zu, flags=%i)",
+             fd, fd_offset, length, sync_flags);
+
+    /* try to mmap with MAP_SHARED flag (without MAP_SYNC) */
+    if (errno == EINVAL || errno == ENOTSUP || errno == EOPNOTSUPP) {
         const int shared_flags = (flags & (~MAP_SYNC)) | MAP_SHARED;
         addr = utils_mmap(hint_addr, length, prot, shared_flags, fd, fd_offset);
         if (addr) {
             LOG_DEBUG("file mapped with the MAP_SHARED flag (fd=%i, "
-                      "offset=%zu, length=%zu)",
-                      fd, fd_offset, length);
+                      "offset=%zu, length=%zu, flags=%i)",
+                      fd, fd_offset, length, shared_flags);
             return addr;
         }
 
         LOG_PERR("mapping file with the MAP_SHARED flag failed (fd=%i, "
-                 "offset=%zu, length=%zu)",
-                 fd, fd_offset, length);
+                 "offset=%zu, length=%zu, flags=%i)",
+                 fd, fd_offset, length, shared_flags);
     }
 
     return NULL;
diff --git a/src/utils/utils_macosx_common.c b/src/utils/utils_macosx_common.c
@@ -12,6 +12,7 @@
 #include <umf/base.h>
 #include <umf/memory_provider.h>
 
+#include "utils_common.h"
 #include "utils_log.h"
 
 umf_result_t
@@ -30,13 +31,14 @@ utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
 }
 
 void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
-                      int fd, size_t fd_offset) {
+                      int fd, size_t fd_offset, bool *map_sync) {
     (void)hint_addr; // unused
     (void)length;    // unused
     (void)prot;      // unused
     (void)flags;     // unused
     (void)fd;        // unused
     (void)fd_offset; // unused
+    (void)map_sync;  // unused
     return NULL;     // not supported
 }
 
diff --git a/src/utils/utils_windows_common.c b/src/utils/utils_windows_common.c
@@ -148,13 +148,14 @@ void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
 }
 
 void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
-                      int fd, size_t fd_offset) {
+                      int fd, size_t fd_offset, bool *map_sync) {
     (void)hint_addr; // unused
     (void)length;    // unused
     (void)prot;      // unused
     (void)flags;     // unused
     (void)fd;        // unused
     (void)fd_offset; // unused
+    (void)map_sync;  // unused
     return NULL;     // not supported
 }
 

Original file line number	Diff line number	Diff line change
`@@ -148,13 +148,14 @@ void utils_mmap(void hint_addr, size_t length, int prot, int flag, int fd,`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`void utils_mmap_file(void hint_addr, size_t length, int prot, int flags,`
`151`		`- int fd, size_t fd_offset) {`
	`151`	`+ int fd, size_t fd_offset, bool *map_sync) {`
`152`	`152`	`(void)hint_addr; // unused`
`153`	`153`	`(void)length; // unused`
`154`	`154`	`(void)prot; // unused`
`155`	`155`	`(void)flags; // unused`
`156`	`156`	`(void)fd; // unused`
`157`	`157`	`(void)fd_offset; // unused`
	`158`	`+ (void)map_sync; // unused`
`158`	`159`	`return NULL; // not supported`
`159`	`160`	`}`
`160`	`161`