openharmony/filemanagement_storage_service
1
0
Fork 0
mirror of https://gitee.com/openharmony/filemanagement_storage_service synced 2024-11-23 06:59:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

storagemanager 支持媒体库fuse

Browse Source 
Signed-off-by: jiangjinpeng3 <jiangjinpeng3@huawei.com>
Change-Id: If7d7b8944910f9bad4574baca9af846e2dcab21e
This commit is contained in:
jiangjinpeng3 2024-11-12 11:53:32 +08:00
parent b055b7ff07
commit db588b55d1
39 changed files with 701 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
interfaces/innerkits/storage_manager/native/istorage_manager.h
View File

@ -125,6 +125,10 @@ public:
virtual int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) = 0;
// media fuse
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) = 0;
virtual int32_t UMountMediaFuse(int32_t userId) = 0;
DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.StorageManager.IStorageManager");
};
} // StorageManager

2
interfaces/innerkits/storage_manager/native/storage_manager_ipc_interface_code.h
View File

@ -89,6 +89,8 @@ namespace StorageManager {
SET_RECOVER_KEY,
NOTIFY_MTP_MOUNT,
NOTIFY_MTP_UNMOUNT,
MOUNT_MEDIA_FUSE,
UMOUNT_MEDIA_FUSE,
};
} // namespace StorageManager
} // namespace OHOS

4
interfaces/innerkits/storage_manager/native/storage_manager_proxy.h
View File

@ -114,6 +114,10 @@ public:
int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) override;
// media fuse
int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
int32_t UMountMediaFuse(int32_t userId) override;
private:
static inline BrokerDelegator<StorageManagerProxy> delegator_;
int32_t SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);

4
services/storage_daemon/include/ipc/istorage_daemon.h
View File

@ -102,6 +102,10 @@ public:
const std::string &networkId, const std::string &deviceId) = 0;
virtual int32_t GetFileEncryptStatus(uint32_t userId, bool &isEncrypted, bool needCheckDirMount = false) = 0;
// media fuse
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) = 0;
virtual int32_t UMountMediaFuse(int32_t userId) = 0;
DECLARE_INTERFACE_DESCRIPTOR(u"ohos.StorageDaemon");
};
} // STORAGE_DAEMON

4
services/storage_daemon/include/ipc/storage_daemon.h
View File

@ -109,6 +109,10 @@ public:
void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
};
// media fuse
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
virtual int32_t UMountMediaFuse(int32_t userId) override;
private:
#ifdef USER_CRYPTO_MIGRATE_KEY
std::string GetNeedRestoreFilePath(int32_t userId, const std::string &user_dir);

2
services/storage_daemon/include/ipc/storage_daemon_ipc_interface_code.h
View File

@ -61,6 +61,8 @@ namespace StorageDaemon {
GET_FILE_ENCRYPT_STATUS,
CREATE_RECOVER_KEY,
SET_RECOVER_KEY,
MOUNT_MEDIA_FUSE,
UMOUNT_MEDIA_FUSE,
};
} // namespace StorageDaemon
} // namespace OHOS

4
services/storage_daemon/include/ipc/storage_daemon_proxy.h
View File

@ -89,6 +89,10 @@ public:
virtual int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) override;
virtual int32_t GetFileEncryptStatus(uint32_t userId, bool &isEncrypted, bool needCheckDirMount = false) override;
// media fuse
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
virtual int32_t UMountMediaFuse(int32_t userId) override;
private:
static inline BrokerDelegator<StorageDaemonProxy> delegator_;
int32_t SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);

3
services/storage_daemon/include/ipc/storage_daemon_stub.h
View File

@ -83,6 +83,9 @@ private:
int32_t HandleGetBundleStatsForIncrease(MessageParcel &data, MessageParcel &reply);
int32_t HandleMountDfsDocs(MessageParcel &data, MessageParcel &reply);
int32_t HandleUMountDfsDocs(MessageParcel &data, MessageParcel &reply);
int32_t HandleMountMediaFuse(MessageParcel &data, MessageParcel &reply);
int32_t HandleUMountMediaFuse(MessageParcel &data, MessageParcel &reply);
};
} // StorageDaemon
} // OHOS

2
services/storage_daemon/include/user/mount_manager.h
View File

@ -108,6 +108,8 @@ public:
const std::string &bundleName, const std::string &userId);
bool CheckMountFileByUser(int32_t userId);
bool CloudDirFlag(const std::string &path);
int32_t MountMediaFuse(int32_t userId, int32_t &devFd);
int32_t UMountMediaFuse(int32_t userId);
private:
bool SupportHmdfs();

1
services/storage_daemon/include/utils/mount_argument_utils.h
View File

@ -62,6 +62,7 @@ struct MountArgument final {
std::string GetCurFileMgrAppdataPath() const;
std::string GetNoSharefsAppdataPath() const;
unsigned long GetFlags() const;
std::string GetFullMediaFuse() const;
};
struct MountArgumentDescriptors final {

10
services/storage_daemon/ipc/src/storage_daemon.cpp
View File

@ -1151,5 +1151,15 @@ void StorageDaemon::ActiveAppCloneUserKey()
}
#endif
}
int32_t StorageDaemon::MountMediaFuse(int32_t userId, int32_t &devFd)
{
return MountManager::GetInstance()->MountMediaFuse(userId, devFd);
}
int32_t StorageDaemon::UMountMediaFuse(int32_t userId)
{
return MountManager::GetInstance()->UMountMediaFuse(userId);
}
} // namespace StorageDaemon
} // namespace OHOS

51
services/storage_daemon/ipc/src/storage_daemon_proxy.cpp
View File

