| // 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 <inttypes.h> |
| |
| #include <limits> |
| #include <safemath/checked_math.h> |
| #include <utility> |
| |
| #include "fvm-host/format.h" |
| |
| namespace { |
| |
| template <class T> uint32_t ToU32(T in) { |
| if (in > std::numeric_limits<uint32_t>::max()) { |
| fprintf(stderr, "%s:%d out of range %" PRIuMAX "\n", __FILE__, __LINE__, |
| safemath::checked_cast<uintmax_t>(in)); |
| exit(-1); |
| } |
| return safemath::checked_cast<uint32_t>(in); |
| } |
| |
| } // namespace |
| |
| BlobfsFormat::BlobfsFormat(fbl::unique_fd fd, const char* type) |
| : Format(), fd_(std::move(fd)) { |
| if (!strcmp(type, kBlobTypeName)) { |
| memcpy(type_, kBlobType, sizeof(kBlobType)); |
| } else if (!strcmp(type, kDefaultTypeName)) { |
| memcpy(type_, kDefaultType, sizeof(kDefaultType)); |
| } else { |
| fprintf(stderr, "Unrecognized type for blobfs: %s\n", type); |
| exit(-1); |
| } |
| |
| if (blobfs::readblk(fd_.get(), 0, reinterpret_cast<void*>(blk_)) < 0) { |
| fprintf(stderr, "blobfs: could not read info block\n"); |
| exit(-1); |
| } |
| |
| if (blobfs::GetBlockCount(fd_.get(), &blocks_) != ZX_OK) { |
| fprintf(stderr, "blobfs: cannot find end of underlying device\n"); |
| exit(-1); |
| } else if (blobfs::CheckSuperblock(&info_, blocks_) != ZX_OK) { |
| fprintf(stderr, "blobfs: Info check failed\n"); |
| exit(-1); |
| } |
| } |
| |
| BlobfsFormat::~BlobfsFormat() = default; |
| |
| zx_status_t BlobfsFormat::ComputeSlices(uint64_t inode_count, uint64_t data_blocks, |
| uint64_t journal_block_count) { |
| auto abm_blocks = blobfs::BlocksRequiredForBits(data_blocks); |
| auto ino_blocks = blobfs::BlocksRequiredForInode(inode_count); |
| |
| fvm_info_.abm_slices = BlocksToSlices(abm_blocks); |
| fvm_info_.ino_slices = BlocksToSlices(ino_blocks); |
| fvm_info_.journal_slices = BlocksToSlices(ToU32(journal_block_count)); |
| fvm_info_.dat_slices = BlocksToSlices(safemath::checked_cast<uint32_t>(data_blocks)); |
| fvm_info_.vslice_count = 1 + fvm_info_.abm_slices + fvm_info_.ino_slices + |
| fvm_info_.dat_slices + fvm_info_.journal_slices; |
| |
| fvm_info_.inode_count = safemath::checked_cast<uint32_t>( |
| fvm_info_.ino_slices * fvm_info_.slice_size / blobfs::kBlobfsInodeSize); |
| fvm_info_.journal_block_count = SlicesToBlocks(fvm_info_.journal_slices); |
| fvm_info_.data_block_count = SlicesToBlocks(fvm_info_.dat_slices); |
| fvm_info_.flags |= blobfs::kBlobFlagFVM; |
| |
| xprintf("Blobfs: slice_size is %" PRIu64 "\n", fvm_info_.slice_size); |
| xprintf("Blobfs: abm_blocks: %" PRIu64 ", abm_slices: %u\n", BlockMapBlocks(fvm_info_), |
| fvm_info_.abm_slices); |
| xprintf("Blobfs: ino_blocks: %" PRIu64 ", ino_slices: %u\n", NodeMapBlocks(fvm_info_), |
| fvm_info_.ino_slices); |
| xprintf("Blobfs: jnl_blocks: %" PRIu64 ", jnl_slices: %u\n", JournalBlocks(fvm_info_), |
| fvm_info_.journal_slices); |
| xprintf("Blobfs: dat_blocks: %" PRIu64 ", dat_slices: %u\n", DataBlocks(fvm_info_), |
| fvm_info_.dat_slices); |
| |
| zx_status_t status; |
| if ((status = CheckSuperblock(&fvm_info_, blocks_)) != ZX_OK) { |
| fprintf(stderr, "Check info failed\n"); |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t BlobfsFormat::MakeFvmReady(size_t slice_size, uint32_t vpart_index, |
| FvmReservation* reserve) { |
| memcpy(&fvm_blk_, &blk_, BlockSize()); |
| xprintf("fvm_info has data block count %" PRIu64 "\n", fvm_info_.data_block_count); |
| fvm_info_.slice_size = slice_size; |
| |
| if (fvm_info_.slice_size % BlockSize()) { |
| fprintf(stderr, "MakeFvmReady: Slice size not multiple of minfs block\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| uint64_t minimum_data_blocks = |
| fbl::round_up(reserve->data().request.value_or(0), BlockSize()) / BlockSize(); |
| if (minimum_data_blocks < fvm_info_.data_block_count) { |
| minimum_data_blocks = fvm_info_.data_block_count; |
| } |
| |
| uint64_t minimum_inode_count = reserve->inodes().request.value_or(0); |
| if (minimum_inode_count < fvm_info_.inode_count) { |
| minimum_inode_count = fvm_info_.inode_count; |
| } |
| |
| zx_status_t status; |
| if ((status = ComputeSlices(minimum_inode_count, minimum_data_blocks, JournalBlocks(info_))) != |
| ZX_OK) { |
| return status; |
| } |
| |
| // Lets see if we can increase journal size now |
| uint64_t slice_limit = reserve->total_bytes().request.value_or(0) / slice_size; |
| if (slice_limit > fvm_info_.vslice_count) { |
| // TODO(auradkar): This should use TransactionLimits |
| uint64_t journal_block_count = blobfs::SuggestJournalBlocks( |
| ToU32(JournalBlocks(fvm_info_)), |
| ToU32((slice_limit - fvm_info_.vslice_count) * slice_size / BlockSize())); |
| // Above, we might have changed number of blocks allocated to the journal. This |
| // might affect the number of allocated/reserved slices. Call ComputeSlices |
| // again to adjust the count. |
| if ((status = ComputeSlices(minimum_inode_count, minimum_data_blocks, |
| journal_block_count)) != ZX_OK) { |
| return status; |
| } |
| } |
| |
| reserve->set_data_reserved(fvm_info_.data_block_count * BlockSize()); |
| reserve->set_inodes_reserved(fvm_info_.inode_count); |
| reserve->set_total_bytes_reserved(SlicesToBlocks(ToU32(fvm_info_.vslice_count)) * BlockSize()); |
| if (!reserve->Approved()) { |
| return ZX_ERR_BUFFER_TOO_SMALL; |
| } |
| |
| fvm_ready_ = true; |
| vpart_index_ = vpart_index; |
| return ZX_OK; |
| } |
| |
| zx_status_t BlobfsFormat::GetVsliceRange(unsigned extent_index, vslice_info_t* vslice_info) const { |
| CheckFvmReady(); |
| switch (extent_index) { |
| case 0: { |
| vslice_info->vslice_start = 0; |
| vslice_info->slice_count = 1; |
| vslice_info->block_offset = 0; |
| vslice_info->block_count = ToU32(SuperblockBlocks(info_)); |
| vslice_info->zero_fill = true; |
| return ZX_OK; |
| } |
| case 1: { |
| vslice_info->vslice_start = blobfs::kFVMBlockMapStart; |
| vslice_info->slice_count = fvm_info_.abm_slices; |
| vslice_info->block_offset = ToU32(BlockMapStartBlock(info_)); |
| vslice_info->block_count = ToU32(BlockMapBlocks(info_)); |
| vslice_info->zero_fill = true; |
| return ZX_OK; |
| } |
| case 2: { |
| vslice_info->vslice_start = blobfs::kFVMNodeMapStart; |
| vslice_info->slice_count = fvm_info_.ino_slices; |
| vslice_info->block_offset = ToU32(NodeMapStartBlock(info_)); |
| vslice_info->block_count = ToU32(NodeMapBlocks(info_)); |
| vslice_info->zero_fill = true; |
| return ZX_OK; |
| } |
| case 3: { |
| vslice_info->vslice_start = blobfs::kFVMJournalStart; |
| vslice_info->slice_count = fvm_info_.journal_slices; |
| vslice_info->block_offset = ToU32(JournalStartBlock(info_)); |
| vslice_info->block_count = ToU32(JournalBlocks(info_)); |
| vslice_info->zero_fill = false; |
| return ZX_OK; |
| } |
| case 4: { |
| vslice_info->vslice_start = blobfs::kFVMDataStart; |
| vslice_info->slice_count = fvm_info_.dat_slices; |
| vslice_info->block_offset = ToU32(DataStartBlock(info_)); |
| vslice_info->block_count = ToU32(DataBlocks(info_)); |
| vslice_info->zero_fill = false; |
| return ZX_OK; |
| } |
| } |
| |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| zx_status_t BlobfsFormat::GetSliceCount(uint32_t* slices_out) const { |
| CheckFvmReady(); |
| *slices_out = 1 + fvm_info_.abm_slices + fvm_info_.ino_slices + fvm_info_.journal_slices |
| + fvm_info_.dat_slices; |
| return ZX_OK; |
| } |
| |
| zx_status_t BlobfsFormat::FillBlock(size_t block_offset) { |
| CheckFvmReady(); |
| // If we are reading the super block, make sure it is the fvm version and not the original |
| if (block_offset == 0) { |
| memcpy(datablk, fvm_blk_, BlockSize()); |
| } else if (blobfs::readblk(fd_.get(), block_offset, datablk) != ZX_OK) { |
| fprintf(stderr, "blobfs: could not read block\n"); |
| return ZX_ERR_INTERNAL; |
| } |
| return ZX_OK; |
| } |
| |
| zx_status_t BlobfsFormat::EmptyBlock() { |
| CheckFvmReady(); |
| memset(datablk, 0, BlockSize()); |
| return ZX_OK; |
| } |
| |
| void* BlobfsFormat::Data() { |
| return datablk; |
| } |
| |
| const char* BlobfsFormat::Name() const { |
| return kBlobfsName; |
| } |
| |
| uint32_t BlobfsFormat::BlockSize() const { |
| return blobfs::kBlobfsBlockSize; |
| } |
| |
| uint32_t BlobfsFormat::BlocksPerSlice() const { |
| CheckFvmReady(); |
| return ToU32(fvm_info_.slice_size / BlockSize()); |
| } |
| |
| uint32_t BlobfsFormat::BlocksToSlices(uint32_t block_count) const { |
| return ToU32(fvm::BlocksToSlices(fvm_info_.slice_size, BlockSize(), block_count)); |
| } |
| |
| uint32_t BlobfsFormat::SlicesToBlocks(uint32_t slice_count) const { |
| return ToU32(fvm::SlicesToBlocks(fvm_info_.slice_size, BlockSize(), slice_count)); |
| } |
