Add test if FSDAX is mapped with the MAP_SYNC flag

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

Author: ldorau

.github/workflows/dax.yml

@@ -22,6 +22,8 @@ permissions:
 
 env:
   UMF_TESTS_DEVDAX_NAMESPACE : "0.0"
+  UMF_TESTS_FSDAX_NAMESPACE : "1.0"
+  UMF_TESTS_FSDAX_PATH: "/mnt/pmem1/file"
   BUILD_DIR : "${{github.workspace}}/build"
   INSTL_DIR : "${{github.workspace}}/../install-dir"
 
@@ -39,11 +41,21 @@ jobs:
     steps:
       - name: Check if the devdax exists, print out UMF_TESTS_DEVDAX_PATH and UMF_TESTS_DEVDAX_SIZE
         run: |
-          ndctl list -N --device-dax
+          echo UMF_TESTS_DEVDAX_NAMESPACE="${UMF_TESTS_DEVDAX_NAMESPACE}"
+          ndctl list --namespace=namespace${UMF_TESTS_DEVDAX_NAMESPACE} --device-dax
           ls -al /dev/dax${UMF_TESTS_DEVDAX_NAMESPACE}
           echo UMF_TESTS_DEVDAX_PATH="/dev/dax${UMF_TESTS_DEVDAX_NAMESPACE}"
           echo UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${UMF_TESTS_DEVDAX_NAMESPACE} | grep size | cut -d':' -f2 | cut -d',' -f1)"
 
+      - name: Check if the FSDAX exists
+        run: |
+          echo UMF_TESTS_FSDAX_NAMESPACE="${UMF_TESTS_FSDAX_NAMESPACE}"
+          echo UMF_TESTS_FSDAX_PATH="${UMF_TESTS_FSDAX_PATH}"
+          ndctl list --namespace=namespace${UMF_TESTS_FSDAX_NAMESPACE}
+          ls -al /dev/$(echo $UMF_TESTS_FSDAX_PATH | cut -d'/' -f3)
+          ls -al /mnt/$(echo $UMF_TESTS_FSDAX_PATH | cut -d'/' -f3)
+          mount | grep -e "/dev/$(echo $UMF_TESTS_FSDAX_PATH | cut -d'/' -f3)"
+
       - name: Checkout
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
@@ -78,3 +90,7 @@ jobs:
           UMF_TESTS_DEVDAX_PATH="/dev/dax${UMF_TESTS_DEVDAX_NAMESPACE}"
           UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${UMF_TESTS_DEVDAX_NAMESPACE} | grep size | cut -d':' -f2 | cut -d',' -f1)"
           ctest -C ${{matrix.build_type}} -R devdax -V
+
+      - name: Run only tests of the file memory provider with FSDAX
+        working-directory: ${{env.BUILD_DIR}}
+        run: ctest -C ${{matrix.build_type}} -R umf-provider_file_memory -V

test/common/test_helpers.c

@@ -4,9 +4,16 @@
 // This file contains tests for UMF pool API
 
 #include <assert.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
 
 #include "pool_null.h"
 #include "pool_trace.h"
@@ -76,3 +83,53 @@ tracePoolCreate(umf_memory_pool_handle_t hUpstreamPool,
     assert(ret == UMF_RESULT_SUCCESS);
     return hPool;
 }
+
+bool is_mapped_with_MAP_SYNC(char *path, char *buf, size_t size_buf) {
+    memset(buf, 0, size_buf);
+
+    int fd = open("/proc/self/smaps", O_RDONLY);
+    if (fd == -1) {
+        return false;
+    }
+
+    // number of bytes read from the file
+    ssize_t nbytes = 1;
+    // string starting from the path of the smaps
+    char *smaps = NULL;
+
+    // Read the "/proc/self/smaps" file
+    // until the path of the smaps is found
+    // or EOF is reached.
+    while (nbytes > 0 && smaps == NULL) {
+        memset(buf, 0, nbytes); // erase previous data
+        nbytes = read(fd, buf, size_buf);
+        // look for the path of the smaps
+        smaps = strstr(buf, path);
+    }
+
+    // String starting from the "sf" flag
+    // marking that memory was mapped with the MAP_SYNC flag.
+    char *sf_flag = NULL;
+
+    if (smaps) {
+        // look for the "VmFlags:" string
+        char *VmFlags = strstr(smaps, "VmFlags:");
+        if (VmFlags) {
+            // look for the EOL
+            char *eol = strstr(VmFlags, "\n");
+            if (eol) {
+                // End the VmFlags string at EOL.
+                *eol = 0;
+                // Now the VmFlags string contains only one line with all VmFlags.
+
+                // Look for the "sf" flag in VmFlags
+                // marking that memory was mapped
+                // with the MAP_SYNC flag.
+                sf_flag = strstr(VmFlags, "sf");
+            }
+        }
+    }
+
+    // fail if the "sf" flag was not found
+    return (sf_flag != NULL);
+}

test/common/test_helpers.h