@ -1009,5 +1009,56 @@ int32_t StorageDaemonProxy::GetFileEncryptStatus(uint32_t userId, bool &isEncryp
isEncrypted = reply.ReadBool();
return reply.ReadInt32();
}
int32_t StorageDaemonProxy::MountMediaFuse(int32_t userId, int32_t &devFd)
{
MessageParcel data;
MessageParcel reply;
MessageOption option(MessageOption::TF_SYNC);
if (!data.WriteInterfaceToken(StorageDaemonProxy::GetDescriptor())) {
LOGE("WriteInterfaceToken failed");
return E_WRITE_DESCRIPTOR_ERR;
}
if (!data.WriteInt32(userId)) {
return E_WRITE_PARCEL_ERR;
}
int32_t err = SendRequest(static_cast<int32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE), data, reply, option);
if (err != E_OK) {
return err;
}
int32_t ret = reply.ReadInt32();
if (ret == E_OK) {
devFd = reply.ReadFileDescriptor();
}
return ret;
}
int32_t StorageDaemonProxy::UMountMediaFuse(int32_t userId)
{
MessageParcel data;
MessageParcel reply;
MessageOption option(MessageOption::TF_SYNC);
if (!data.WriteInterfaceToken(StorageDaemonProxy::GetDescriptor())) {
LOGE("WriteInterfaceToken failed");
return E_WRITE_DESCRIPTOR_ERR;
}
if (!data.WriteInt32(userId)) {
return E_WRITE_PARCEL_ERR;
}
int32_t err = SendRequest(static_cast<int32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE), data, reply, option);
if (err != E_OK) {
return err;
}
return reply.ReadInt32();
}
} // StorageDaemon
} // OHOS

46
services/storage_daemon/ipc/src/storage_daemon_stub.cpp
View File

@ -102,6 +102,10 @@ StorageDaemonStub::StorageDaemonStub()
&StorageDaemonStub::HandleCreateRecoverKey;
opToInterfaceMap_[static_cast<uint32_t>(StorageDaemonInterfaceCode::SET_RECOVER_KEY)] =
&StorageDaemonStub::HandleSetRecoverKey;
opToInterfaceMap_[static_cast<uint32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE)] =
&StorageDaemonStub::HandleMountMediaFuse;
opToInterfaceMap_[static_cast<uint32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE)] =
&StorageDaemonStub::HandleUMountMediaFuse;
}
int32_t StorageDaemonStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
@ -151,6 +155,8 @@ int32_t StorageDaemonStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
case static_cast<uint32_t>(StorageDaemonInterfaceCode::GENERATE_APP_KEY):
case static_cast<uint32_t>(StorageDaemonInterfaceCode::DELETE_APP_KEY):
case static_cast<uint32_t>(StorageDaemonInterfaceCode::GET_FILE_ENCRYPT_STATUS):
case static_cast<uint32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE):
case static_cast<uint32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE):
return OnRemoteRequestForApp(code, data, reply);
default:
LOGE("Cannot response request %d: unknown tranction", code);
@ -253,6 +259,10 @@ int32_t StorageDaemonStub::OnRemoteRequestForApp(uint32_t code, MessageParcel &d
return HandleDeleteAppkey(data, reply);
case static_cast<uint32_t>(StorageDaemonInterfaceCode::GET_FILE_ENCRYPT_STATUS):
return HandleGetFileEncryptStatus(data, reply);
case static_cast<uint32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE):
return HandleMountMediaFuse(data, reply);
case static_cast<uint32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE):
return HandleUMountMediaFuse(data, reply);
default:
LOGE("Cannot response request %d: unknown tranction", code);
return E_SYS_ERR;
@ -812,5 +822,41 @@ int32_t StorageDaemonStub::HandleGetFileEncryptStatus(MessageParcel &data, Messa
return E_OK;
}
int32_t StorageDaemonStub::HandleMountMediaFuse(MessageParcel &data, MessageParcel &reply)
{
LOGI("StorageDaemonStub::HandleMountMediaFuse start.");
int32_t userId = data.ReadInt32();
int32_t fd = -1;
int32_t ret = MountMediaFuse(userId, fd);
if (!reply.WriteInt32(ret)) {
LOGE("Write reply error code failed");
if (ret == E_OK) {
close(fd);
}
return E_WRITE_REPLY_ERR;
}
if (ret == E_OK && fd > 0) {
if (!reply.WriteFileDescriptor(fd)) {
LOGE("Write reply fd failed");
close(fd);
return E_WRITE_REPLY_ERR;
}
close(fd);
}
return E_OK;
}
int32_t StorageDaemonStub::HandleUMountMediaFuse(MessageParcel &data, MessageParcel &reply)
{
LOGI("StorageDaemonStub::HandleUMountMediaFuse start.");
int32_t userId = data.ReadInt32();
int32_t ret = UMountMediaFuse(userId);
if (!reply.WriteInt32(ret)) {
return E_WRITE_REPLY_ERR;
}
return E_OK;
}
} // StorageDaemon
} // OHOS

55
services/storage_daemon/ipc/test/storage_daemon_proxy_test.cpp
View File

