| // 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 "src/storage/f2fs/f2fs.h" |
| |
| namespace f2fs { |
| |
| bool F2fs::SpaceForRollForward() { |
| SuperblockInfo &superblock_info = GetSuperblockInfo(); |
| std::lock_guard stat_lock(superblock_info.GetStatLock()); |
| if (superblock_info.GetLastValidBlockCount() + superblock_info.GetAllocValidBlockCount() > |
| superblock_info.GetUserBlockCount()) |
| return false; |
| return true; |
| } |
| |
| F2fs::FsyncInodeEntry *F2fs::GetFsyncInode(FsyncInodeList &inode_list, nid_t ino) { |
| auto inode_entry = |
| inode_list.find_if([ino](const auto &entry) { return entry.GetVnode().Ino() == ino; }); |
| if (inode_entry == inode_list.end()) |
| return nullptr; |
| return &(*inode_entry); |
| } |
| |
| zx_status_t F2fs::RecoverDentry(NodePage &ipage, VnodeF2fs &vnode) { |
| Node *raw_node = ipage.GetAddress<Node>(); |
| Inode *raw_inode = &(raw_node->i); |
| fbl::RefPtr<VnodeF2fs> dir_refptr; |
| zx_status_t err = ZX_OK; |
| |
| if (!ipage.IsDentDnode()) { |
| return ZX_OK; |
| } |
| |
| if (err = VnodeF2fs::Vget(this, LeToCpu(raw_inode->i_pino), &dir_refptr); err != ZX_OK) { |
| return err; |
| } |
| |
| auto dir = static_cast<Dir *>(dir_refptr.get()); |
| fbl::RefPtr<Page> page; |
| auto dir_entry = dir->FindEntry(vnode.GetNameView(), &page); |
| if (dir_entry == nullptr) { |
| dir->AddLink(vnode.GetNameView(), &vnode); |
| } else if (dir_entry && vnode.Ino() != LeToCpu(dir_entry->ino)) { |
| // Remove old dentry |
| fbl::RefPtr<VnodeF2fs> old_vnode_refptr; |
| if (err = VnodeF2fs::Vget(this, dir_entry->ino, &old_vnode_refptr); err != ZX_OK) { |
| return err; |
| } |
| dir->DeleteEntry(dir_entry, page, old_vnode_refptr.get()); |
| ZX_ASSERT(dir->FindEntry(vnode.GetNameView()).status_value() == ZX_ERR_NOT_FOUND); |
| dir->AddLink(vnode.GetNameView(), &vnode); |
| } |
| return err; |
| } |
| |
| zx_status_t F2fs::RecoverInode(VnodeF2fs &vnode, NodePage &node_page) { |
| struct Node *raw_node = node_page.GetAddress<Node>(); |
| struct Inode *raw_inode = &(raw_node->i); |
| |
| vnode.SetMode(LeToCpu(raw_inode->i_mode)); |
| vnode.SetSize(LeToCpu(raw_inode->i_size)); |
| vnode.SetATime(LeToCpu(raw_inode->i_atime), LeToCpu(raw_inode->i_atime_nsec)); |
| vnode.SetCTime(LeToCpu(raw_inode->i_ctime), LeToCpu(raw_inode->i_ctime_nsec)); |
| vnode.SetMTime(LeToCpu(raw_inode->i_mtime), LeToCpu(raw_inode->i_mtime_nsec)); |
| |
| return RecoverDentry(node_page, vnode); |
| } |
| |
| zx_status_t F2fs::FindFsyncDnodes(FsyncInodeList &inode_list) { |
| SuperblockInfo &superblock_info = GetSuperblockInfo(); |
| uint64_t cp_ver = LeToCpu(superblock_info.GetCheckpoint().checkpoint_ver); |
| fbl::RefPtr<VnodeF2fs> vnode_refptr; |
| zx_status_t err = ZX_OK; |
| |
| // Retrieve the curseg information of kCursegWarmNode |
| CursegInfo *curseg = segment_manager_->CURSEG_I(CursegType::kCursegWarmNode); |
| // Get blkaddr from which it starts finding fsynced dnode block |
| block_t blkaddr = segment_manager_->StartBlock(curseg->segno) + curseg->next_blkoff; |
| |
| while (true) { |
| LockedPage page; |
| // Since node inode cache cannot be used for recovery, use meta inode cache temporarily and |
| // delete it later. Meta vnode is indexed by LBA, it can be used to read node blocks. This |
| // method eliminates duplicate node block reads. |
| if (zx_status_t ret = GetMetaPage(blkaddr, &page); ret != ZX_OK) { |
| return ret; |
| } |
| |
| if (cp_ver != page.GetPage<NodePage>().CpverOfNode()) { |
| break; |
| } |
| |
| if (!page.GetPage<NodePage>().IsFsyncDnode()) { |
| // Check next segment |
| blkaddr = page.GetPage<NodePage>().NextBlkaddrOfNode(); |
| page->ClearUptodate(); |
| continue; |
| } |
| |
| auto entry_ptr = GetFsyncInode(inode_list, page.GetPage<NodePage>().InoOfNode()); |
| if (entry_ptr) { |
| entry_ptr->SetLastDnodeBlkaddr(blkaddr); |
| if (IsInode(*page) && page.GetPage<NodePage>().IsDentDnode()) { |
| entry_ptr->GetVnode().SetFlag(InodeInfoFlag::kIncLink); |
| } |
| } else { |
| if (IsInode(*page) && page.GetPage<NodePage>().IsDentDnode()) { |
| if (err = GetNodeManager().RecoverInodePage(page.GetPage<NodePage>()); err != ZX_OK) { |
| break; |
| } |
| } |
| |
| if (err = VnodeF2fs::Vget(this, page.GetPage<NodePage>().InoOfNode(), &vnode_refptr); |
| err != ZX_OK) { |
| break; |
| } |
| |
| // Add this fsync inode to the list |
| auto entry = std::make_unique<FsyncInodeEntry>(std::move(vnode_refptr)); |
| entry_ptr = entry.get(); |
| entry->SetLastDnodeBlkaddr(blkaddr); |
| inode_list.push_back(std::move(entry)); |
| } |
| |
| if (IsInode(*page)) { |
| if (err = RecoverInode(entry_ptr->GetVnode(), page.GetPage<NodePage>()); err != ZX_OK) { |
| break; |
| } |
| } |
| |
| // Get the next block information from footer |
| blkaddr = page.GetPage<NodePage>().NextBlkaddrOfNode(); |
| page->ClearUptodate(); |
| } |
| return err; |
| } |
| |
| void F2fs::DestroyFsyncDnodes(FsyncInodeList &inode_list) { |
| while (!inode_list.is_empty()) { |
| inode_list.pop_front(); |
| } |
| } |
| |
| void F2fs::CheckIndexInPrevNodes(block_t blkaddr) { |
| SuperblockInfo &superblock_info = GetSuperblockInfo(); |
| uint32_t segno = segment_manager_->GetSegmentNumber(blkaddr); |
| uint16_t blkoff = static_cast<uint16_t>(segment_manager_->GetSegOffFromSeg0(blkaddr) & |
| (superblock_info.GetBlocksPerSeg() - 1)); |
| Summary sum; |
| nid_t ino; |
| block_t bidx; |
| int i; |
| |
| SegmentEntry &sentry = GetSegmentManager().GetSegmentEntry(segno); |
| if (!TestValidBitmap(blkoff, sentry.cur_valid_map.get())) { |
| return; |
| } |
| |
| // Get the previous summary |
| for (i = static_cast<int>(CursegType::kCursegWarmData); |
| i <= static_cast<int>(CursegType::kCursegColdData); ++i) { |
| CursegInfo *curseg = segment_manager_->CURSEG_I(static_cast<CursegType>(i)); |
| if (curseg->segno == segno) { |
| sum = curseg->sum_blk->entries[blkoff]; |
| break; |
| } |
| } |
| if (i > static_cast<int>(CursegType::kCursegColdData)) { |
| LockedPage sum_page; |
| GetSegmentManager().GetSumPage(segno, &sum_page); |
| SummaryBlock *sum_node; |
| sum_node = sum_page->GetAddress<SummaryBlock>(); |
| sum = sum_node->entries[blkoff]; |
| } |
| |
| // Get the node page |
| { |
| LockedPage node_page; |
| if (zx_status_t err = GetNodeManager().GetNodePage(LeToCpu(sum.nid), &node_page); |
| err != ZX_OK) { |
| FX_LOGS(ERROR) << "F2fs::CheckIndexInPrevNodes, GetNodePage Error!!!"; |
| return; |
| } |
| bidx = node_page.GetPage<NodePage>().StartBidxOfNode() + LeToCpu(sum.ofs_in_node); |
| ino = node_page.GetPage<NodePage>().InoOfNode(); |
| } |
| |
| // Deallocate previous index in the node page |
| fbl::RefPtr<VnodeF2fs> vnode_refptr; |
| VnodeF2fs::Vget(this, ino, &vnode_refptr); |
| vnode_refptr->TruncateHole(bidx, bidx + 1); |
| } |
| |
| void F2fs::DoRecoverData(VnodeF2fs &vnode, NodePage &page) { |
| uint32_t start, end; |
| Summary sum; |
| NodeInfo ni; |
| |
| if (vnode.RecoverInlineData(page) == ZX_OK) { |
| // Restored from inline data. |
| return; |
| } |
| |
| start = page.StartBidxOfNode(); |
| if (IsInode(page)) { |
| end = start + kAddrsPerInode; |
| } else { |
| end = start + kAddrsPerBlock; |
| } |
| |
| LockedPage dnode_page; |
| if (GetNodeManager().GetLockedDnodePage(vnode, start, &dnode_page) != ZX_OK) { |
| return; |
| } |
| |
| dnode_page->WaitOnWriteback(); |
| |
| GetNodeManager().GetNodeInfo(dnode_page.GetPage<NodePage>().NidOfNode(), ni); |
| ZX_DEBUG_ASSERT(ni.ino == page.InoOfNode()); |
| ZX_DEBUG_ASSERT(dnode_page.GetPage<NodePage>().OfsOfNode() == page.OfsOfNode()); |
| |
| zx::status<uint32_t> result; |
| if (result = GetNodeManager().GetOfsInDnode(vnode, start); result.is_error()) { |
| return; |
| } |
| uint32_t offset_in_dnode = result.value(); |
| |
| for (; start < end; ++start) { |
| block_t src, dest; |
| |
| src = DatablockAddr(&dnode_page.GetPage<NodePage>(), offset_in_dnode); |
| dest = DatablockAddr(&page, offset_in_dnode); |
| |
| if (src != dest && dest != kNewAddr && dest != kNullAddr) { |
| if (src == kNullAddr) { |
| ZX_ASSERT(vnode.ReserveNewBlock(dnode_page.GetPage<NodePage>(), offset_in_dnode) == ZX_OK); |
| } |
| |
| // Check the previous node page having this index |
| CheckIndexInPrevNodes(dest); |
| |
| GetSegmentManager().SetSummary(&sum, dnode_page.GetPage<NodePage>().NidOfNode(), |
| offset_in_dnode, ni.version); |
| |
| // Write dummy data page |
| GetSegmentManager().RecoverDataPage(sum, src, dest); |
| vnode.SetDataBlkaddr(dnode_page.GetPage<NodePage>(), offset_in_dnode, dest); |
| vnode.UpdateExtentCache(dest, page.StartBidxOfNode()); |
| } |
| ++offset_in_dnode; |
| } |
| |
| // Write node page in place |
| GetSegmentManager().SetSummary(&sum, dnode_page.GetPage<NodePage>().NidOfNode(), 0, 0); |
| if (IsInode(*dnode_page)) { |
| vnode.MarkInodeDirty(); |
| } |
| |
| dnode_page.GetPage<NodePage>().CopyNodeFooterFrom(page); |
| dnode_page.GetPage<NodePage>().FillNodeFooter(ni.nid, ni.ino, page.OfsOfNode(), false); |
| dnode_page->SetDirty(); |
| } |
| |
| void F2fs::RecoverData(FsyncInodeList &inode_list, CursegType type) { |
| SuperblockInfo &superblock_info = GetSuperblockInfo(); |
| uint64_t cp_ver = LeToCpu(superblock_info.GetCheckpoint().checkpoint_ver); |
| block_t blkaddr = segment_manager_->NextFreeBlkAddr(type); |
| |
| while (true) { |
| LockedPage page; |
| // Eliminate duplicate node block reads using a meta inode cache. |
| if (zx_status_t ret = GetMetaVnode().GrabCachePage(blkaddr, &page); ret != ZX_OK) { |
| return; |
| } |
| |
| if (MakeOperation(storage::OperationType::kRead, page, blkaddr, PageType::kNode)) { |
| break; |
| } |
| |
| if (cp_ver != page.GetPage<NodePage>().CpverOfNode()) { |
| break; |
| } |
| |
| if (auto entry = GetFsyncInode(inode_list, page.GetPage<NodePage>().InoOfNode()); |
| entry != nullptr) { |
| DoRecoverData(entry->GetVnode(), page.GetPage<NodePage>()); |
| if (entry->GetLastDnodeBlkaddr() == blkaddr) { |
| inode_list.erase(*entry); |
| } |
| } |
| // check next segment |
| blkaddr = page.GetPage<NodePage>().NextBlkaddrOfNode(); |
| page->ClearUptodate(); |
| } |
| |
| GetSegmentManager().AllocateNewSegments(); |
| } |
| |
| void F2fs::RecoverFsyncData() { |
| SuperblockInfo &superblock_info = GetSuperblockInfo(); |
| FsyncInodeList inode_list; |
| |
| // Step #1: find fsynced inode numbers |
| if (auto result = FindFsyncDnodes(inode_list); result == ZX_OK) { |
| // Step #2: recover data |
| if (!inode_list.is_empty()) { |
| superblock_info.SetOnRecovery(); |
| RecoverData(inode_list, CursegType::kCursegWarmNode); |
| superblock_info.ClearOnRecovery(); |
| ZX_DEBUG_ASSERT(inode_list.is_empty()); |
| GetMetaVnode().InvalidatePages(GetSegmentManager().GetMainAreaStartBlock()); |
| WriteCheckpoint(false, false); |
| } |
| } |
| // TODO: Handle error cases |
| GetMetaVnode().InvalidatePages(GetSegmentManager().GetMainAreaStartBlock()); |
| DestroyFsyncDnodes(inode_list); |
| } |
| |
| } // namespace f2fs |