From 336c11d82e3b547e7d93f58055ec18700311efd0 Mon Sep 17 00:00:00 2001
From: XUranus <2257238649wdx@gmail.com>
Date: Fri, 29 Dec 2023 13:52:33 +0800
Subject: [PATCH] add mount read-only interface

---
 cli/vcopymount.cpp                            |  31 +-
 include/VolumeCopyMountProvider.h             |   2 +
 include/VolumeProtector.h                     |   2 +-
 include/native/FileSystemAPI.h                |   4 -
 .../linux/LinuxDeviceMapperMountProvider.h    |  15 +-
 .../native/linux/LinuxLoopbackMountProvider.h |   2 +
 include/native/linux/LinuxMountAPI.h          |   0
 include/native/linux/LinuxMountUtils.h        |  27 ++
 src/VolumeCopyMountProvider.cpp               |   8 +-
 src/native/FileSystemAPI.cpp                  |  41 --
 .../linux/LinuxDeviceMapperMountProvider.cpp  |  48 +--
 .../linux/LinuxLoopbackMountProvider.cpp      |  20 +-
 src/native/linux/LinuxMountUtils.cpp          | 365 ++++++++++++++++++
 13 files changed, 458 insertions(+), 107 deletions(-)
 delete mode 100644 include/native/linux/LinuxMountAPI.h
 create mode 100644 include/native/linux/LinuxMountUtils.h
 create mode 100644 src/native/linux/LinuxMountUtils.cpp

diff --git a/cli/vcopymount.cpp b/cli/vcopymount.cpp
index 3944222..e5ecbbc 100644
--- a/cli/vcopymount.cpp
+++ b/cli/vcopymount.cpp
@@ -28,7 +28,8 @@ static const char* g_helpMessage =
     "--output  <path>      output dir path to ouput checkpoint\n"
     "--target  <path>      dir target to mount to\n"
     "--type    <fs>        mount fs type, ex: ext4, xfs...\n"