@ -1085,5 +1085,60 @@ HWTEST_F(StorageDaemonProxyTest, StorageDaemonProxyTest_GetBundleStatsForIncreas
EXPECT_EQ(ret, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageDaemonProxyTest_GetBundleStatsForIncrease_001 end";
}
/**
* @tc.name: StorageDaemonProxyTest_MountMediaFuse_001
* @tc.desc: Verify the MountMediaFuse function.
* @tc.type: FUNC
*/
HWTEST_F(StorageDaemonProxyTest, StorageDaemonProxyTest_MountMediaFuse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageDaemonProxyTest_MountMediaFuse_001 start";
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Invoke(mock_.GetRefPtr(), &StorageDaemonServiceMock::InvokeSendRequest));
ASSERT_TRUE(proxy_ != nullptr);
int32_t userId = 100;
int32_t devFd = -1;
int32_t ret = proxy_->MountMediaFuse(userId, devFd);
ASSERT_TRUE(ret == E_OK);
ASSERT_TRUE(mock_ != nullptr);
int m = static_cast<int32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE);
ASSERT_TRUE(m == mock_->code_);
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Return(E_WRITE_PARCEL_ERR));
ret = proxy_->MountMediaFuse(userId, devFd);
EXPECT_EQ(ret, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageDaemonProxyTest_MountMediaFuse_001 end";
}
/**
* @tc.name: StorageDaemonProxyTest_UMountMediaFuse_001
* @tc.desc: Verify the UMountMediaFuse function.
* @tc.type: FUNC
*/
HWTEST_F(StorageDaemonProxyTest, StorageDaemonProxyTest_UMountMediaFuse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageDaemonProxyTest_UMountMediaFuse_001 start";
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Invoke(mock_.GetRefPtr(), &StorageDaemonServiceMock::InvokeSendRequest));
ASSERT_TRUE(proxy_ != nullptr);
int32_t userId = 100;
int32_t ret = proxy_->UMountMediaFuse(userId);
ASSERT_TRUE(ret == E_OK);
ASSERT_TRUE(mock_ != nullptr);
int m = static_cast<int32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE);
ASSERT_TRUE(m == mock_->code_);
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Return(E_WRITE_PARCEL_ERR));
ret = proxy_->UMountMediaFuse(userId);
EXPECT_EQ(ret, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageDaemonProxyTest_UMountMediaFuse_001 end";
}
} // STORAGE_DAEMON
} // OHOS

10
services/storage_daemon/ipc/test/storage_daemon_service_mock.h
View File

@ -233,6 +233,16 @@ public:
{
return E_OK;
}
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override
{
return E_OK;
}
virtual int32_t UMountMediaFuse(int32_t userId) override
{
return E_OK;
}
};
} // namespace StorageDaemon
} // namespace OHOS

3
services/storage_daemon/ipc/test/storage_daemon_stub_mock.h
View File

@ -67,6 +67,9 @@ public:
MOCK_METHOD4(CreateRecoverKey, int32_t (uint32_t, uint32_t, const std::vector<uint8_t> &,
const std::vector<uint8_t> &));
MOCK_METHOD1(SetRecoverKey, int32_t (const std::vector<uint8_t> &));
MOCK_METHOD2(MountMediaFuse, int32_t (int32_t, int32_t &));
MOCK_METHOD1(UMountMediaFuse, int32_t (int32_t));
};
} // namespace StorageDaemon
} // namespace OHOS

4
services/storage_daemon/ipc/test/storage_daemon_stub_test.cpp
View File

@ -67,6 +67,8 @@ namespace {
static_cast<int32_t>(StorageDaemonInterfaceCode::CREATE_RECOVER_KEY),
static_cast<int32_t>(StorageDaemonInterfaceCode::SET_RECOVER_KEY),
static_cast<int32_t>(StorageDaemonInterfaceCode::COMPLETE_ADD_USER),
static_cast<int32_t>(StorageDaemonInterfaceCode::MOUNT_MEDIA_FUSE),
static_cast<int32_t>(StorageDaemonInterfaceCode::UMOUNT_MEDIA_FUSE),
};
}
@ -173,6 +175,8 @@ HWTEST_F(StorageDaemonStubTest, Storage_Manager_StorageDaemonStubTest_OnRemoteRe
EXPECT_CALL(mock, GetFileEncryptStatus(testing::_, testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, CreateRecoverKey(testing::_, testing::_, testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, SetRecoverKey(testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, MountMediaFuse(testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, UMountMediaFuse(testing::_)).WillOnce(testing::Return(E_OK));
for (auto c : g_code) {
MessageParcel data;

35
services/storage_daemon/ipc/test/storage_daemon_test.cpp
View File

@ -549,5 +549,40 @@ HWTEST_F(StorageDaemonTest, Storage_Manager_StorageDaemonTest_GetBundleStatsForI
GTEST_LOG_(INFO) << "Storage_Manager_StorageDaemonTest_GetBundleStatsForIncrease_001 end";
}
/**
* @tc.name: Storage_Manager_StorageDaemonTest_MountMediaFuse_001
* @tc.desc: check the MountMediaFuse function normal
* @tc.type: FUNC
*/
HWTEST_F(StorageDaemonTest, Storage_Manager_StorageDaemonTest_MountMediaFuse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Storage_Manager_StorageDaemonTest_MountMediaFuse_001 start";
ASSERT_TRUE(storageDaemon_ != nullptr);
int32_t userId = 105;
int32_t devFd = -1;
auto ret = storageDaemon_->MountMediaFuse(userId, devFd);
EXPECT_EQ(ret, E_MOUNT);
GTEST_LOG_(INFO) << "Storage_Manager_StorageDaemonTest_MountMediaFuse_001 end";
}
/**
* @tc.name: Storage_Manager_StorageDaemonTest_UMountMediaFuse_001
* @tc.desc: check the UMountMediaFuse function normal
* @tc.type: FUNC
*/
HWTEST_F(StorageDaemonTest, Storage_Manager_StorageDaemonTest_UMountMediaFuse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Storage_Manager_StorageDaemonTest_UMountMediaFuse_001 start";
ASSERT_TRUE(storageDaemon_ != nullptr);
int32_t userId = 105;
auto ret = storageDaemon_->UMountMediaFuse(userId);
EXPECT_EQ(ret, E_UMOUNT);
GTEST_LOG_(INFO) << "Storage_Manager_StorageDaemonTest_UMountMediaFuse_001 end";
}
} // STORAGE_DAEMON
} // OHOS

72
services/storage_daemon/user/src/mount_manager.cpp
View File

@ -167,6 +167,7 @@ std::vector<DirInfo> MountManager::InitVirtualDir()
{"/mnt/data/%d/", MODE_0711, OID_ROOT, OID_ROOT},
{"/mnt/data/%d/cloud", MODE_0711, OID_ROOT, OID_ROOT},
{"/mnt/data/%d/cloud_fuse", MODE_0711, OID_DFS, OID_DFS},
{"/mnt/data/%d/media_fuse", MODE_0711, OID_USER_DATA_RW, OID_USER_DATA_RW},
{"/mnt/data/%d/hmdfs", MODE_0711, OID_FILE_MANAGER, OID_FILE_MANAGER},
{"/mnt/hmdfs/", MODE_0711, OID_ROOT, OID_ROOT},
{"/mnt/hmdfs/%d/", MODE_0711, OID_ROOT, OID_ROOT},
@ -1141,6 +1142,20 @@ int32_t MountManager::UmountByUser(int32_t userId)
LOGE("failed to umount cloud mount point, err %{public}d", err);
return E_UMOUNT;
}
LOGI("umount media fuse mount point start.");
count = 0;
while (count < UMOUNT_RETRY_TIMES) {
err = UMountMediaFuse(userId);
if (err == E_OK) {
break;
} else if (errno == EBUSY) {
count++;
continue;
}
LOGE("failed to umount media fuse mount point, err %{public}d", err);
return E_UMOUNT;
}
return E_OK;
}
@ -1530,5 +1545,62 @@ int32_t MountManager::UmountMntUserTmpfs(int32_t userId)
}
return E_OK;
}
int32_t MountManager::MountMediaFuse(int32_t userId, int32_t &devFd)
{
LOGI("start mount media fuse");
// umount mountpoint first
Utils::MountArgument mediaMntArgs(Utils::MountArgumentDescriptors::Alpha(userId, ""));
const string path = mediaMntArgs.GetFullMediaFuse();
if (E_OK != UMount2(path.c_str(), MNT_DETACH)) {
LOGE("UMount media fuse mountpoint failed, errno = %{public}d", errno);
}
// open fuse
devFd = open("/dev/fuse", O_RDWR);
if (devFd < 0) {
LOGE("open /dev/fuse fail");
return E_MOUNT;
}
// mount fuse mountpoint
string opt = StringPrintf("fd=%i,"
"rootmode=40000,"
"default_permissions,"
"allow_other,"
"user_id=0,group_id=0,"
"context=\"u:object_r:hmdfs:s0\","
"fscontext=u:object_r:hmdfs:s0",
devFd);
int ret = Mount("/dev/fuse", path.c_str(), "fuse", MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opt.c_str());
if (ret) {
LOGE("failed to mount fuse, err %{public}d %{public}d %{public}s", errno, ret, path.c_str());
close(devFd);
return E_MOUNT;
}
LOGI("mount %{public}s success", path.c_str());
return E_OK;
}
int32_t MountManager::UMountMediaFuse(int32_t userId)
{
int32_t err = E_OK;
LOGI("start umount media fuse");
Utils::MountArgument mediaMntArgs(Utils::MountArgumentDescriptors::Alpha(userId, ""));
const string path = mediaMntArgs.GetFullMediaFuse();
err = UMount2(path, MNT_DETACH);
if (err != E_OK) {
LOGE("fuse umount2 failed, errno %{public}d, fuse dst %{public}s", errno, path.c_str());
return E_UMOUNT;
}
LOGI("umount %{public}s success", path.c_str());
return E_OK;
}
} // namespace StorageDaemon
} // namespace OHOS

