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/provider_file_memory.cpp

@@ -2,6 +2,10 @@
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
 #include "base.hpp"
 
 #include "cpp_helpers.hpp"
@@ -121,6 +125,85 @@ 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);
+    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 fsdax
+    char *fsdax = nullptr;
+
+    // Read the "/proc/self/smaps" file
+    // until the path of the fsdax is found
+    // or EOF is reached.
+    while (nbytes > 0 && fsdax == nullptr) {
+        memset(buf, 0, nbytes); // erase previous data
+        nbytes = read(fd, buf, size);
+        // look for the path of the fsdax
+        fsdax = strstr(buf, path);
+    }
+
+    // String starting from the "sf" flag
+    // marking that memory was mapped with the MAP_SYNC flag.
+    char *sf_flag = nullptr;
+
+    if (fsdax) {
+        // look for the "VmFlags:" string
+        char *VmFlags = strstr(fsdax, "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");
+            }
+        }
+    }
+
+    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);
+}
+
 // positive tests using test_alloc_free_success
 
 umf_file_memory_provider_params_t get_file_params_shared(char *path) {