| // Copyright 2016 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "cryptohome/dircrypto_data_migrator/migration_helper.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include <fcntl.h> |
| #include <sys/ioctl.h> |
| #include <sys/stat.h> |
| #include <sys/xattr.h> |
| #include <unistd.h> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include <base/bind.h> |
| #include <base/files/file_path.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/rand_util.h> |
| #include <base/strings/string_number_conversions.h> |
| #include <base/synchronization/waitable_event.h> |
| #include <base/threading/thread.h> |
| |
| #include "cryptohome/migration_type.h" |
| #include "cryptohome/mock_platform.h" |
| |
| extern "C" { |
| #include <linux/fs.h> |
| } |
| |
| using base::FilePath; |
| using base::ScopedTempDir; |
| using testing::_; |
| using testing::DoDefault; |
| using testing::Invoke; |
| using testing::InvokeWithoutArgs; |
| using testing::NiceMock; |
| using testing::Return; |
| using testing::SetErrnoAndReturn; |
| using testing::Values; |
| |
| namespace cryptohome { |
| namespace dircrypto_data_migrator { |
| |
| namespace { |
| constexpr uint64_t kDefaultChunkSize = 128; |
| constexpr char kMtimeXattrName[] = "user.mtime"; |
| constexpr char kAtimeXattrName[] = "user.atime"; |
| |
| constexpr char kStatusFilesDir[] = "/home/.shadow/deadbeef/status_dir"; |
| constexpr char kFromDir[] = "/home/.shadow/deadbeef/temporary_mount"; |
| constexpr char kToDir[] = "/home/.shadow/deadbeef/mount"; |
| } // namespace |
| |
| class MigrationHelperTest : public ::testing::Test { |
| public: |
| MigrationHelperTest() |
| : status_files_dir_(kStatusFilesDir), |
| from_dir_(kFromDir), |
| to_dir_(kToDir) {} |
| virtual ~MigrationHelperTest() {} |
| |
| void SetUp() override { |
| ASSERT_TRUE(platform_.CreateDirectory(status_files_dir_)); |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_)); |
| ASSERT_TRUE(platform_.CreateDirectory(to_dir_)); |
| } |
| |
| void ProgressCaptor( |
| const user_data_auth::DircryptoMigrationProgress& progress) { |
| migrated_values_.push_back(progress.current_bytes()); |
| total_values_.push_back(progress.total_bytes()); |
| status_values_.push_back(progress.status()); |
| } |
| |
| protected: |
| NiceMock<MockPlatform> platform_; |
| |
| base::FilePath status_files_dir_; |
| base::FilePath from_dir_; |
| base::FilePath to_dir_; |
| |
| std::vector<uint64_t> migrated_values_; |
| std::vector<uint64_t> total_values_; |
| std::vector<user_data_auth::DircryptoMigrationStatus> status_values_; |
| }; |
| |
| TEST_F(MigrationHelperTest, EmptyTest) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(from_dir_)); |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(to_dir_)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| TEST_F(MigrationHelperTest, CopyAttributesDirectory) { |
| // This test only covers permissions and xattrs. Ownership copying requires |
| // more extensive mocking and is covered in CopyOwnership test. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kDirectory[] = "directory"; |
| const FilePath kFromDirPath = from_dir_.Append(kDirectory); |
| ASSERT_TRUE(platform_.CreateDirectory(kFromDirPath)); |
| |
| // Set some attributes to this directory. |
| |
| mode_t mode = S_ISVTX | S_IRUSR | S_IWUSR | S_IXUSR; |
| ASSERT_TRUE(platform_.SetPermissions(kFromDirPath, mode)); |
| // GetPermissions call is needed because some bits to mode are applied |
| // automatically, so our original |mode| value is not what the resulting file |
| // actually has. |
| ASSERT_TRUE(platform_.GetPermissions(kFromDirPath, &mode)); |
| |
| constexpr char kAttrName[] = "user.attr"; |
| constexpr char kValue[] = "value"; |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute(kFromDirPath, kAttrName, |
| kValue, sizeof(kValue))); |
| |
| // Set ext2 attributes |
| int ext2_attrs = FS_SYNC_FL | FS_NODUMP_FL; |
| ASSERT_TRUE(platform_.SetExtFileAttributes(kFromDirPath, ext2_attrs)); |
| |
| base::stat_wrapper_t from_stat; |
| ASSERT_TRUE(platform_.Stat(kFromDirPath, &from_stat)); |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| const FilePath kToDirPath = to_dir_.Append(kDirectory); |
| base::stat_wrapper_t to_stat; |
| ASSERT_TRUE(platform_.Stat(kToDirPath, &to_stat)); |
| EXPECT_TRUE(platform_.DirectoryExists(kToDirPath)); |
| |
| // Verify mtime was coppied. atime for directories is not |
| // well-preserved because we have to traverse the directories to determine |
| // migration size. |
| EXPECT_EQ(from_stat.st_mtim.tv_sec, to_stat.st_mtim.tv_sec); |
| EXPECT_EQ(from_stat.st_mtim.tv_nsec, to_stat.st_mtim.tv_nsec); |
| |
| // Verify Permissions and xattrs were copied |
| mode_t to_mode; |
| ASSERT_TRUE(platform_.GetPermissions(kToDirPath, &to_mode)); |
| EXPECT_EQ(mode, to_mode); |
| char value[sizeof(kValue) + 1]; |
| ASSERT_TRUE(platform_.GetExtendedFileAttribute(kToDirPath, kAttrName, value, |
| sizeof(kValue))); |
| value[sizeof(kValue)] = '\0'; |
| EXPECT_STREQ(kValue, value); |
| |
| // Verify ext2 flags were copied |
| int new_ext2_attrs; |
| ASSERT_TRUE(platform_.GetExtFileAttributes(kToDirPath, &new_ext2_attrs)); |
| EXPECT_EQ(ext2_attrs, new_ext2_attrs & ext2_attrs); |
| } |
| |
| TEST_F(MigrationHelperTest, DirectoryPartiallyMigrated) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kDirectory[] = "directory"; |
| const FilePath kFromDirPath = from_dir_.Append(kDirectory); |
| ASSERT_TRUE(platform_.CreateDirectory(kFromDirPath)); |
| constexpr struct timespec kMtime = {123, 456}; |
| constexpr struct timespec kAtime = {234, 567}; |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute( |
| to_dir_, kMtimeXattrName, reinterpret_cast<const char*>(&kMtime), |
| sizeof(kMtime))); |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute( |
| to_dir_, kAtimeXattrName, reinterpret_cast<const char*>(&kAtime), |
| sizeof(kAtime))); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| base::stat_wrapper_t to_stat; |
| |
| // Verify that stored timestamps for in-progress migrations are respected |
| ASSERT_TRUE(platform_.Stat(to_dir_, &to_stat)); |
| EXPECT_EQ(kMtime.tv_sec, to_stat.st_mtim.tv_sec); |
| EXPECT_EQ(kMtime.tv_nsec, to_stat.st_mtim.tv_nsec); |
| EXPECT_EQ(kAtime.tv_sec, to_stat.st_atim.tv_sec); |
| EXPECT_EQ(kAtime.tv_nsec, to_stat.st_atim.tv_nsec); |
| |
| // Verify subdirectory was migrated |
| const FilePath kToDirPath = to_dir_.Append(kDirectory); |
| EXPECT_TRUE(platform_.DirectoryExists(kToDirPath)); |
| } |
| |
| TEST_F(MigrationHelperTest, CopySymlink) { |
| // This test does not cover setting ownership values as that requires more |
| // extensive mocking. Ownership copying instead is covered by the |
| // CopyOwnership test. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| FilePath target; |
| |
| constexpr char kFileName[] = "file"; |
| constexpr char kAbsLinkTarget[] = "/dev/null"; |
| const FilePath kTargetInMigrationDirAbsLinkTarget = |
| from_dir_.Append(kFileName); |
| const FilePath kRelLinkTarget = base::FilePath(kFileName); |
| constexpr char kRelLinkName[] = "link1"; |
| constexpr char kAbsLinkName[] = "link2"; |
| constexpr char kTargetInMigrationDirAbsLinkName[] = "link3"; |
| const FilePath kFromRelLinkPath = from_dir_.Append(kRelLinkName); |
| const FilePath kFromAbsLinkPath = from_dir_.Append(kAbsLinkName); |
| const FilePath kFromTargetInMigrationDirAbsLinkPath = |
| from_dir_.Append(kTargetInMigrationDirAbsLinkName); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kFromRelLinkPath, kRelLinkTarget)); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kFromAbsLinkPath, |
| base::FilePath(kAbsLinkTarget))); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kFromTargetInMigrationDirAbsLinkPath, |
| kTargetInMigrationDirAbsLinkTarget)); |
| base::stat_wrapper_t from_stat; |
| ASSERT_TRUE(platform_.Stat(kFromRelLinkPath, &from_stat)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| const FilePath kToFilePath = to_dir_.Append(kFileName); |
| const FilePath kToRelLinkPath = to_dir_.Append(kRelLinkName); |
| const FilePath kToAbsLinkPath = to_dir_.Append(kAbsLinkName); |
| const FilePath kToTargetInMigrationDirAbsLinkPath = |
| to_dir_.Append(kTargetInMigrationDirAbsLinkName); |
| const FilePath kExpectedTargetInMigrationDirAbsLinkTarget = |
| to_dir_.Append(kFileName); |
| |
| // Verify that timestamps were updated appropriately. |
| base::stat_wrapper_t to_stat; |
| ASSERT_TRUE(platform_.Stat(kToRelLinkPath, &to_stat)); |
| EXPECT_EQ(from_stat.st_atim.tv_sec, to_stat.st_atim.tv_sec); |
| EXPECT_EQ(from_stat.st_atim.tv_nsec, to_stat.st_atim.tv_nsec); |
| EXPECT_EQ(from_stat.st_mtim.tv_sec, to_stat.st_mtim.tv_sec); |
| EXPECT_EQ(from_stat.st_mtim.tv_nsec, to_stat.st_mtim.tv_nsec); |
| |
| // Verify that all links have been copied correctly |
| EXPECT_TRUE(platform_.ReadLink(kToRelLinkPath, &target)); |
| EXPECT_EQ(kRelLinkTarget.value(), target.value()); |
| EXPECT_TRUE(platform_.ReadLink(kToAbsLinkPath, &target)); |
| EXPECT_EQ(kAbsLinkTarget, target.value()); |
| EXPECT_TRUE(platform_.ReadLink(kToTargetInMigrationDirAbsLinkPath, &target)); |
| EXPECT_EQ(kExpectedTargetInMigrationDirAbsLinkTarget.value(), target.value()); |
| } |
| |
| TEST_F(MigrationHelperTest, OneEmptyFile) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "empty_file"; |
| |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(kFileName))); |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(to_dir_)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // The file is moved. |
| EXPECT_FALSE(platform_.FileExists(from_dir_.Append(kFileName))); |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(kFileName))); |
| } |
| |
| TEST_F(MigrationHelperTest, OneEmptyFileInDirectory) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kDir1[] = "directory1"; |
| constexpr char kDir2[] = "directory2"; |
| constexpr char kFileName[] = "empty_file"; |
| |
| // Create directory1/directory2/empty_file in from_dir_. |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_.Append(kDir1).Append(kDir2))); |
| ASSERT_TRUE(platform_.TouchFileDurable( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(to_dir_)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // The file is moved. |
| EXPECT_FALSE(platform_.FileExists( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| EXPECT_TRUE(platform_.IsDirectoryEmpty(from_dir_.Append(kDir1))); |
| EXPECT_TRUE(platform_.FileExists( |
| to_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| } |
| |
| TEST_F(MigrationHelperTest, UnreadableFile) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kDir1[] = "directory1"; |
| constexpr char kDir2[] = "directory2"; |
| constexpr char kFileName[] = "empty_file"; |
| |
| // Create directory1/directory2/empty_file in from_dir_. File will be |
| // unreadable to test failure case. |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_.Append(kDir1).Append(kDir2))); |
| ASSERT_TRUE(platform_.TouchFileDurable( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(to_dir_)); |
| ASSERT_TRUE(platform_.SetPermissions( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName), S_IWUSR)); |
| |
| EXPECT_FALSE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // The file is not moved. |
| EXPECT_TRUE(platform_.FileExists( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| } |
| |
| TEST_F(MigrationHelperTest, CopyAttributesFile) { |
| // This test does not cover setting ownership values as that requires more |
| // extensive mocking. Ownership copying instead is covered by the |
| // CopyOwnership test. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "file"; |
| const FilePath kFromFilePath = from_dir_.Append(kFileName); |
| const FilePath kToFilePath = to_dir_.Append(kFileName); |
| |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(kFileName))); |
| // Set some attributes to this file. |
| |
| mode_t mode = S_ISVTX | S_IRUSR | S_IWUSR | S_IXUSR; |
| ASSERT_TRUE(platform_.SetPermissions(kFromFilePath, mode)); |
| // GetPermissions call is needed because some bits to mode are applied |
| // automatically, so our original |mode| value is not what the resulting file |
| // actually has. |
| ASSERT_TRUE(platform_.GetPermissions(kFromFilePath, &mode)); |
| |
| constexpr char kAttrName[] = "user.attr"; |
| constexpr char kValue[] = "value"; |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute(kFromFilePath, kAttrName, |
| kValue, sizeof(kValue))); |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute( |
| kFromFilePath, kSourceURLXattrName, kValue, sizeof(kValue))); |
| ASSERT_TRUE(platform_.SetExtendedFileAttribute( |
| kFromFilePath, kReferrerURLXattrName, kValue, sizeof(kValue))); |
| |
| // Set ext2 attributes |
| int ext2_attrs = FS_SYNC_FL | FS_NODUMP_FL; |
| ASSERT_TRUE(platform_.SetExtFileAttributes(kFromFilePath, ext2_attrs)); |
| |
| base::stat_wrapper_t from_stat; |
| ASSERT_TRUE(platform_.Stat(kFromFilePath, &from_stat)); |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| base::stat_wrapper_t to_stat; |
| ASSERT_TRUE(platform_.Stat(kToFilePath, &to_stat)); |
| EXPECT_EQ(from_stat.st_atim.tv_sec, to_stat.st_atim.tv_sec); |
| EXPECT_EQ(from_stat.st_atim.tv_nsec, to_stat.st_atim.tv_nsec); |
| EXPECT_EQ(from_stat.st_mtim.tv_sec, to_stat.st_mtim.tv_sec); |
| EXPECT_EQ(from_stat.st_mtim.tv_nsec, to_stat.st_mtim.tv_nsec); |
| |
| EXPECT_TRUE(platform_.FileExists(kToFilePath)); |
| |
| mode_t permission; |
| ASSERT_TRUE(platform_.GetPermissions(kToFilePath, &permission)); |
| EXPECT_EQ(mode, permission); |
| |
| char value[sizeof(kValue) + 1]; |
| ASSERT_TRUE(platform_.GetExtendedFileAttribute(kToFilePath, kAttrName, value, |
| sizeof(kValue))); |
| value[sizeof(kValue)] = '\0'; |
| EXPECT_STREQ(kValue, value); |
| |
| // The temporary xatttrs for storing mtime/atime should be removed. |
| ASSERT_FALSE(platform_.GetExtendedFileAttribute(kToFilePath, kMtimeXattrName, |
| nullptr, 0)); |
| ASSERT_EQ(ENODATA, errno); |
| ASSERT_FALSE(platform_.GetExtendedFileAttribute(kToFilePath, kAtimeXattrName, |
| nullptr, 0)); |
| ASSERT_EQ(ENODATA, errno); |
| |
| // Quarantine xattrs storing the origin and referrer of downloaded files |
| // should also be removed. |
| ASSERT_FALSE(platform_.GetExtendedFileAttribute( |
| kToFilePath, kSourceURLXattrName, nullptr, 0)); |
| ASSERT_EQ(ENODATA, errno); |
| ASSERT_FALSE(platform_.GetExtendedFileAttribute( |
| kToFilePath, kReferrerURLXattrName, nullptr, 0)); |
| ASSERT_EQ(ENODATA, errno); |
| |
| // Verify ext2 flags were copied |
| int new_ext2_attrs; |
| ASSERT_TRUE(platform_.GetExtFileAttributes(kToFilePath, &new_ext2_attrs)); |
| EXPECT_EQ(ext2_attrs, new_ext2_attrs & ext2_attrs); |
| } |
| |
| TEST_F(MigrationHelperTest, CopyOwnership) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| const base::FilePath kLinkTarget = base::FilePath("foo"); |
| const base::FilePath kLink("link"); |
| const base::FilePath kFile("file"); |
| const base::FilePath kDir("dir"); |
| const base::FilePath kFromLink = from_dir_.Append(kLink); |
| const base::FilePath kFromFile = from_dir_.Append(kFile); |
| const base::FilePath kFromDir = from_dir_.Append(kDir); |
| const base::FilePath kToLink = to_dir_.Append(kLink); |
| const base::FilePath kToFile = to_dir_.Append(kFile); |
| const base::FilePath kToDir = to_dir_.Append(kDir); |
| uid_t file_uid = 1; |
| gid_t file_gid = 2; |
| uid_t link_uid = 3; |
| gid_t link_gid = 4; |
| uid_t dir_uid = 5; |
| gid_t dir_gid = 6; |
| ASSERT_TRUE(platform_.TouchFileDurable(kFromFile)); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kFromLink, kLinkTarget)); |
| ASSERT_TRUE(platform_.CreateDirectory(kFromDir)); |
| ASSERT_TRUE(platform_.TouchFileDurable(kToFile)); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kToLink, kLinkTarget)); |
| ASSERT_TRUE(platform_.CreateDirectory(kToDir)); |
| |
| base::stat_wrapper_t stat; |
| ASSERT_TRUE(platform_.Stat(kFromFile, &stat)); |
| stat.st_uid = file_uid; |
| stat.st_gid = file_gid; |
| EXPECT_CALL(platform_, SetOwnership(kToFile, file_uid, file_gid, false)) |
| .WillOnce(Return(true)); |
| EXPECT_TRUE( |
| helper.CopyAttributes(kFile, FileEnumerator::FileInfo(kFromFile, stat))); |
| |
| ASSERT_TRUE(platform_.Stat(kFromLink, &stat)); |
| stat.st_uid = link_uid; |
| stat.st_gid = link_gid; |
| EXPECT_CALL(platform_, SetOwnership(kToLink, link_uid, link_gid, false)) |
| .WillOnce(Return(true)); |
| EXPECT_TRUE( |
| helper.CopyAttributes(kLink, FileEnumerator::FileInfo(kFromLink, stat))); |
| |
| ASSERT_TRUE(platform_.Stat(kFromDir, &stat)); |
| stat.st_uid = dir_uid; |
| stat.st_gid = dir_gid; |
| EXPECT_CALL(platform_, SetOwnership(kToDir, dir_uid, dir_gid, false)) |
| .WillOnce(Return(true)); |
| EXPECT_TRUE( |
| helper.CopyAttributes(kDir, FileEnumerator::FileInfo(kFromDir, stat))); |
| } |
| |
| TEST_F(MigrationHelperTest, MigrateNestedDir) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kDir1[] = "directory1"; |
| constexpr char kDir2[] = "directory2"; |
| constexpr char kFileName[] = "empty_file"; |
| |
| // Create directory1/directory2/empty_file in from_dir_. |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_.Append(kDir1).Append(kDir2))); |
| ASSERT_TRUE(platform_.TouchFileDurable( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| ASSERT_TRUE(platform_.IsDirectoryEmpty(to_dir_)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // The file is moved. |
| EXPECT_TRUE(platform_.FileExists( |
| to_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| EXPECT_FALSE(platform_.FileExists( |
| from_dir_.Append(kDir1).Append(kDir2).Append(kFileName))); |
| EXPECT_TRUE(platform_.IsDirectoryEmpty(from_dir_.Append(kDir1))); |
| } |
| |
| TEST_F(MigrationHelperTest, MigrateInProgress) { |
| // Test the case where the migration was interrupted part way through, but in |
| // a clean way such that the two directory trees are consistent (files are |
| // only present in one or the other) |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFile1[] = "kFile1"; |
| constexpr char kFile2[] = "kFile2"; |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(kFile1))); |
| ASSERT_TRUE(platform_.TouchFileDurable(to_dir_.Append(kFile2))); |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // Both files have been moved to to_dir_ |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(kFile1))); |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(kFile2))); |
| EXPECT_FALSE(platform_.FileExists(from_dir_.Append(kFile1))); |
| EXPECT_FALSE(platform_.FileExists(from_dir_.Append(kFile2))); |
| } |
| |
| TEST_F(MigrationHelperTest, MigrateInProgressDuplicateFile) { |
| // Test the case where the migration was interrupted part way through, |
| // resulting in files that were successfully written to destination but not |
| // yet removed from the source. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFile1[] = "kFile1"; |
| constexpr char kFile2[] = "kFile2"; |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(kFile1))); |
| ASSERT_TRUE(platform_.TouchFileDurable(to_dir_.Append(kFile1))); |
| ASSERT_TRUE(platform_.TouchFileDurable(to_dir_.Append(kFile2))); |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // Both files have been moved to to_dir_ |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(kFile1))); |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(kFile2))); |
| EXPECT_FALSE(platform_.FileExists(from_dir_.Append(kFile1))); |
| EXPECT_FALSE(platform_.FileExists(from_dir_.Append(kFile2))); |
| } |
| |
| TEST_F(MigrationHelperTest, MigrateInProgressPartialFile) { |
| // Test the case where the migration was interrupted part way through, with a |
| // file having been partially copied to the destination but not fully. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "file"; |
| const FilePath kFromFilePath = from_dir_.Append(kFileName); |
| const FilePath kToFilePath = to_dir_.Append(kFileName); |
| |
| const size_t kFinalFileSize = kDefaultChunkSize * 2; |
| const size_t kFromFileSize = kDefaultChunkSize; |
| const size_t kToFileSize = kDefaultChunkSize; |
| char full_contents[kFinalFileSize]; |
| base::RandBytes(full_contents, kFinalFileSize); |
| |
| ASSERT_TRUE( |
| platform_.WriteArrayToFile(kFromFilePath, full_contents, kFromFileSize)); |
| base::File kToFile; |
| platform_.InitializeFile(&kToFile, kToFilePath, |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(kToFile.IsValid()); |
| kToFile.SetLength(kFinalFileSize); |
| const size_t kToFileOffset = kFinalFileSize - kToFileSize; |
| ASSERT_EQ( |
| kToFileSize, |
| kToFile.Write(kToFileOffset, full_contents + kToFileOffset, kToFileSize)); |
| ASSERT_EQ(kFinalFileSize, kToFile.GetLength()); |
| kToFile.Close(); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // File has been moved to to_dir_ |
| std::string to_contents; |
| ASSERT_TRUE(platform_.ReadFileToString(kToFilePath, &to_contents)); |
| EXPECT_EQ(std::string(full_contents, kFinalFileSize), to_contents); |
| EXPECT_FALSE(platform_.FileExists(kFromFilePath)); |
| } |
| |
| TEST_F(MigrationHelperTest, MigrateInProgressPartialFileDuplicateData) { |
| // Test the case where the migration was interrupted part way through, with a |
| // file having been partially copied to the destination but the source file |
| // not yet having been truncated to reflect that. |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "file"; |
| const FilePath kFromFilePath = from_dir_.Append(kFileName); |
| const FilePath kToFilePath = to_dir_.Append(kFileName); |
| |
| const size_t kFinalFileSize = kDefaultChunkSize * 2; |
| const size_t kFromFileSize = kFinalFileSize; |
| const size_t kToFileSize = kDefaultChunkSize; |
| char full_contents[kFinalFileSize]; |
| base::RandBytes(full_contents, kFinalFileSize); |
| |
| ASSERT_TRUE( |
| platform_.WriteArrayToFile(kFromFilePath, full_contents, kFromFileSize)); |
| base::File kToFile; |
| platform_.InitializeFile(&kToFile, kToFilePath, |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(kToFile.IsValid()); |
| kToFile.SetLength(kFinalFileSize); |
| const size_t kToFileOffset = kFinalFileSize - kToFileSize; |
| ASSERT_EQ( |
| kDefaultChunkSize, |
| kToFile.Write(kToFileOffset, full_contents + kToFileOffset, kToFileSize)); |
| ASSERT_EQ(kFinalFileSize, kToFile.GetLength()); |
| kToFile.Close(); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // File has been moved to to_dir_ |
| std::string to_contents; |
| ASSERT_TRUE(platform_.ReadFileToString(kToFilePath, &to_contents)); |
| EXPECT_EQ(std::string(full_contents, kFinalFileSize), to_contents); |
| EXPECT_FALSE(platform_.FileExists(kFromFilePath)); |
| } |
| |
| TEST_F(MigrationHelperTest, ProgressCallback) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "file"; |
| constexpr char kLinkName[] = "link"; |
| constexpr char kDirName[] = "dir"; |
| const FilePath kFromSubdir = from_dir_.Append(kDirName); |
| const FilePath kFromFile = kFromSubdir.Append(kFileName); |
| const FilePath kFromLink = kFromSubdir.Append(kLinkName); |
| const FilePath kToSubdir = to_dir_.Append(kDirName); |
| const FilePath kToFile = kToSubdir.Append(kFileName); |
| |
| const size_t kFileSize = kDefaultChunkSize; |
| char from_contents[kFileSize]; |
| base::RandBytes(from_contents, kFileSize); |
| ASSERT_TRUE(platform_.CreateDirectory(kFromSubdir)); |
| ASSERT_TRUE(platform_.CreateSymbolicLink(kFromLink, kFromFile.BaseName())); |
| ASSERT_TRUE(platform_.WriteArrayToFile(kFromFile, from_contents, kFileSize)); |
| int64_t expected_size = kFileSize; |
| expected_size += kFromFile.BaseName().value().length(); |
| int64_t dir_size; |
| ASSERT_TRUE(platform_.GetFileSize(kFromSubdir, &dir_size)); |
| expected_size += dir_size; |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| ASSERT_EQ(migrated_values_.size(), total_values_.size()); |
| int callbacks = migrated_values_.size(); |
| EXPECT_GT(callbacks, 2); |
| EXPECT_EQ(callbacks, total_values_.size()); |
| EXPECT_EQ(callbacks, status_values_.size()); |
| |
| // Verify that the progress goes from initializing to in_progress. |
| EXPECT_EQ(user_data_auth::DIRCRYPTO_MIGRATION_INITIALIZING, |
| status_values_[0]); |
| for (int i = 1; i < callbacks; i++) { |
| SCOPED_TRACE(i); |
| EXPECT_EQ(user_data_auth::DIRCRYPTO_MIGRATION_IN_PROGRESS, |
| status_values_[i]); |
| } |
| |
| // Verify that migrated value starts at 0 and increases to total |
| EXPECT_EQ(0, migrated_values_[1]); |
| for (int i = 2; i < callbacks - 1; i++) { |
| SCOPED_TRACE(i); |
| EXPECT_GE(migrated_values_[i], migrated_values_[i - 1]); |
| } |
| EXPECT_EQ(expected_size, migrated_values_[callbacks - 1]); |
| |
| // Verify that total always matches the expected size |
| EXPECT_EQ(callbacks, total_values_.size()); |
| for (int i = 1; i < callbacks; i++) { |
| SCOPED_TRACE(i); |
| EXPECT_EQ(expected_size, total_values_[i]); |
| } |
| } |
| |
| TEST_F(MigrationHelperTest, NotEnoughFreeSpace) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| |
| EXPECT_CALL(platform_, AmountOfFreeDiskSpace(_)).WillOnce(Return(0)); |
| EXPECT_FALSE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| TEST_F(MigrationHelperTest, ForceSmallerChunkSize) { |
| constexpr int kMaxChunkSize = 128 << 20; // 128MB |
| constexpr int kNumJobThreads = 2; |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kMaxChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| helper.set_num_job_threads_for_testing(kNumJobThreads); |
| |
| constexpr int kFreeSpace = 13 << 20; |
| // Chunk size should be limited to a multiple of 4MB (kErasureBlockSize) |
| // smaller than (kFreeSpace - kFreeSpaceBuffer) / kNumJobThreads (4MB) |
| constexpr int kExpectedChunkSize = 4 << 20; |
| constexpr int kFileSize = 7 << 20; |
| const FilePath kFromFilePath = from_dir_.Append("file"); |
| base::File from_file; |
| platform_.InitializeFile(&from_file, kFromFilePath, |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(from_file.IsValid()); |
| |
| from_file.SetLength(kFileSize); |
| from_file.Close(); |
| |
| EXPECT_CALL(platform_, AmountOfFreeDiskSpace(_)).WillOnce(Return(kFreeSpace)); |
| EXPECT_CALL(platform_, SendFile(_, _, kExpectedChunkSize, |
| kFileSize - kExpectedChunkSize)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(platform_, SendFile(_, _, 0, kExpectedChunkSize)) |
| .WillOnce(Return(true)); |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| TEST_F(MigrationHelperTest, SkipInvalidSQLiteFiles) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| const char kCorruptedFilePath[] = |
| "root/android-data/data/user/0/com.google.android.gms/" |
| "databases/playlog.db-shm"; |
| const FilePath kFromSQLiteShm = from_dir_.Append(kCorruptedFilePath); |
| const FilePath kToSQLiteShm = to_dir_.Append(kCorruptedFilePath); |
| const FilePath kSkippedFileLog = to_dir_.Append(kSkippedFileListFileName); |
| ASSERT_TRUE(platform_.CreateDirectory(kFromSQLiteShm.DirName())); |
| ASSERT_TRUE(platform_.TouchFileDurable(kFromSQLiteShm)); |
| EXPECT_CALL(platform_, InitializeFile(_, _, _)).WillRepeatedly(DoDefault()); |
| EXPECT_CALL(platform_, InitializeFile(_, kFromSQLiteShm, _)) |
| .WillOnce( |
| Invoke([](base::File* file, const FilePath& path, uint32_t mode) { |
| *file = base::File(base::File::FILE_ERROR_IO); |
| })); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| EXPECT_TRUE(platform_.DirectoryExists(kToSQLiteShm.DirName())); |
| EXPECT_FALSE(platform_.FileExists(kToSQLiteShm)); |
| EXPECT_FALSE(platform_.FileExists(kFromSQLiteShm)); |
| EXPECT_TRUE(platform_.FileExists(kSkippedFileLog)); |
| std::string contents; |
| ASSERT_TRUE(platform_.ReadFileToString(kSkippedFileLog, &contents)); |
| EXPECT_EQ(std::string(kCorruptedFilePath) + "\n", contents); |
| } |
| |
| TEST_F(MigrationHelperTest, AllJobThreadsFailing) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr int kNumJobThreads = 2; |
| helper.set_num_job_threads_for_testing(kNumJobThreads); |
| helper.set_max_job_list_size_for_testing(1); |
| |
| // Create more files than the job threads. |
| for (int i = 0; i < kNumJobThreads * 2; ++i) { |
| ASSERT_TRUE(platform_.TouchFileDurable( |
| from_dir_.AppendASCII(base::NumberToString(i)))); |
| } |
| // All job threads will stop processing jobs because of errors. Also, set |
| // errno to avoid confusing base::File::OSErrorToFileError(). crbug.com/731809 |
| EXPECT_CALL(platform_, DeleteFile(_)) |
| .WillRepeatedly(SetErrnoAndReturn(EIO, false)); |
| // Migrate() still returns the result without deadlocking. crbug.com/731575 |
| EXPECT_FALSE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| TEST_F(MigrationHelperTest, SkipDuppedGCacheTmpDir) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| // Prepare the problematic path. |
| constexpr char kGCacheV1[] = "user/GCache/v1"; |
| constexpr char kTmpDir[] = "tmp"; |
| constexpr char kCachedDir[] = "foobar"; |
| constexpr char kCachedFile[] = "tmp.gdoc"; |
| |
| const base::FilePath v1_path(from_dir_.Append(kGCacheV1)); |
| const base::FilePath cached_dir = v1_path.Append(kTmpDir).Append(kCachedDir); |
| const base::FilePath cached_file = cached_dir.Append(kCachedFile); |
| |
| ASSERT_TRUE(platform_.CreateDirectory(cached_dir)); |
| ASSERT_TRUE(platform_.TouchFileDurable(cached_file)); |
| |
| // Test the migration. |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // Ensure that the inner path is never visited. |
| ASSERT_FALSE(platform_.FileExists(v1_path)); |
| ASSERT_TRUE(platform_.FileExists(to_dir_.Append(kGCacheV1))); |
| ASSERT_FALSE(platform_.FileExists(to_dir_.Append(kGCacheV1).Append(kTmpDir))); |
| } |
| |
| TEST_F(MigrationHelperTest, MinimalMigration) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::MINIMAL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| std::vector<FilePath> expect_kept_dirs; |
| std::vector<FilePath> expect_kept_files; |
| std::vector<FilePath> expect_skipped_dirs; |
| std::vector<FilePath> expect_skipped_files; |
| |
| // Set up expectations about what is skipped and what is kept. |
| // Random stuff not on the allowlist is skipped. |
| expect_skipped_dirs.emplace_back("user/Application Cache"); |
| expect_skipped_dirs.emplace_back("root/android-data"); |
| expect_skipped_files.emplace_back("user/Application Cache/subfile"); |
| expect_skipped_files.emplace_back("user/skipped_file"); |
| expect_skipped_files.emplace_back("root/skipped_file"); |
| |
| // session_manager/policy in the root section is kept along with children. |
| expect_kept_dirs.emplace_back("root/session_manager/policy"); |
| expect_kept_files.emplace_back("root/session_manager/policy/subfile1"); |
| expect_kept_files.emplace_back("root/session_manager/policy/subfile2"); |
| expect_kept_dirs.emplace_back("user/log"); |
| // .pki directory is kept along with contents |
| expect_kept_dirs.emplace_back("user/.pki"); |
| expect_kept_dirs.emplace_back("user/.pki/nssdb"); |
| expect_kept_files.emplace_back("user/.pki/nssdb/subfile1"); |
| expect_kept_files.emplace_back("user/.pki/nssdb/subfile2"); |
| // top-level Web Data is kept |
| expect_kept_files.emplace_back("user/Web Data"); |
| |
| // Create all directories |
| for (const auto& path : expect_kept_dirs) |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_.Append(path))) |
| << path.value(); |
| |
| for (const auto& path : expect_skipped_dirs) |
| ASSERT_TRUE(platform_.CreateDirectory(from_dir_.Append(path))) |
| << path.value(); |
| |
| // Create all files |
| for (const auto& path : expect_kept_files) |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(path))) |
| << path.value(); |
| |
| for (const auto& path : expect_skipped_files) |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(path))) |
| << path.value(); |
| |
| // Test the minimal migration. |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // Only the expected files and directories are moved. |
| for (const auto& path : expect_kept_dirs) |
| EXPECT_TRUE(platform_.DirectoryExists(to_dir_.Append(path))) |
| << path.value(); |
| |
| for (const auto& path : expect_kept_files) |
| EXPECT_TRUE(platform_.FileExists(to_dir_.Append(path))) << path.value(); |
| |
| for (const auto& path : expect_skipped_dirs) |
| EXPECT_FALSE(platform_.FileExists(to_dir_.Append(path))) << path.value(); |
| |
| for (const auto& path : expect_skipped_files) |
| EXPECT_FALSE(platform_.FileExists(to_dir_.Append(path))) << path.value(); |
| |
| // The source is empty. |
| EXPECT_TRUE(platform_.IsDirectoryEmpty(from_dir_)); |
| } |
| |
| TEST_F(MigrationHelperTest, CancelMigrationBeforeStart) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| // Cancel migration before starting, and migration just fails. |
| helper.Cancel(); |
| EXPECT_FALSE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| TEST_F(MigrationHelperTest, CancelMigrationOnAnotherThread) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| // One empty file to migrate. |
| constexpr char kFileName[] = "empty_file"; |
| ASSERT_TRUE(platform_.TouchFileDurable(from_dir_.Append(kFileName))); |
| // Wait in SyncFile so that cancellation happens before migration finishes. |
| base::WaitableEvent syncfile_is_called_event( |
| base::WaitableEvent::ResetPolicy::AUTOMATIC, |
| base::WaitableEvent::InitialState::NOT_SIGNALED); |
| base::WaitableEvent cancel_is_called_event( |
| base::WaitableEvent::ResetPolicy::AUTOMATIC, |
| base::WaitableEvent::InitialState::NOT_SIGNALED); |
| EXPECT_CALL(platform_, SyncFile(to_dir_.Append(kFileName))) |
| .WillOnce(InvokeWithoutArgs( |
| [&syncfile_is_called_event, &cancel_is_called_event]() { |
| syncfile_is_called_event.Signal(); |
| cancel_is_called_event.Wait(); |
| return true; |
| })); |
| |
| // Cancel on another thread after waiting for SyncFile to get called. |
| base::Thread thread("Canceller thread"); |
| ASSERT_TRUE(thread.Start()); |
| thread.task_runner()->PostTask( |
| FROM_HERE, base::BindOnce(&base::WaitableEvent::Wait, |
| base::Unretained(&syncfile_is_called_event))); |
| thread.task_runner()->PostTask( |
| FROM_HERE, |
| base::BindOnce(&MigrationHelper::Cancel, base::Unretained(&helper))); |
| thread.task_runner()->PostTask( |
| FROM_HERE, base::BindOnce(&base::WaitableEvent::Signal, |
| base::Unretained(&cancel_is_called_event))); |
| // Migration gets cancelled. |
| EXPECT_FALSE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| } |
| |
| class DataMigrationTest : public MigrationHelperTest, |
| public ::testing::WithParamInterface<size_t> {}; |
| |
| TEST_P(DataMigrationTest, CopyFileData) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| |
| constexpr char kFileName[] = "file"; |
| const FilePath kFromFile = from_dir_.Append(kFileName); |
| const FilePath kToFile = to_dir_.Append(kFileName); |
| |
| const size_t kFileSize = GetParam(); |
| char from_contents[kFileSize]; |
| base::RandBytes(from_contents, kFileSize); |
| ASSERT_TRUE(platform_.WriteArrayToFile(kFromFile, from_contents, kFileSize)); |
| |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| std::string to_contents; |
| ASSERT_TRUE(platform_.ReadFileToString(kToFile, &to_contents)); |
| EXPECT_EQ(0, strncmp(from_contents, to_contents.data(), kFileSize)); |
| EXPECT_FALSE(platform_.FileExists(kFromFile)); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(WithRandomData, |
| DataMigrationTest, |
| Values(kDefaultChunkSize / 2, |
| kDefaultChunkSize, |
| kDefaultChunkSize * 2, |
| kDefaultChunkSize * 2 + kDefaultChunkSize / 2, |
| kDefaultChunkSize * 10, |
| kDefaultChunkSize * 100, |
| 123456, |
| 1, |
| 2)); |
| |
| // MigrationHelperJobListTest verifies that the job list size limit doesn't |
| // cause dead lock, however small (or big) the limit is. |
| class MigrationHelperJobListTest |
| : public MigrationHelperTest, |
| public ::testing::WithParamInterface<size_t> {}; |
| |
| TEST_P(MigrationHelperJobListTest, ProcessJobs) { |
| MigrationHelper helper(&platform_, from_dir_, to_dir_, status_files_dir_, |
| kDefaultChunkSize, MigrationType::FULL); |
| helper.set_namespaced_mtime_xattr_name_for_testing(kMtimeXattrName); |
| helper.set_namespaced_atime_xattr_name_for_testing(kAtimeXattrName); |
| helper.set_max_job_list_size_for_testing(GetParam()); |
| |
| // Prepare many files and directories. |
| constexpr int kNumDirectories = 100; |
| constexpr int kNumFilesPerDirectory = 10; |
| for (int i = 0; i < kNumDirectories; ++i) { |
| SCOPED_TRACE(i); |
| FilePath dir = from_dir_.AppendASCII(base::NumberToString(i)); |
| ASSERT_TRUE(platform_.CreateDirectory(dir)); |
| for (int j = 0; j < kNumFilesPerDirectory; ++j) { |
| SCOPED_TRACE(j); |
| const std::string data = |
| base::NumberToString(i * kNumFilesPerDirectory + j); |
| ASSERT_TRUE(platform_.WriteStringToFile( |
| dir.AppendASCII(base::NumberToString(j)), data)); |
| } |
| } |
| |
| // Migrate. |
| EXPECT_TRUE(helper.Migrate(base::BindRepeating( |
| &MigrationHelperTest::ProgressCaptor, base::Unretained(this)))); |
| |
| // The files and directories are moved. |
| for (int i = 0; i < kNumDirectories; ++i) { |
| SCOPED_TRACE(i); |
| FilePath dir = to_dir_.AppendASCII(base::NumberToString(i)); |
| EXPECT_TRUE(platform_.DirectoryExists(dir)); |
| for (int j = 0; j < kNumFilesPerDirectory; ++j) { |
| SCOPED_TRACE(j); |
| std::string data; |
| EXPECT_TRUE(platform_.ReadFileToString( |
| dir.AppendASCII(base::NumberToString(j)), &data)); |
| EXPECT_EQ(base::NumberToString(i * kNumFilesPerDirectory + j), data); |
| } |
| } |
| EXPECT_TRUE(platform_.IsDirectoryEmpty(from_dir_)); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(JobListSize, |
| MigrationHelperJobListTest, |
| Values(1, 10, 100, 1000)); |
| |
| } // namespace dircrypto_data_migrator |
| } // namespace cryptohome |