23
services/storage_daemon/user/test/user_manager_test.cpp
View File

@ -583,7 +583,6 @@ HWTEST_F(UserManagerTest, Storage_Manager_MountManagerTest_UmountFailRadar_000,
* @tc.name: Storage_Manager_MountManagerTest_CheckMaps_001
* @tc.desc: Verify the CheckMaps function.
* @tc.type: FUNC
* @tc.require: AR000GK4HB
*/
HWTEST_F(UserManagerTest, Storage_Manager_MountManagerTest_CheckMaps_000, TestSize.Level1)
{
@ -604,5 +603,27 @@ HWTEST_F(UserManagerTest, Storage_Manager_MountManagerTest_CheckMaps_000, TestSi
mountManager->CheckSymlink(path, prefix, mountFailList);
GTEST_LOG_(INFO) << "Storage_Manager_MountManagerTest_UmountFailRadar_000 end";
}
/**
* @tc.name: Storage_Manager_MountManagerTest_MountMediaFuse_001
* @tc.desc: Verify the MountMediaFuse function.
* @tc.type: FUNC
*/
HWTEST_F(UserManagerTest, Storage_Manager_MountManagerTest_MountMediaFuse_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "Storage_Manager_MountManagerTest_MountMediaFuse_001 start";
std::shared_ptr<MountManager> mountManager = MountManager::GetInstance();
ASSERT_TRUE(mountManager != nullptr);
int32_t userId = 101;
int32_t devFd = -1;
int32_t ret = mountManager->MountMediaFuse(userId, devFd);
EXPECT_EQ(ret, E_MOUNT);
ret = mountManager->UMountMediaFuse(userId);
EXPECT_EQ(ret, E_UMOUNT);
GTEST_LOG_(INFO) << "Storage_Manager_MountManagerTest_MountMediaFuse_001 end";
}
} // STORAGE_DAEMON
} // OHOS

7
services/storage_daemon/utils/mount_argument_utils.cpp
View File

@ -296,6 +296,13 @@ unsigned long MountArgument::GetFlags() const
return MS_NODEV;
}
string MountArgument::GetFullMediaFuse() const
{
stringstream ss;
ss << TMPFS_MNT_DATA << userId_ << "/" << "media_fuse";
return ss.str();
}
MountArgument MountArgumentDescriptors::Alpha(int userId, string relativePath)
{
MountArgument mountArgument = {

5
services/storage_manager/include/ipc/storage_manager.h
View File

@ -122,6 +122,11 @@ public:
const std::string &networkId, const std::string &deviceId) override;
int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) override;
// media fuse
int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
int32_t UMountMediaFuse(int32_t userId) override;
// reset user event record api
void ResetUserEventRecord(int32_t userId);

4
services/storage_manager/include/ipc/storage_manager_stub.h
View File

