| // Copyright 2020 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 <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/fdio/fdio.h> |
| |
| #include <block-client/cpp/block-device.h> |
| #include <block-client/cpp/fake-device.h> |
| #include <gtest/gtest.h> |
| |
| #include "src/storage/blobfs/blobfs.h" |
| #include "src/storage/blobfs/mkfs.h" |
| #include "src/storage/blobfs/mount.h" |
| #include "src/storage/blobfs/runner.h" |
| #include "src/storage/blobfs/test/blob_utils.h" |
| #include "src/storage/blobfs/test/integration/blobfs_fixtures.h" |
| #include "src/storage/blobfs/test/integration/fdio_test.h" |
| |
| namespace blobfs { |
| namespace { |
| |
| using SyncFdioTest = FdioTest; |
| |
| uint64_t GetSucceededFlushCalls(block_client::FakeBlockDevice* device) { |
| fuchsia_hardware_block_BlockStats stats; |
| device->GetStats(true, &stats); |
| return stats.flush.success.total_calls; |
| } |
| |
| } // namespace |
| |
| // Verifies that fdio "fsync" calls actually sync blobfs files to the block device and verifies |
| // behavior for different lifecycles of creating a file. |
| TEST_F(SyncFdioTest, Sync) { |
| std::unique_ptr<BlobInfo> info = GenerateRandomBlob("", 64); |
| |
| memmove(info->path, info->path + 1, strlen(info->path)); // Remove leading slash. |
| int file = openat(root_fd(), info->path, O_RDWR | O_CREAT); |
| EXPECT_TRUE(file >= 1); |
| |
| // We have not written any data to the file. Blobfs requires the file data to be written so the |
| // name is the hash of the contents. |
| EXPECT_EQ(-1, fsync(file)); |
| |
| // Write the contents. The file must be truncated before writing to declare its size. |
| EXPECT_EQ(0, ftruncate(file, info->size_data)); |
| EXPECT_EQ(write(file, info->data.get(), info->size_data), static_cast<ssize_t>(info->size_data)); |
| |
| // Sync the file. This will block until woken up by the file_wake_thread. |
| EXPECT_EQ(0, fsync(file)); |
| |
| // fsync on a file will flush the journal but won't trigger a flush to the device above and beyond |
| // those required to flush the journal. This might change, but presently, flushing the journal |
| // will trigger a flush after writing data, but before writing to the journal, another one after |
| // between writing to the journal and writing to the final metadata location, and then another one |
| // prior to writing a new info-block, so we should see 3 flush calls plus a flush that's triggered |
| // when we format, so 4 in total. |
| fuchsia_hardware_block_BlockStats stats; |
| block_device()->GetStats(true, &stats); |
| EXPECT_LE(1u, stats.write.success.total_calls); |
| EXPECT_EQ(4u, stats.flush.success.total_calls); |
| |
| // Sync the root directory. Syncing a directory will force the block device to flush. |
| EXPECT_EQ(0, fsync(root_fd())); |
| EXPECT_EQ(1u, GetSucceededFlushCalls(block_device())); |
| } |
| |
| // Verifies that fdio "sync" actually flushes a NAND device. This tests the fdio, blobfs, block |
| // device, and FTL layers. |
| TEST(SyncNandTest, Sync) { |
| // Make a VMO to give to the RAM-NAND. |
| const size_t kVmoSize = 100 * (4096 + 8) * 64; |
| fzl::OwnedVmoMapper vmo; |
| ASSERT_EQ(vmo.CreateAndMap(kVmoSize, "vmo"), ZX_OK); |
| memset(vmo.start(), 0xff, kVmoSize); |
| |
| auto options = BlobfsDefaultTestParam(); |
| options.use_ram_nand = true; |
| options.ram_nand_vmo = vmo.vmo().borrow(); |
| options.device_block_count = 0; // Uses VMO size. |
| options.device_block_size = 8192; |
| |
| std::unique_ptr<BlobInfo> info = GenerateRandomBlob("", 64); |
| |
| memmove(info->path, info->path + 1, strlen(info->path)); // Remove leading slash. |
| auto snapshot = std::make_unique<uint8_t[]>(kVmoSize); |
| |
| { |
| auto fs_or = fs_test::TestFilesystem::Create(options); |
| ASSERT_TRUE(fs_or.is_ok()) << "Unable to create file system: " << fs_or.status_string(); |
| auto fs = std::move(fs_or).value(); |
| |
| fbl::unique_fd root_fd(open(fs.mount_path().c_str(), O_DIRECTORY)); |
| fbl::unique_fd file(openat(root_fd.get(), info->path, O_RDWR | O_CREAT)); |
| ASSERT_TRUE(file.is_valid()); |
| |
| // Write the contents. The file must be truncated before writing to declare its size. |
| ASSERT_EQ(ftruncate(file.get(), info->size_data), 0); |
| ASSERT_EQ(write(file.get(), info->data.get(), info->size_data), |
| static_cast<ssize_t>(info->size_data)); |
| |
| // This should block until the sync is complete. fsync-ing the root FD is required to flush |
| // everything. |
| ASSERT_EQ(fsync(file.get()), 0); |
| ASSERT_EQ(fsync(root_fd.get()), 0); |
| |
| // Without closing the file or tearing down the existing connection (which may add extra |
| // flushes, etc.), create a snapshot of the current. This will emulate a power cycle. |
| memcpy(snapshot.get(), vmo.start(), kVmoSize); |
| } |
| |
| // Restore snapshot and remount. |
| memcpy(vmo.start(), snapshot.get(), kVmoSize); |
| auto fs_or = fs_test::TestFilesystem::Open(options); |
| ASSERT_TRUE(fs_or.is_ok()) << "Unable to open file system: " << fs_or.status_string(); |
| auto fs = std::move(fs_or).value(); |
| |
| // The blob file should exist. |
| fbl::unique_fd root_fd(open(fs.mount_path().c_str(), O_DIRECTORY)); |
| fbl::unique_fd file(openat(root_fd.get(), info->path, O_RDONLY)); |
| ASSERT_TRUE(file.is_valid()); |
| |
| // The contents should be exactly what we wrote. |
| std::unique_ptr<char[]> read_data = std::make_unique<char[]>(info->size_data); |
| ASSERT_EQ(read(file.get(), read_data.get(), info->size_data), |
| static_cast<ssize_t>(info->size_data)); |
| EXPECT_EQ(memcmp(info->data.get(), &read_data[0], info->size_data), 0); |
| } |
| |
| } // namespace blobfs |