-    "--option  <option>    mount fs option args\n";
+    "--option  <option>    mount fs option args\n"
+    "--readonly            mount as read-only";
 
 struct CliArgs {
     std::string     copyName;
@@ -39,6 +40,7 @@ struct CliArgs {
     std::string     mountFsType;
     std::string     mountOptions;
     std::string     mountRecordJsonFilePath;
+    bool            readOnly                    { false };
     bool            isMount                     { false };
     bool            isUmount                    { false };
     bool            printHelp                   { false };
@@ -57,6 +59,7 @@ static bool MountCopy(const VolumeCopyMountConfig& mountConfig)
     std::cout << "CopyDataDirPath " << mountConfig.copyDataDirPath << std::endl;
     std::cout << "MountTargetPath " << mountConfig.mountTargetPath << std::endl;
     std::cout << "OutputDirPath " << mountConfig.outputDirPath << std::endl;
+    std::cout << "ReadOnly " << mountConfig.readOnly << std::endl;
     std::cout << "MountFsType " << mountConfig.mountFsType << std::endl;
     std::cout << "MountOptions " << mountConfig.mountOptions << std::endl;
     std::cout << std::endl;
@@ -108,9 +111,9 @@ static CliArgs ParseCliArgs(int argc, const char** argv)
     GetOptionResult result = GetOption(
         argv + 1,
         argc - 1,
-        "n:m:d:ht:o:",
+        "n:m:d:hrt:o:",
         {
-            "--name=", "--meta=","--data=", "--target=", "--help",
+            "--name=", "--meta=","--data=", "--target=", "--help", "--readonly",
             "--mount", "--umount=", "--output=", "--type=", "--option="});
     for (const OptionResult opt: result.opts) {
         if (opt.option == "n" || opt.option == "name") {
@@ -134,6 +137,8 @@ static CliArgs ParseCliArgs(int argc, const char** argv)
             cliArgs.mountOptions = opt.value;
         } else if (opt.option == "h" || opt.option == "help") {
             cliArgs.printHelp = true;
+        }  else if (opt.option == "r" || opt.option == "readonly") {
+            cliArgs.readOnly = true;
         }
     }
     return cliArgs;
@@ -149,15 +154,17 @@ int main(int argc, const char** argv)
         return 0;
     }
     if (cliArgs.isMount) {
-        return !MountCopy(VolumeCopyMountConfig {
-            cliArgs.outputDirPath,
-            cliArgs.copyName,
-            cliArgs.copyMetaDirPath,
-            cliArgs.copyDataDirPath,
-            cliArgs.mountTargetPath,
-            cliArgs.mountFsType,
-            cliArgs.mountOptions
-        });
+        VolumeCopyMountConfig mountConfig {};
+        mountConfig.outputDirPath = cliArgs.outputDirPath;
+        mountConfig.copyName = cliArgs.copyName;
+        mountConfig.copyMetaDirPath = cliArgs.copyMetaDirPath;
+        mountConfig.copyDataDirPath = cliArgs.copyDataDirPath;
+        mountConfig.mountTargetPath = cliArgs.mountTargetPath;
+        mountConfig.readOnly = cliArgs.readOnly;
+        mountConfig.mountFsType = cliArgs.mountFsType;
+        mountConfig.mountOptions = cliArgs.mountOptions;
+
+        return !MountCopy(mountConfig);
     }
     if (cliArgs.isUmount) {
         return !UmountCopy(cliArgs.mountRecordJsonFilePath);
diff --git a/include/VolumeCopyMountProvider.h b/include/VolumeCopyMountProvider.h
index bee7af2..ba88940 100644
--- a/include/VolumeCopyMountProvider.h
+++ b/include/VolumeCopyMountProvider.h
@@ -52,6 +52,8 @@ struct VolumeCopyMountConfig {
     std::string     mountFsType;
     ///< Only used for *unix mount to sepecify mount options (option "-o", eg: "ro,loop,noatime")
     std::string     mountOptions;
+    ///< Only used for *unix mount, make the attached loop device and mounted copy readonly
+    bool            readOnly { true };
 };
 
 /**
diff --git a/include/VolumeProtector.h b/include/VolumeProtector.h
index 4773f1e..78bab3f 100644
--- a/include/VolumeProtector.h
+++ b/include/VolumeProtector.h
@@ -134,7 +134,7 @@ struct VOLUMEPROTECT_API TaskStatistics {
     uint64_t bytesToWrite   { 0 };
     uint64_t bytesWritten   { 0 };
 
-    TaskStatistics operator+ (const TaskStatistics& taskStatistics) const;
+    TaskStatistics operator + (const TaskStatistics& statistic) const;
 };
 
 /**
diff --git a/include/native/FileSystemAPI.h b/include/native/FileSystemAPI.h
index 20bf710..c102fe7 100644
--- a/include/native/FileSystemAPI.h
+++ b/include/native/FileSystemAPI.h
@@ -50,10 +50,6 @@ bool        RemoveFile(const std::string& filepath);
 
 #ifdef __linux__
 uint64_t    ReadSectorSizeLinux(const std::string& devicePath);
-
-bool        IsMountPoint(const std::string& dirPath);
-// get the block device path of the mount point
-std::string GetMountDevicePath(const std::string& mountTargetPath);
 #endif
 
 }
diff --git a/include/native/linux/LinuxDeviceMapperMountProvider.h b/include/native/linux/LinuxDeviceMapperMountProvider.h
index c155fa7..60e6a3b 100644
--- a/include/native/linux/LinuxDeviceMapperMountProvider.h
+++ b/include/native/linux/LinuxDeviceMapperMountProvider.h
@@ -19,6 +19,7 @@ struct LinuxDeviceMapperMountProviderParams {
     std::string                 copyName;
     std::vector<CopySegment>    segments;
     std::string                 mountTargetPath;
+    bool                        readOnly            { true };
     std::string                 mountFsType;
     std::string                 mountOptions;
 };
@@ -106,20 +107,15 @@ class LinuxDeviceMapperMountProvider : public VolumeCopyMountProvider {
     std::string GetMountRecordPath() const override;
 
 protected:
-    virtual bool MountReadOnlyDevice(
-        const std::string& devicePath,
-        const std::string& mountTargetPath,
-        const std::string& fsType,
-        const std::string& mountOptions);
-
-    virtual bool CreateReadOnlyDmDevice(
+    virtual bool CreateDmDevice(
         const std::vector<CopySliceTarget> copySlices,
         std::string& dmDeviceName,
-        std::string& dmDevicePath);
+        std::string& dmDevicePath,
+        bool readOnly);
 
     virtual bool RemoveDmDeviceIfExists(const std::string& dmDeviceName);
 
-    virtual bool AttachReadOnlyLoopDevice(const std::string& filePath, std::string& loopDevicePath);
+    virtual bool AttachDmLoopDevice(const std::string& filePath, std::string& loopDevicePath);
 
     virtual bool DetachLoopDeviceIfAttached(const std::string& loopDevicePath);
 
@@ -133,6 +129,7 @@ class LinuxDeviceMapperMountProvider : public VolumeCopyMountProvider {
     std::string     m_copyMetaDirPath;
     std::string     m_copyName;
     std::string     m_mountTargetPath;
+    bool            m_readOnly      { true };
     std::string     m_mountFsType;
     std::string     m_mountOptions;
     std::vector<CopySegment>    m_segments;
diff --git a/include/native/linux/LinuxLoopbackMountProvider.h b/include/native/linux/LinuxLoopbackMountProvider.h
index cebd736..d5ab7d4 100644
--- a/include/native/linux/LinuxLoopbackMountProvider.h
+++ b/include/native/linux/LinuxLoopbackMountProvider.h
@@ -22,6 +22,7 @@ struct LinuxLoopbackMountProviderParams {
     std::string     copyName;
     std::string     imageFilePath;
     std::string     mountTargetPath;
+    bool            readOnly            { true };
     std::string     mountFsType;
     std::string     mountOptions;
 };
@@ -53,6 +54,7 @@ class LinuxLoopbackMountProvider : public VolumeCopyMountProvider {
     std::string     m_copyName;
     std::string     m_imageFilePath;
     std::string     m_mountTargetPath;
+    bool            m_readOnly          { true };
 
     // [optional] used for *nix system
     std::string     m_mountFsType;
diff --git a/include/native/linux/LinuxMountAPI.h b/include/native/linux/LinuxMountAPI.h
deleted file mode 100644
index e69de29..0000000
diff --git a/include/native/linux/LinuxMountUtils.h b/include/native/linux/LinuxMountUtils.h
new file mode 100644
index 0000000..6552f67
--- /dev/null
+++ b/include/native/linux/LinuxMountUtils.h
@@ -0,0 +1,27 @@
+#ifndef LINUX_MOUNT_UTILS_HEADER
+#define LINUX_MOUNT_UTILS_HEADER
+
+#ifdef __linux__
+
+#include <string>
+
+namespace linuxmountutil {
+
+bool Mount(
+    const std::string& devicePath,
+    const std::string& mountTargetPath,
+    const std::string& fsType,
+    const std::string& mountOptions,
+    bool readOnly);
+
+bool Umount(const std::string& mountTargetPath, bool force);
+
+bool IsMountPoint(const std::string& dirPath);
+
+// get the block device path of the mount point
+std::string GetMountDevicePath(const std::string& mountTargetPath);
+
+}
+
+#endif
+#endif
\ No newline at end of file
diff --git a/src/VolumeCopyMountProvider.cpp b/src/VolumeCopyMountProvider.cpp
index da860f5..e8582a0 100644
--- a/src/VolumeCopyMountProvider.cpp
+++ b/src/VolumeCopyMountProvider.cpp
@@ -56,10 +56,10 @@ void InnerErrorLoggerTrait::RecordError(const char* message, ...)
     va_list args;
     va_start(args, message);
     // Determine the length of the formatted string
-    va_list args_copy;
-    va_copy(args_copy, args);
-    int length = std::vsnprintf(nullptr, 0, message, args_copy);
-    va_end(args_copy);
+    va_list argsCopy;
+    va_copy(argsCopy, args);
+    int length = std::vsnprintf(nullptr, 0, message, argsCopy);
+    va_end(argsCopy);
     if (length <= 0) {
         va_end(args);
         ERRLOG("failed to compute str format buffer size, errno %u", errno);
diff --git a/src/native/FileSystemAPI.cpp b/src/native/FileSystemAPI.cpp
index bd4010d..802a7f0 100644
--- a/src/native/FileSystemAPI.cpp
+++ b/src/native/FileSystemAPI.cpp
@@ -55,8 +55,6 @@ using namespace volumeprotect::fsapi;
 namespace {
     constexpr auto DEFAULT_PROCESSORS_NUM = 4;
     constexpr auto DEFAULT_MKDIR_MASK = 0755;
-    const int MNTENT_BUFFER_MAX = 4096;
-    const std::string SYS_MOUNTS_ENTRY_PATH = "/proc/mounts";
 }
 
 #ifdef _WIN32
@@ -404,43 +402,4 @@ uint64_t fsapi::ReadSectorSizeLinux(const std::string& devicePath)
     return sectorSize;
 }
 
-bool fsapi::IsMountPoint(const std::string& dirPath)
-{
-	bool mounted = false;
-    FILE* mountsFile = ::setmntent(SYS_MOUNTS_ENTRY_PATH.c_str(), "r");
-    if (mountsFile == nullptr) {
-        ERRLOG("failed to open /proc/mounts, errno %u", errno);
-        return false;
-    }
-    struct mntent entry {};
-    char mntentBuffer[MNTENT_BUFFER_MAX] = { 0 };
-    while (::getmntent_r(mountsFile, &entry, mntentBuffer, MNTENT_BUFFER_MAX) != nullptr) {
-        if (std::string(entry.mnt_dir) == dirPath) {
-            mounted = true;
-            break;
-        }
-    }
-    ::endmntent(mountsFile);
-    return mounted;
-}
-
-std::string fsapi::GetMountDevicePath(const std::string& mountTargetPath)
-{
-	std::string devicePath;
-    FILE* mountsFile = ::setmntent(SYS_MOUNTS_ENTRY_PATH.c_str(), "r");
-    if (mountsFile == nullptr) {
-        ERRLOG("failed to open /proc/mounts, errno %u", errno);
-        return "";
-    }
-    struct mntent entry {};
-    char mntentBuffer[MNTENT_BUFFER_MAX] = { 0 };
-    while (::getmntent_r(mountsFile, &entry, mntentBuffer, MNTENT_BUFFER_MAX) != nullptr) {
-        if (std::string(entry.mnt_dir) == mountTargetPath) {
-            devicePath = entry.mnt_fsname;
-            break;
-        }
-    }
-    ::endmntent(mountsFile);
-    return devicePath;
-}
 #endif
\ No newline at end of file
diff --git a/src/native/linux/LinuxDeviceMapperMountProvider.cpp b/src/native/linux/LinuxDeviceMapperMountProvider.cpp
index fd340d9..69e6a2c 100644
--- a/src/native/linux/LinuxDeviceMapperMountProvider.cpp
+++ b/src/native/linux/LinuxDeviceMapperMountProvider.cpp
@@ -7,13 +7,12 @@
 #ifdef __linux__
 
 #include "native/linux/LinuxDeviceMapperMountProvider.h"
-#include "Json.h"
 #include "Logger.h"
-#include "RawIO.h"
 #include "common/VolumeUtils.h"
 #include "native/FileSystemAPI.h"
 #include "native/linux/LoopDeviceControl.h"
 #include "native/linux/DeviceMapperControl.h"
+#include "native/linux/LinuxMountUtils.h"
 
 #include <cerrno>
 #include <fcntl.h>
@@ -117,6 +116,7 @@ std::unique_ptr<LinuxDeviceMapperMountProvider> LinuxDeviceMapperMountProvider::
     }
     params.segments = volumeCopyMeta.segments;
     params.mountTargetPath = volumeCopyMountConfig.mountTargetPath;
+    params.readOnly = volumeCopyMountConfig.readOnly;
     params.mountFsType = volumeCopyMountConfig.mountFsType;
     params.mountOptions = volumeCopyMountConfig.mountOptions;
     return exstd::make_unique<LinuxDeviceMapperMountProvider>(params);
@@ -129,6 +129,7 @@ LinuxDeviceMapperMountProvider::LinuxDeviceMapperMountProvider(
     m_copyMetaDirPath(params.copyMetaDirPath),
     m_copyName(params.copyName),
     m_mountTargetPath(params.mountTargetPath),
+    m_readOnly(params.readOnly),
     m_mountFsType(params.mountFsType),
     m_mountOptions(params.mountOptions),
     m_segments(params.segments)
@@ -148,7 +149,7 @@ bool LinuxDeviceMapperMountProvider::Mount()
         std::string copyFilePath = common::GetCopyDataFilePath(
             m_copyDataDirPath, m_copyName, CopyFormat::BIN, sessionIndex);
         std::string loopDevicePath;
-        if (!AttachReadOnlyLoopDevice(copyFilePath, loopDevicePath)) {
+        if (!AttachDmLoopDevice(copyFilePath, loopDevicePath)) {
             RollbackClearResidue();
             return false;
         }
@@ -163,7 +164,7 @@ bool LinuxDeviceMapperMountProvider::Mount()
         mountRecord.devicePath = mountRecord.loopDevices[0];
     } else {
         // multiple slices involved, need to attach loop device and create dm device
-        if (!CreateReadOnlyDmDevice(mountRecord.copySlices, mountRecord.dmDeviceName, mountRecord.devicePath)) {
+        if (!CreateDmDevice(mountRecord.copySlices, mountRecord.dmDeviceName, mountRecord.devicePath, m_readOnly)) {
             RollbackClearResidue();
             return false;
         }
@@ -172,10 +173,14 @@ bool LinuxDeviceMapperMountProvider::Mount()
     }
 
     // mount the loop/dm device to target
-    if (!MountReadOnlyDevice(mountRecord.devicePath, m_mountTargetPath, m_mountFsType, m_mountOptions)) {
+    if (!linuxmountutil::Mount(mountRecord.devicePath, m_mountTargetPath, m_mountFsType, m_mountOptions, m_readOnly)) {
+        RECORD_INNER_ERROR("mount %s to %s failed, type %s, option %s, read-only %u, errno %u",
+            mountRecord.devicePath.c_str(), m_mountTargetPath.c_str(), m_mountFsType.c_str(),
+            m_mountOptions.c_str(), m_readOnly, errno);
         RollbackClearResidue();
         return false;
     }
+
     // save mount record json to cache directory
     std::string filepath = GetMountRecordPath();
     if (!common::JsonDeserialize(mountRecord, filepath)) {
@@ -186,21 +191,6 @@ bool LinuxDeviceMapperMountProvider::Mount()
     return true;
 }
 
-bool LinuxDeviceMapperMountProvider::MountReadOnlyDevice(
-    const std::string& devicePath,
-    const std::string& mountTargetPath,
-    const std::string& fsType,
-    const std::string& mountOptions)
-{
-    unsigned long mountFlags = MS_RDONLY;
-    if (::mount(devicePath.c_str(), mountTargetPath.c_str(), fsType.c_str(), mountFlags, mountOptions.c_str()) != 0) {
-        RECORD_INNER_ERROR("mount %s to %s failed, type %s, option %s, errno %u",
-            devicePath.c_str(), mountTargetPath.c_str(), fsType.c_str(), mountOptions.c_str(), errno);
-        return false;
-    }
-    return true;
-}
-
 bool LinuxDeviceMapperMountProvider::RollbackClearResidue()
 {
     bool success = true; // allow failure, make every effort to remove residual
@@ -273,13 +263,17 @@ std::string LinuxDeviceMapperMountProvider::GetMountRecordPath() const
 
 // implement private methods here ...
 
-bool LinuxDeviceMapperMountProvider::CreateReadOnlyDmDevice(
+bool LinuxDeviceMapperMountProvider::CreateDmDevice(
     const std::vector<CopySliceTarget> copySlices,
     std::string& dmDeviceName,
-    std::string& dmDevicePath)
+    std::string& dmDevicePath,
+    bool readOnly)
 {
     dmDeviceName = GenerateNewDmDeviceName();
     devicemapper::DmTable dmTable;
+    if (readOnly) {
+        dmTable.SetReadOnly();
+    }
     for (const auto& copySlice : copySlices) {
         std::string blockDevicePath = copySlice.loopDevicePath;
         uint64_t sectorSize = 0LLU;
@@ -313,10 +307,11 @@ bool LinuxDeviceMapperMountProvider::RemoveDmDeviceIfExists(const std::string& d
     return true;
 }
 
-bool LinuxDeviceMapperMountProvider::AttachReadOnlyLoopDevice(const std::string& filePath, std::string& loopDevicePath)
+bool LinuxDeviceMapperMountProvider::AttachDmLoopDevice(const std::string& filePath, std::string& loopDevicePath)
 {
-    if (!loopback::Attach(filePath, loopDevicePath, O_RDONLY)) {
-        RECORD_INNER_ERROR("failed to attach read only loopback device from %s, errno %u", filePath.c_str(), errno);
+    if (!loopback::Attach(filePath, loopDevicePath,  m_readOnly ? O_RDONLY : O_RDWR)) {
+        RECORD_INNER_ERROR("failed to attach loopback device from %s, (read-only %u) errno %u",
+            filePath.c_str(), m_readOnly, errno);
         return false;
     }
     // keep checkpoint for loopback device creation
@@ -394,8 +389,7 @@ bool LinuxDeviceMapperUmountProvider::Umount()
 {
     bool success = true; // if error occurs, make every effort to clear the mount
     // umount the device first
-    if (fsapi::IsMountPoint(m_mountTargetPath) &&
-        ::umount2(m_mountTargetPath.c_str(), MNT_FORCE | MNT_DETACH) != 0) {
+    if (!linuxmountutil::Umount(m_mountTargetPath, true)) {
         RECORD_INNER_ERROR("failed to umount target %s, errno %u", m_mountTargetPath.c_str(), errno);
         success = false;
     }
diff --git a/src/native/linux/LinuxLoopbackMountProvider.cpp b/src/native/linux/LinuxLoopbackMountProvider.cpp
index 5c3a307..9ec2e7a 100644
--- a/src/native/linux/LinuxLoopbackMountProvider.cpp
+++ b/src/native/linux/LinuxLoopbackMountProvider.cpp
@@ -21,6 +21,7 @@
 #include "Logger.h"
 #include "common/VolumeUtils.h"
 #include "native/linux/LinuxLoopbackMountProvider.h"
+#include "native/linux/LinuxMountUtils.h"
 
 using namespace volumeprotect;
 using namespace volumeprotect::common;
@@ -65,6 +66,7 @@ std::unique_ptr<LinuxLoopbackMountProvider> LinuxLoopbackMountProvider::Build(
         volumeCopyMountConfig.copyDataDirPath,
         volumeCopyMeta.segments.front().copyDataFile);
     params.mountTargetPath = volumeCopyMountConfig.mountTargetPath;
+    params.readOnly = volumeCopyMountConfig.readOnly;
     params.mountFsType = volumeCopyMountConfig.mountFsType;
     params.mountOptions = volumeCopyMountConfig.mountOptions;
     return exstd::make_unique<LinuxLoopbackMountProvider>(params);
@@ -75,6 +77,7 @@ LinuxLoopbackMountProvider::LinuxLoopbackMountProvider(const LinuxLoopbackMountP
     m_copyName(params.copyName),
     m_imageFilePath(params.imageFilePath),
     m_mountTargetPath(params.mountTargetPath),
+    m_readOnly(params.readOnly),
     m_mountFsType(params.mountFsType),
     m_mountOptions(params.mountOptions)
 {}
@@ -89,7 +92,7 @@ bool LinuxLoopbackMountProvider::Mount()
 {
     // 1. attach loopback device
     std::string loopDevicePath;
-    if (!loopback::Attach(m_imageFilePath, loopDevicePath, O_RDONLY)) {
+    if (!loopback::Attach(m_imageFilePath, loopDevicePath, m_readOnly ? O_RDONLY : O_RDWR)) {
         RECORD_INNER_ERROR("failed to attach read only loopback device from %s, errno %u",
             m_imageFilePath.c_str(), errno);
         return false;
@@ -102,11 +105,10 @@ bool LinuxLoopbackMountProvider::Mount()
     }
 
     // 2. mount block device as readonly
-    unsigned long mountFlags = MS_RDONLY;
-    if (::mount(loopDevicePath.c_str(), m_mountTargetPath.c_str(), m_mountFsType.c_str(),
-        mountFlags, m_mountOptions.c_str()) != 0) {
-        RECORD_INNER_ERROR("mount %s to %s failed, type %s, option %s, errno %u",
-            loopDevicePath.c_str(), m_mountTargetPath.c_str(), m_mountFsType.c_str(), m_mountOptions.c_str(), errno);
+    if (!linuxmountutil::Mount(loopDevicePath, m_mountTargetPath, m_mountFsType, m_mountOptions, m_readOnly)) {
+        RECORD_INNER_ERROR("mount %s to %s failed, type %s, option %s, read-only %u, errno %u",
+            loopDevicePath.c_str(), m_mountTargetPath.c_str(), m_mountFsType.c_str(),
+            m_mountOptions.c_str(), m_readOnly, errno);
         PosixLoopbackMountRollback(loopDevicePath);
         return false;
     }
@@ -133,7 +135,8 @@ bool LinuxLoopbackMountProvider::PosixLoopbackMountRollback(const std::string& l
 		// no loopback device attached, no mounts, return directly
 		return true;
     }
-    if (fsapi::IsMountPoint(m_mountTargetPath) && fsapi::GetMountDevicePath(m_mountTargetPath) != loopbackDevicePath) {
+    if (linuxmountutil::IsMountPoint(m_mountTargetPath)
+        && linuxmountutil::GetMountDevicePath(m_mountTargetPath) != loopbackDevicePath) {
     	// moint point used by other application, return directly
     	return true;
     }
@@ -170,8 +173,7 @@ bool LinuxLoopbackUmountProvider::Umount()
 {
     // 1. umount filesystem
     if (!m_mountTargetPath.empty()
-        && fsapi::IsMountPoint(m_mountTargetPath)
-        && ::umount2(m_mountTargetPath.c_str(), MNT_FORCE | MNT_DETACH) != 0) {
+        && !linuxmountutil::Umount(m_mountTargetPath, true)) {
         RECORD_INNER_ERROR("failed to umount target %s, errno %u", m_mountTargetPath.c_str(), errno);
         return false;
     }
diff --git a/src/native/linux/LinuxMountUtils.cpp b/src/native/linux/LinuxMountUtils.cpp
new file mode 100644
index 0000000..2bd4580
--- /dev/null
+++ b/src/native/linux/LinuxMountUtils.cpp
@@ -0,0 +1,365 @@
+/**
+ * @file LinuxMountAPI.cpp
+ * Code referenced from
+ * https://android.googlesource.com/platform/system/core/+/jb-mr1.1-dev-plus-aosp/toolbox/mount.c
+ */
+
+#include <cerrno>
+#include <fcntl.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <mntent.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "common/VolumeProtectMacros.h"
+#include "Logger.h"
+#include "native/linux/LinuxMountUtils.h"
+
+namespace {
+    const int MNTENT_BUFFER_MAX = 4096;
+    const std::string SYS_MOUNTS_ENTRY_PATH = "/proc/mounts";
+}
+
+// #include <sys/mount.h>
+// #include <sys/stat.h>
+// #include <fcntl.h>
+// #include <errno.h>
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <string.h>
+// #include <unistd.h>
+// #include <linux/loop.h>
+
+// #define ARRAY_SIZE(x)	(sizeof(x) / sizeof(x[0]))
+// #define DEFAULT_LOOP_DEVICE "/dev/block/loop0"
+// #define LOOPDEV_MAXLEN 64
+// struct mount_opts {
+// 	const char str[16];
+// 	unsigned long rwmask;
+// 	unsigned long rwset;
+// 	unsigned long rwnoset;
+// };
+// struct extra_opts {
+// 	char *str;
+// 	char *end;
+// 	int used_size;
+// 	int alloc_size;
+// };
+// /*
+//  * These options define the function of "mount(2)".
+//  */
+// #define MS_TYPE	(MS_REMOUNT|MS_BIND|MS_MOVE)
+// static const struct mount_opts options[] = {
+// 	/* name		mask		set		noset		*/
+// 	{ "async",	MS_SYNCHRONOUS,	0,		MS_SYNCHRONOUS	},
+// 	{ "atime",	MS_NOATIME,	0,		MS_NOATIME	},
+// 	{ "bind",	MS_TYPE,	MS_BIND,	0,		},
+// 	{ "dev",	MS_NODEV,	0,		MS_NODEV	},
+// 	{ "diratime",	MS_NODIRATIME,	0,		MS_NODIRATIME	},
+// 	{ "dirsync",	MS_DIRSYNC,	MS_DIRSYNC,	0		},
+// 	{ "exec",	MS_NOEXEC,	0,		MS_NOEXEC	},
+// 	{ "move",	MS_TYPE,	MS_MOVE,	0		},
+// 	{ "recurse",	MS_REC,		MS_REC,		0		},
+// 	{ "rec",	MS_REC,		MS_REC,		0		},
+// 	{ "remount",	MS_TYPE,	MS_REMOUNT,	0		},
+// 	{ "ro",		MS_RDONLY,	MS_RDONLY,	0		},
+// 	{ "rw",		MS_RDONLY,	0,		MS_RDONLY	},
+// 	{ "suid",	MS_NOSUID,	0,		MS_NOSUID	},
+// 	{ "sync",	MS_SYNCHRONOUS,	MS_SYNCHRONOUS,	0		},
+// 	{ "verbose",	MS_VERBOSE,	MS_VERBOSE,	0		},
+// 	{ "unbindable",	MS_UNBINDABLE,	MS_UNBINDABLE,	0		},
+// 	{ "private",	MS_PRIVATE,	MS_PRIVATE,	0		},
+// 	{ "slave",	MS_SLAVE,	MS_SLAVE,	0		},
+// 	{ "shared",	MS_SHARED,	MS_SHARED,	0		},
+// };
+
+// static void add_extra_option(struct extra_opts *extra, char *s)
+// {
+// 	int len = strlen(s);
+// 	int newlen;
+// 	if (extra->str)
+// 	       len++;			/* +1 for ',' */
+// 	newlen = extra->used_size + len;
+// 	if (newlen >= extra->alloc_size) {
+// 		char *new;
+// 		new = realloc(extra->str, newlen + 1);	/* +1 for NUL */
+// 		if (!new)
+// 			return;
+// 		extra->str = new;
+// 		extra->end = extra->str + extra->used_size;
+// 		extra->alloc_size = newlen + 1;
+// 	}
+// 	if (extra->used_size) {
+// 		*extra->end = ',';
+// 		extra->end++;
+// 	}
+// 	strcpy(extra->end, s);
+// 	extra->used_size += len;
+// }
+// static unsigned long
+// parse_mount_options(char *arg, unsigned long rwflag, struct extra_opts *extra, int* loop, char *loopdev)
+// {
+// 	char *s;
+    
+//     *loop = 0;
+// 	while ((s = strsep(&arg, ",")) != NULL) {
+// 		char *opt = s;
+// 		unsigned int i;
+// 		int res, no = s[0] == 'n' && s[1] == 'o';
+// 		if (no)
+// 			s += 2;
+//         if (strncmp(s, "loop=", 5) == 0) {
+//             *loop = 1;
+//             strlcpy(loopdev, s + 5, LOOPDEV_MAXLEN);
+//             continue;
+//         }
+//         if (strcmp(s, "loop") == 0) {
+//             *loop = 1;
+//             strlcpy(loopdev, DEFAULT_LOOP_DEVICE, LOOPDEV_MAXLEN);
+//             continue;
+//         }
+// 		for (i = 0, res = 1; i < ARRAY_SIZE(options); i++) {
+// 			res = strcmp(s, options[i].str);
+// 			if (res == 0) {
+// 				rwflag &= ~options[i].rwmask;
+// 				if (no)
+// 					rwflag |= options[i].rwnoset;
+// 				else
+// 					rwflag |= options[i].rwset;
+// 			}
+// 			if (res <= 0)
+// 				break;
+// 		}
+// 		if (res != 0 && s[0])
+// 			add_extra_option(extra, opt);
+// 	}
+// 	return rwflag;
+// }
+// static char *progname;
+// static struct extra_opts extra;
+// static unsigned long rwflag;
+// static int
+// do_mount(char *dev, char *dir, char *type, unsigned long rwflag, void *data, int loop,
+//          char *loopdev)
+// {
+// 	char *s;
+// 	int error = 0;
+//     if (loop) {
+//         int file_fd, device_fd;
+//         int flags;
+//         flags = (rwflag & MS_RDONLY) ? O_RDONLY : O_RDWR;
+        
+//         file_fd = open(dev, flags);
+//         if (file_fd < 0) {
+//             perror("open backing file failed");
+//             return 1;
+//         }
+//         device_fd = open(loopdev, flags);
+//         if (device_fd < 0) {
+//             perror("open loop device failed");
+//             close(file_fd);
+//             return 1;
+//         }
+//         if (ioctl(device_fd, LOOP_SET_FD, file_fd) < 0) {
+//             perror("ioctl LOOP_SET_FD failed");
+//             close(file_fd);
+//             close(device_fd);
+//             return 1;
+//         }
+//         close(file_fd);
+//         close(device_fd);
+//         dev = loopdev;
+//     }
+// 	while ((s = strsep(&type, ",")) != NULL) {
+// retry:
+// 		if (mount(dev, dir, s, rwflag, data) == -1) {
+// 			error = errno;
+// 			/*
+// 			 * If the filesystem is not found, or the
+// 			 * superblock is invalid, try the next.
+// 			 */
+// 			if (error == ENODEV || error == EINVAL)
+// 				continue;
+// 			/*
+// 			 * If we get EACCESS, and we're trying to
+// 			 * mount readwrite and this isn't a remount,
+// 			 * try read only.
+// 			 */
+// 			if (error == EACCES &&
+// 			    (rwflag & (MS_REMOUNT|MS_RDONLY)) == 0) {
+// 				rwflag |= MS_RDONLY;
+// 				goto retry;
+// 			}
+// 			break;
+// 		}
+// 	}
+// 	if (error) {
+// 		errno = error;
+// 		perror("mount");
+// 		return 255;
+// 	}
+// 	return 0;
+// }
+
+// static int get_mounts_dev_dir(const char *arg, char **dev, char **dir)
+// {
+// 	FILE *f;
+// 	char mount_dev[256];
+// 	char mount_dir[256];
+// 	char mount_type[256];
+// 	char mount_opts[256];
+// 	int mount_freq;
+// 	int mount_passno;
+// 	int match;
+// 	f = fopen("/proc/mounts", "r");
+// 	if (!f) {
+// 		fprintf(stdout, "could not open /proc/mounts\n");
+// 		return -1;
+// 	}
+// 	do {
+// 		match = fscanf(f, "%255s %255s %255s %255s %d %d\n",
+// 					   mount_dev, mount_dir, mount_type,
+// 					   mount_opts, &mount_freq, &mount_passno);
+// 		mount_dev[255] = 0;
+// 		mount_dir[255] = 0;
+// 		mount_type[255] = 0;
+// 		mount_opts[255] = 0;
+// 		if (match == 6 &&
+// 			(strcmp(arg, mount_dev) == 0 ||
+// 			 strcmp(arg, mount_dir) == 0)) {
+// 			*dev = strdup(mount_dev);
+// 			*dir = strdup(mount_dir);
+// 			fclose(f);
+// 			return 0;
+// 		}
+// 	} while (match != EOF);
+// 	fclose(f);
+// 	return -1;
+// }
+
+
+// int Mount(
+//     const std::string& devicePath,
+//     const std::string& mountTargetPath,
+//     const std::string& mountType,
+//     const std::string& mountOptions,
+//     bool readOnly)
+// {
+//     int rwflag = MS_VERBOSE;
+//     if (readOnly) {
+//         rwflag |= MS_RDONLY;
+//     }
+
+//     /*
+// 	 * If remount, bind or move was specified, then we don't
+// 	 * have a "type" as such.  Use the dummy "none" type.
+// 	 */
+//     const char* type = mountType.empty() ? "none" : mountType.c_str();
+// 	if (rwflag & MS_TYPE) {
+// 		type = "none";
+//     }
+
+//     if (!LinuxApiMount(devicePath, mountTargetPath, mountType, mountOptions)) {
+//         return CommandMount(devicePath, mountTargetPath, mountType, mountOptions);
+//     }
+// }
+
+// {}
+// 	char *type = NULL;
+// 	char *dev = NULL;
+// 	char *dir = NULL;
+// 	int c;
+// 	int loop = 0;
+// 	char loopdev[LOOPDEV_MAXLEN];
+// 	progname = argv[0];
+// 	rwflag = MS_VERBOSE;
+	
+
+// 		case 'o':
+// 			rwflag = parse_mount_options(optarg, rwflag, &extra, &loop, loopdev);
+// 			break;
+// 		case 'w':
+// 			rwflag &= ~MS_RDONLY;
+// 			break;
+
+
+// 	if (optind + 2 == argc) {
+// 		dev = argv[optind];
+// 		dir = argv[optind + 1];
+// 	} else if (optind + 1 == argc && rwflag & MS_REMOUNT) {
+// 		get_mounts_dev_dir(argv[optind], &dev, &dir);
+// 	}
+
+// 	return do_mount(dev, dir, type, rwflag, extra.str, loop, loopdev);
+// 	/* We leak dev and dir in some cases, but we're about to exit */
+// }
+
+
+bool linuxmountutil::Mount(
+    const std::string& devicePath,
+    const std::string& mountTargetPath,
+    const std::string& fsType,
+    const std::string& mountOptions,
+    bool readOnly)
+{
+    unsigned long mountFlags = readOnly ? MS_RDONLY : 0; // TODO:: check mountOptions contains ro
+    if (::mount(devicePath.c_str(),
+        mountTargetPath.c_str(),
+        fsType.c_str(),
+        mountFlags,
+        mountOptions.c_str()) != 0) {
+        return false;
+    }
+    return true;
+}
+
+bool linuxmountutil::Umount(const std::string& mountTargetPath, bool force)
+{
+    int flags = force ? (MNT_FORCE | MNT_DETACH) : 0;
+    if (linuxmountutil::IsMountPoint(mountTargetPath) &&
+        ::umount2(mountTargetPath.c_str(), flags) != 0) {
+        return false;
+    }
+}
+
+bool linuxmountutil::IsMountPoint(const std::string& dirPath)
+{
+	bool mounted = false;
+    FILE* mountsFile = ::setmntent(SYS_MOUNTS_ENTRY_PATH.c_str(), "r");
+    if (mountsFile == nullptr) {
+        ERRLOG("failed to open /proc/mounts, errno %u", errno);
+        return false;
+    }
+    struct mntent entry {};
+    char mntentBuffer[MNTENT_BUFFER_MAX] = { 0 };
+    while (::getmntent_r(mountsFile, &entry, mntentBuffer, MNTENT_BUFFER_MAX) != nullptr) {
+        if (std::string(entry.mnt_dir) == dirPath) {
+            mounted = true;
+            break;
+        }
+    }
+    ::endmntent(mountsFile);
+    return mounted;
+}
+
+std::string linuxmountutil::GetMountDevicePath(const std::string& mountTargetPath)
+{
+	std::string devicePath;
+    FILE* mountsFile = ::setmntent(SYS_MOUNTS_ENTRY_PATH.c_str(), "r");
+    if (mountsFile == nullptr) {
+        ERRLOG("failed to open /proc/mounts, errno %u", errno);
+        return "";
+    }
+    struct mntent entry {};
+    char mntentBuffer[MNTENT_BUFFER_MAX] = { 0 };
+    while (::getmntent_r(mountsFile, &entry, mntentBuffer, MNTENT_BUFFER_MAX) != nullptr) {
+        if (std::string(entry.mnt_dir) == mountTargetPath) {
+            devicePath = entry.mnt_fsname;
+            break;
+        }
+    }
+    ::endmntent(mountsFile);
+    return devicePath;
+}
\ No newline at end of file