@ -95,6 +95,10 @@ private:
// dfs service
int32_t HandleMountDfsDocs(MessageParcel &data, MessageParcel &reply);
int32_t HandleUMountDfsDocs(MessageParcel &data, MessageParcel &reply);
// mount media fuse
int32_t HandleMountMediaFuse(MessageParcel &data, MessageParcel &reply);
int32_t HandleUMountMediaFuse(MessageParcel &data, MessageParcel &reply);
};
} // StorageManager
} // OHOS

2
services/storage_manager/include/mock/storage_daemon_proxy_mock.h
View File

@ -89,6 +89,8 @@ public:
virtual int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) override;
virtual int32_t GetFileEncryptStatus(uint32_t userId, bool &isEncrypted, bool needCheckDirMount = false) override;
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
virtual int32_t UMountMediaFuse(int32_t userId) override;
private:
static inline BrokerDelegator<StorageDaemonProxy> delegator_;
int32_t SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);

2
services/storage_manager/include/mock/storage_manager_proxy_mock.h
View File

@ -113,6 +113,8 @@ public:
int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId) override;
int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override;
int32_t UMountMediaFuse(int32_t userId) override;
private:
static inline BrokerDelegator<StorageManagerProxy> delegator_;
int32_t SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option);

4
services/storage_manager/include/storage_daemon_communication/storage_daemon_communication.h
View File

@ -95,6 +95,10 @@ public:
const std::string &networkId, const std::string &deviceId);
int32_t UMountDfsDocs(int32_t userId, const std::string &relativePath,
const std::string &networkId, const std::string &deviceId);
// media fuse mount
int32_t MountMediaFuse(int32_t userId, int32_t &devFd);
int32_t UMountMediaFuse(int32_t userId);
private:
sptr<OHOS::StorageDaemon::IStorageDaemon> storageDaemon_;
sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;

54
services/storage_manager/innerkits_impl/src/storage_manager_proxy.cpp
View File

@ -1589,5 +1589,59 @@ int32_t StorageManagerProxy::GetFileEncryptStatus(uint32_t userId, bool &isEncry
return reply.ReadInt32();
}
int32_t StorageManagerProxy::MountMediaFuse(int32_t userId, int32_t &devFd)
{
MessageParcel data;
MessageParcel reply;
MessageOption option(MessageOption::TF_SYNC);
if (!data.WriteInterfaceToken(StorageManagerProxy::GetDescriptor())) {
LOGE("WriteInterfaceToken failed");
return E_WRITE_DESCRIPTOR_ERR;
}
if (!data.WriteInt32(userId)) {
LOGE("WriteInt32 failed");
return E_WRITE_PARCEL_ERR;
}
int32_t err = SendRequest(
static_cast<int32_t>(StorageManagerInterfaceCode::MOUNT_MEDIA_FUSE), data, reply, option);
if (err != E_OK) {
return err;
}
int32_t ret = reply.ReadInt32();
if (ret == E_OK) {
devFd = reply.ReadFileDescriptor();
}
return ret;
}
int32_t StorageManagerProxy::UMountMediaFuse(int32_t userId)
{
MessageParcel data;
MessageParcel reply;
MessageOption option(MessageOption::TF_SYNC);
if (!data.WriteInterfaceToken(StorageManagerProxy::GetDescriptor())) {
LOGE("WriteInterfaceToken failed");
return E_WRITE_DESCRIPTOR_ERR;
}
if (!data.WriteInt32(userId)) {
LOGE("WriteInt32 failed");
return E_WRITE_PARCEL_ERR;
}
int32_t err = SendRequest(
static_cast<int32_t>(StorageManagerInterfaceCode::UMOUNT_MEDIA_FUSE), data, reply, option);
if (err != E_OK) {
return err;
}
return reply.ReadInt32();
}
} // StorageManager
} // OHOS

14
services/storage_manager/ipc/src/storage_manager.cpp
View File

@ -669,5 +669,19 @@ int32_t StorageManager::NotifyMtpUnmounted(const std::string &id, const std::str
#endif
return E_OK;
}
int32_t StorageManager::MountMediaFuse(int32_t userId, int32_t &devFd)
{
std::shared_ptr<StorageDaemonCommunication> sdCommunication;
sdCommunication = DelayedSingleton<StorageDaemonCommunication>::GetInstance();
return sdCommunication->MountMediaFuse(userId, devFd);
}
int32_t StorageManager::UMountMediaFuse(int32_t userId)
{
std::shared_ptr<StorageDaemonCommunication> sdCommunication;
sdCommunication = DelayedSingleton<StorageDaemonCommunication>::GetInstance();
return sdCommunication->UMountMediaFuse(userId);
}
}
}

83
services/storage_manager/ipc/src/storage_manager_stub.cpp
View File

