Add test if FSDAX is mapped with the MAP_SYNC flag

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

Author: ldorau

.github/workflows/dax.yml

@@ -23,6 +23,9 @@ permissions:
 
 env:
   DEVDAX_NAMESPACE : "0.0"
+  FSDAX_NAMESPACE : "1.0"
+  FSDAX_PMEM: "pmem1"
+  UMF_TESTS_FSDAX_PATH: "/mnt/pmem1/file"
   BUILD_DIR : "${{github.workspace}}/build"
   INSTL_DIR : "${{github.workspace}}/../install-dir"
 
@@ -46,6 +49,16 @@ jobs:
           echo UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}"
           echo UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)"
 
+      - name: Check configuration of the FSDAX
+        run: |
+          echo FSDAX_NAMESPACE="${{env.FSDAX_NAMESPACE}}"
+          echo UMF_TESTS_FSDAX_PATH="${{env.UMF_TESTS_FSDAX_PATH}}"
+          ndctl list --namespace=namespace${{env.FSDAX_NAMESPACE}}
+          ls -al /dev/${{env.FSDAX_PMEM}} /mnt/${{env.FSDAX_PMEM}}
+          mount | grep -e "/dev/${{env.FSDAX_PMEM}}"
+          touch ${{env.UMF_TESTS_FSDAX_PATH}}
+          rm -f ${{env.UMF_TESTS_FSDAX_PATH}}
+
       - name: Checkout
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
@@ -80,3 +93,9 @@ jobs:
           UMF_TESTS_DEVDAX_PATH="/dev/dax${{env.DEVDAX_NAMESPACE}}"
           UMF_TESTS_DEVDAX_SIZE="$(ndctl list --namespace=namespace${{env.DEVDAX_NAMESPACE}} | grep size | cut -d':' -f2 | cut -d',' -f1)"
           ctest -C ${{matrix.build_type}} -R devdax -V
+
+      - name: Run the FSDAX tests
+        working-directory: ${{env.BUILD_DIR}}
+        run: >
+          UMF_TESTS_FSDAX_PATH=${{env.UMF_TESTS_FSDAX_PATH}}
+          ctest -C ${{matrix.build_type}} -R umf-provider_file_memory -V

test/common/CMakeLists.txt

@@ -9,6 +9,10 @@ set(COMMON_SOURCES
     provider_null.c
     provider_trace.c)
 
+if(LINUX)
+    set(COMMON_SOURCES ${COMMON_SOURCES} test_helpers_linux.c)
+endif(LINUX)
+
 add_umf_library(
     NAME umf_test_common
     TYPE STATIC

test/common/test_helpers_linux.c

@@ -0,0 +1,67 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// This file contains tests for UMF pool API
+
+#include <fcntl.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "test_helpers_linux.h"
+
+// Check if the file given by the 'path' argument was mapped with the MAP_SYNC flag:
+// 1) Open and read the /proc/self/smaps file.
+// 2) Look for the section of the 'path' file.
+// 3) Check if the VmFlags of the 'path' file contains the "sf" flag
+//    marking that the file was mapped with the MAP_SYNC flag.
+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");
+            }
+        }
+    }
+
+    return (sf_flag != NULL);
+}

test/common/test_helpers_linux.h

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Intel Corporation
+// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// This file contains helpers for tests for UMF pool API
+
+#ifndef UMF_TEST_HELPERS_LINUX_H
+#define UMF_TEST_HELPERS_LINUX_H 1
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool is_mapped_with_MAP_SYNC(char *path, char *buf, size_t size_buf);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_TEST_HELPERS_LINUX_H */

test/provider_devdax_memory.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #ifndef _WIN32
+#include "test_helpers_linux.h"
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -11,6 +12,7 @@
 #include "base.hpp"
 
 #include "cpp_helpers.hpp"
+#include "test_helpers.h"
 
 #include <umf/memory_provider.h>
 #include <umf/providers/provider_devdax_memory.h>
@@ -137,10 +139,6 @@ static void test_alloc_failure(umf_memory_provider_handle_t provider,
 // TESTS
 
 // Test checking if devdax was mapped with the MAP_SYNC flag:
-// 1) Open and read the /proc/self/smaps file.
-// 2) Look for the section of the devdax (the /dev/daxX.Y path).
-// 3) Check if the VmFlags of the /dev/daxX.Y contains the "sf" flag
-//    marking that the devdax 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;
@@ -167,56 +165,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

@@ -6,6 +6,9 @@
 
 #include "cpp_helpers.hpp"
 #include "test_helpers.h"
+#ifndef _WIN32
+#include "test_helpers_linux.h"
+#endif
 
 #include <umf/memory_provider.h>
 #include <umf/providers/provider_file_memory.h>
@@ -121,6 +124,41 @@ static void test_alloc_failure(umf_memory_provider_handle_t provider,
 
 // TESTS
 
+// Test checking if FSDAX 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) {