fastpath: Restrict IO to ext4 (data=ordered) or xfs unless HIPFILE_UNSUPPORTED_FILE_SYSTEMS=true

CHANGELOG.md

@@ -14,6 +14,9 @@
 * `AIS_USE_SANITIZERS` now also enables the following sanitizers: integer, float-divide-by-zero, local-bounds, vptr, nullability (in addition to address, leak, and undefined). Sanitizers should also now emit usable stack trace info.
 * Added check in the Fastpath/AIS backend to ensure the HIP Runtime is initialized. This avoids causing a segfault in the HIP Runtime.
 * The default CMake build type was changed from `Debug` to `RelWithDebInfo`
+* Added `HIPFILE_UNSUPPORTED_FILE_SYSTEMS` environment variable to allow fastpath operations on unsupported file systems (defaults to false)
+* Added validation in Fastpath::score() to ensure the file is a regular file (not a directory, symlink, character device, etc.)
+* Added file system validation in Fastpath::score() to accept only ext4 file systems with ordered journaling mode and XFS file systems. Other file systems can be explicitly allowed via the `HIPFILE_UNSUPPORTED_FILE_SYSTEMS` environment variable.
 
 ### Removed
 * The rocFile library has been completely removed and the code is now a part of hipFile.

src/amd_detail/backend/fastpath.cpp

@@ -11,6 +11,7 @@
 #include "hip.h"
 #include "hipfile.h"
 #include "io.h"
+#include "mountinfo.h"
 #include "stats.h"
 
 #include <cstdint>
@@ -138,6 +139,17 @@ Fastpath::score(shared_ptr<IFile> file, shared_ptr<IBuffer> buffer, size_t size,
     accept_io &= 0 <= file_offset;
     accept_io &= 0 <= buffer_offset;
 
+    bool unsupported_file_systems{Context<Configuration>::get()->unsupportedFileSystems()};
+    bool ext4_ordered{false};
+    bool xfs{false};
+    auto mount_info{file->getMountInfo()};
+    if (mount_info.has_value()) {
+        ext4_ordered = mount_info->type == FilesystemType::ext4 &&
+                       mount_info->options.ext4.journaling_mode == ExtJournalingMode::ordered;
+        xfs = mount_info->type == FilesystemType::xfs;
+    }
+    accept_io &= unsupported_file_systems || ext4_ordered || xfs;
+
     uint64_t mem_align_mask{4096 - 1};
     uint64_t offset_align_mask{4096 - 1};
 

src/amd_detail/configuration.cpp

@@ -46,3 +46,10 @@ Configuration::statsLevel() const noexcept
     HIPFILE_STATIC unsigned int stats_level_env{Environment::stats_level().value_or(0)};
     return stats_level_env;
 }
+
+bool
+Configuration::unsupportedFileSystems() const noexcept
+{
+    HIPFILE_STATIC bool unsupported_file_systems_env{Environment::unsupported_file_systems().value_or(false)};
+    return unsupported_file_systems_env;
+}

src/amd_detail/configuration.h

@@ -37,6 +37,11 @@ class Configuration {
     /// @brief Shows the level of detail for stats collection
     /// @return 0 if stats collection disabled, higher levels of detail as value increases
     virtual unsigned int statsLevel() const noexcept;
+
+    /// @brief Checks if unsupported file systems are allowed in the fastpath backend
+    /// @return true if unsupported file systems are allowed, false if only supported file systems are
+    /// permitted (default)
+    virtual bool unsupportedFileSystems() const noexcept;
 };
 
 }

src/amd_detail/environment.cpp

@@ -64,6 +64,12 @@ Environment::force_compat_mode()
     return Environment::get<bool>(Environment::FORCE_COMPAT_MODE);
 }
 
+optional<bool>
+Environment::unsupported_file_systems()
+{
+    return Environment::get<bool>(Environment::UNSUPPORTED_FILE_SYSTEMS);
+}
+
 optional<unsigned int>
 Environment::stats_level()
 {

src/amd_detail/environment.h

@@ -47,6 +47,19 @@ class Environment {
     static constexpr const char *const STATS_LEVEL{"HIPFILE_STATS_LEVEL"};
 
     static std::optional<unsigned int> stats_level();
+
+    /// @brief Allow unsupported file systems in the fastpath backend
+    ///
+    /// If enabled, the fastpath backend will allow I/O on file systems other than
+    /// ext4 (with ordered journaling) and xfs. If disabled (default), only supported
+    /// file systems are permitted.
+    static constexpr const char *const UNSUPPORTED_FILE_SYSTEMS{"HIPFILE_UNSUPPORTED_FILE_SYSTEMS"};
+
+    /// @brief Get the value of HIPFILE_UNSUPPORTED_FILE_SYSTEMS from the environment
+    /// @return An optional boolean value if HIPFILE_UNSUPPORTED_FILE_SYSTEMS was set,
+    /// nullopt if HIPFILE_UNSUPPORTED_FILE_SYSTEMS was unset or had a value other than
+    /// true or false.
+    static std::optional<bool> unsupported_file_systems();
 };
 
 }

test/amd_detail/configuration.cpp

@@ -48,6 +48,12 @@ struct HipFileConfiguration : public Test {
         EXPECT_CALL(msys, getenv(StrEq(hipFile::Environment::STATS_LEVEL)))
             .WillOnce(Return(const_cast<char *>(hipfile_stats_level)));
     }
+
+    void expect_configuration_unsupported_file_systems(const char *hipfile_unsupported_file_systems)
+    {
+        EXPECT_CALL(msys, getenv(StrEq(hipFile::Environment::UNSUPPORTED_FILE_SYSTEMS)))
+            .WillOnce(Return(const_cast<char *>(hipfile_unsupported_file_systems)));
+    }
 };
 
 TEST_F(HipFileConfiguration, FastpathEnabledIfForceCompatModeEnvironmentVariableIsNotSet)
@@ -194,4 +200,28 @@ TEST_F(HipFileConfiguration, StatsLevelEnvironmentVariableIsSet)
     ASSERT_EQ(1, Configuration().statsLevel());
 }
 
+TEST_F(HipFileConfiguration, UnsupportedFilesystemsDisabledIfEnvironmentVariableIsNotSet)
+{
+    expect_configuration_unsupported_file_systems(nullptr);
+    ASSERT_FALSE(Configuration().unsupportedFileSystems());
+}
+
+TEST_F(HipFileConfiguration, UnsupportedFilesystemsDisabledIfEnvironmentVariableIsInvalid)
+{
+    expect_configuration_unsupported_file_systems("not-a-bool");
+    ASSERT_FALSE(Configuration().unsupportedFileSystems());
+}
+
+TEST_F(HipFileConfiguration, UnsupportedFilesystemsEnabledIfEnvironmentVariableIsTrue)
+{
+    expect_configuration_unsupported_file_systems("true");
+    ASSERT_TRUE(Configuration().unsupportedFileSystems());
+}
+
+TEST_F(HipFileConfiguration, UnsupportedFilesystemsDisabledIfEnvironmentVariableIsFalse)
+{
+    expect_configuration_unsupported_file_systems("false");
+    ASSERT_FALSE(Configuration().unsupportedFileSystems());
+}
+
 HIPFILE_WARN_NO_GLOBAL_CTOR_ON