@ -16,6 +16,7 @@
#include "ipc/storage_manager_stub.h"
#include "accesstoken_kit.h"
#include "ipc_skeleton.h"
#include "storage/bundle_manager_connector.h"
#include "storage_manager_ipc_interface_code.h"
#include "storage_service_errno.h"
#include "storage_service_log.h"
@ -28,6 +29,7 @@ constexpr pid_t ACCOUNT_UID = 3058;
constexpr pid_t BACKUP_SA_UID = 1089;
constexpr pid_t FOUNDATION_UID = 5523;
constexpr pid_t DFS_UID = 1009;
const std::string MEDIALIBRARY_BUNDLE_NAME = "com.ohos.medialibrary.medialibrarydata";
const std::string PERMISSION_STORAGE_MANAGER_CRYPT = "ohos.permission.STORAGE_MANAGER_CRYPT";
const std::string PERMISSION_STORAGE_MANAGER = "ohos.permission.STORAGE_MANAGER";
const std::string PERMISSION_MOUNT_MANAGER = "ohos.permission.MOUNT_UNMOUNT_MANAGER";
@ -190,6 +192,10 @@ StorageManagerStub::StorageManagerStub()
&StorageManagerStub::HandleNotifyMtpMount;
opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_MTP_UNMOUNT)] =
&StorageManagerStub::HandleNotifyMtpUnmount;
opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT_MEDIA_FUSE)] =
&StorageManagerStub::HandleMountMediaFuse;
opToInterfaceMap_[static_cast<uint32_t>(StorageManagerInterfaceCode::UMOUNT_MEDIA_FUSE)] =
&StorageManagerStub::HandleUMountMediaFuse;
}
int32_t StorageManagerStub::OnRemoteRequest(uint32_t code,
@ -307,6 +313,10 @@ int32_t StorageManagerStub::OnRemoteRequest(uint32_t code,
return HandleNotifyMtpMount(data, reply);
case static_cast<uint32_t>(StorageManagerInterfaceCode::NOTIFY_MTP_UNMOUNT):
return HandleNotifyMtpUnmount(data, reply);
case static_cast<uint32_t>(StorageManagerInterfaceCode::MOUNT_MEDIA_FUSE):
return HandleMountMediaFuse(data, reply);
case static_cast<uint32_t>(StorageManagerInterfaceCode::UMOUNT_MEDIA_FUSE):
return HandleUMountMediaFuse(data, reply);
default:
LOGE("Cannot response request %d: unknown tranction", code);
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
@ -1269,5 +1279,78 @@ int32_t StorageManagerStub::HandleNotifyMtpUnmount(MessageParcel &data, MessageP
LOGI("StorageManagerStub::HandleNotifyMtpUnmount");
return E_OK;
}
int32_t StorageManagerStub::HandleMountMediaFuse(MessageParcel &data, MessageParcel &reply)
{
LOGI("StorageManagerStub::HandleMountMediaFuse start.");
// Only for medialibrary to mount fuse.
std::string bundleName;
int32_t uid = IPCSkeleton::GetCallingUid();
auto bundleMgr = DelayedSingleton<BundleMgrConnector>::GetInstance()->GetBundleMgrProxy();
if (bundleMgr == nullptr) {
LOGE("Connect bundle manager sa proxy failed.");
return E_BUNDLEMGR_ERROR;
}
if (!bundleMgr->GetBundleNameForUid(uid, bundleName)) {
LOGE("Invoke bundleMgr interface to get bundle name failed.");
return E_BUNDLEMGR_ERROR;
}
if (bundleName != MEDIALIBRARY_BUNDLE_NAME) {
LOGE("permissionCheck error, caller is %{public}s(%{public}d), should be %{public}s",
bundleName.c_str(), uid, MEDIALIBRARY_BUNDLE_NAME.c_str());
return E_PERMISSION_DENIED;
}
int32_t userId = data.ReadInt32();
int32_t fd = -1;
int32_t ret = MountMediaFuse(userId, fd);
if (!reply.WriteInt32(ret)) {
LOGE("Write reply error code failed");
if (ret == E_OK) {
close(fd);
}
return E_WRITE_REPLY_ERR;
}
if (ret == E_OK) {
if (!reply.WriteFileDescriptor(fd)) {
LOGE("Write reply fd failed");
close(fd);
return E_WRITE_REPLY_ERR;
}
close(fd);
}
return E_OK;
}
int32_t StorageManagerStub::HandleUMountMediaFuse(MessageParcel &data, MessageParcel &reply)
{
LOGI("StorageManagerStub::HandleUMountMediaFuse start.");
// Only for medialibrary to mount fuse.
std::string bundleName;
int32_t uid = IPCSkeleton::GetCallingUid();
auto bundleMgr = DelayedSingleton<BundleMgrConnector>::GetInstance()->GetBundleMgrProxy();
if (bundleMgr == nullptr) {
LOGE("Connect bundle manager sa proxy failed.");
return E_BUNDLEMGR_ERROR;
}
if (!bundleMgr->GetBundleNameForUid(uid, bundleName)) {
LOGE("Invoke bundleMgr interface to get bundle name failed.");
return E_BUNDLEMGR_ERROR;
}
if (bundleName != MEDIALIBRARY_BUNDLE_NAME) {
LOGE("permissionCheck error, caller is %{public}s(%{public}d), should be %{public}s",
bundleName.c_str(), uid, MEDIALIBRARY_BUNDLE_NAME.c_str());
return E_PERMISSION_DENIED;
}
int32_t userId = data.ReadInt32();
int32_t ret = UMountMediaFuse(userId);
if (!reply.WriteInt32(ret)) {
return E_WRITE_REPLY_ERR;
}
return E_OK;
}
} // StorageManager
} // OHOS

9
services/storage_manager/ipc/test/BUILD.gn
View File

