Rename utils_devdax_mmap to utils_mmap_file and improve it

Rename utils_devdax_mmap to utils_mmap_file and improve it:
- add support for MAP_PRIVATE
- add flags and fd_offset arguments

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

src/provider/provider_devdax_memory.c

@@ -130,8 +130,13 @@ static umf_result_t devdax_initialize(void *params, void **provider) {
         goto err_free_devdax_provider;
     }
 
-    devdax_provider->base = utils_devdax_mmap(NULL, devdax_provider->size,
-                                              devdax_provider->protection, fd);
+    unsigned map_sync_flag = 0;
+    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 */);
     utils_close_fd(fd);
     if (devdax_provider->base == NULL) {
         LOG_PDEBUG("devdax memory mapping failed (path=%s, size=%zu)",
@@ -458,8 +463,13 @@ static umf_result_t devdax_open_ipc_handle(void *provider,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    char *base = utils_devdax_mmap(NULL, devdax_provider->size,
-                                   devdax_provider->protection, fd);
+    unsigned map_sync_flag = 0;
+    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)
+    char *base = utils_mmap_file(NULL, devdax_provider->size,
+                                 devdax_provider->protection, map_sync_flag, fd,
+                                 0 /* offset */);
     if (base == NULL) {
         devdax_store_last_native_error(UMF_DEVDAX_RESULT_ERROR_ALLOC_FAILED,
                                        errno);

src/utils/utils_common.h

@@ -124,7 +124,8 @@ int utils_set_file_size(int fd, size_t size);
 void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
                  size_t fd_offset);
 
-void *utils_devdax_mmap(void *hint_addr, size_t length, int prot, int fd);
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset);
 
 int utils_munmap(void *addr, size_t length);
 

src/utils/utils_linux_common.c

@@ -39,26 +39,57 @@ utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
 }
 
 /*
- * MMap a /dev/dax device.
- * First try to mmap with (MAP_SHARED_VALIDATE | MAP_SYNC) flags
- * which allows flushing from the user-space. If MAP_SYNC fails
- * try to mmap with MAP_SHARED flag (without MAP_SYNC).
+ * 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).
  */
-void *utils_devdax_mmap(void *hint_addr, size_t length, int prot, int fd) {
-    void *ptr = utils_mmap(hint_addr, length, prot,
-                           MAP_SHARED_VALIDATE | MAP_SYNC, fd, 0);
-    if (ptr) {
-        LOG_DEBUG(
-            "devdax mapped with the (MAP_SHARED_VALIDATE | MAP_SYNC) flags");
-        return ptr;
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset) {
+    void *addr;
+
+    /*
+     * 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) {
+            LOG_PERR("mapping file with the MAP_PRIVATE flag failed");
+            return NULL;
+        }
+
+        LOG_DEBUG("file mapped with the MAP_PRIVATE flag");
+        return addr;
     }
 
-    ptr = utils_mmap(hint_addr, length, prot, MAP_SHARED, fd, 0);
-    if (ptr) {
-        LOG_DEBUG("devdax mapped with the MAP_SHARED flag");
-        return ptr;
+    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");
+            return addr;
+        }
     }
 
+    if ((!(flags & MAP_SYNC)) || errno == EINVAL || errno == ENOTSUP ||
+        errno == EOPNOTSUPP) {
+        /* try to mmap with MAP_SHARED flag (without MAP_SYNC) */
+        addr = utils_mmap(hint_addr, length, prot, flags | MAP_SHARED, fd,
+                          fd_offset);
+        if (addr) {
+            LOG_DEBUG("file mapped with the MAP_SHARED flag");
+            return addr;
+        }
+    }
+
+    LOG_PERR("memory mapping failed");
+
     return NULL;
 }
 

src/utils/utils_macosx_common.c

@@ -29,11 +29,14 @@ utils_translate_mem_visibility_flag(umf_memory_visibility_t in_flag,
     return UMF_RESULT_ERROR_INVALID_ARGUMENT;
 }
 
-void *utils_devdax_mmap(void *hint_addr, size_t length, int prot, int fd) {
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset) {
     (void)hint_addr; // unused
     (void)length;    // unused
     (void)prot;      // unused
+    (void)flags;     // unused
     (void)fd;        // unused
+    (void)fd_offset; // unused
     return NULL;     // not supported
 }
 

src/utils/utils_windows_common.c

@@ -147,12 +147,15 @@ void *utils_mmap(void *hint_addr, size_t length, int prot, int flag, int fd,
     return VirtualAlloc(hint_addr, length, MEM_RESERVE | MEM_COMMIT, prot);
 }
 
-void *utils_devdax_mmap(void *hint_addr, size_t length, int prot, int fd) {
+void *utils_mmap_file(void *hint_addr, size_t length, int prot, int flags,
+                      int fd, size_t fd_offset) {
     (void)hint_addr; // unused
     (void)length;    // unused
     (void)prot;      // unused
+    (void)flags;     // unused
     (void)fd;        // unused
-    return NULL;     // not supported on Windows
+    (void)fd_offset; // unused
+    return NULL;     // not supported
 }
 
 int utils_munmap(void *addr, size_t length) {