| // Copyright 2016 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 <fcntl.h> | |
| #include <lib/fdio/fd.h> | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <sys/stat.h> | |
| #include <unistd.h> | |
| #include <zircon/errors.h> | |
| #include <zircon/types.h> | |
| #include <thread> | |
| #include <tuple> | |
| #include <vector> | |
| #include <fbl/unique_fd.h> | |
| #include "src/storage/fs_test/fs_test_fixture.h" | |
| namespace fs_test { | |
| namespace { | |
| using AppendTest = FilesystemTest; | |
| TEST_P(AppendTest, Append) { | |
| char buf[4096]; | |
| const char* hello = "Hello, "; | |
| const char* world = "World!\n"; | |
| struct stat st; | |
| const std::string alpha = GetPath("alpha"); | |
| fbl::unique_fd fd(open(alpha.c_str(), O_RDWR | O_CREAT, 0644)); | |
| ASSERT_TRUE(fd); | |
| // Write "hello" | |
| ASSERT_EQ(strlen(hello), strlen(world)); | |
| ASSERT_EQ(write(fd.get(), hello, strlen(hello)), static_cast<ssize_t>(strlen(hello))); | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(read(fd.get(), buf, strlen(hello)), static_cast<ssize_t>(strlen(hello))); | |
| ASSERT_EQ(strncmp(buf, hello, strlen(hello)), 0); | |
| // At the start of the file, write "world" | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(write(fd.get(), world, strlen(world)), static_cast<ssize_t>(strlen(world))); | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(read(fd.get(), buf, strlen(world)), static_cast<ssize_t>(strlen(world))); | |
| // Ensure that the file contains "world", but not "hello" | |
| ASSERT_EQ(strncmp(buf, world, strlen(world)), 0); | |
| ASSERT_EQ(stat(alpha.c_str(), &st), 0); | |
| ASSERT_EQ(st.st_size, (off_t)strlen(world)); | |
| ASSERT_EQ(unlink(alpha.c_str()), 0); | |
| ASSERT_EQ(close(fd.release()), 0); | |
| fd.reset(open(alpha.c_str(), O_RDWR | O_CREAT | O_APPEND, 0644)); | |
| ASSERT_TRUE(fd); | |
| // Write "hello" | |
| ASSERT_EQ(strlen(hello), strlen(world)); | |
| ASSERT_EQ(write(fd.get(), hello, strlen(hello)), static_cast<ssize_t>(strlen(hello))); | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(read(fd.get(), buf, strlen(hello)), static_cast<ssize_t>(strlen(hello))); | |
| ASSERT_EQ(strncmp(buf, hello, strlen(hello)), 0); | |
| // At the start of the file, write "world" | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(write(fd.get(), world, strlen(world)), static_cast<ssize_t>(strlen(hello))); | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(read(fd.get(), buf, strlen(hello) + strlen(world)), | |
| static_cast<ssize_t>(strlen(hello) + strlen(world))); | |
| // Ensure that the file contains both "hello" and "world" | |
| ASSERT_EQ(strncmp(buf, hello, strlen(hello)), 0); | |
| ASSERT_EQ(strncmp(buf + strlen(hello), world, strlen(world)), 0); | |
| ASSERT_EQ(stat(alpha.c_str(), &st), 0); | |
| ASSERT_EQ(st.st_size, (off_t)(strlen(hello) + strlen(world))); | |
| ASSERT_EQ(unlink(alpha.c_str()), 0); | |
| ASSERT_EQ(close(fd.release()), 0); | |
| } | |
| TEST_P(AppendTest, AppendOnClone) { | |
| enum AppendState { | |
| Append, | |
| NoAppend, | |
| }; | |
| auto verify_append = [](fbl::unique_fd& fd, AppendState appendState) { | |
| // Ensure we have a file of non-zero size. | |
| char buf[32]; | |
| memset(buf, 'a', sizeof(buf)); | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(write(fd.get(), buf, sizeof(buf)), static_cast<ssize_t>(sizeof(buf))); | |
| struct stat st; | |
| ASSERT_EQ(fstat(fd.get(), &st), 0); | |
| off_t size = st.st_size; | |
| // Write at the 'start' of the file. | |
| ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0); | |
| ASSERT_EQ(write(fd.get(), buf, sizeof(buf)), static_cast<ssize_t>(sizeof(buf))); | |
| ASSERT_EQ(fstat(fd.get(), &st), 0); | |
| switch (appendState) { | |
| case Append: | |
| // Even though we wrote to the 'start' of the file, it | |
| // appends to the end if the file was opened as O_APPEND. | |
| ASSERT_EQ(st.st_size, size + static_cast<off_t>(sizeof(buf))); | |
| ASSERT_EQ(fcntl(fd.get(), F_GETFL), O_APPEND | O_RDWR); | |
| break; | |
| case NoAppend: | |
| // We wrote to the start of the file, so the size | |
| // should be unchanged. | |
| ASSERT_EQ(st.st_size, size); | |
| ASSERT_EQ(fcntl(fd.get(), F_GETFL), O_RDWR); | |
| break; | |
| default: | |
| ASSERT_TRUE(false); | |
| } | |
| }; | |
| const std::string append_clone = GetPath("append_clone"); | |
| fbl::unique_fd fd(open(append_clone.c_str(), O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)); | |
| ASSERT_TRUE(fd) << strerror(errno); | |
| // Verify the file was originally opened as append. | |
| ASSERT_NO_FATAL_FAILURE(verify_append(fd, Append)); | |
| // Verify we can toggle append off and back on. | |
| ASSERT_EQ(fcntl(fd.get(), F_SETFL, 0), 0); | |
| ASSERT_NO_FATAL_FAILURE(verify_append(fd, NoAppend)); | |
| ASSERT_EQ(fcntl(fd.get(), F_SETFL, O_APPEND), 0); | |
| ASSERT_NO_FATAL_FAILURE(verify_append(fd, Append)); | |
| // Verify that cloning the fd doesn't lose the APPEND flag. | |
| zx_handle_t handle = ZX_HANDLE_INVALID; | |
| ASSERT_EQ(fdio_fd_clone(fd.get(), &handle), ZX_OK); | |
| int raw_fd = -1; | |
| ASSERT_EQ(fdio_fd_create(handle, &raw_fd), ZX_OK); | |
| fbl::unique_fd cloned_fd(raw_fd); | |
| ASSERT_NO_FATAL_FAILURE(verify_append(cloned_fd, Append)); | |
| ASSERT_EQ(unlink(append_clone.c_str()), 0); | |
| } | |
| using ParamType = std::tuple<TestFilesystemOptions, /*thread_count=*/int>; | |
| class AppendAtomicTest : public BaseFilesystemTest, public testing::WithParamInterface<ParamType> { | |
| public: | |
| AppendAtomicTest() : BaseFilesystemTest(std::get<0>(GetParam())) {} | |
| int thread_count() const { return std::get<1>(GetParam()); } | |
| }; | |
| TEST_P(AppendAtomicTest, MultiThreadedTest) { | |
| constexpr int kWriteLength = 32; | |
| constexpr int kNumWrites = 128; | |
| const std::string append_atomic = GetPath("append-atomic"); | |
| // Create a group of threads which all append 'i' to a file. | |
| // At the end of this test, we should see: | |
| // - A file of length kWriteLength * kNumWrites * thread_count(). | |
| // - kWriteLength * kNumWrites of the character 'i' for all | |
| // values of i in the range [0, thread_count()). | |
| // - Those 'i's should be grouped in units of kWriteLength. | |
| auto threads = std::vector<std::thread>(thread_count()); | |
| for (int i = 0; i < thread_count(); i++) { | |
| threads[i] = std::thread([&append_atomic, i]() { | |
| fbl::unique_fd fd( | |
| open(append_atomic.c_str(), O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)); | |
| if (!fd) { | |
| return -1; | |
| } | |
| char buf[kWriteLength]; | |
| memset(buf, static_cast<int>(i + 1), sizeof(buf)); | |
| for (size_t j = 0; j < kNumWrites; j++) { | |
| if (write(fd.get(), buf, sizeof(buf)) != sizeof(buf)) { | |
| return -1; | |
| } | |
| } | |
| return close(fd.release()); | |
| }); | |
| } | |
| for (std::thread& thread : threads) { | |
| thread.join(); | |
| } | |
| // Verify the contents of the file | |
| fbl::unique_fd fd(open(append_atomic.c_str(), O_RDONLY)); | |
| ASSERT_GE(fd.get(), 0) << "Can't reopen file for verification"; | |
| struct stat st; | |
| ASSERT_EQ(fstat(fd.get(), &st), 0); | |
| ASSERT_EQ(st.st_size, static_cast<off_t>(kWriteLength * kNumWrites * thread_count())); | |
| const size_t kBufLen = kWriteLength * kNumWrites * thread_count(); | |
| auto buf = std::make_unique<char[]>(kBufLen); | |
| ASSERT_EQ(read(fd.get(), buf.get(), kBufLen), static_cast<ssize_t>(kBufLen)); | |
| std::vector<int> counts(thread_count() + 1); | |
| for (size_t i = 0; i < kBufLen; i += kWriteLength) { | |
| size_t val = static_cast<size_t>(buf[i]); | |
| EXPECT_NE(val, 0u) << "Found zeroes at offset " << i; | |
| ASSERT_LE(val, counts.size()) << "Read unexpected value from file"; | |
| counts[val]++; | |
| auto tmp = std::make_unique<char[]>(kWriteLength); | |
| memset(tmp.get(), buf[i], kWriteLength); | |
| ASSERT_EQ(memcmp(&buf[i], tmp.get(), kWriteLength), 0) << "Non-atomic Append Detected"; | |
| } | |
| for (size_t i = 1; i < counts.size(); i++) { | |
| EXPECT_EQ(counts[i], kNumWrites) << "Unexpected number of writes from thread " << i; | |
| } | |
| ASSERT_EQ(close(fd.release()), 0); | |
| ASSERT_EQ(unlink(append_atomic.c_str()), 0); | |
| } | |
| std::string GetParamDescription(const testing::TestParamInfo<ParamType>& param) { | |
| std::stringstream s; | |
| s << std::get<0>(param.param) << "WithThreadCount" << std::get<1>(param.param); | |
| return s.str(); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(/*no prefix*/, AppendTest, testing::ValuesIn(AllTestFilesystems()), | |
| testing::PrintToStringParamName()); | |
| INSTANTIATE_TEST_SUITE_P(/*no prefix*/, AppendAtomicTest, | |
| testing::Combine(testing::ValuesIn(AllTestFilesystems()), | |
| testing::Values(1, 2, 5, 10)), | |
| GetParamDescription); | |
| } // namespace | |
| } // namespace fs_test |