@ -108,6 +108,7 @@ ohos_unittest("storage_manager_stub_test") {
"${storage_manager_path}/innerkits_impl/src/volume_external.cpp",
"${storage_manager_path}/ipc/src/storage_manager_stub.cpp",
"${storage_manager_path}/ipc/test/storage_manager_stub_test.cpp",
"${storage_manager_path}/storage/src/bundle_manager_connector.cpp",
"${storage_manager_path}/utils/src/storage_utils.cpp",
]
@ -119,6 +120,8 @@ ohos_unittest("storage_manager_stub_test") {
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"app_file_service:fileshare_native",
"bundle_framework:appexecfwk_base",
"bundle_framework:appexecfwk_core",
"c_utils:utils",
"googletest:gmock_main",
"googletest:gtest_main",
@ -165,6 +168,7 @@ ohos_unittest("storage_manager_stub_nonpermission_test") {
"${storage_manager_path}/innerkits_impl/src/volume_external.cpp",
"${storage_manager_path}/ipc/src/storage_manager_stub.cpp",
"${storage_manager_path}/ipc/test/storage_manager_stub_noper_test.cpp",
"${storage_manager_path}/storage/src/bundle_manager_connector.cpp",
"${storage_manager_path}/utils/src/storage_utils.cpp",
]
@ -174,6 +178,8 @@ ohos_unittest("storage_manager_stub_nonpermission_test") {
"ability_base:zuri",
"access_token:libaccesstoken_sdk",
"app_file_service:fileshare_native",
"bundle_framework:appexecfwk_base",
"bundle_framework:appexecfwk_core",
"c_utils:utils",
"googletest:gmock_main",
"googletest:gtest_main",
@ -222,6 +228,7 @@ ohos_unittest("storage_manager_stub_mockipc_test") {
"${storage_manager_path}/ipc/src/storage_manager_stub.cpp",
"${storage_manager_path}/ipc/test/ipc_skeleton_mock.cpp",
"${storage_manager_path}/ipc/test/storage_manager_stub_mockipc_test.cpp",
"${storage_manager_path}/storage/src/bundle_manager_connector.cpp",
"${storage_manager_path}/utils/src/storage_utils.cpp",
]
@ -231,6 +238,8 @@ ohos_unittest("storage_manager_stub_mockipc_test") {
"ability_base:zuri",
"access_token:libaccesstoken_sdk",
"app_file_service:fileshare_native",
"bundle_framework:appexecfwk_base",
"bundle_framework:appexecfwk_core",
"c_utils:utils",
"googletest:gmock_main",
"googletest:gtest_main",

57
services/storage_manager/ipc/test/storage_manager_proxy_test.cpp
View File

@ -1707,4 +1707,61 @@ HWTEST_F(StorageManagerProxyTest, Storage_manager_proxy_NotifyMtpUnmounted_0000,
EXPECT_EQ(result, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageManagerProxyTest-end Storage_manager_proxy_NotifyMtpUnmounted_0000";
}
/**
* @tc.number: SUB_STORAGE_Storage_manager_proxy_MountMediaFuse_0000
* @tc.name: Storage_manager_proxy_MountMediaFuse_0000
* @tc.desc: Test function of MountMediaFuse interface for SUCCESS.
* @tc.size: MEDIUM
* @tc.type: FUNC
* @tc.level Level 1
*/
HWTEST_F(StorageManagerProxyTest, Storage_manager_proxy_MountMediaFuse_0000, testing::ext::TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageManagerProxyTest-begin Storage_manager_proxy_MountMediaFuse_0000";
ASSERT_TRUE(mock_ != nullptr) << "StorageManagerServiceMock failed";
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Invoke(mock_.GetRefPtr(), &StorageManagerServiceMock::InvokeSendRequest));
int32_t userId = 130;
int32_t devFd = 140;
ASSERT_TRUE(proxy_ != nullptr) << "StorageManagerProxy failed";
int32_t result = proxy_->MountMediaFuse(userId, devFd);
EXPECT_EQ(result, E_OK);
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Return(E_WRITE_PARCEL_ERR));
result = proxy_->MountMediaFuse(userId, devFd);
EXPECT_EQ(result, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageManagerProxyTest-end Storage_manager_proxy_MountMediaFuse_0000";
}
/**
* @tc.number: SUB_STORAGE_Storage_manager_proxy_UMountMediaFuse_0000
* @tc.name: Storage_manager_proxy_UMountMediaFuse_0000
* @tc.desc: Test function of UMountMediaFuse interface for SUCCESS.
* @tc.size: MEDIUM
* @tc.type: FUNC
* @tc.level Level 1
*/
HWTEST_F(StorageManagerProxyTest, Storage_manager_proxy_UMountMediaFuse_0000, testing::ext::TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageManagerProxyTest-begin Storage_manager_proxy_UMountMediaFuse_0000";
ASSERT_TRUE(mock_ != nullptr) << "StorageManagerServiceMock failed";
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Invoke(mock_.GetRefPtr(), &StorageManagerServiceMock::InvokeSendRequest));
int32_t userId = 130;
ASSERT_TRUE(proxy_ != nullptr) << "StorageManagerProxy failed";
int32_t result = proxy_->UMountMediaFuse(userId);
EXPECT_EQ(result, E_OK);
EXPECT_CALL(*mock_, SendRequest(testing::_, testing::_, testing::_, testing::_))
.Times(1)
.WillOnce(testing::Return(E_WRITE_PARCEL_ERR));
result = proxy_->UMountMediaFuse(userId);
EXPECT_EQ(result, E_WRITE_PARCEL_ERR);
GTEST_LOG_(INFO) << "StorageManagerProxyTest-end Storage_manager_proxy_UMountMediaFuse_0000";
}
} // namespace

10
services/storage_manager/ipc/test/storage_manager_service_mock.h
View File

@ -318,6 +318,16 @@ public:
{
return E_OK;
}
virtual int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override
{
return E_OK;
}
virtual int32_t UMountMediaFuse(int32_t userId) override
{
return E_OK;
}
};
} // namespace StorageManager
} // namespace OHOS

3
services/storage_manager/ipc/test/storage_manager_stub_mock.h
View File

@ -85,6 +85,9 @@ public:
MOCK_METHOD4(NotifyMtpMounted, int32_t(const std::string &, const std::string &, const std::string &,
const std::string &));
MOCK_METHOD2(NotifyMtpUnmounted, int32_t(const std::string &, const std::string &));
MOCK_METHOD2(MountMediaFuse, int32_t (int32_t, int32_t &));
MOCK_METHOD1(UMountMediaFuse, int32_t (int32_t));
};
} // namespace StorageManager
} // namespace OHOS

4
services/storage_manager/ipc/test/storage_manager_stub_test.cpp
View File