@@ -97,6 +97,8 @@ tracePoolCreate(umf_memory_pool_handle_t hUpstreamPool,
                 umf_memory_provider_handle_t providerDesc, void *trace_context,
                 trace_handler_t trace_handler);
 
+bool is_mapped_with_MAP_SYNC(char *path, char *buf, size_t size_buf);
+
 #ifdef __cplusplus
 }
 #endif

test/provider_devdax_memory.cpp

@@ -11,6 +11,7 @@
 #include "base.hpp"
 
 #include "cpp_helpers.hpp"
+#include "test_helpers.h"
 
 #include <umf/memory_provider.h>
 #include <umf/providers/provider_devdax_memory.h>
@@ -167,56 +168,16 @@ TEST_F(test, test_if_mapped_with_MAP_SYNC) {
     umf_result = umfMemoryProviderAlloc(hProvider, size, 0, (void **)&buf);
     ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
     ASSERT_NE(buf, nullptr);
-    memset(buf, 0, size);
-
-    int fd = open("/proc/self/smaps", O_RDONLY);
-    ASSERT_NE(fd, -1);
-
-    // number of bytes read from the file
-    ssize_t nbytes = 1;
-    // string starting from the path of the devdax
-    char *devdax = nullptr;
-
-    // Read the "/proc/self/smaps" file
-    // until the path of the devdax is found
-    // or EOF is reached.
-    while (nbytes > 0 && devdax == nullptr) {
-        memset(buf, 0, nbytes); // erase previous data
-        nbytes = read(fd, buf, size);
-        // look for the path of the devdax
-        devdax = strstr(buf, path);
-    }
 
-    // String starting from the "sf" flag
-    // marking that memory was mapped with the MAP_SYNC flag.
-    char *sf_flag = nullptr;
-
-    if (devdax) {
-        // look for the "VmFlags:" string
-        char *VmFlags = strstr(devdax, "VmFlags:");
-        if (VmFlags) {
-            // look for the EOL
-            char *eol = strstr(VmFlags, "\n");
-            if (eol) {
-                // End the VmFlags string at EOL.
-                *eol = 0;
-                // Now the VmFlags string contains only one line with all VmFlags.
-
-                // Look for the "sf" flag in VmFlags
-                // marking that memory was mapped
-                // with the MAP_SYNC flag.
-                sf_flag = strstr(VmFlags, "sf");
-            }
-        }
-    }
+    bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
 
     umf_result = umfMemoryProviderFree(hProvider, buf, size);
     ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
 
     umfMemoryProviderDestroy(hProvider);
 
     // fail test if the "sf" flag was not found
-    ASSERT_NE(sf_flag, nullptr);
+    ASSERT_EQ(flag_found, true);
 }
 
 // positive tests using test_alloc_free_success

test/provider_file_memory.cpp

@@ -121,6 +121,45 @@ static void test_alloc_failure(umf_memory_provider_handle_t provider,
 
 // TESTS
 
+// Test checking if FSDAX was mapped with the MAP_SYNC flag:
+// 1) Open and read the /proc/self/smaps file.
+// 2) Look for the section of the FSDAX file (for example /mnt/pmem1/file path).
+// 3) Check if the VmFlags of the /mnt/pmem1/file contains the "sf" flag
+//    marking that the FSDAX file was mapped with the MAP_SYNC flag.
+TEST_F(test, test_if_mapped_with_MAP_SYNC) {
+    umf_memory_provider_handle_t hProvider = nullptr;
+    umf_result_t umf_result;
+
+    char *path = getenv("UMF_TESTS_FSDAX_PATH");
+    if (path == nullptr || path[0] == 0) {
+        GTEST_SKIP() << "Test skipped, UMF_TESTS_FSDAX_PATH is not set";
+    }
+
+    auto params = umfFileMemoryProviderParamsDefault(path);
+    params.visibility = UMF_MEM_MAP_SYNC;
+
+    umf_result = umfMemoryProviderCreate(umfFileMemoryProviderOps(), &params,
+                                         &hProvider);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(hProvider, nullptr);
+
+    char *buf;
+    size_t size = 2 * 1024 * 1024; // 2MB
+    umf_result = umfMemoryProviderAlloc(hProvider, size, 0, (void **)&buf);
+    ASSERT_EQ(umf_result, UMF_RESULT_SUCCESS);
+    ASSERT_NE(buf, nullptr);
+
+    bool flag_found = is_mapped_with_MAP_SYNC(path, buf, size);
+
+    umf_result = umfMemoryProviderFree(hProvider, buf, size);
+    ASSERT_EQ(umf_result, UMF_RESULT_ERROR_NOT_SUPPORTED);
+
+    umfMemoryProviderDestroy(hProvider);
+
+    // fail test if the "sf" flag was not found
+    ASSERT_EQ(flag_found, true);
+}
+
 // positive tests using test_alloc_free_success
 
 umf_file_memory_provider_params_t get_file_params_shared(char *path) {