| // Copyright 2017 The Fuchsia 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 <dirent.h> | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <stdio.h> | |
| #include <sys/stat.h> | |
| #include <threads.h> | |
| #include <unistd.h> | |
| #include <atomic> | |
| #include <functional> | |
| #include <tuple> | |
| #include <vector> | |
| #include <fbl/unique_fd.h> | |
| #include "src/storage/fs_test/fs_test_fixture.h" | |
| namespace fs_test { | |
| namespace { | |
| using ParamType = std::tuple<TestFilesystemOptions, /*reuse_subdirectory=*/bool>; | |
| class InodeReuseTest : public BaseFilesystemTest, public testing::WithParamInterface<ParamType> { | |
| public: | |
| InodeReuseTest() : BaseFilesystemTest(std::get<0>(GetParam())) {} | |
| bool reuse_subdirectory() const { return std::get<1>(GetParam()); } | |
| }; | |
| // Try repeatedly creating and removing a file within a directory, as fast as possible, in an | |
| // attempt to trigger filesystem-internal threading races between creation and deletion of a file. | |
| TEST_P(InodeReuseTest, InodeReuse) { | |
| const std::string reuse = GetPath("reuse"); | |
| ASSERT_EQ(mkdir(reuse.c_str(), 0755), 0); | |
| DIR* d = opendir(reuse.c_str()); | |
| ASSERT_NE(d, nullptr); | |
| for (size_t i = 0; i < 1000; i++) { | |
| ASSERT_EQ(mkdirat(dirfd(d), "foo", 0666), 0); | |
| if (reuse_subdirectory()) { | |
| ASSERT_EQ(mkdirat(dirfd(d), "foo/bar", 0666), 0); | |
| ASSERT_EQ(unlinkat(dirfd(d), "foo/bar", 0), 0); | |
| } | |
| ASSERT_EQ(unlinkat(dirfd(d), "foo", 0), 0); | |
| } | |
| ASSERT_EQ(closedir(d), 0); | |
| ASSERT_EQ(rmdir(reuse.c_str()), 0); | |
| } | |
| // Return codes from helper threads | |
| constexpr int kSuccess = 1; | |
| constexpr int kFailure = -1; | |
| constexpr int kUnexpectedFailure = -2; | |
| using thrd_cb_t = int(void*); | |
| class ThreadingTest : public FilesystemTest { | |
| protected: | |
| // Launch some threads, and have them all execute callback 'cb'. | |
| // | |
| // It is expected that: | |
| // - kSuccessCount threads will return "kSuccess" | |
| // - ALL OTHER threads will return "kFailure" | |
| // | |
| // In any other condition, this helper fails. For example, returning "kUnexpectedFailure" from cb | |
| // is an easy way to fail the entire test from a background thread. | |
| template <size_t kNumThreads, size_t kSuccessCount> | |
| void ThreadActionTest(std::function<int()> cb) { | |
| static_assert(kNumThreads >= kSuccessCount, "Need more threads or less successes"); | |
| thrd_t threads[kNumThreads]; | |
| auto callback_wrapper = +[](void* arg) { | |
| auto cb = reinterpret_cast<std::function<int()>*>(arg); | |
| return (*cb)(); | |
| }; | |
| for (size_t i = 0; i < kNumThreads; i++) { | |
| ASSERT_EQ(thrd_create(&threads[i], callback_wrapper, &cb), thrd_success); | |
| } | |
| // Join all threads first before checking whether they were successful. This way all threads | |
| // will be cleaned up even if we encounter a failure. | |
| int success[kNumThreads]; | |
| int result[kNumThreads]; | |
| for (size_t i = 0; i < kNumThreads; i++) { | |
| success[i] = thrd_join(threads[i], &result[i]); | |
| }; | |
| size_t success_count = 0; | |
| for (size_t i = 0; i < kNumThreads; i++) { | |
| ASSERT_EQ(success[i], thrd_success); | |
| if (result[i] == kSuccess) { | |
| success_count++; | |
| ASSERT_LE(success_count, kSuccessCount) << "Too many succeeding threads"; | |
| } else { | |
| ASSERT_EQ(result[i], kFailure) << "Unexpected return code from worker thread"; | |
| } | |
| } | |
| ASSERT_EQ(success_count, kSuccessCount) << "Not enough succeeding threads"; | |
| } | |
| }; | |
| constexpr size_t kIterCount = 10; | |
| TEST_P(ThreadingTest, CreateUnlinkExclusive) { | |
| for (size_t i = 0; i < kIterCount; i++) { | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| fbl::unique_fd fd( | |
| open(GetPath("exclusive").c_str(), O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)); | |
| if (fd) { | |
| return close(fd.release()) == 0 ? kSuccess : kUnexpectedFailure; | |
| } else if (errno == EEXIST) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| if (unlink(GetPath("exclusive").c_str()) == 0) { | |
| return kSuccess; | |
| } else if (errno == ENOENT) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| } | |
| } | |
| TEST_P(ThreadingTest, MkdirRmdirExclusive) { | |
| for (size_t i = 0; i < kIterCount; i++) { | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| if (mkdir(GetPath("exclusive").c_str(), 0666) == 0) { | |
| return kSuccess; | |
| } else if (errno == EEXIST) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| if (rmdir(GetPath("exclusive").c_str()) == 0) { | |
| return kSuccess; | |
| } else if (errno == ENOENT) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| } | |
| } | |
| TEST_P(ThreadingTest, RenameExclusive) { | |
| for (size_t i = 0; i < kIterCount; i++) { | |
| // Test case of renaming from a single source. | |
| ASSERT_EQ(mkdir(GetPath("rename_start").c_str(), 0666), 0); | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| if (rename(GetPath("rename_start").c_str(), GetPath("rename_end").c_str()) == 0) { | |
| return kSuccess; | |
| } else if (errno == ENOENT) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| ASSERT_EQ(rmdir(GetPath("rename_end").c_str()), 0); | |
| // Test case of renaming from multiple sources at once, to a single destination | |
| std::atomic<uint32_t> ctr{0}; | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this, &ctr]() { | |
| char start[128]; | |
| snprintf(start, sizeof(start) - 1, GetPath("rename_start_%u").c_str(), ctr.fetch_add(1)); | |
| if (mkdir(start, 0666)) { | |
| return kUnexpectedFailure; | |
| } | |
| // Give the target a child, so it cannot be overwritten as a target | |
| char child[256]; | |
| snprintf(child, sizeof(child) - 1, "%s/child", start); | |
| if (mkdir(child, 0666)) { | |
| return kUnexpectedFailure; | |
| } | |
| if (rename(start, GetPath("rename_end").c_str()) == 0) { | |
| return kSuccess; | |
| } else if (errno == ENOTEMPTY || errno == EEXIST) { | |
| return rmdir(child) == 0 && rmdir(start) == 0 ? kFailure : kUnexpectedFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| DIR* dir = opendir(GetPath("rename_end").c_str()); | |
| ASSERT_NE(dir, nullptr); | |
| struct dirent* de; | |
| while ((de = readdir(dir)) && de != nullptr) { | |
| unlinkat(dirfd(dir), de->d_name, AT_REMOVEDIR); | |
| } | |
| ASSERT_EQ(closedir(dir), 0); | |
| ASSERT_EQ(rmdir(GetPath("rename_end").c_str()), 0); | |
| } | |
| } | |
| TEST_P(ThreadingTest, RenameOverwrite) { | |
| for (size_t i = 0; i < kIterCount; i++) { | |
| // Test case of renaming from multiple sources at once, to a single destination | |
| std::atomic<uint32_t> ctr{0}; | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 10>([this, &ctr]() { | |
| char start[128]; | |
| snprintf(start, sizeof(start) - 1, GetPath("rename_start_%u").c_str(), ctr.fetch_add(1)); | |
| if (mkdir(start, 0666)) { | |
| return kUnexpectedFailure; | |
| } | |
| if (rename(start, GetPath("rename_end").c_str()) == 0) { | |
| return kSuccess; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| ASSERT_EQ(rmdir(GetPath("rename_end").c_str()), 0); | |
| } | |
| } | |
| using ThreadingLinkTest = ThreadingTest; | |
| TEST_P(ThreadingLinkTest, LinkExclusive) { | |
| for (size_t i = 0; i < kIterCount; i++) { | |
| fbl::unique_fd fd( | |
| open(GetPath("link_start").c_str(), O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR)); | |
| ASSERT_TRUE(fd); | |
| ASSERT_EQ(close(fd.release()), 0); | |
| ASSERT_NO_FATAL_FAILURE((ThreadActionTest<10, 1>([this]() { | |
| if (link(GetPath("link_start").c_str(), GetPath("link_end").c_str()) == 0) { | |
| return kSuccess; | |
| } else if (errno == EEXIST) { | |
| return kFailure; | |
| } | |
| return kUnexpectedFailure; | |
| }))); | |
| ASSERT_EQ(unlink(GetPath("link_start").c_str()), 0); | |
| ASSERT_EQ(unlink(GetPath("link_end").c_str()), 0); | |
| if (!fs().GetTraits().in_memory) { | |
| EXPECT_EQ(fs().Unmount().status_value(), ZX_OK); | |
| EXPECT_EQ(fs().Fsck().status_value(), ZX_OK); | |
| EXPECT_EQ(fs().Mount().status_value(), ZX_OK); | |
| } | |
| } | |
| } | |
| std::vector<TestFilesystemOptions> GetThreadingLinkTestCombinations() { | |
| std::vector<TestFilesystemOptions> test_combinations; | |
| for (const TestFilesystemOptions& options : AllTestFilesystems()) { | |
| if (options.filesystem->GetTraits().supports_hard_links) { | |
| test_combinations.push_back(options); | |
| } | |
| } | |
| return test_combinations; | |
| } | |
| std::string GetParamDescription(const testing::TestParamInfo<ParamType>& param) { | |
| std::stringstream s; | |
| s << std::get<0>(param.param) << (std::get<1>(param.param) ? "ReusingSubdir" : ""); | |
| return s.str(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(/*no prefix*/, InodeReuseTest, | |
| testing::Combine(testing::ValuesIn(AllTestFilesystems()), testing::Bool()), | |
| GetParamDescription); | |
| INSTANTIATE_TEST_SUITE_P(/*no prefix*/, ThreadingTest, testing::ValuesIn(AllTestFilesystems()), | |
| testing::PrintToStringParamName()); | |
| INSTANTIATE_TEST_SUITE_P(/*no prefix*/, ThreadingLinkTest, | |
| testing::ValuesIn(GetThreadingLinkTestCombinations()), | |
| testing::PrintToStringParamName()); | |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ThreadingLinkTest); | |
| } // namespace | |
| } // namespace fs_test |