@ -79,6 +79,8 @@ namespace {
static_cast<uint32_t>(StorageManagerInterfaceCode::SET_RECOVER_KEY),
static_cast<int32_t>(StorageManagerInterfaceCode::NOTIFY_MTP_MOUNT),
static_cast<int32_t>(StorageManagerInterfaceCode::NOTIFY_MTP_UNMOUNT),
static_cast<int32_t>(StorageManagerInterfaceCode::MOUNT_MEDIA_FUSE),
static_cast<int32_t>(StorageManagerInterfaceCode::UMOUNT_MEDIA_FUSE),
};
}
@ -217,6 +219,8 @@ HWTEST_F(StorageManagerStubTest, Storage_Manager_StorageManagerStubTest_OnRemote
EXPECT_CALL(mock, SetRecoverKey(testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, NotifyMtpMounted(testing::_, testing::_, testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, NotifyMtpUnmounted(testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, MountMediaFuse(testing::_, testing::_)).WillOnce(testing::Return(E_OK));
EXPECT_CALL(mock, UMountMediaFuse(testing::_)).WillOnce(testing::Return(E_OK));
for (auto c : g_code) {
MessageParcel data;

10
services/storage_manager/mock/storage_daemon_proxy_mock.cpp
View File

@ -235,5 +235,15 @@ int32_t StorageDaemonProxy::GetFileEncryptStatus(uint32_t userId, bool &isEncryp
{
return E_OK;
}
int32_t StorageDaemonProxy::MountMediaFuse(int32_t userId, int32_t &devFd)
{
return E_OK;
}
int32_t StorageDaemonProxy::UMountMediaFuse(int32_t userId)
{
return E_OK;
}
} // StorageDaemon
} // OHOS

10
services/storage_manager/mock/storage_manager_proxy_mock.cpp
View File

@ -316,5 +316,15 @@ int32_t StorageManagerProxy::NotifyMtpUnmounted(const std::string &id, const std
{
return E_OK;
}
int32_t StorageManagerProxy::MountMediaFuse(int32_t userId, int32_t &devFd)
{
return E_OK;
}
int32_t StorageManagerProxy::UMountMediaFuse(int32_t userId)
{
return E_OK;
}
} // StorageManager
} // OHOS

28
services/storage_manager/storage_daemon_communication/src/storage_daemon_communication.cpp
View File

@ -659,5 +659,33 @@ int32_t StorageDaemonCommunication::UMountDfsDocs(int32_t userId, const std::str
return storageDaemon_->UMountDfsDocs(userId, relativePath, networkId, deviceId);
}
int32_t StorageDaemonCommunication::MountMediaFuse(int32_t userId, int32_t &devFd)
{
int32_t err = Connect();
if (err != E_OK) {
LOGE("Connect failed");
return err;
}
if (storageDaemon_ == nullptr) {
LOGE("StorageDaemonCommunication::Connect service nullptr");
return E_SERVICE_IS_NULLPTR;
}
return storageDaemon_->MountMediaFuse(userId, devFd);
}
int32_t StorageDaemonCommunication::UMountMediaFuse(int32_t userId)
{
int32_t err = Connect();
if (err != E_OK) {
LOGE("Connect failed");
return err;
}
if (storageDaemon_ == nullptr) {
LOGE("StorageDaemonCommunication::Connect service nullptr");
return E_SERVICE_IS_NULLPTR;
}
return storageDaemon_->UMountMediaFuse(userId);
}
} // namespace StorageManager
} // namespace OHOS

41
services/storage_manager/storage_daemon_communication/test/storage_daemon_communication_test.cpp
View File

@ -215,6 +215,47 @@ HWTEST_F(StorageDaemonCommunicationTest, Daemon_communication_UMountDfsDocs_001,
GTEST_LOG_(INFO) << "StorageDaemonCommunicationTest-end Daemon_communication_UMountDfsDocs_001 SUCCESS";
}
/**
* @tc.number: SUB_STORAGE_Daemon_communication_MountMediaFuse_001
* @tc.name: Daemon_communication_MountMediaFuse_001
* @tc.desc: Test function of MountMediaFuse interface for SUCCESS.
* @tc.size: MEDIUM
* @tc.type: FUNC
* @tc.level Level 1
*/
HWTEST_F(StorageDaemonCommunicationTest, Daemon_communication_MountMediaFuse_001, testing::ext::TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageDaemonCommunicationTest-begin Daemon_communication_MountMediaFuse_001 SUCCESS";
std::shared_ptr<StorageDaemonCommunication> sdCommunication =
DelayedSingleton<StorageDaemonCommunication>::GetInstance();
int32_t userId = 130;
int32_t devFd = 140;
int32_t result = sdCommunication->MountMediaFuse(userId, devFd);
EXPECT_EQ(result, E_OK);
GTEST_LOG_(INFO) << "StorageDaemonCommunicationTest-end Daemon_communication_MountMediaFuse_001 SUCCESS";
}
/**
* @tc.number: SUB_STORAGE_Daemon_communication_UMountMediaFus_001
* @tc.name: Daemon_communication_UMountMediaFuse_001
* @tc.desc: Test function of UMountMediaFuse interface for SUCCESS.
* @tc.size: MEDIUM
* @tc.type: FUNC
* @tc.level Level 1
*/
HWTEST_F(StorageDaemonCommunicationTest, Daemon_communication_UMountMediaFuse_001, testing::ext::TestSize.Level1)
{
GTEST_LOG_(INFO) << "StorageDaemonCommunicationTest-begin Daemon_communication_UMountMediaFuse_001 SUCCESS";
std::shared_ptr<StorageDaemonCommunication> sdCommunication =
DelayedSingleton<StorageDaemonCommunication>::GetInstance();
int32_t userId = 130;
int32_t result = sdCommunication->UMountMediaFuse(userId);
EXPECT_EQ(result, E_OK);
GTEST_LOG_(INFO) << "StorageDaemonCommunicationTest-end Daemon_communication_UMountMediaFuse_001 SUCCESS";
}
/**
* @tc.number: SUB_STORAGE_Daemon_communication_ResetSdProxy_001
* @tc.name: Daemon_communication_ResetSdProxy_001

10
test/fuzztest/storagemanagerproxy_fuzzer/storagemanagerproxymock.h
View File

@ -314,6 +314,16 @@ public:
{
return E_OK;
}
int32_t MountMediaFuse(int32_t userId, int32_t &devFd) override
{
return E_OK;
}
int32_t UMountMediaFuse(int32_t userId) override
{
return E_OK;
}
};
} // namespace StorageManager
} // namespace OHOS