src/storage/fs_test/truncate.cc - fuchsia - Git at Google

 // 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 <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <random>
 #include <tuple>

 #include <fbl/unique_fd.h>

 #include "src/storage/fs_test/truncate_fixture.h"

 namespace fs_test {
 namespace {

 using TruncateTest = FilesystemTest;

 void CheckFileContains(const char* filename, const void* data, ssize_t len) {
   char buf[4096];
   struct stat st;

   ASSERT_EQ(stat(filename, &st), 0);
   ASSERT_EQ(st.st_size, len);
   fbl::unique_fd fd(open(filename, O_RDWR, 0644));
   ASSERT_TRUE(fd);
   ASSERT_EQ(read(fd.get(), buf, len), len);
   ASSERT_EQ(memcmp(buf, data, len), 0);
 }

 void CheckFileEmpty(const char* filename) {
   struct stat st;
   ASSERT_EQ(stat(filename, &st), 0);
   ASSERT_EQ(st.st_size, 0);
 }

 // Test that the really simple cases of truncate are operational
 TEST_P(TruncateTest, TruncateSmall) {
   const char* str = "Hello, World!\n";
   const std::string filename = GetPath("alpha");

   // Try writing a string to a file
   fbl::unique_fd fd(open(filename.c_str(), O_RDWR | O_CREAT, 0644));
   ASSERT_TRUE(fd);
   ASSERT_EQ(write(fd.get(), str, strlen(str)), static_cast<ssize_t>(strlen(str)));
   ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, strlen(str)));

   // Check that opening a file with O_TRUNC makes it empty
   fbl::unique_fd fd2(open(filename.c_str(), O_RDWR | O_TRUNC, 0644));
   ASSERT_TRUE(fd2);
   ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

   // Check that we can still write to a file that has been truncated
   ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0);
   ASSERT_EQ(write(fd.get(), str, strlen(str)), static_cast<ssize_t>(strlen(str)));
   ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, strlen(str)));

   // Check that we can truncate the file using the "truncate" function
   ASSERT_EQ(truncate(filename.c_str(), 5), 0);
   ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, 5));
   ASSERT_EQ(truncate(filename.c_str(), 0), 0);
   ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

   // Check that truncating an already empty file does not cause problems
   ASSERT_EQ(truncate(filename.c_str(), 0), 0);
   ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

   // Check that we can use truncate to extend a file
   char empty[5] = {0, 0, 0, 0, 0};
   ASSERT_EQ(truncate(filename.c_str(), 5), 0);
   ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), empty, 5));

   ASSERT_EQ(close(fd.release()), 0);
   ASSERT_EQ(close(fd2.release()), 0);
   ASSERT_EQ(unlink(filename.c_str()), 0);
 }

 enum class SparseTestType {
   UnlinkThenClose,
   CloseThenUnlink,
 };

 using ParamType = std::tuple<TestFilesystemOptions, SparseTestType>;

 class SparseTruncateTest : public BaseFilesystemTest,
                            public testing::WithParamInterface<ParamType> {
  public:
   SparseTruncateTest() : BaseFilesystemTest(std::get<0>(GetParam())) {}

   SparseTestType test_type() const { return std::get<1>(GetParam()); }
 };

 // This test catches a particular regression in MinFS truncation, where, if a block is cut in half
 // for truncation, it is read, filled with zeroes, and written back out to disk.
 //
 // This test tries to proke at a variety of offsets of interest.
 TEST_P(SparseTruncateTest, PartialBlockSparse) {
   constexpr size_t kBlockSize = 8192;
   constexpr size_t kDirectBlocks = 16;
   constexpr size_t kIndirectBlocks = 31;
   constexpr size_t kDirectPerIndirect = kBlockSize / 4;

   uint8_t buf[kBlockSize];
   memset(buf, 0xAB, sizeof(buf));

   off_t write_offsets[] = {
       kBlockSize * 5,
       kBlockSize * kDirectBlocks,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * 1,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * 2,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks -
           2 * kBlockSize,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks - kBlockSize,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks,
       kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks + kBlockSize,
   };

   for (off_t write_off : write_offsets) {
     fbl::unique_fd fd(
         open(GetPath("truncate-sparse").c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR));
     ASSERT_TRUE(fd);
     ASSERT_EQ(lseek(fd.get(), write_off, SEEK_SET), write_off);
     ASSERT_EQ(write(fd.get(), buf, sizeof(buf)), static_cast<ssize_t>(sizeof(buf)))
         << "errno=" << errno << ", write_off=" << write_off;
     ASSERT_EQ(ftruncate(fd.get(), write_off + 2 * kBlockSize), 0);
     ASSERT_EQ(ftruncate(fd.get(), write_off + kBlockSize + kBlockSize / 2), 0);
     ASSERT_EQ(ftruncate(fd.get(), write_off + kBlockSize / 2), 0);
     ASSERT_EQ(ftruncate(fd.get(), write_off - kBlockSize / 2), 0);
     if (test_type() == SparseTestType::UnlinkThenClose) {
       ASSERT_EQ(unlink(GetPath("truncate-sparse").c_str()), 0);
       ASSERT_EQ(close(fd.release()), 0);
     } else {
       ASSERT_EQ(close(fd.release()), 0);
       ASSERT_EQ(unlink(GetPath("truncate-sparse").c_str()), 0);
     }
   }
 }

 TEST_P(TruncateTest, Errno) {
   fbl::unique_fd fd(
       open(GetPath("truncate_errno").c_str(), O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR));
   ASSERT_TRUE(fd);

   ASSERT_EQ(ftruncate(fd.get(), -1), -1);
   ASSERT_EQ(errno, EINVAL);
   errno = 0;

   const off_t max_file_size = fs().GetTraits().max_file_size;
   if (max_file_size < std::numeric_limits<off_t>::max()) {
     ASSERT_EQ(ftruncate(fd.get(), max_file_size + 1), -1);
     ASSERT_EQ(errno, EINVAL);
   }

   ASSERT_EQ(unlink(GetPath("truncate_errno").c_str()), 0);
   ASSERT_EQ(close(fd.release()), 0);
 }

 TEST_P(TruncateTest, ShrinkRace) {
   std::string file = GetPath("truncate_shrink_race");
   const char* file_name = file.c_str();
   const uint32_t page_size = zx_system_get_page_size();
   const uint32_t offset = page_size - 2;
   const char data[] = "hello";
   const ssize_t len = static_cast<ssize_t>(strlen(data));
   const uint32_t end = offset + len;
   std::vector<uint8_t> zero(offset);
   for (int i = 0; i < 100; ++i) {
     {
       fbl::unique_fd fd(open(file_name, O_RDWR | O_CREAT | O_TRUNC, 0666));
       ASSERT_TRUE(fd) << strerror(errno);
       ASSERT_EQ(pwrite(fd.get(), data, len, offset), len);
       fd.reset();
     }
     std::thread thread1([&] {
       fbl::unique_fd fd(open(file_name, O_RDWR));
       ASSERT_TRUE(fd);
       std::random_device random;
       std::uniform_int_distribution distribution(0, 1000);
       usleep(distribution(random));
       const size_t buf_size = page_size * 2 + 100;
       char buf[buf_size];
       ssize_t result = read(fd.get(), buf, buf_size);
       EXPECT_TRUE(result == end || result == 0) << errno;
       if (result == end) {
         EXPECT_EQ(memcmp(buf, zero.data(), zero.size()), 0);
         EXPECT_EQ(memcmp(buf + offset, data, len), 0);
       }
     });
     std::thread thread2([&] {
       fbl::unique_fd fd(open(file_name, O_RDWR));
       ASSERT_TRUE(fd);
       EXPECT_EQ(ftruncate(fd.get(), 0), 0);
       EXPECT_EQ(fsync(fd.get()), 0);
     });
     thread1.join();
     thread2.join();
   }
 }

 TEST_P(TruncateTest, GrowAndRead) {
   // Grow the file using truncate making sure that it's growing the file by more than a page and
   // then read at the end (which should be zeroed).
   std::string file_name = GetPath("GrowAndRead");
   fbl::unique_fd fd(open(file_name.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666));
   ASSERT_TRUE(fd);
   constexpr off_t kSize = 100'000;
   EXPECT_EQ(ftruncate(fd.get(), kSize), 0);
   char buf[10] = {1, 1, 1, 1, 1};
   EXPECT_EQ(pread(fd.get(), buf, sizeof(buf), kSize - 5), 5) << strerror(errno);
   char zeros[5] = {0};
   EXPECT_EQ(memcmp(buf, zeros, 5), 0);
 }

 std::string GetParamDescription(const testing::TestParamInfo<ParamType>& param) {
   std::stringstream s;
   s << std::get<0>(param.param);
   switch (std::get<1>(param.param)) {
     case SparseTestType::UnlinkThenClose:
       s << "UnlinkThenClose";
       break;
     case SparseTestType::CloseThenUnlink:
       s << "CloseThenUnlink";
       break;
   }
   return s.str();
 }

 INSTANTIATE_TEST_SUITE_P(/*no prefix*/, TruncateTest, testing::ValuesIn(AllTestFilesystems()),
                          testing::PrintToStringParamName());

 // These tests will only work on a file system that supports sparse files.
 INSTANTIATE_TEST_SUITE_P(
     /*no prefix*/, SparseTruncateTest,
     testing::Combine(
         testing::ValuesIn(MapAndFilterAllTestFilesystems(
             [](const TestFilesystemOptions& options) -> std::optional<TestFilesystemOptions> {
               if (options.filesystem->GetTraits().supports_sparse_files) {
                 return options;
               } else {
                 return std::nullopt;
               }
             })),
         testing::Values(SparseTestType::UnlinkThenClose, SparseTestType::CloseThenUnlink)),
     GetParamDescription);

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SparseTruncateTest);

 INSTANTIATE_TEST_SUITE_P(
     /*no prefix*/, LargeTruncateTest,
     testing::Combine(testing::ValuesIn(AllTestFilesystems()),
                      testing::Values(std::make_tuple(1 << 10, 100, LargeTruncateTestType::KeepOpen),
                                      std::make_tuple(1 << 10, 100, LargeTruncateTestType::Reopen),
                                      std::make_tuple(1 << 15, 50, LargeTruncateTestType::KeepOpen),
                                      std::make_tuple(1 << 15, 50, LargeTruncateTestType::Reopen))),
     GetDescriptionForLargeTruncateTestParamType);

 }  // namespace
 }  // namespace fs_test
	// 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 <errno.h>
	#include <fcntl.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <random>
	#include <tuple>

	#include <fbl/unique_fd.h>

	#include "src/storage/fs_test/truncate_fixture.h"

	namespace fs_test {
	namespace {

	using TruncateTest = FilesystemTest;

	void CheckFileContains(const char* filename, const void* data, ssize_t len) {
	char buf[4096];
	struct stat st;

	ASSERT_EQ(stat(filename, &st), 0);
	ASSERT_EQ(st.st_size, len);
	fbl::unique_fd fd(open(filename, O_RDWR, 0644));
	ASSERT_TRUE(fd);
	ASSERT_EQ(read(fd.get(), buf, len), len);
	ASSERT_EQ(memcmp(buf, data, len), 0);
	}

	void CheckFileEmpty(const char* filename) {
	struct stat st;
	ASSERT_EQ(stat(filename, &st), 0);
	ASSERT_EQ(st.st_size, 0);
	}

	// Test that the really simple cases of truncate are operational
	TEST_P(TruncateTest, TruncateSmall) {
	const char* str = "Hello, World!\n";
	const std::string filename = GetPath("alpha");

	// Try writing a string to a file
	fbl::unique_fd fd(open(filename.c_str(), O_RDWR \| O_CREAT, 0644));
	ASSERT_TRUE(fd);
	ASSERT_EQ(write(fd.get(), str, strlen(str)), static_cast<ssize_t>(strlen(str)));
	ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, strlen(str)));

	// Check that opening a file with O_TRUNC makes it empty
	fbl::unique_fd fd2(open(filename.c_str(), O_RDWR \| O_TRUNC, 0644));
	ASSERT_TRUE(fd2);
	ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

	// Check that we can still write to a file that has been truncated
	ASSERT_EQ(lseek(fd.get(), 0, SEEK_SET), 0);
	ASSERT_EQ(write(fd.get(), str, strlen(str)), static_cast<ssize_t>(strlen(str)));
	ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, strlen(str)));

	// Check that we can truncate the file using the "truncate" function
	ASSERT_EQ(truncate(filename.c_str(), 5), 0);
	ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), str, 5));
	ASSERT_EQ(truncate(filename.c_str(), 0), 0);
	ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

	// Check that truncating an already empty file does not cause problems
	ASSERT_EQ(truncate(filename.c_str(), 0), 0);
	ASSERT_NO_FATAL_FAILURE(CheckFileEmpty(filename.c_str()));

	// Check that we can use truncate to extend a file
	char empty[5] = {0, 0, 0, 0, 0};
	ASSERT_EQ(truncate(filename.c_str(), 5), 0);
	ASSERT_NO_FATAL_FAILURE(CheckFileContains(filename.c_str(), empty, 5));

	ASSERT_EQ(close(fd.release()), 0);
	ASSERT_EQ(close(fd2.release()), 0);
	ASSERT_EQ(unlink(filename.c_str()), 0);
	}

	enum class SparseTestType {
	UnlinkThenClose,
	CloseThenUnlink,
	};

	using ParamType = std::tuple<TestFilesystemOptions, SparseTestType>;

	class SparseTruncateTest : public BaseFilesystemTest,
	public testing::WithParamInterface<ParamType> {
	public:
	SparseTruncateTest() : BaseFilesystemTest(std::get<0>(GetParam())) {}

	SparseTestType test_type() const { return std::get<1>(GetParam()); }
	};

	// This test catches a particular regression in MinFS truncation, where, if a block is cut in half
	// for truncation, it is read, filled with zeroes, and written back out to disk.
	//
	// This test tries to proke at a variety of offsets of interest.
	TEST_P(SparseTruncateTest, PartialBlockSparse) {
	constexpr size_t kBlockSize = 8192;
	constexpr size_t kDirectBlocks = 16;
	constexpr size_t kIndirectBlocks = 31;
	constexpr size_t kDirectPerIndirect = kBlockSize / 4;

	uint8_t buf[kBlockSize];
	memset(buf, 0xAB, sizeof(buf));

	off_t write_offsets[] = {
	kBlockSize * 5,
	kBlockSize * kDirectBlocks,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * 1,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * 2,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks -
	2 * kBlockSize,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks - kBlockSize,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks,
	kBlockSize * kDirectBlocks + kBlockSize * kDirectPerIndirect * kIndirectBlocks + kBlockSize,
	};

	for (off_t write_off : write_offsets) {
	fbl::unique_fd fd(
	open(GetPath("truncate-sparse").c_str(), O_CREAT \| O_RDWR, S_IRUSR \| S_IWUSR));
	ASSERT_TRUE(fd);
	ASSERT_EQ(lseek(fd.get(), write_off, SEEK_SET), write_off);
	ASSERT_EQ(write(fd.get(), buf, sizeof(buf)), static_cast<ssize_t>(sizeof(buf)))
	<< "errno=" << errno << ", write_off=" << write_off;
	ASSERT_EQ(ftruncate(fd.get(), write_off + 2 * kBlockSize), 0);
	ASSERT_EQ(ftruncate(fd.get(), write_off + kBlockSize + kBlockSize / 2), 0);
	ASSERT_EQ(ftruncate(fd.get(), write_off + kBlockSize / 2), 0);
	ASSERT_EQ(ftruncate(fd.get(), write_off - kBlockSize / 2), 0);
	if (test_type() == SparseTestType::UnlinkThenClose) {
	ASSERT_EQ(unlink(GetPath("truncate-sparse").c_str()), 0);
	ASSERT_EQ(close(fd.release()), 0);
	} else {
	ASSERT_EQ(close(fd.release()), 0);
	ASSERT_EQ(unlink(GetPath("truncate-sparse").c_str()), 0);
	}
	}
	}

	TEST_P(TruncateTest, Errno) {
	fbl::unique_fd fd(
	open(GetPath("truncate_errno").c_str(), O_RDWR \| O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR));
	ASSERT_TRUE(fd);

	ASSERT_EQ(ftruncate(fd.get(), -1), -1);
	ASSERT_EQ(errno, EINVAL);
	errno = 0;

	const off_t max_file_size = fs().GetTraits().max_file_size;
	if (max_file_size < std::numeric_limits<off_t>::max()) {
	ASSERT_EQ(ftruncate(fd.get(), max_file_size + 1), -1);
	ASSERT_EQ(errno, EINVAL);
	}

	ASSERT_EQ(unlink(GetPath("truncate_errno").c_str()), 0);
	ASSERT_EQ(close(fd.release()), 0);
	}

	TEST_P(TruncateTest, ShrinkRace) {
	std::string file = GetPath("truncate_shrink_race");
	const char* file_name = file.c_str();
	const uint32_t page_size = zx_system_get_page_size();
	const uint32_t offset = page_size - 2;
	const char data[] = "hello";
	const ssize_t len = static_cast<ssize_t>(strlen(data));
	const uint32_t end = offset + len;
	std::vector<uint8_t> zero(offset);
	for (int i = 0; i < 100; ++i) {
	{
	fbl::unique_fd fd(open(file_name, O_RDWR \| O_CREAT \| O_TRUNC, 0666));
	ASSERT_TRUE(fd) << strerror(errno);
	ASSERT_EQ(pwrite(fd.get(), data, len, offset), len);
	fd.reset();
	}
	std::thread thread1([&] {
	fbl::unique_fd fd(open(file_name, O_RDWR));
	ASSERT_TRUE(fd);
	std::random_device random;
	std::uniform_int_distribution distribution(0, 1000);
	usleep(distribution(random));
	const size_t buf_size = page_size * 2 + 100;
	char buf[buf_size];
	ssize_t result = read(fd.get(), buf, buf_size);
	EXPECT_TRUE(result == end \|\| result == 0) << errno;
	if (result == end) {
	EXPECT_EQ(memcmp(buf, zero.data(), zero.size()), 0);
	EXPECT_EQ(memcmp(buf + offset, data, len), 0);
	}
	});
	std::thread thread2([&] {
	fbl::unique_fd fd(open(file_name, O_RDWR));
	ASSERT_TRUE(fd);
	EXPECT_EQ(ftruncate(fd.get(), 0), 0);
	EXPECT_EQ(fsync(fd.get()), 0);
	});
	thread1.join();
	thread2.join();
	}
	}

	TEST_P(TruncateTest, GrowAndRead) {
	// Grow the file using truncate making sure that it's growing the file by more than a page and
	// then read at the end (which should be zeroed).
	std::string file_name = GetPath("GrowAndRead");
	fbl::unique_fd fd(open(file_name.c_str(), O_RDWR \| O_CREAT \| O_TRUNC, 0666));
	ASSERT_TRUE(fd);
	constexpr off_t kSize = 100'000;
	EXPECT_EQ(ftruncate(fd.get(), kSize), 0);
	char buf[10] = {1, 1, 1, 1, 1};
	EXPECT_EQ(pread(fd.get(), buf, sizeof(buf), kSize - 5), 5) << strerror(errno);
	char zeros[5] = {0};
	EXPECT_EQ(memcmp(buf, zeros, 5), 0);
	}

	std::string GetParamDescription(const testing::TestParamInfo<ParamType>& param) {
	std::stringstream s;
	s << std::get<0>(param.param);
	switch (std::get<1>(param.param)) {
	case SparseTestType::UnlinkThenClose:
	s << "UnlinkThenClose";
	break;
	case SparseTestType::CloseThenUnlink:
	s << "CloseThenUnlink";
	break;
	}
	return s.str();
	}

	INSTANTIATE_TEST_SUITE_P(/no prefix/, TruncateTest, testing::ValuesIn(AllTestFilesystems()),
	testing::PrintToStringParamName());

	// These tests will only work on a file system that supports sparse files.
	INSTANTIATE_TEST_SUITE_P(
	/no prefix/, SparseTruncateTest,
	testing::Combine(
	testing::ValuesIn(MapAndFilterAllTestFilesystems(
	[](const TestFilesystemOptions& options) -> std::optional<TestFilesystemOptions> {
	if (options.filesystem->GetTraits().supports_sparse_files) {
	return options;
	} else {
	return std::nullopt;
	}
	})),
	testing::Values(SparseTestType::UnlinkThenClose, SparseTestType::CloseThenUnlink)),
	GetParamDescription);

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SparseTruncateTest);

	INSTANTIATE_TEST_SUITE_P(
	/no prefix/, LargeTruncateTest,
	testing::Combine(testing::ValuesIn(AllTestFilesystems()),
	testing::Values(std::make_tuple(1 << 10, 100, LargeTruncateTestType::KeepOpen),
	std::make_tuple(1 << 10, 100, LargeTruncateTestType::Reopen),
	std::make_tuple(1 << 15, 50, LargeTruncateTestType::KeepOpen),
	std::make_tuple(1 << 15, 50, LargeTruncateTestType::Reopen))),
	GetDescriptionForLargeTruncateTestParamType);

	} // namespace
	} // namespace fs_test