Add is_fsdax to file provider's parameters

`is_fsdax` should be set to true if the file is located on FSDAX.
It is needed, because FSDAX requires 2 MB page size.

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

Author: ldorau

examples/dram_and_fsdax/dram_and_fsdax.c

@@ -51,6 +51,7 @@ static umf_memory_pool_handle_t create_fsdax_pool(const char *path) {
     umf_file_memory_provider_params_t params_fsdax =
         umfFileMemoryProviderParamsDefault(path);
     // FSDAX requires mapping the UMF_MEM_MAP_SYNC flag
+    params_fsdax.is_fsdax = true;
     params_fsdax.visibility = UMF_MEM_MAP_SYNC;
 
     umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(),

include/umf/providers/provider_file_memory.h

@@ -8,6 +8,8 @@
 #ifndef UMF_FILE_MEMORY_PROVIDER_H
 #define UMF_FILE_MEMORY_PROVIDER_H
 
+#include <stdbool.h>
+
 #include <umf/providers/provider_os_memory.h>
 
 #ifdef __cplusplus
@@ -22,6 +24,8 @@ extern "C" {
 typedef struct umf_file_memory_provider_params_t {
     /// a path to the file (of maximum length PATH_MAX characters)
     const char *path;
+    /// true if the file is located on FSDAX
+    bool is_fsdax;
     /// combination of 'umf_mem_protection_flags_t' flags
     unsigned protection;
     /// memory visibility mode
@@ -43,6 +47,7 @@ static inline umf_file_memory_provider_params_t
 umfFileMemoryProviderParamsDefault(const char *path) {
     umf_file_memory_provider_params_t params = {
         path,                                       /* a path to the file */
+        false,                                      /* is FSDAX */
         UMF_PROTECTION_READ | UMF_PROTECTION_WRITE, /* protection */
         UMF_MEM_MAP_PRIVATE,                        /* visibility mode */
     };

src/provider/provider_file_memory.c

@@ -33,12 +33,15 @@ umf_memory_provider_ops_t *umfFileMemoryProviderOps(void) {
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
+#define FSDAX_PAGE_SIZE_2MB ((size_t)(2 * 1024 * 1024)) // == 2 MB
+
 #define TLS_MSG_BUF_LEN 1024
 
 typedef struct file_memory_provider_t {
     utils_mutex_t lock; // lock for file parameters (size and offsets)
 
     char path[PATH_MAX]; // a path to the file
+    bool is_fsdax;       // true if the file is located on FSDAX
     int fd;              // file descriptor for memory mapping
     size_t size_fd;      // size of the file used for memory mappings
     size_t offset_fd;    // offset in the file used for memory mappings
@@ -131,7 +134,11 @@ static umf_result_t file_initialize(void *params, void **provider) {
     umf_file_memory_provider_params_t *in_params =
         (umf_file_memory_provider_params_t *)params;
 
-    size_t page_size = utils_get_page_size();
+    if (in_params->is_fsdax && in_params->visibility != UMF_MEM_MAP_SYNC) {
+        LOG_ERR("memory visibility has to be set to UMF_MEM_MAP_SYNC in case "
+                "of FSDAX");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
     if (in_params->path == NULL) {
         LOG_ERR("file path is missing");
@@ -146,7 +153,12 @@ static umf_result_t file_initialize(void *params, void **provider) {
 
     memset(file_provider, 0, sizeof(*file_provider));
 
-    file_provider->page_size = page_size;
+    file_provider->is_fsdax = in_params->is_fsdax;
+    if (file_provider->is_fsdax) {
+        file_provider->page_size = FSDAX_PAGE_SIZE_2MB;
+    } else {
+        file_provider->page_size = utils_get_page_size();
+    }
 
     ret = file_translate_params(in_params, file_provider);
     if (ret != UMF_RESULT_SUCCESS) {
@@ -164,13 +176,13 @@ static umf_result_t file_initialize(void *params, void **provider) {
         goto err_free_file_provider;
     }
 
-    if (utils_set_file_size(file_provider->fd, page_size)) {
+    if (utils_set_file_size(file_provider->fd, file_provider->page_size)) {
         LOG_ERR("cannot set size of the file: %s", in_params->path);
         ret = UMF_RESULT_ERROR_UNKNOWN;
         goto err_close_fd;
     }
 
-    file_provider->size_fd = page_size;
+    file_provider->size_fd = file_provider->page_size;
 
     LOG_DEBUG("size of the file %s is: %zu", in_params->path,
               file_provider->size_fd);
@@ -481,7 +493,8 @@ static umf_result_t file_get_recommended_page_size(void *provider, size_t size,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    *page_size = utils_get_page_size();
+    file_memory_provider_t *file_provider = (file_memory_provider_t *)provider;
+    *page_size = file_provider->page_size;
 
     return UMF_RESULT_SUCCESS;
 }

test/ipc_file_prov_consumer.c

@@ -38,8 +38,10 @@ int main(int argc, char *argv[]) {
 
     file_params = umfFileMemoryProviderParamsDefault(file_name);
     if (is_fsdax) {
+        file_params.is_fsdax = true;
         file_params.visibility = UMF_MEM_MAP_SYNC;
     } else {
+        file_params.is_fsdax = false;
         file_params.visibility = UMF_MEM_MAP_SHARED;
     }
 

test/ipc_file_prov_producer.c

@@ -38,8 +38,10 @@ int main(int argc, char *argv[]) {
 
     file_params = umfFileMemoryProviderParamsDefault(file_name);
     if (is_fsdax) {
+        file_params.is_fsdax = true;
         file_params.visibility = UMF_MEM_MAP_SYNC;
     } else {
+        file_params.is_fsdax = false;
         file_params.visibility = UMF_MEM_MAP_SHARED;
     }
 

test/provider_file_memory.cpp

@@ -137,6 +137,7 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     }
 
     auto params = umfFileMemoryProviderParamsDefault(path);
+    params.is_fsdax = true;
     params.visibility = UMF_MEM_MAP_SYNC;
 
     umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(), &params,
@@ -161,6 +162,21 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     ASSERT_EQ(flag_found, true);
 }
 
+// Negative test checking if FSDAX is to be mapped with the MAP_SYNC flag
+TEST_F(test, test_if_fsdax_visibility_is_MAP_SYNC) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    umf_result_t umf_result;
+
+    auto params = umfFileMemoryProviderParamsDefault(FILE_PATH);
+    params.is_fsdax = true;
+    params.visibility = UMF_MEM_MAP_SHARED;
+
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(), &params,
+                                         &hProvider);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ASSERT_EQ(hProvider, nullptr);
+}
+
 // positive tests using test_alloc_free_success
 
 umf_file_memory_provider_params_t file_params_default =