Google Git
Sign in
fuchsia / fuchsia / 57ef8eaaff96ca15cebfbd2e5605521ab24317e6 / . / src / storage / f2fs / fsck.cc
blob: 4b7c16eaf67267289c13a1ea629c6b92db7c57f7 [file] [log] [blame]
// Copyright 2021 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 <bitset>
#include <iostream>
#include <safemath/checked_math.h>
#include "src/storage/f2fs/f2fs.h"
namespace f2fs {
namespace {
uint32_t MaxInlineData(const Inode &inode) {
uint16_t extra_isize = (inode.i_inline & kExtraAttr) ? inode.i_extra_isize : 0;
return sizeof(uint32_t) *
(kAddrsPerInode - extra_isize / sizeof(uint32_t) - kInlineXattrAddrs - 1);
}
uint32_t MaxInlineDentry(const Inode &inode) {
return MaxInlineData(inode) * kBitsPerByte /
((kSizeOfDirEntry + kDentrySlotLen) * kBitsPerByte + 1);
}
const uint8_t *InlineDataPtr(const Inode &inode) {
uint16_t extra_isize = (inode.i_inline & kExtraAttr) ? inode.i_extra_isize : 0;
return reinterpret_cast<const uint8_t *>(
&inode.i_addr[extra_isize / sizeof(uint32_t) + kInlineStartOffset]);
}
const uint8_t *InlineDentryBitmap(const Inode &inode) { return InlineDataPtr(inode); }
const DirEntry *InlineDentryArray(const Inode &inode) {
uint32_t reserved =
MaxInlineData(inode) - MaxInlineDentry(inode) * (kSizeOfDirEntry + kDentrySlotLen);
return reinterpret_cast<const DirEntry *>(InlineDentryBitmap(inode) + reserved);
}
const uint8_t (*InlineDentryNameArray(const Inode &inode))[kDentrySlotLen] {
uint32_t reserved = MaxInlineData(inode) - MaxInlineDentry(inode) * kDentrySlotLen;
return reinterpret_cast<const uint8_t(*)[kDentrySlotLen]>(InlineDentryBitmap(inode) + reserved);
}
} // namespace
template <typename T>
static inline void DisplayMember(uint32_t typesize, T value, std::string_view name) {
if (typesize == sizeof(char)) {
std::cout << name << " [" << value << "]" << std::endl;
} else {
ZX_ASSERT(sizeof(T) <= typesize);
std::cout << name << " [0x" << std::hex << value << " : " << std::dec << value << "]"
<< std::endl;
}
}
static int32_t operator-(CursegType &a, CursegType &&b) {
return (static_cast<int32_t>(a) - static_cast<int32_t>(b));
}
static bool operator<=(int32_t &a, CursegType &&b) { return (a <= static_cast<int32_t>(b)); }
CursegType operator+(CursegType a, uint32_t &&b) {
return static_cast<CursegType>(static_cast<uint32_t>(a) + b);
}
static inline bool IsSumNodeSeg(SummaryFooter &footer) { return footer.entry_type == kSumTypeNode; }
static inline uint64_t BlkoffFromMain(SegmentManager &manager, uint64_t block_address) {
ZX_ASSERT(block_address >= manager.GetMainAreaStartBlock());
return block_address - manager.GetMainAreaStartBlock();
}
static inline uint32_t OffsetInSegment(SuperblockInfo &sbi, SegmentManager &manager,
uint64_t block_address) {
return (uint32_t)(BlkoffFromMain(manager, block_address) % (1 << sbi.GetLogBlocksPerSeg()));
}
static inline uint16_t AddrsPerInode(const Inode *i) {
#if 0 // porting needed
if (i->i_inline & kInlineXattr)
return kAddrPerInode - kInlineXattrAddrs;
#endif
return kAddrsPerInode;
}
zx_status_t FsckWorker::ReadBlock(FsBlock &fs_block, block_t bno) {
#ifdef __Fuchsia__
return bc_->Readblk(bno, fs_block.GetData().data());
#else // __Fuchsia__
return bc_->Readblk(bno, fs_block.GetData());
#endif // __Fuchsia__
}
zx_status_t FsckWorker::WriteBlock(FsBlock &fs_block, block_t bno) {
#ifdef __Fuchsia__
return bc_->Writeblk(bno, fs_block.GetData().data());
#else // __Fuchsia__
return bc_->Writeblk(bno, fs_block.GetData());
#endif // __Fuchsia__
}
void FsckWorker::AddIntoInodeLinkMap(nid_t nid, uint32_t link_count) {
auto ret = fsck_.inode_link_map.insert({nid, {.links = link_count, .actual_links = 1}});
ZX_ASSERT(ret.second);
if (link_count > 1) {
FX_LOGS(INFO) << "ino[0x" << std::hex << nid << "] has hard links [0x" << link_count << "]";
}
}
zx_status_t FsckWorker::FindAndIncreaseInodeLinkMap(nid_t nid) {
if (auto ret = fsck_.inode_link_map.find(nid); ret != fsck_.inode_link_map.end()) {
++ret->second.actual_links;
return ZX_OK;
}
return ZX_ERR_NOT_FOUND;
}
bool FsckWorker::IsValidSsaNodeBlock(nid_t nid, uint32_t block_address) {
auto [ret, summary_entry] = GetSummaryEntry(block_address);
ZX_ASSERT(static_cast<int>(ret) >= 0);
if (ret == SegType::kSegTypeData || ret == SegType::kSegTypeCurData) {
FX_LOGS(ERROR) << "Summary footer is not a node segment summary";
ZX_ASSERT(0);
} else if (ret == SegType::kSegTypeNode) {
if (LeToCpu(summary_entry.nid) != nid) {
FX_LOGS(ERROR) << "nid [0x" << std::hex << nid << "]";
FX_LOGS(ERROR) << "target block_address [0x" << std::hex << block_address << "]";
FX_LOGS(ERROR) << "summary block_address [0x" << std::hex
<< segment_manager_->GetSumBlock(
segment_manager_->GetSegmentNumber(block_address))
<< "]";
FX_LOGS(ERROR) << "seg no / offset [0x" << std::hex
<< segment_manager_->GetSegmentNumber(block_address) << "/0x" << std::hex
<< OffsetInSegment(superblock_info_, *segment_manager_, block_address) << "]";
FX_LOGS(ERROR) << "summary_entry.nid [0x" << std::hex << LeToCpu(summary_entry.nid)
<< "]";
FX_LOGS(ERROR) << "--> node block's nid [0x" << std::hex << nid << "]";
FX_LOGS(ERROR) << "Invalid node seg summary\n";
ZX_ASSERT(0);
}
} else if (ret == SegType::kSegTypeCurNode) {
// current node segment has no ssa
} else {
FX_LOGS(ERROR) << "Invalid return value of 'GetSummaryEntry'";
ZX_ASSERT(0);
}
return true;
}
bool FsckWorker::IsValidSsaDataBlock(uint32_t block_address, uint32_t parent_nid,
uint16_t index_in_node, uint8_t version) {
auto [ret, summary_entry] = GetSummaryEntry(block_address);
ZX_ASSERT(ret == SegType::kSegTypeData || ret == SegType::kSegTypeCurData);
if (LeToCpu(summary_entry.nid) != parent_nid || summary_entry.version != version ||
LeToCpu(summary_entry.ofs_in_node) != index_in_node) {
FX_LOGS(ERROR) << "summary_entry.nid [0x" << std::hex << LeToCpu(summary_entry.nid)
<< "]";
FX_LOGS(ERROR) << "summary_entry.version [0x" << std::hex << summary_entry.version << "]";
FX_LOGS(ERROR) << "summary_entry.ofs_in_node [0x" << std::hex
<< LeToCpu(summary_entry.ofs_in_node) << "]";
FX_LOGS(ERROR) << "parent nid [0x" << std::hex << parent_nid << "]";
FX_LOGS(ERROR) << "version from nat [0x" << std::hex << version << "]";
FX_LOGS(ERROR) << "index in parent node [0x" << std::hex << index_in_node << "]";
FX_LOGS(ERROR) << "Target data block address [0x" << std::hex << block_address << "]";
FX_LOGS(ERROR) << "Invalid data seg summary\n";
ZX_ASSERT(0);
}
return true;
}
bool FsckWorker::IsValidNid(nid_t nid) {
return nid <= (kNatEntryPerBlock * superblock_info_.GetRawSuperblock().segment_count_nat
<< (superblock_info_.GetLogBlocksPerSeg() - 1));
}
bool FsckWorker::IsValidBlockAddress(uint32_t addr) {
if (addr >= superblock_info_.GetRawSuperblock().block_count) {
std::cout << std::hex << "block[0x" << addr << "] should be less than [0x"
<< superblock_info_.GetRawSuperblock().block_count << "]\n";
return false;
}
if (addr < segment_manager_->GetMainAreaStartBlock()) {
std::cout << std::hex << "block[0x" << addr << "] should be greater than [0x"
<< segment_manager_->GetMainAreaStartBlock() << "]\n";
return false;
}
return true;
}
zx_status_t FsckWorker::ValidateNodeBlock(const Node &node_block, NodeInfo node_info,
FileType ftype, NodeType ntype) {
if (node_info.nid != LeToCpu(node_block.footer.nid) ||
node_info.ino != LeToCpu(node_block.footer.ino)) {
FX_LOGS(ERROR) << std::hex << "ino[0x" << node_info.ino << "] nid[0x" << node_info.nid
<< "] blk_addr[0x" << node_info.blk_addr << "] footer.nid[0x"
<< LeToCpu(node_block.footer.nid) << "] footer.ino[0x"
<< LeToCpu(node_block.footer.ino) << "]";
return ZX_ERR_INTERNAL;
}
if (ntype == NodeType::kTypeInode) {
uint32_t i_links = LeToCpu(node_block.i.i_links);
// Orphan node. i_links should be 0.
if (ftype == FileType::kFtOrphan) {
ZX_ASSERT(i_links == 0);
} else {
ZX_ASSERT(i_links > 0);
}
}
return ZX_OK;
}
zx::status<bool> FsckWorker::UpdateContext(const Node &node_block, NodeInfo node_info,
FileType ftype, NodeType ntype) {
nid_t nid = node_info.nid;
if (ftype != FileType::kFtOrphan || TestValidBitmap(nid, fsck_.nat_area_bitmap.get()) != 0x0) {
ClearValidBitmap(nid, fsck_.nat_area_bitmap.get());
} else {
FX_LOGS(WARNING) << "nid duplicated [0x" << std::hex << nid << "]";
}
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, node_info.blk_addr),
fsck_.main_area_bitmap.get()) == 0x0) {
// Unvisited node, mark visited.
SetValidBitmap(BlkoffFromMain(*segment_manager_, node_info.blk_addr),
fsck_.main_area_bitmap.get());
if (ntype == NodeType::kTypeInode) {
uint32_t i_links = LeToCpu(node_block.i.i_links);
if (ftype != FileType::kFtDir) {
// First time visiting this inode.
AddIntoInodeLinkMap(nid, i_links);
if (i_links > 1) {
++fsck_.result.multi_hard_link_files;
}
}
++fsck_.result.valid_inode_count;
}
++fsck_.result.valid_block_count;
++fsck_.result.valid_node_count;
} else {
// Once visited here, it should be an Inode.
if (ntype != NodeType::kTypeInode) {
FX_LOGS(ERROR) << std::hex << "Duplicated node block. nid[0x" << nid << "] blk_addr[0x"
<< node_info.blk_addr << "]";
return zx::error(ZX_ERR_INTERNAL);
}
uint32_t i_links = LeToCpu(node_block.i.i_links);
if (ftype == FileType::kFtDir) {
FX_LOGS(INFO) << "Duplicated inode blk. ino[0x" << std::hex << nid << "][0x" << std::hex
<< node_info.blk_addr;
return zx::error(ZX_ERR_INTERNAL);
} else {
FX_LOGS(INFO) << "ino[0x" << std::hex << nid << "] has hard links [0x" << std::hex << i_links
<< "]";
// We don't go deeper.
if (auto status = FindAndIncreaseInodeLinkMap(nid); status != ZX_OK) {
return zx::error(status);
}
return zx::ok(false);
}
}
return zx::ok(true);
}
zx::status<std::pair<std::unique_ptr<FsBlock>, NodeInfo>> FsckWorker::ReadNodeBlock(nid_t nid) {
if (!IsValidNid(nid)) {
return zx::error(ZX_ERR_INVALID_ARGS);
}
auto result = GetNodeInfo(nid);
if (result.is_error()) {
return zx::error(ZX_ERR_NOT_FOUND);
}
NodeInfo node_info = *result;
if (node_info.blk_addr == kNewAddr) {
return zx::ok(std::pair<std::unique_ptr<FsBlock>, NodeInfo>{nullptr, node_info});
}
if (!IsValidBlockAddress(node_info.blk_addr) || !IsValidSsaNodeBlock(nid, node_info.blk_addr)) {
return zx::error(ZX_ERR_INTERNAL);
}
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, node_info.blk_addr),
sit_area_bitmap_.get()) == 0x0) {
FX_LOGS(INFO) << "SIT bitmap is 0x0. block_address[0x" << std::hex << node_info.blk_addr << "]";
return zx::error(ZX_ERR_INTERNAL);
}
auto fs_block = std::make_unique<FsBlock>();
ZX_ASSERT(ReadBlock(*fs_block, node_info.blk_addr) == ZX_OK);
return zx::ok(std::pair<std::unique_ptr<FsBlock>, NodeInfo>{std::move(fs_block), node_info});
}
zx::status<TraverseResult> FsckWorker::CheckNodeBlock(const Inode *inode, nid_t nid, FileType ftype,
NodeType ntype) {
uint64_t block_count = 0;
uint32_t link_count = 0;
// Read the node block.
auto result = ReadNodeBlock(nid);
if (result.is_error()) {
return result.take_error();
}
auto [fs_block, node_info] = std::move(*result);
if (fs_block == nullptr) {
// This means that the block was already allocated, but not stored in disk.
ZX_ASSERT(node_info.blk_addr == kNewAddr);
++fsck_.result.valid_block_count;
++fsck_.result.valid_node_count;
if (ntype == NodeType::kTypeInode) {
++fsck_.result.valid_inode_count;
}
return zx::ok(TraverseResult{block_count, link_count});
}
#ifdef __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData().data());
#else // __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData());
#endif // __Fuchsia__
// Validate the node block.
if (auto status = ValidateNodeBlock(*node_block, node_info, ftype, ntype); status != ZX_OK) {
return zx::error(status);
}
// Update fsck context.
auto do_traverse = UpdateContext(*node_block, node_info, ftype, ntype);
if (do_traverse.is_error()) {
return do_traverse.take_error();
}
if (*do_traverse == true) {
// Traverse to underlying structures.
zx::status<TraverseResult> ret;
switch (ntype) {
case NodeType::kTypeInode:
ret = TraverseInodeBlock(*node_block, node_info, ftype);
break;
case NodeType::kTypeDirectNode:
ret = TraverseDnodeBlock(inode, *node_block, node_info, ftype);
break;
case NodeType::kTypeIndirectNode:
ret = TraverseIndirectNodeBlock(inode, *node_block, ftype);
break;
case NodeType::kTypeDoubleIndirectNode:
ret = TraverseDoubleIndirectNodeBlock(inode, *node_block, ftype);
break;
default:
ret = zx::error(ZX_ERR_INTERNAL);
break;
}
if (ret.is_error()) {
return ret.take_error();
}
block_count += ret->block_count;
link_count += ret->link_count;
if (ntype == NodeType::kTypeInode) {
uint32_t i_links = LeToCpu(node_block->i.i_links);
uint64_t i_blocks = LeToCpu(node_block->i.i_blocks);
if (i_blocks != block_count) {
PrintNodeInfo(*node_block);
FX_LOGS(ERROR) << "i_blocks != block_count";
return zx::error(ZX_ERR_INTERNAL);
}
if (ftype == FileType::kFtDir && i_links != link_count) {
PrintNodeInfo(*node_block);
FX_LOGS(ERROR) << "i_links != link_count";
return zx::error(ZX_ERR_INTERNAL);
}
}
}
return zx::ok(TraverseResult{block_count, link_count});
}
zx::status<TraverseResult> FsckWorker::TraverseInodeBlock(const Node &node_block,
NodeInfo node_info, FileType ftype) {
uint32_t child_count = 0, child_files = 0;
uint64_t block_count = 1;
nid_t nid = node_info.nid;
NodeType ntype;
uint64_t i_blocks = LeToCpu(node_block.i.i_blocks);
// ValidateNodeBlock ensures below.
ZX_ASSERT(node_info.nid == node_info.ino);
ZX_ASSERT(LeToCpu(node_block.footer.nid) == node_info.nid);
ZX_ASSERT(LeToCpu(node_block.footer.ino) == node_info.ino);
#if 0 // porting needed
fsck_chk_xattr_blk(sbi, nid, LeToCpu(node_block->i.i_xattr_nid), block_count);
#endif
do {
if (ftype == FileType::kFtChrdev || ftype == FileType::kFtBlkdev ||
ftype == FileType::kFtFifo || ftype == FileType::kFtSock) {
break;
}
if (node_block.i.i_inline & kInlineData) {
if (!(node_block.i.i_inline & kDataExist)) {
char zeroes[MaxInlineData(node_block.i)];
memset(zeroes, 0, MaxInlineData(node_block.i));
if (memcmp(zeroes, InlineDataPtr(node_block.i), MaxInlineData(node_block.i))) {
FX_LOGS(WARNING) << "ino[0x" << std::hex << nid << "] has junk inline data";
fsck_.data_exist_flag_set.insert(nid);
}
}
break;
}
if (node_block.i.i_inline & kInlineDentry) {
if (auto status =
CheckDentries(child_count, child_files, 1, InlineDentryBitmap(node_block.i),
InlineDentryArray(node_block.i), InlineDentryNameArray(node_block.i),
MaxInlineDentry(node_block.i));
status != ZX_OK) {
return zx::error(status);
}
} else {
uint16_t base =
(node_block.i.i_inline & kExtraAttr) ? node_block.i.i_extra_isize / sizeof(uint32_t) : 0;
// check data blocks in inode
for (uint16_t index = base; index < AddrsPerInode(&node_block.i); ++index) {
if (LeToCpu(node_block.i.i_addr[index]) != 0) {
++block_count;
if (auto status = CheckDataBlock(LeToCpu(node_block.i.i_addr[index]), child_count,
child_files, (i_blocks == block_count), ftype, nid,
index - base, node_info.version);
status != ZX_OK) {
return zx::error(status);
}
}
}
}
// check node blocks in inode: direct(2) + indirect(2) + double indirect(1)
for (int index = 0; index < 5; ++index) {
if (index == 0 || index == 1) {
ntype = NodeType::kTypeDirectNode;
} else if (index == 2 || index == 3) {
ntype = NodeType::kTypeIndirectNode;
} else if (index == 4) {
ntype = NodeType::kTypeDoubleIndirectNode;
} else {
ZX_ASSERT(0);
}
if (LeToCpu(node_block.i.i_nid[index]) != 0) {
auto ret = CheckNodeBlock(&node_block.i, LeToCpu(node_block.i.i_nid[index]), ftype, ntype);
if (ret.is_error()) {
return ret.take_error();
}
block_count += ret->block_count;
child_count += ret->link_count;
}
}
} while (0);
return zx::ok(TraverseResult{block_count, child_count});
}
zx::status<TraverseResult> FsckWorker::TraverseDnodeBlock(const Inode *inode,
const Node &node_block,
NodeInfo node_info, FileType ftype) {
nid_t nid = node_info.nid;
uint64_t block_count = 1;
uint32_t child_count = 0, child_files = 0;
for (uint16_t index = 0; index < kAddrsPerBlock; ++index) {
if (LeToCpu(node_block.dn.addr[index]) == 0x0) {
continue;
}
++block_count;
if (auto status = CheckDataBlock(LeToCpu(node_block.dn.addr[index]), child_count, child_files,
LeToCpu(inode->i_blocks) == block_count, ftype, nid, index,
node_info.version);
status != ZX_OK) {
return zx::error(status);
}
}
return zx::ok(TraverseResult{block_count, child_count});
}
zx::status<TraverseResult> FsckWorker::TraverseIndirectNodeBlock(const Inode *inode,
const Node &node_block,
FileType ftype) {
uint64_t block_count = 1;
uint32_t child_count = 0;
for (uint32_t i = 0; i < kNidsPerBlock; ++i) {
if (LeToCpu(node_block.in.nid[i]) == 0x0) {
continue;
}
auto ret =
CheckNodeBlock(inode, LeToCpu(node_block.in.nid[i]), ftype, NodeType::kTypeDirectNode);
if (ret.is_error()) {
return ret;
}
block_count += ret->block_count;
child_count += ret->link_count;
}
return zx::ok(TraverseResult{block_count, child_count});
}
zx::status<TraverseResult> FsckWorker::TraverseDoubleIndirectNodeBlock(const Inode *inode,
const Node &node_block,
FileType ftype) {
uint64_t block_count = 1;
uint32_t child_count = 0;
for (int i = 0; i < kNidsPerBlock; ++i) {
if (LeToCpu(node_block.in.nid[i]) == 0x0) {
continue;
}
auto ret =
CheckNodeBlock(inode, LeToCpu(node_block.in.nid[i]), ftype, NodeType::kTypeIndirectNode);
if (ret.is_error()) {
return ret;
}
block_count += ret->block_count;
child_count += ret->link_count;
}
return zx::ok(TraverseResult{block_count, child_count});
}
void FsckWorker::PrintDentry(const uint32_t depth, std::string_view name,
const uint8_t *dentry_bitmap, const DirEntry &dentry, const int index,
const int last_block, const int max_entries) {
int last_de = 0;
int next_idx = 0;
int name_len;
int bit_offset;
name_len = LeToCpu(dentry.name_len);
next_idx = index + (name_len + kDentrySlotLen - 1) / kDentrySlotLen;
bit_offset = FindNextBit(dentry_bitmap, max_entries, next_idx);
if (bit_offset >= max_entries && last_block) {
last_de = 1;
}
if (tree_mark_.size() <= depth) {
tree_mark_.resize(tree_mark_.size() * 2, 0);
}
if (last_de) {
tree_mark_[depth] = '`';
} else {
tree_mark_[depth] = '|';
}
if (tree_mark_[depth - 1] == '`') {
tree_mark_[depth - 1] = ' ';
}
for (uint32_t i = 1; i < depth; ++i) {
std::cout << tree_mark_[i] << " ";
}
std::cout << (last_de ? "`" : "|") << "-- " << name << std::endl;
}
zx_status_t FsckWorker::CheckDentries(uint32_t &child_count, uint32_t &child_files,
const int last_block, const uint8_t *dentry_bitmap,
const DirEntry *dentries, const uint8_t (*filename)[kNameLen],
const int max_entries) {
uint32_t hash_code;
FileType ftype;
++fsck_.dentry_depth;
for (int i = 0; i < max_entries;) {
if (TestBit(i, dentry_bitmap) == 0x0) {
++i;
continue;
}
std::string_view name(reinterpret_cast<const char *>(filename[i]),
LeToCpu(dentries[i].name_len));
hash_code = DentryHash(name);
ftype = static_cast<FileType>(dentries[i].file_type);
// Becareful. 'dentry.file_type' is not imode
if (ftype == FileType::kFtDir) {
++child_count;
if (IsDotOrDotDot(name)) {
++i;
continue;
}
}
// TODO: Should we check '.' and '..' entries?
ZX_ASSERT(LeToCpu(dentries[i].hash_code) == hash_code);
#if 0 // TODO: implement debug level
// TODO: DBG (2)
printf("[%3u] - no[0x%x] name[%s] len[0x%x] ino[0x%x] type[0x%x]\n", fsck->dentry_depth, i,
name.data(), LeToCpu(dentries[i].name_len), LeToCpu(dentries[i].ino),
dentries[i].file_type);
#endif
PrintDentry(fsck_.dentry_depth, name, dentry_bitmap, dentries[i], i, last_block, max_entries);
auto ret = CheckNodeBlock(nullptr, LeToCpu(dentries[i].ino), ftype, NodeType::kTypeInode);
if (ret.is_error()) {
return ret.error_value();
}
i += (name.length() + kDentrySlotLen - 1) / kDentrySlotLen;
++child_files;
}
--fsck_.dentry_depth;
return ZX_OK;
}
zx_status_t FsckWorker::CheckDentryBlock(uint32_t block_address, uint32_t &child_count,
uint32_t &child_files, int last_block) {
DentryBlock *de_blk;
auto fs_block = std::make_unique<FsBlock>();
ZX_ASSERT(ReadBlock(*fs_block, block_address) == ZX_OK);
#ifdef __Fuchsia__
de_blk = reinterpret_cast<DentryBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
de_blk = reinterpret_cast<DentryBlock *>(fs_block->GetData());
#endif // __Fuchsia__
return CheckDentries(child_count, child_files, last_block, de_blk->dentry_bitmap, de_blk->dentry,
de_blk->filename, kNrDentryInBlock);
}
zx_status_t FsckWorker::CheckDataBlock(uint32_t block_address, uint32_t &child_count,
uint32_t &child_files, int last_block, FileType ftype,
uint32_t parent_nid, uint16_t index_in_node, uint8_t ver) {
// Is it reserved block?
if (block_address == kNewAddr) {
++fsck_.result.valid_block_count;
return ZX_OK;
}
if (!IsValidBlockAddress(block_address)) {
return ZX_ERR_INTERNAL;
}
IsValidSsaDataBlock(block_address, parent_nid, index_in_node, ver);
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, block_address), sit_area_bitmap_.get()) ==
0x0) {
ZX_ASSERT_MSG(0, "SIT bitmap is 0x0. block_address[0x%x]\n", block_address);
}
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, block_address),
fsck_.main_area_bitmap.get()) != 0) {
ZX_ASSERT_MSG(0, "Duplicated data block. pnid[0x%x] index[0x%x] block_address[0x%x]\n",
parent_nid, index_in_node, block_address);
}
SetValidBitmap(BlkoffFromMain(*segment_manager_, block_address), fsck_.main_area_bitmap.get());
++fsck_.result.valid_block_count;
if (ftype == FileType::kFtDir) {
return CheckDentryBlock(block_address, child_count, child_files, last_block);
}
return ZX_OK;
}
zx_status_t FsckWorker::CheckOrphanNodes() {
block_t start_blk, orphan_blkaddr;
auto fs_block = std::make_unique<FsBlock>();
if (!superblock_info_.TestCpFlags(CpFlag::kCpOrphanPresentFlag)) {
return ZX_OK;
}
start_blk =
superblock_info_.StartCpAddr() + 1 + LeToCpu(superblock_info_.GetRawSuperblock().cp_payload);
orphan_blkaddr = superblock_info_.StartSumAddr() - 1;
for (block_t i = 0; i < orphan_blkaddr; ++i) {
ZX_ASSERT(ReadBlock(*fs_block, start_blk + i) == ZX_OK);
#ifdef __Fuchsia__
OrphanBlock *orphan_block = reinterpret_cast<OrphanBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
OrphanBlock *orphan_block = reinterpret_cast<OrphanBlock *>(fs_block->GetData());
#endif // __Fuchsia__
for (block_t j = 0; j < LeToCpu(orphan_block->entry_count); ++j) {
nid_t ino = LeToCpu(orphan_block->ino[j]);
#if 0 // TODO: implement debug level
// TODO: DBG (1)
printf("[%3d] ino [0x%x]\n", i, ino);
#endif
auto status = CheckNodeBlock(nullptr, ino, FileType::kFtOrphan, NodeType::kTypeInode);
if (status.is_error()) {
return status.error_value();
}
}
}
return ZX_OK;
}
#if 0 // porting needed
int FsckWorker::FsckChkXattrBlk(uint32_t ino, uint32_t x_nid, uint32_t *block_count) {
FsckInfo *fsck = &fsck_;
NodeInfo ni;
if (x_nid == 0x0)
return 0;
if (TestValidBitmap(x_nid, fsck->nat_area_bitmap) != 0x0) {
ClearValidBitmap(x_nid, fsck->nat_area_bitmap);
} else {
ZX_ASSERT_MSG(0, "xattr_nid duplicated [0x%x]\n", x_nid);
}
*block_count = *block_count + 1;
++fsck->chk.valid_block_count;
++fsck->chk.valid_node_count;
ZX_ASSERT(GetNodeInfo(x_nid, &ni) >= 0);
if (TestValidBitmap(BlkoffFromMain(superblock_info, ni.blk_addr), fsck->main_area_bitmap) != 0) {
ZX_ASSERT_MSG(0,
"Duplicated node block for x_attr. "
"x_nid[0x%x] block addr[0x%x]\n",
x_nid, ni.blk_addr);
}
SetValidBitmap(BlkoffFromMain(superblock_info, ni.blk_addr), fsck->main_area_bitmap);
#if 0 // TODO: implement debug level
// TODO: DBG (2)
printf("ino[0x%x] x_nid[0x%x]\n", ino, x_nid);
#endif
return 0;
}
#endif
zx_status_t FsckWorker::Init() {
fsck_ = FsckInfo{};
fsck_.nr_main_blocks = segment_manager_->GetMainSegmentsCount()
<< superblock_info_.GetLogBlocksPerSeg();
fsck_.main_area_bitmap_size = (fsck_.nr_main_blocks + kBitsPerByte - 1) / kBitsPerByte;
ZX_ASSERT(fsck_.main_area_bitmap_size == sit_area_bitmap_size_);
fsck_.main_area_bitmap = std::make_unique<uint8_t[]>(fsck_.main_area_bitmap_size);
if (fsck_.main_area_bitmap == nullptr) {
return ZX_ERR_NO_MEMORY;
}
BuildNatAreaBitmap();
return ZX_OK;
}
zx_status_t FsckWorker::VerifyCursegOffset(CursegType segtype) {
CursegInfo *curseg = segment_manager_->CURSEG_I(segtype);
if (curseg->next_blkoff >= kSitVBlockMapSize * kBitsPerByte) {
return ZX_ERR_INTERNAL;
}
block_t logical_curseg_offset = segment_manager_->GetMainAreaStartBlock() +
curseg->segno * superblock_info_.GetBlocksPerSeg() +
curseg->next_blkoff;
if (!IsValidBlockAddress(logical_curseg_offset)) {
return ZX_ERR_INTERNAL;
}
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, logical_curseg_offset),
sit_area_bitmap_.get()) != 0x0) {
return ZX_ERR_INTERNAL;
}
if (curseg->alloc_type == static_cast<uint8_t>(AllocMode::kLFS)) {
for (block_t offset = curseg->next_blkoff + 1; offset < kSitVBlockMapSize; ++offset) {
block_t logical_offset = segment_manager_->GetMainAreaStartBlock() +
curseg->segno * superblock_info_.GetBlocksPerSeg() + offset;
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, logical_offset),
sit_area_bitmap_.get()) != 0x0) {
return ZX_ERR_INTERNAL;
}
}
}
return ZX_OK;
}
zx_status_t FsckWorker::Verify() {
zx_status_t status = ZX_OK;
uint32_t nr_unref_nid = 0;
for (uint32_t i = 0; i < fsck_.nr_nat_entries; ++i) {
if (TestValidBitmap(i, fsck_.nat_area_bitmap.get()) != 0) {
printf("NID[0x%x] is unreachable\n", i);
++nr_unref_nid;
}
}
auto iter = fsck_.inode_link_map.begin();
while (iter != fsck_.inode_link_map.end()) {
if (iter->second.links == iter->second.actual_links) {
iter = fsck_.inode_link_map.erase(iter);
} else {
++iter;
}
}
for (auto const [nid, links] : fsck_.inode_link_map) {
std::cout << std::hex << "NID[0x" << nid << "] has inconsistent link count [0x" << links.links
<< "] (actual: 0x" << links.actual_links << ")\n";
}
printf("[FSCK] Unreachable nat entries ");
if (nr_unref_nid == 0x0) {
printf(" [Ok..] [0x%x]\n", nr_unref_nid);
} else {
printf(" [Fail] [0x%x]\n", nr_unref_nid);
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] SIT valid block bitmap checking ");
if (memcmp(sit_area_bitmap_.get(), fsck_.main_area_bitmap.get(), sit_area_bitmap_size_) == 0x0) {
printf("[Ok..]\n");
} else {
printf("[Fail]\n");
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] Hard link checking for regular file ");
if (fsck_.inode_link_map.empty()) {
printf(" [Ok..] [0x%x]\n", fsck_.result.multi_hard_link_files);
} else {
printf(" [Fail] [0x%x]\n", fsck_.result.multi_hard_link_files);
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] valid_block_count matching with CP ");
if (superblock_info_.GetTotalValidBlockCount() == fsck_.result.valid_block_count) {
printf(" [Ok..] [0x%x]\n", (uint32_t)fsck_.result.valid_block_count);
} else {
printf(" [Fail] [0x%x]\n", (uint32_t)fsck_.result.valid_block_count);
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] valid_node_count matcing with CP (de lookup) ");
if (superblock_info_.GetTotalValidNodeCount() == fsck_.result.valid_node_count) {
printf(" [Ok..] [0x%x]\n", fsck_.result.valid_node_count);
} else {
printf(" [Fail] [0x%x]\n", fsck_.result.valid_node_count);
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] valid_node_count matcing with CP (nat lookup) ");
if (superblock_info_.GetTotalValidNodeCount() == fsck_.result.valid_nat_entry_count) {
printf(" [Ok..] [0x%x]\n", fsck_.result.valid_nat_entry_count);
} else {
printf(" [Fail] [0x%x]\n", fsck_.result.valid_nat_entry_count);
status = ZX_ERR_INTERNAL;
}
printf("[FSCK] valid_inode_count matched with CP ");
if (superblock_info_.GetTotalValidInodeCount() == fsck_.result.valid_inode_count) {
printf(" [Ok..] [0x%x]\n", fsck_.result.valid_inode_count);
} else {
printf(" [Fail] [0x%x]\n", fsck_.result.valid_inode_count);
status = ZX_ERR_INTERNAL;
}
std::cout << "[FSCK] next_blkoff in curseg is free ";
std::string segnums = " [free: ";
bool is_free = true;
for (uint32_t segtype = 0; segtype < kNrCursegType; ++segtype) {
if (VerifyCursegOffset(static_cast<CursegType>(segtype)) != ZX_OK) {
is_free = false;
} else {
segnums += std::to_string(segtype);
segnums += " ";
}
}
segnums += "]";
if (is_free) {
std::cout << " [Ok..]" << segnums << std::endl;
} else {
status = ZX_ERR_INTERNAL;
std::cout << " [Fail]" << segnums << std::endl;
}
std::cout << "[FSCK] Junk inline data checking for regular file ";
if (fsck_.data_exist_flag_set.empty()) {
std::cout << " [Ok..]" << std::endl;
} else {
std::cout << " [Fail]" << std::endl;
status = ZX_ERR_INTERNAL;
}
return status;
}
zx_status_t FsckWorker::RepairNat() {
CursegInfo *curseg = segment_manager_->CURSEG_I(CursegType::kCursegHotData);
SummaryBlock *summary_block = curseg->sum_blk;
bool need_journal_update = false;
for (nid_t nid = 0; nid < fsck_.nr_nat_entries; ++nid) {
if (TestValidBitmap(nid, fsck_.nat_area_bitmap.get()) != 0) {
std::cout << "Removing unreachable node [0x" << std::hex << nid << "]\n";
// Lookup the journal first.
bool found = false;
for (int i = 0; i < NatsInCursum(summary_block); ++i) {
if (LeToCpu(NidInJournal(summary_block, i)) == nid) {
// If found, bring in the last entry.
summary_block->nat_j.entries[i].nid =
summary_block->nat_j.entries[LeToCpu(summary_block->n_nats) - 1].nid;
summary_block->n_nats =
CpuToLe(static_cast<uint16_t>(LeToCpu(summary_block->n_nats) - 1));
need_journal_update = true;
found = true;
break;
}
}
if (found) {
continue;
}
// If not found, go for the NAT.
block_t block_off = nid / kNatEntryPerBlock;
int entry_off = nid % kNatEntryPerBlock;
block_t seg_off = block_off >> superblock_info_.GetLogBlocksPerSeg();
block_t block_addr = (node_manager_->GetNatAddress() +
(seg_off << superblock_info_.GetLogBlocksPerSeg() << 1) +
(block_off & ((1 << superblock_info_.GetLogBlocksPerSeg()) - 1)));
if (TestValidBitmap(block_off, node_manager_->GetNatBitmap())) {
block_addr += superblock_info_.GetBlocksPerSeg();
}
auto fs_block = std::make_unique<FsBlock>();
ZX_ASSERT(ReadBlock(*fs_block, block_addr) == ZX_OK);
#ifdef __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData());
#endif // __Fuchsia__
nat_block->entries[entry_off] = RawNatEntry{};
if (auto status = WriteBlock(*fs_block, block_addr); status != ZX_OK) {
return status;
}
}
}
if (need_journal_update) {
if (superblock_info_.TestCpFlags(CpFlag::kCpCompactSumFlag)) {
block_t summary_addr = StartSummaryBlock();
auto fs_block = std::make_unique<FsBlock>();
ReadBlock(*fs_block, summary_addr);
#ifdef __Fuchsia__
memcpy(fs_block->GetData().data(), &summary_block->n_nats, kSumJournalSize);
#else // __Fuchsia__
memcpy(fs_block->GetData(), &summary_block->n_nats, kSumJournalSize);
#endif // __Fuchsia__
return WriteBlock(*fs_block, summary_addr);
} else {
if (superblock_info_.TestCpFlags(CpFlag::kCpUmountFlag)) {
return WriteBlock(
*reinterpret_cast<FsBlock *>(summary_block),
SummaryBlockAddress(kNrCursegType, static_cast<int>(CursegType::kCursegHotData)));
} else {
return WriteBlock(
*reinterpret_cast<FsBlock *>(summary_block),
SummaryBlockAddress(kNrCursegDataType, static_cast<int>(CursegType::kCursegHotData)));
}
}
}
return ZX_OK;
}
zx_status_t FsckWorker::RepairSit() {
SitInfo &sit_i = segment_manager_->GetSitInfo();
CursegInfo *curseg = segment_manager_->CURSEG_I(CursegType::kCursegColdData);
SummaryBlock *summary_block = curseg->sum_blk;
bool need_journal_update = false;
for (uint32_t segno = 0; segno < sit_area_bitmap_size_ / kSitVBlockMapSize; ++segno) {
uint32_t sit_byte_offset = segno * kSitVBlockMapSize;
if (memcmp(sit_area_bitmap_.get() + sit_byte_offset,
fsck_.main_area_bitmap.get() + sit_byte_offset,
std::min(kSitVBlockMapSize, sit_area_bitmap_size_ - sit_byte_offset)) == 0x0) {
continue;
}
// Lookup the journal first.
bool found = false;
for (int i = 0; i < SitsInCursum(summary_block); ++i) {
if (LeToCpu(SegnoInJournal(summary_block, i)) == segno) {
SitEntry &sit = summary_block->sit_j.entries[i].se;
memcpy(sit.valid_map, fsck_.main_area_bitmap.get() + sit_byte_offset, kSitVBlockMapSize);
sit.vblocks = 0;
for (uint64_t j = 0; j < kSitVBlockMapSize; ++j) {
sit.vblocks += std::bitset<8>(sit.valid_map[j]).count();
}
need_journal_update = true;
found = true;
break;
}
}
if (found) {
continue;
}
// If not found in journal, go for the Sit.
std::unique_ptr<FsBlock> sit_block = GetCurrentSitPage(segno);
uint32_t offset = segment_manager_->SitBlockOffset(segno);
block_t sit_block_addr = sit_i.sit_base_addr + offset;
if (TestValidBitmap(offset, sit_i.sit_bitmap.get())) {
sit_block_addr += sit_i.sit_blocks;
}
SitEntry &sit_entry = reinterpret_cast<SitBlock *>(sit_block.get())
->entries[segment_manager_->SitEntryOffset(segno)];
memcpy(sit_entry.valid_map, fsck_.main_area_bitmap.get() + sit_byte_offset, kSitVBlockMapSize);
sit_entry.vblocks = 0;
for (uint64_t j = 0; j < kSitVBlockMapSize; ++j) {
sit_entry.vblocks += std::bitset<8>(sit_entry.valid_map[j]).count();
}
if (auto status = WriteBlock(*sit_block.get(), sit_block_addr); status != ZX_OK) {
return status;
}
}
if (need_journal_update) {
// Write the summary.
if (superblock_info_.TestCpFlags(CpFlag::kCpCompactSumFlag)) {
block_t summary_addr = StartSummaryBlock();
auto fs_block = std::make_unique<FsBlock>();
ReadBlock(*fs_block, summary_addr);
#ifdef __Fuchsia__
memcpy(fs_block->GetData().data() + kSumJournalSize, &summary_block->n_sits, kSumJournalSize);
#else // __Fuchsia__
memcpy(fs_block->GetData() + kSumJournalSize, &summary_block->n_sits, kSumJournalSize);
#endif // __Fuchsia__
return WriteBlock(*fs_block, summary_addr);
} else {
if (superblock_info_.TestCpFlags(CpFlag::kCpUmountFlag)) {
return WriteBlock(
*reinterpret_cast<FsBlock *>(summary_block),
SummaryBlockAddress(kNrCursegType, static_cast<int>(CursegType::kCursegColdData)));
} else {
return WriteBlock(
*reinterpret_cast<FsBlock *>(summary_block),
SummaryBlockAddress(kNrCursegDataType, static_cast<int>(CursegType::kCursegColdData)));
}
}
}
return ZX_OK;
}
zx_status_t FsckWorker::RepairCheckpoint() {
bool need_update_checkpoint = false;
if (superblock_info_.GetTotalValidBlockCount() != fsck_.result.valid_block_count) {
superblock_info_.GetCheckpoint().valid_block_count = fsck_.result.valid_block_count;
need_update_checkpoint = true;
}
if (superblock_info_.GetTotalValidNodeCount() != fsck_.result.valid_node_count) {
superblock_info_.GetCheckpoint().valid_node_count = fsck_.result.valid_node_count;
need_update_checkpoint = true;
}
if (superblock_info_.GetTotalValidInodeCount() != fsck_.result.valid_inode_count) {
superblock_info_.GetCheckpoint().valid_inode_count = fsck_.result.valid_inode_count;
need_update_checkpoint = true;
}
for (uint32_t segtype = 0; segtype < kNrCursegType; ++segtype) {
CursegInfo *curseg = segment_manager_->CURSEG_I(static_cast<CursegType>(segtype));
if (VerifyCursegOffset(static_cast<CursegType>(segtype)) != ZX_OK) {
uint16_t offset;
for (offset = 0; offset < kSitVBlockMapSize * kBitsPerByte; ++offset) {
block_t logical_offset = segment_manager_->GetMainAreaStartBlock() +
curseg->segno * superblock_info_.GetBlocksPerSeg() + offset;
if (TestValidBitmap(BlkoffFromMain(*segment_manager_, logical_offset),
sit_area_bitmap_.get()) == 0x0) {
break;
}
}
if (segtype < static_cast<uint32_t>(CursegType::kCursegHotNode)) {
superblock_info_.GetCheckpoint().cur_data_blkoff[segtype] = offset;
} else {
superblock_info_.GetCheckpoint()
.cur_node_blkoff[segtype - static_cast<uint32_t>(CursegType::kCursegHotNode)] = offset;
}
superblock_info_.GetCheckpoint().alloc_type[segtype] = static_cast<uint8_t>(AllocMode::kSSR);
need_update_checkpoint = true;
}
}
if (need_update_checkpoint) {
FsBlock checkpoint_block;
#ifdef __Fuchsia__
Checkpoint *checkpoint = reinterpret_cast<Checkpoint *>(checkpoint_block.GetData().data());
#else // __Fuchsia__
Checkpoint *checkpoint = reinterpret_cast<Checkpoint *>(checkpoint_block.GetData());
#endif // __Fuchsia__
memcpy(&checkpoint_block, &superblock_info_.GetCheckpoint(), superblock_info_.GetBlocksize());
uint32_t crc = F2fsCalCrc32(kF2fsSuperMagic, checkpoint, LeToCpu(checkpoint->checksum_offset));
*(reinterpret_cast<uint32_t *>(reinterpret_cast<uint8_t *>(checkpoint) +
LeToCpu(checkpoint->checksum_offset))) = crc;
if (auto status = WriteBlock(checkpoint_block, superblock_info_.StartCpAddr());
status != ZX_OK) {
return status;
}
if (auto status = WriteBlock(checkpoint_block, superblock_info_.StartCpAddr() +
checkpoint->cp_pack_total_block_count - 1);
status != ZX_OK) {
return status;
}
}
return ZX_OK;
}
zx_status_t FsckWorker::RepairInodeLinks() {
for (auto const [nid, links] : fsck_.inode_link_map) {
auto status = ReadNodeBlock(nid);
if (status.is_error()) {
return ZX_ERR_INTERNAL;
}
auto [fs_block, node_info] = std::move(*status);
#ifdef __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData().data());
#else // __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData());
#endif // __Fuchsia__
node_block->i.i_links = CpuToLe(links.actual_links);
if (WriteBlock(*fs_block.get(), node_info.blk_addr) != ZX_OK) {
return ZX_ERR_INTERNAL;
}
}
return ZX_OK;
}
zx_status_t FsckWorker::RepairDataExistFlag() {
for (auto const nid : fsck_.data_exist_flag_set) {
auto status = ReadNodeBlock(nid);
if (status.is_error()) {
return ZX_ERR_INTERNAL;
}
auto [fs_block, node_info] = std::move(*status);
#ifdef __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData().data());
#else // __Fuchsia__
auto node_block = reinterpret_cast<Node *>(fs_block->GetData());
#endif // __Fuchsia__
node_block->i.i_inline |= kDataExist;
if (WriteBlock(*fs_block.get(), node_info.blk_addr) != ZX_OK) {
return ZX_ERR_INTERNAL;
}
}
return ZX_OK;
}
zx_status_t FsckWorker::Repair() {
if (auto ret = RepairNat(); ret != ZX_OK) {
return ret;
}
if (auto ret = RepairSit(); ret != ZX_OK) {
return ret;
}
if (auto ret = RepairCheckpoint(); ret != ZX_OK) {
return ret;
}
if (auto ret = RepairInodeLinks(); ret != ZX_OK) {
return ret;
}
if (auto ret = RepairDataExistFlag(); ret != ZX_OK) {
return ret;
}
return ZX_OK;
}
void FsckWorker::PrintInodeInfo(Inode &inode) {
int namelen = LeToCpu(inode.i_namelen);
DisplayMember(sizeof(uint32_t), inode.i_mode, "i_mode");
DisplayMember(sizeof(uint32_t), inode.i_uid, "i_uid");
DisplayMember(sizeof(uint32_t), inode.i_gid, "i_gid");
DisplayMember(sizeof(uint32_t), inode.i_links, "i_links");
DisplayMember(sizeof(uint64_t), inode.i_size, "i_size");
DisplayMember(sizeof(uint64_t), inode.i_blocks, "i_blocks");
DisplayMember(sizeof(uint64_t), inode.i_atime, "i_atime");
DisplayMember(sizeof(uint32_t), inode.i_atime_nsec, "i_atime_nsec");
DisplayMember(sizeof(uint64_t), inode.i_ctime, "i_ctime");
DisplayMember(sizeof(uint32_t), inode.i_ctime_nsec, "i_ctime_nsec");
DisplayMember(sizeof(uint64_t), inode.i_mtime, "i_mtime");
DisplayMember(sizeof(uint32_t), inode.i_mtime_nsec, "i_mtime_nsec");
DisplayMember(sizeof(uint32_t), inode.i_generation, "i_generation");
DisplayMember(sizeof(uint32_t), inode.i_current_depth, "i_current_depth");
DisplayMember(sizeof(uint32_t), inode.i_xattr_nid, "i_xattr_nid");
DisplayMember(sizeof(uint32_t), inode.i_flags, "i_flags");
DisplayMember(sizeof(uint32_t), inode.i_pino, "i_pino");
if (namelen) {
DisplayMember(sizeof(uint32_t), inode.i_namelen, "i_namelen");
inode.i_name[namelen] = '\0';
DisplayMember(sizeof(char), inode.i_name, "i_name");
}
printf("i_ext: fofs:%x blkaddr:%x len:%x\n", inode.i_ext.fofs, inode.i_ext.blk_addr,
inode.i_ext.len);
DisplayMember(sizeof(uint32_t), inode.i_addr[0], "i_addr[0]"); // Pointers to data blocks
DisplayMember(sizeof(uint32_t), inode.i_addr[1], "i_addr[1]"); // Pointers to data blocks
DisplayMember(sizeof(uint32_t), inode.i_addr[2], "i_addr[2]"); // Pointers to data blocks
DisplayMember(sizeof(uint32_t), inode.i_addr[3], "i_addr[3]"); // Pointers to data blocks
for (uint32_t i = 4; i < AddrsPerInode(&inode); ++i) {
if (inode.i_addr[i] != 0x0) {
printf("i_addr[0x%x] points data block\r\t\t\t\t[0x%4x]\n", i, inode.i_addr[i]);
break;
}
}
DisplayMember(sizeof(uint32_t), inode.i_nid[0], "i_nid[0]"); // direct
DisplayMember(sizeof(uint32_t), inode.i_nid[1], "i_nid[1]"); // direct
DisplayMember(sizeof(uint32_t), inode.i_nid[2], "i_nid[2]"); // indirect
DisplayMember(sizeof(uint32_t), inode.i_nid[3], "i_nid[3]"); // indirect
DisplayMember(sizeof(uint32_t), inode.i_nid[4], "i_nid[4]"); // double indirect
printf("\n");
}
void FsckWorker::PrintNodeInfo(Node &node_block) {
nid_t ino = LeToCpu(node_block.footer.ino);
nid_t nid = LeToCpu(node_block.footer.nid);
if (ino == nid) {
FX_LOGS(INFO) << "Node ID [0x" << std::hex << nid << ":" << nid << "] is inode";
PrintInodeInfo(node_block.i);
} else {
uint32_t *dump_blk = (uint32_t *)&node_block;
FX_LOGS(INFO) << "Node ID [0x" << std::hex << nid << ":" << nid
<< "] is direct node or indirect node";
for (int i = 0; i <= 10; ++i) { // MSG (0)
printf("[%d]\t\t\t[0x%8x : %d]\n", i, dump_blk[i], dump_blk[i]);
}
}
}
void FsckWorker::PrintRawSuperblockInfo() {
const Superblock &sb = superblock_info_.GetRawSuperblock();
std::cout << std::endl
<< "+--------------------------------------------------------+" << std::endl
<< "| Super block |" << std::endl
<< "+--------------------------------------------------------+" << std::endl;
DisplayMember(sizeof(uint32_t), sb.magic, "magic");
DisplayMember(sizeof(uint32_t), sb.major_ver, "major_ver");
DisplayMember(sizeof(uint32_t), sb.minor_ver, "minor_ver");
DisplayMember(sizeof(uint32_t), sb.log_sectorsize, "log_sectorsize");
DisplayMember(sizeof(uint32_t), sb.log_sectors_per_block, "log_sectors_per_block");
DisplayMember(sizeof(uint32_t), sb.log_blocksize, "log_blocksize");
DisplayMember(sizeof(uint32_t), sb.log_blocks_per_seg, "log_blocks_per_seg");
DisplayMember(sizeof(uint32_t), sb.segs_per_sec, "segs_per_sec");
DisplayMember(sizeof(uint32_t), sb.secs_per_zone, "secs_per_zone");
DisplayMember(sizeof(uint32_t), sb.checksum_offset, "checksum_offset");
DisplayMember(sizeof(uint64_t), sb.block_count, "block_count");
DisplayMember(sizeof(uint32_t), sb.section_count, "section_count");
DisplayMember(sizeof(uint32_t), sb.segment_count, "segment_count");
DisplayMember(sizeof(uint32_t), sb.segment_count_ckpt, "segment_count_ckpt");
DisplayMember(sizeof(uint32_t), sb.segment_count_sit, "segment_count_sit");
DisplayMember(sizeof(uint32_t), sb.segment_count_nat, "segment_count_nat");
DisplayMember(sizeof(uint32_t), sb.segment_count_ssa, "segment_count_ssa");
DisplayMember(sizeof(uint32_t), sb.segment_count_main, "segment_count_main");
DisplayMember(sizeof(uint32_t), sb.segment0_blkaddr, "segment0_blkaddr");
DisplayMember(sizeof(uint32_t), sb.cp_blkaddr, "cp_blkaddr");
DisplayMember(sizeof(uint32_t), sb.sit_blkaddr, "sit_blkaddr");
DisplayMember(sizeof(uint32_t), sb.nat_blkaddr, "nat_blkaddr");
DisplayMember(sizeof(uint32_t), sb.ssa_blkaddr, "ssa_blkaddr");
DisplayMember(sizeof(uint32_t), sb.main_blkaddr, "main_blkaddr");
DisplayMember(sizeof(uint32_t), sb.root_ino, "root_ino");
DisplayMember(sizeof(uint32_t), sb.node_ino, "node_ino");
DisplayMember(sizeof(uint32_t), sb.meta_ino, "meta_ino");
DisplayMember(sizeof(uint32_t), sb.cp_payload, "cp_payload");
}
void FsckWorker::PrintCheckpointInfo() {
Checkpoint &cp = superblock_info_.GetCheckpoint();
uint32_t alloc_type;
std::cout << std::endl
<< "+--------------------------------------------------------+" << std::endl
<< "| Checkpoint |" << std::endl
<< "+--------------------------------------------------------+" << std::endl;
DisplayMember(sizeof(uint64_t), cp.checkpoint_ver, "checkpoint_ver");
DisplayMember(sizeof(uint64_t), cp.user_block_count, "user_block_count");
DisplayMember(sizeof(uint64_t), cp.valid_block_count, "valid_block_count");
DisplayMember(sizeof(uint32_t), cp.rsvd_segment_count, "rsvd_segment_count");
DisplayMember(sizeof(uint32_t), cp.overprov_segment_count, "overprov_segment_count");
DisplayMember(sizeof(uint32_t), cp.free_segment_count, "free_segment_count");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegHotNode)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegHotNode]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegWarmNode)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegWarmNode]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegColdNode)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegColdNode]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegHotNode)];
DisplayMember(sizeof(uint32_t), cp.cur_node_segno[0], "cur_node_segno[0]");
DisplayMember(sizeof(uint32_t), cp.cur_node_segno[1], "cur_node_segno[1]");
DisplayMember(sizeof(uint32_t), cp.cur_node_segno[2], "cur_node_segno[2]");
DisplayMember(sizeof(uint32_t), cp.cur_node_blkoff[0], "cur_node_blkoff[0]");
DisplayMember(sizeof(uint32_t), cp.cur_node_blkoff[1], "cur_node_blkoff[1]");
DisplayMember(sizeof(uint32_t), cp.cur_node_blkoff[2], "cur_node_blkoff[2]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegHotData)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegHotData]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegWarmData)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegWarmData]");
alloc_type = cp.alloc_type[static_cast<int>(CursegType::kCursegColdData)];
DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegColdData]");
DisplayMember(sizeof(uint32_t), cp.cur_data_segno[0], "cur_data_segno[0]");
DisplayMember(sizeof(uint32_t), cp.cur_data_segno[1], "cur_data_segno[1]");
DisplayMember(sizeof(uint32_t), cp.cur_data_segno[2], "cur_data_segno[2]");
DisplayMember(sizeof(uint32_t), cp.cur_data_blkoff[0], "cur_data_blkoff[0]");
DisplayMember(sizeof(uint32_t), cp.cur_data_blkoff[1], "cur_data_blkoff[1]");
DisplayMember(sizeof(uint32_t), cp.cur_data_blkoff[2], "cur_data_blkoff[2]");
DisplayMember(sizeof(uint32_t), cp.ckpt_flags, "ckpt_flags");
DisplayMember(sizeof(uint32_t), cp.cp_pack_total_block_count, "cp_pack_total_block_count");
DisplayMember(sizeof(uint32_t), cp.cp_pack_start_sum, "cp_pack_start_sum");
DisplayMember(sizeof(uint32_t), cp.valid_node_count, "valid_node_count");
DisplayMember(sizeof(uint32_t), cp.valid_inode_count, "valid_inode_count");
DisplayMember(sizeof(uint32_t), cp.next_free_nid, "next_free_nid");
DisplayMember(sizeof(uint32_t), cp.sit_ver_bitmap_bytesize, "sit_ver_bitmap_bytesize");
DisplayMember(sizeof(uint32_t), cp.nat_ver_bitmap_bytesize, "nat_ver_bitmap_bytesize");
DisplayMember(sizeof(uint32_t), cp.checksum_offset, "checksum_offset");
DisplayMember(sizeof(uint64_t), cp.elapsed_time, "elapsed_time");
}
zx_status_t FsckWorker::SanityCheckRawSuper(const Superblock *raw_super) {
if (kF2fsSuperMagic != LeToCpu(raw_super->magic)) {
return ZX_ERR_INTERNAL;
}
if (kBlockSize != kPageSize) {
return ZX_ERR_INTERNAL;
}
block_t blocksize = 1 << LeToCpu(raw_super->log_blocksize);
if (kBlockSize != blocksize) {
return ZX_ERR_INTERNAL;
}
if (LeToCpu(raw_super->log_sectorsize) > kMaxLogSectorSize ||
LeToCpu(raw_super->log_sectorsize) < kMinLogSectorSize) {
return ZX_ERR_INTERNAL;
}
if (LeToCpu(raw_super->log_sectors_per_block) + LeToCpu(raw_super->log_sectorsize) !=
kMaxLogSectorSize) {
return ZX_ERR_INTERNAL;
}
return ZX_OK;
}
zx::status<std::unique_ptr<FsBlock>> FsckWorker::GetSuperblock(block_t index) {
if (index >= kSuperblockCopies) {
return zx::error(ZX_ERR_OUT_OF_RANGE);
}
auto fs_blk = std::make_unique<FsBlock>();
if (auto status = ReadBlock(*fs_blk.get(), kSuperblockStart + index) != ZX_OK; status != ZX_OK) {
return zx::error(status);
}
return zx::ok(std::move(fs_blk));
}
zx_status_t FsckWorker::GetValidSuperblock() {
for (block_t i = 0; i < kSuperblockCopies; ++i) {
if (auto status = GetSuperblock(i); status.is_ok()) {
#ifdef __Fuchsia__
auto sb_ptr = reinterpret_cast<Superblock *>(status->GetData().data() + kSuperOffset);
#else // __Fuchsia__
auto sb_ptr = reinterpret_cast<Superblock *>(status->GetData() + kSuperOffset);
#endif // __Fuchsia__
if (auto sanity = SanityCheckRawSuper(sb_ptr); sanity == ZX_OK) {
auto sb = std::make_shared<Superblock>(*sb_ptr);
superblock_info_.SetRawSuperblock(sb);
InitSuperblockInfo();
return ZX_OK;
}
}
FX_LOGS(WARNING) << "Can't find a valid F2FS superblock in block [" << i << "]";
}
return ZX_ERR_NOT_FOUND;
}
void FsckWorker::InitSuperblockInfo() {
const Superblock &raw_super = superblock_info_.GetRawSuperblock();
superblock_info_.SetLogSectorsPerBlock(LeToCpu(raw_super.log_sectors_per_block));
superblock_info_.SetLogBlocksize(LeToCpu(raw_super.log_blocksize));
superblock_info_.SetBlocksize(1 << superblock_info_.GetLogBlocksize());
superblock_info_.SetLogBlocksPerSeg(LeToCpu(raw_super.log_blocks_per_seg));
superblock_info_.SetBlocksPerSeg(1 << superblock_info_.GetLogBlocksPerSeg());
superblock_info_.SetSegsPerSec(LeToCpu(raw_super.segs_per_sec));
superblock_info_.SetSecsPerZone(LeToCpu(raw_super.secs_per_zone));
superblock_info_.SetTotalSections(LeToCpu(raw_super.section_count));
superblock_info_.SetTotalNodeCount((LeToCpu(raw_super.segment_count_nat) / 2) *
superblock_info_.GetBlocksPerSeg() * kNatEntryPerBlock);
superblock_info_.SetRootIno(LeToCpu(raw_super.root_ino));
superblock_info_.SetNodeIno(LeToCpu(raw_super.node_ino));
superblock_info_.SetMetaIno(LeToCpu(raw_super.meta_ino));
#if 0 // porting needed
superblock_info_.cur_victim_sec = kNullSegNo;
#endif
}
zx::status<std::pair<std::unique_ptr<FsBlock>, uint64_t>> FsckWorker::ValidateCheckpoint(
block_t cp_addr) {
auto cp_page_1 = std::make_unique<FsBlock>();
auto cp_page_2 = std::make_unique<FsBlock>();
Checkpoint *cp_block;
block_t blk_size = superblock_info_.GetBlocksize();
uint64_t cur_version = 0, pre_version = 0;
uint32_t crc = 0;
uint32_t crc_offset;
// Read the 1st cp block in this CP pack
if (ReadBlock(*cp_page_1.get(), cp_addr) != ZX_OK) {
return zx::error(ZX_ERR_INTERNAL);
}
cp_block = (Checkpoint *)cp_page_1.get();
crc_offset = LeToCpu(cp_block->checksum_offset);
if (crc_offset >= blk_size) {
return zx::error(ZX_ERR_INTERNAL);
}
crc = *(uint32_t *)((uint8_t *)cp_block + crc_offset);
if (!F2fsCrcValid(crc, cp_block, crc_offset)) {
return zx::error(ZX_ERR_INTERNAL);
}
pre_version = LeToCpu(cp_block->checkpoint_ver);
// Read the 2nd cp block in this CP pack
cp_addr += LeToCpu(cp_block->cp_pack_total_block_count) - 1;
if (ReadBlock(*cp_page_2.get(), cp_addr) != ZX_OK) {
return zx::error(ZX_ERR_INTERNAL);
}
cp_block = (Checkpoint *)cp_page_2.get();
crc_offset = LeToCpu(cp_block->checksum_offset);
if (crc_offset >= blk_size) {
return zx::error(ZX_ERR_INTERNAL);
}
crc = *(uint32_t *)((uint8_t *)cp_block + crc_offset);
if (!F2fsCrcValid(crc, cp_block, crc_offset)) {
return zx::error(ZX_ERR_INTERNAL);
}
cur_version = LeToCpu(cp_block->checkpoint_ver);
if (cur_version == pre_version) {
return zx::ok(std::pair<std::unique_ptr<FsBlock>, uint64_t>{std::move(cp_page_1), cur_version});
}
return zx::error(ZX_ERR_INTERNAL);
}
zx_status_t FsckWorker::GetValidCheckpoint() {
const Superblock &raw_sb = superblock_info_.GetRawSuperblock();
zx::status<std::pair<std::unique_ptr<FsBlock>, uint64_t>> current = zx::error(ZX_ERR_NOT_FOUND);
block_t cp_start_blk_no = 0;
for (auto checkpoint_start :
{LeToCpu(raw_sb.cp_blkaddr),
LeToCpu(raw_sb.cp_blkaddr) + (1 << LeToCpu(raw_sb.log_blocks_per_seg))}) {
auto status = ValidateCheckpoint(checkpoint_start);
if (status.is_error()) {
continue;
}
if (current.is_error() || VerAfter(status->second, current->second)) {
current = std::move(status);
cp_start_blk_no = checkpoint_start;
}
}
if (current.is_error()) {
return current.error_value();
}
block_t blk_size = superblock_info_.GetBlocksize();
memcpy(&superblock_info_.GetCheckpoint(), current->first.get(), blk_size);
std::vector<FsBlock> checkpoint_trailer(raw_sb.cp_payload);
for (uint32_t i = 0; i < raw_sb.cp_payload; ++i) {
ReadBlock(checkpoint_trailer[i], cp_start_blk_no + 1 + i);
}
superblock_info_.SetCheckpointTrailer(std::move(checkpoint_trailer));
return ZX_OK;
}
zx_status_t FsckWorker::SanityCheckCkpt() {
uint32_t total, fsmeta;
const Superblock &raw_super = superblock_info_.GetRawSuperblock();
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
total = LeToCpu(raw_super.segment_count);
fsmeta = LeToCpu(raw_super.segment_count_ckpt);
fsmeta += LeToCpu(raw_super.segment_count_sit);
fsmeta += LeToCpu(raw_super.segment_count_nat);
fsmeta += LeToCpu(ckpt.rsvd_segment_count);
fsmeta += LeToCpu(raw_super.segment_count_ssa);
if (fsmeta >= total) {
return ZX_ERR_INVALID_ARGS;
}
return ZX_OK;
}
zx_status_t FsckWorker::InitNodeManager() {
const Superblock &sb_raw = superblock_info_.GetRawSuperblock();
uint32_t nat_segs, nat_blocks;
node_manager_->SetNatAddress(LeToCpu(sb_raw.nat_blkaddr));
// segment_count_nat includes pair segment so divide to 2.
nat_segs = LeToCpu(sb_raw.segment_count_nat) >> 1;
nat_blocks = nat_segs << LeToCpu(sb_raw.log_blocks_per_seg);
node_manager_->SetMaxNid(kNatEntryPerBlock * nat_blocks);
node_manager_->SetFirstScanNid(LeToCpu(superblock_info_.GetCheckpoint().next_free_nid));
node_manager_->SetNextScanNid(LeToCpu(superblock_info_.GetCheckpoint().next_free_nid));
if (zx_status_t status =
node_manager_->AllocNatBitmap(superblock_info_.BitmapSize(MetaBitmap::kNatBitmap));
status != ZX_OK) {
return ZX_ERR_NO_MEMORY;
}
// copy version bitmap
node_manager_->SetNatBitmap(
static_cast<uint8_t *>(superblock_info_.BitmapPtr(MetaBitmap::kNatBitmap)));
return ZX_OK;
}
zx_status_t FsckWorker::BuildNodeManager() {
if (node_manager_ = std::make_unique<NodeManager>(&superblock_info_); node_manager_ == nullptr) {
return ZX_ERR_NO_MEMORY;
}
if (zx_status_t err = InitNodeManager(); err != ZX_OK) {
return err;
}
return ZX_OK;
}
zx_status_t FsckWorker::BuildSitInfo() {
const Superblock &raw_sb = superblock_info_.GetRawSuperblock();
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
std::unique_ptr<SitInfo> sit_i;
uint32_t sit_segs;
uint8_t *src_bitmap;
uint32_t bitmap_size;
if (sit_i = std::make_unique<SitInfo>(); sit_i == nullptr) {
return ZX_ERR_NO_MEMORY;
}
sit_i->sentries = new SegmentEntry[segment_manager_->TotalSegs()]();
for (uint32_t start = 0; start < segment_manager_->TotalSegs(); ++start) {
sit_i->sentries[start].cur_valid_map = std::make_unique<uint8_t[]>(kSitVBlockMapSize);
sit_i->sentries[start].ckpt_valid_map = std::make_unique<uint8_t[]>(kSitVBlockMapSize);
if (sit_i->sentries[start].cur_valid_map == nullptr ||
sit_i->sentries[start].ckpt_valid_map == nullptr) {
return ZX_ERR_NO_MEMORY;
}
}
sit_segs = LeToCpu(raw_sb.segment_count_sit) >> 1;
bitmap_size = superblock_info_.BitmapSize(MetaBitmap::kSitBitmap);
if (src_bitmap = static_cast<uint8_t *>(superblock_info_.BitmapPtr(MetaBitmap::kSitBitmap));
src_bitmap == nullptr) {
return ZX_ERR_NO_MEMORY;
}
if (sit_i->sit_bitmap = std::make_unique<uint8_t[]>(bitmap_size); sit_i->sit_bitmap == nullptr) {
return ZX_ERR_NO_MEMORY;
}
memcpy(sit_i->sit_bitmap.get(), src_bitmap, bitmap_size);
sit_i->sit_base_addr = LeToCpu(raw_sb.sit_blkaddr);
sit_i->sit_blocks = sit_segs << superblock_info_.GetLogBlocksPerSeg();
sit_i->written_valid_blocks = LeToCpu(safemath::checked_cast<uint32_t>(ckpt.valid_block_count));
sit_i->bitmap_size = bitmap_size;
sit_i->dirty_sentries = 0;
sit_i->sents_per_block = kSitEntryPerBlock;
sit_i->elapsed_time = LeToCpu(ckpt.elapsed_time);
segment_manager_->SetSitInfo(std::move(sit_i));
return ZX_OK;
}
void FsckWorker::ResetCurseg(CursegType type, int modified) {
CursegInfo *curseg = segment_manager_->CURSEG_I(type);
curseg->segno = curseg->next_segno;
curseg->zone = segment_manager_->GetZoneNoFromSegNo(curseg->segno);
curseg->next_blkoff = 0;
curseg->next_segno = kNullSegNo;
}
zx_status_t FsckWorker::ReadCompactedSummaries() {
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
block_t start;
auto fs_block = std::make_unique<FsBlock>();
uint32_t offset;
CursegInfo *curseg;
start = StartSummaryBlock();
ReadBlock(*fs_block, start++);
curseg = segment_manager_->CURSEG_I(CursegType::kCursegHotData);
#ifdef __Fuchsia__
memcpy(&curseg->sum_blk->n_nats, fs_block->GetData().data(), kSumJournalSize);
#else // __Fuchsia__
memcpy(&curseg->sum_blk->n_nats, fs_block->GetData(), kSumJournalSize);
#endif // __Fuchsia__
curseg = segment_manager_->CURSEG_I(CursegType::kCursegColdData);
#ifdef __Fuchsia__
memcpy(&curseg->sum_blk->n_sits, fs_block->GetData().data() + kSumJournalSize, kSumJournalSize);
#else // __Fuchsia__
memcpy(&curseg->sum_blk->n_sits, fs_block->GetData() + kSumJournalSize, kSumJournalSize);
#endif // __Fuchsia__
offset = 2 * kSumJournalSize;
for (int32_t i = static_cast<int32_t>(CursegType::kCursegHotData);
i <= CursegType::kCursegColdData; ++i) {
unsigned short blk_off;
uint32_t segno;
curseg = segment_manager_->CURSEG_I(static_cast<CursegType>(i));
segno = LeToCpu(ckpt.cur_data_segno[i]);
blk_off = LeToCpu(ckpt.cur_data_blkoff[i]);
curseg->next_segno = segno;
ResetCurseg(static_cast<CursegType>(i), 0);
curseg->alloc_type = ckpt.alloc_type[i];
curseg->next_blkoff = blk_off;
if (curseg->alloc_type == static_cast<uint8_t>(AllocMode::kSSR)) {
blk_off = safemath::checked_cast<unsigned short>(superblock_info_.GetBlocksPerSeg());
}
for (uint32_t j = 0; j < blk_off; ++j) {
Summary *s;
#ifdef __Fuchsia__
s = (Summary *)(fs_block->GetData().data() + offset);
#else // __Fuchsia__
s = (Summary *)(fs_block->GetData() + offset);
#endif // __Fuchsia__
curseg->sum_blk->entries[j] = *s;
offset += kSummarySize;
if (offset + kSummarySize <= kPageSize - kSumFooterSize) {
continue;
}
#ifdef __Fuchsia__
memset(fs_block->GetData().data(), 0, kPageSize);
#else // __Fuchsia__
memset(fs_block->GetData(), 0, kPageSize);
#endif // __Fuchsia__
ReadBlock(*fs_block, start++);
offset = 0;
}
}
return ZX_OK;
}
zx_status_t FsckWorker::RestoreNodeSummary(uint32_t segno, SummaryBlock &summary_block) {
Node *node_block;
block_t addr;
auto fs_block = std::make_unique<FsBlock>();
// scan the node segment
addr = segment_manager_->StartBlock(segno);
for (uint32_t i = 0; i < superblock_info_.GetBlocksPerSeg(); ++i, ++addr) {
if (ReadBlock(*fs_block, addr)) {
break;
}
#ifdef __Fuchsia__
node_block = reinterpret_cast<Node *>(fs_block->GetData().data());
#else // __Fuchsia__
node_block = reinterpret_cast<Node *>(fs_block->GetData());
#endif // __Fuchsia__
summary_block.entries[i].nid = node_block->footer.nid;
}
return ZX_OK;
}
zx_status_t FsckWorker::ReadNormalSummaries(CursegType type) {
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
auto fs_block = std::make_unique<FsBlock>();
SummaryBlock *summary_block;
CursegInfo *curseg;
unsigned short blk_off;
uint32_t segno = 0;
block_t block_address = 0;
if (segment_manager_->IsDataSeg(type)) {
segno = LeToCpu(ckpt.cur_data_segno[static_cast<int>(type)]);
blk_off = LeToCpu(ckpt.cur_data_blkoff[type - CursegType::kCursegHotData]);
if (superblock_info_.TestCpFlags(CpFlag::kCpUmountFlag)) {
block_address = SummaryBlockAddress(kNrCursegType, static_cast<int>(type));
} else {
block_address = SummaryBlockAddress(kNrCursegDataType, static_cast<int>(type));
}
} else {
segno = LeToCpu(ckpt.cur_node_segno[type - CursegType::kCursegHotNode]);
blk_off = LeToCpu(ckpt.cur_node_blkoff[type - CursegType::kCursegHotNode]);
if (superblock_info_.TestCpFlags(CpFlag::kCpUmountFlag)) {
block_address = SummaryBlockAddress(kNrCursegNodeType, type - CursegType::kCursegHotNode);
} else {
block_address = segment_manager_->GetSumBlock(segno);
}
}
ReadBlock(*fs_block, block_address);
#ifdef __Fuchsia__
summary_block = reinterpret_cast<SummaryBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
summary_block = reinterpret_cast<SummaryBlock *>(fs_block->GetData());
#endif // __Fuchsia__
if (segment_manager_->IsNodeSeg(type)) {
if (superblock_info_.TestCpFlags(CpFlag::kCpUmountFlag)) {
#if 0 // do not change original value
Summary *sum_entry = &sum_blk->entries[0];
for (uint64_t i = 0; i < superblock_info->GetBlocksPerSeg(); ++i, ++sum_entry) {
sum_entry->version = 0;
sum_entry->ofs_in_node = 0;
}
#endif
} else {
if (zx_status_t ret = RestoreNodeSummary(segno, *summary_block); ret != ZX_OK) {
return ret;
}
}
}
curseg = segment_manager_->CURSEG_I(type);
memcpy(curseg->sum_blk, summary_block, kPageSize);
curseg->next_segno = segno;
ResetCurseg(type, 0);
curseg->alloc_type = ckpt.alloc_type[static_cast<int>(type)];
curseg->next_blkoff = blk_off;
return ZX_OK;
}
zx_status_t FsckWorker::RestoreCursegSummaries() {
int32_t type = static_cast<int32_t>(CursegType::kCursegHotData);
if (superblock_info_.TestCpFlags(CpFlag::kCpCompactSumFlag)) {
if (zx_status_t ret = ReadCompactedSummaries(); ret != ZX_OK) {
return ret;
}
type = static_cast<int32_t>(CursegType::kCursegHotNode);
}
for (; type <= CursegType::kCursegColdNode; ++type) {
if (zx_status_t ret = ReadNormalSummaries(static_cast<CursegType>(type)); ret != ZX_OK) {
return ret;
}
}
return ZX_OK;
}
zx_status_t FsckWorker::BuildCurseg() {
for (int i = 0; i < kNrCursegType; ++i) {
CursegInfo *curseg = segment_manager_->CURSEG_I(static_cast<CursegType>(i));
curseg->raw_blk = new FsBlock();
curseg->segno = kNullSegNo;
curseg->next_blkoff = 0;
}
return RestoreCursegSummaries();
}
inline void FsckWorker::CheckSegmentRange(uint32_t segno) {
uint32_t end_segno = segment_manager_->GetSegmentsCount() - 1;
ZX_ASSERT(segno <= end_segno);
}
std::unique_ptr<FsBlock> FsckWorker::GetCurrentSitPage(uint32_t segno) {
SitInfo &sit_i = segment_manager_->GetSitInfo();
uint32_t offset = segment_manager_->SitBlockOffset(segno);
block_t block_address = sit_i.sit_base_addr + offset;
auto sit_block = std::make_unique<FsBlock>();
CheckSegmentRange(segno);
// calculate sit block address
if (TestValidBitmap(offset, sit_i.sit_bitmap.get())) {
block_address += sit_i.sit_blocks;
}
ReadBlock(*sit_block.get(), block_address);
return sit_block;
}
void FsckWorker::CheckBlockCount(uint32_t segno, const SitEntry &raw_sit) {
uint32_t end_segno = segment_manager_->GetSegmentsCount() - 1;
int valid_blocks = 0;
// check segment usage
ZX_ASSERT(GetSitVblocks(raw_sit) <= superblock_info_.GetBlocksPerSeg());
// check boundary of a given segment number
ZX_ASSERT(segno <= end_segno);
// check bitmap with valid block count
for (uint64_t i = 0; i < superblock_info_.GetBlocksPerSeg(); ++i) {
if (TestValidBitmap(i, raw_sit.valid_map)) {
++valid_blocks;
}
}
ZX_ASSERT(GetSitVblocks(raw_sit) == valid_blocks);
}
void FsckWorker::SegmentInfoFromRawSit(SegmentEntry &segment_entry, const SitEntry &raw_sit) {
segment_entry.valid_blocks = GetSitVblocks(raw_sit);
segment_entry.ckpt_valid_blocks = GetSitVblocks(raw_sit);
memcpy(segment_entry.cur_valid_map.get(), raw_sit.valid_map, kSitVBlockMapSize);
memcpy(segment_entry.ckpt_valid_map.get(), raw_sit.valid_map, kSitVBlockMapSize);
segment_entry.type = GetSitType(raw_sit);
segment_entry.mtime = LeToCpu(raw_sit.mtime);
}
SegmentEntry &FsckWorker::GetSegmentEntry(uint32_t segno) {
SitInfo &sit_i = segment_manager_->GetSitInfo();
return sit_i.sentries[segno];
}
std::pair<std::unique_ptr<FsBlock>, SegType> FsckWorker::GetSumBlockInfo(uint32_t segno) {
auto summary_block = std::make_unique<FsBlock>();
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
CursegInfo *curseg;
block_t ssa_blk;
ssa_blk = segment_manager_->GetSumBlock(segno);
for (int type = 0; type < kNrCursegNodeType; ++type) {
if (segno == ckpt.cur_node_segno[type]) {
curseg = segment_manager_->CURSEG_I(CursegType::kCursegHotNode + type);
memcpy(summary_block.get(), curseg->sum_blk, kBlockSize);
return {std::move(summary_block),
SegType::kSegTypeCurNode}; // current node seg was not stored
}
}
for (int type = 0; type < kNrCursegDataType; ++type) {
if (segno == ckpt.cur_data_segno[type]) {
curseg = segment_manager_->CURSEG_I(CursegType::kCursegHotData + type);
#ifdef __Fuchsia__
memcpy(summary_block->GetData().data(), curseg->sum_blk, kBlockSize);
#else // __Fuchsia__
memcpy(summary_block->GetData(), curseg->sum_blk, kBlockSize);
#endif // __Fuchsia__
ZX_ASSERT(!IsSumNodeSeg((reinterpret_cast<SummaryBlock *>(summary_block.get()))->footer));
#if 0 // TODO: implement debug level
// TODO: DBG (2)
printf("segno [0x%x] is current data seg[0x%x]\n", segno, type);
#endif
return {std::move(summary_block),
SegType::kSegTypeCurData}; // current data seg was not stored
}
}
ZX_ASSERT(ReadBlock(*summary_block.get(), ssa_blk) == ZX_OK);
if (IsSumNodeSeg((reinterpret_cast<SummaryBlock *>(summary_block.get()))->footer)) {
return {std::move(summary_block), SegType::kSegTypeNode};
}
return {std::move(summary_block), SegType::kSegTypeData};
}
uint32_t FsckWorker::GetSegmentNumber(uint32_t block_address) {
return (uint32_t)(BlkoffFromMain(*segment_manager_, block_address) >>
superblock_info_.GetLogBlocksPerSeg());
}
std::pair<SegType, Summary> FsckWorker::GetSummaryEntry(uint32_t block_address) {
uint32_t segno, offset;
Summary summary_entry;
segno = GetSegmentNumber(block_address);
offset = OffsetInSegment(superblock_info_, *segment_manager_, block_address);
auto [summary_block, type] = GetSumBlockInfo(segno);
#ifdef __Fuchsia__
memcpy(&summary_entry,
&((reinterpret_cast<SummaryBlock *>(summary_block->GetData().data()))->entries[offset]),
sizeof(Summary));
#else // __Fuchsia__
memcpy(&summary_entry,
&((reinterpret_cast<SummaryBlock *>(summary_block->GetData()))->entries[offset]),
sizeof(Summary));
#endif // __Fuchsia__
return {type, summary_entry};
}
zx::status<RawNatEntry> FsckWorker::GetNatEntry(nid_t nid) {
block_t block_off;
block_t block_addr;
block_t seg_off;
int entry_off;
if ((nid / kNatEntryPerBlock) > fsck_.nr_nat_entries) {
FX_LOGS(WARNING) << "nid is over max nid";
return zx::error(ZX_ERR_INVALID_ARGS);
}
if (auto result = LookupNatInJournal(nid); result.is_ok()) {
return result;
}
block_off = nid / kNatEntryPerBlock;
entry_off = nid % kNatEntryPerBlock;
seg_off = block_off >> superblock_info_.GetLogBlocksPerSeg();
block_addr =
(node_manager_->GetNatAddress() + (seg_off << superblock_info_.GetLogBlocksPerSeg() << 1) +
(block_off & ((1 << superblock_info_.GetLogBlocksPerSeg()) - 1)));
if (TestValidBitmap(block_off, node_manager_->GetNatBitmap())) {
block_addr += superblock_info_.GetBlocksPerSeg();
}
auto fs_block = std::make_unique<FsBlock>();
ZX_ASSERT(ReadBlock(*fs_block, block_addr) == ZX_OK);
#ifdef __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData());
#endif // __Fuchsia__
return zx::ok(nat_block->entries[entry_off]);
}
zx::status<NodeInfo> FsckWorker::GetNodeInfo(nid_t nid) {
NodeInfo node_info;
auto result = GetNatEntry(nid);
if (result.is_error()) {
return result.take_error();
}
RawNatEntry raw_nat = *result;
node_info.nid = nid;
NodeInfoFromRawNat(node_info, raw_nat);
return zx::ok(node_info);
}
void FsckWorker::BuildSitEntries() {
SitInfo &sit_i = segment_manager_->GetSitInfo();
CursegInfo *curseg = segment_manager_->CURSEG_I(CursegType::kCursegColdData);
SummaryBlock *sum = curseg->sum_blk;
for (uint32_t segno = 0; segno < segment_manager_->TotalSegs(); ++segno) {
SegmentEntry &segment_entry = sit_i.sentries[segno];
SitEntry sit;
bool found = false;
for (int i = 0; i < SitsInCursum(sum); ++i) {
if (LeToCpu(SegnoInJournal(sum, i)) == segno) {
sit = sum->sit_j.entries[i].se;
found = true;
break;
}
}
if (found == false) {
std::unique_ptr<FsBlock> sit_block = GetCurrentSitPage(segno);
sit = reinterpret_cast<SitBlock *>(sit_block.get())
->entries[segment_manager_->SitEntryOffset(segno)];
}
CheckBlockCount(segno, sit);
SegmentInfoFromRawSit(segment_entry, sit);
}
}
zx_status_t FsckWorker::BuildSegmentManager() {
Superblock &raw_super = superblock_info_.GetRawSuperblock();
Checkpoint &ckpt = superblock_info_.GetCheckpoint();
if (segment_manager_ = std::make_unique<SegmentManager>(&superblock_info_);
segment_manager_ == nullptr) {
return ZX_ERR_NO_MEMORY;
}
// init sm info
segment_manager_->SetSegment0StartBlock(LeToCpu(raw_super.segment0_blkaddr));
segment_manager_->SetMainAreaStartBlock(LeToCpu(raw_super.main_blkaddr));
segment_manager_->SetSegmentsCount(LeToCpu(raw_super.segment_count));
segment_manager_->SetReservedSegmentsCount(LeToCpu(ckpt.rsvd_segment_count));
segment_manager_->SetOPSegmentsCount(LeToCpu(ckpt.overprov_segment_count));
segment_manager_->SetMainSegmentsCount(LeToCpu(raw_super.segment_count_main));
segment_manager_->SetSSAreaStartBlock(LeToCpu(raw_super.ssa_blkaddr));
if (auto status = BuildSitInfo(); status != ZX_OK) {
return status;
}
if (auto status = BuildCurseg(); status != ZX_OK) {
return status;
}
BuildSitEntries();
return ZX_OK;
}
void FsckWorker::BuildSitAreaBitmap() {
uint32_t vblocks = 0;
sit_area_bitmap_size_ = segment_manager_->GetMainSegmentsCount() * kSitVBlockMapSize;
sit_area_bitmap_ = std::make_unique<uint8_t[]>(sit_area_bitmap_size_);
uint8_t *ptr = sit_area_bitmap_.get();
for (uint32_t segno = 0; segno < segment_manager_->GetMainSegmentsCount(); ++segno) {
SegmentEntry &segment_entry = GetSegmentEntry(segno);
memcpy(ptr, segment_entry.cur_valid_map.get(), kSitVBlockMapSize);
ptr += kSitVBlockMapSize;
vblocks = 0;
for (uint64_t j = 0; j < kSitVBlockMapSize; ++j) {
vblocks += std::bitset<8>(segment_entry.cur_valid_map[j]).count();
}
ZX_ASSERT(vblocks == segment_entry.valid_blocks);
if (segment_entry.valid_blocks == 0x0) {
if (superblock_info_.GetCheckpoint().cur_node_segno[0] == segno ||
superblock_info_.GetCheckpoint().cur_data_segno[0] == segno ||
superblock_info_.GetCheckpoint().cur_node_segno[1] == segno ||
superblock_info_.GetCheckpoint().cur_data_segno[1] == segno ||
superblock_info_.GetCheckpoint().cur_node_segno[2] == segno ||
superblock_info_.GetCheckpoint().cur_data_segno[2] == segno) {
continue;
}
} else {
ZX_ASSERT(segment_entry.valid_blocks <= 512);
}
}
}
zx::status<RawNatEntry> FsckWorker::LookupNatInJournal(nid_t nid) {
RawNatEntry raw_nat;
CursegInfo *curseg = segment_manager_->CURSEG_I(CursegType::kCursegHotData);
SummaryBlock *sum = curseg->sum_blk;
for (int i = 0; i < NatsInCursum(sum); ++i) {
if (LeToCpu(NidInJournal(sum, i)) == nid) {
RawNatEntry ret = NatInJournal(sum, i);
#if 0 // TODO: implement debug level
// TODO: DBG (3)
printf("==> Found nid [0x%x] in nat cache\n", nid);
#endif
memcpy(&raw_nat, &ret, sizeof(RawNatEntry));
return zx::ok(raw_nat);
}
}
return zx::error(ZX_ERR_NOT_FOUND);
}
void FsckWorker::BuildNatAreaBitmap() {
const Superblock &raw_sb = superblock_info_.GetRawSuperblock();
nid_t nid, nr_nat_blks;
block_t block_off;
block_t block_addr;
block_t seg_off;
// Alloc & build nat entry bitmap
nr_nat_blks = (LeToCpu(raw_sb.segment_count_nat) / 2) << superblock_info_.GetLogBlocksPerSeg();
fsck_.nr_nat_entries = nr_nat_blks * kNatEntryPerBlock;
fsck_.nat_area_bitmap_size = (fsck_.nr_nat_entries + 7) / 8;
fsck_.nat_area_bitmap = std::make_unique<uint8_t[]>(fsck_.nat_area_bitmap_size);
ZX_ASSERT(fsck_.nat_area_bitmap.get() != nullptr);
for (block_off = 0; block_off < nr_nat_blks; ++block_off) {
seg_off = block_off >> superblock_info_.GetLogBlocksPerSeg();
block_addr = node_manager_->GetNatAddress() +
(seg_off << superblock_info_.GetLogBlocksPerSeg() << 1) +
(block_off & ((1 << superblock_info_.GetLogBlocksPerSeg()) - 1));
if (TestValidBitmap(block_off, node_manager_->GetNatBitmap())) {
block_addr += superblock_info_.GetBlocksPerSeg();
}
auto fs_block = std::make_unique<FsBlock>();
ZX_ASSERT(ReadBlock(*fs_block, block_addr) == ZX_OK);
#ifdef __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData().data());
#else // __Fuchsia__
NatBlock *nat_block = reinterpret_cast<NatBlock *>(fs_block->GetData());
#endif // __Fuchsia__
nid = block_off * kNatEntryPerBlock;
for (uint32_t i = 0; i < kNatEntryPerBlock; ++i) {
NodeInfo node_info;
node_info.nid = nid + i;
if ((nid + i) == superblock_info_.GetNodeIno() ||
(nid + i) == superblock_info_.GetMetaIno()) {
ZX_ASSERT(nat_block->entries[i].block_addr != 0x0);
continue;
}
if (auto result = LookupNatInJournal(nid + i); result.is_ok()) {
RawNatEntry raw_nat = *result;
NodeInfoFromRawNat(node_info, raw_nat);
if (node_info.blk_addr != kNullAddr) {
SetValidBitmap(nid + i, fsck_.nat_area_bitmap.get());
++fsck_.result.valid_nat_entry_count;
#if 0 // TODO: implement debug level
// TODO: DBG (3)
printf("nid[0x%x] in nat cache\n", nid + i);
#endif
}
} else {
NodeInfoFromRawNat(node_info, nat_block->entries[i]);
if (node_info.blk_addr != kNullAddr) {
ZX_ASSERT(nid + i != 0x0);
#if 0 // TODO: implement debug level
// TODO: DBG (3)
printf("nid[0x%8x] in nat entry [0x%16x] [0x%8x]\n", nid + i, ni.blk_addr, ni.ino);
#endif
SetValidBitmap(nid + i, fsck_.nat_area_bitmap.get());
++fsck_.result.valid_nat_entry_count;
}
}
}
}
#if 0 // TODO: implement debug level
// TODO: DBG (1)
printf("valid nat entries (block_addr != 0x0) [0x%8x : %u]\n", fsck->chk.valid_nat_entry_cnt,
fsck->chk.valid_nat_entry_cnt);
#endif
}
zx_status_t FsckWorker::DoMount() {
if (mounted_) {
DoUmount();
}
superblock_info_.SetActiveLogs(kNrCursegType);
if (auto status = GetValidSuperblock(); status != ZX_OK) {
return status;
}
if (auto status = GetValidCheckpoint(); status != ZX_OK) {
FX_LOGS(ERROR) << "Can't find valid checkpoint" << status;
return status;
}
if (auto status = SanityCheckCkpt(); status != ZX_OK) {
FX_LOGS(ERROR) << "Checkpoint is polluted" << status;
return status;
}
superblock_info_.SetTotalValidNodeCount(
LeToCpu(superblock_info_.GetCheckpoint().valid_node_count));
superblock_info_.SetTotalValidInodeCount(
LeToCpu(superblock_info_.GetCheckpoint().valid_inode_count));
superblock_info_.SetUserBlockCount(
LeToCpu(static_cast<block_t>(superblock_info_.GetCheckpoint().user_block_count)));
superblock_info_.SetTotalValidBlockCount(
LeToCpu(static_cast<block_t>(superblock_info_.GetCheckpoint().valid_block_count)));
superblock_info_.SetLastValidBlockCount(superblock_info_.GetTotalValidBlockCount());
superblock_info_.SetAllocValidBlockCount(0);
if (auto status = BuildSegmentManager(); status != ZX_OK) {
FX_LOGS(ERROR) << "build_segment_manager failed: " << status;
return status;
}
if (auto status = BuildNodeManager(); status != ZX_OK) {
FX_LOGS(ERROR) << "build_segment_manager failed: " << status;
return status;
}
BuildSitAreaBitmap();
mounted_ = true;
return ZX_OK;
}
void FsckWorker::DoUmount() {
if (!mounted_) {
return;
}
SitInfo &sit_i = segment_manager_->GetSitInfo();
node_manager_.reset();
for (uint32_t i = 0; i < segment_manager_->TotalSegs(); ++i) {
sit_i.sentries[i].cur_valid_map.reset();
sit_i.sentries[i].ckpt_valid_map.reset();
}
delete[] sit_i.sentries;
sit_i.sit_bitmap.reset();
for (uint32_t i = 0; i < kNrCursegType; ++i) {
CursegInfo *curseg = segment_manager_->CURSEG_I(static_cast<CursegType>(i));
delete curseg->raw_blk;
}
segment_manager_.reset();
mounted_ = false;
}
zx_status_t FsckWorker::DoFsck() {
if (auto status = Init(); status != ZX_OK) {
return status;
}
if (auto status = CheckOrphanNodes(); status != ZX_OK) {
return status;
}
// Traverse all block recursively from root inode
if (auto status = CheckNodeBlock(nullptr, superblock_info_.GetRootIno(), FileType::kFtDir,
NodeType::kTypeInode);
status.is_error()) {
return status.error_value();
}
if (auto status = Verify(); status != ZX_OK) {
std::cout << "[FSCK] Corruption detected.." << std::endl;
if (fsck_options_.repair) {
status = Repair();
std::cout << "[FSCK] Repair.. "
<< (status == ZX_OK ? " [Ok..]" : " [Fail]") << std::endl;
}
return status;
}
return ZX_OK;
}
zx_status_t FsckWorker::Run() {
zx_status_t status = ZX_OK;
if (status = DoMount(); status != ZX_OK) {
return status;
}
std::cout << std::endl << "[FSCK] Start.." << std::endl;
status = DoFsck();
std::cout << "[FSCK] Done.. ";
if (status != ZX_OK) {
std::cout << " [Fail] [" << status << "]" << std::endl;
PrintRawSuperblockInfo();
PrintCheckpointInfo();
} else {
std::cout << " [Ok..]" << std::endl;
}
// TODO: Add dump
return status;
}
zx_status_t Fsck(std::unique_ptr<Bcache> bc, const FsckOptions &options,
std::unique_ptr<Bcache> *out) {
zx_status_t status;
FsckWorker fsck(std::move(bc), options);
status = fsck.Run();
if (out != nullptr) {
*out = fsck.Destroy();
}
return status;
}
} // namespace f2fs