[f2fs] Correct the code formatting
Run 'fx format-code --all'
Change-Id: I44d131e81cd036eaca103b6caecd07116ff428f7
Reviewed-on: https://fuchsia-review.googlesource.com/c/third_party/f2fs/+/532681
Reviewed-by: Brett Wilson <brettw@google.com>
diff --git a/BUILD.gn b/BUILD.gn
index 395049b..d72c6b4 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -12,40 +12,39 @@
}
static_library("f2fs") {
-
sources = [
- "f2fs.cc",
- "vnode.cc",
- "mkfs.cc",
"bcache.cc",
- "super.cc",
- "dir.cc",
- "file.cc",
- "dir_hash.cc",
- "data.cc",
- "segment.cc",
- "node.cc",
- "namei.cc",
"checkpoint.cc",
+ "data.cc",
+ "dir.cc",
+ "dir_hash.cc",
+ "f2fs.cc",
+ "file.cc",
+ "mkfs.cc",
+ "namei.cc",
+ "node.cc",
"recovery.cc",
- "third_party/ext2_hash/hash.h",
+ "segment.cc",
+ "super.cc",
"third_party/ext2_hash/hash.cc",
+ "third_party/ext2_hash/hash.h",
+ "vnode.cc",
]
public = [
- "f2fs_types.h",
- "f2fs_lib.h",
- "f2fs_layout.h",
- "f2fs_internal.h",
- "vnode.h",
- "mkfs.h",
"bcache.h",
- "node.h",
"dir.h",
- "file.h",
- "segment.h",
- "node.h",
"f2fs.h",
+ "f2fs_internal.h",
+ "f2fs_layout.h",
+ "f2fs_lib.h",
+ "f2fs_types.h",
+ "file.h",
+ "mkfs.h",
+ "node.h",
+ "node.h",
+ "segment.h",
+ "vnode.h",
]
public_deps = [
@@ -59,20 +58,21 @@
"//sdk/fidl/fuchsia.hardware.block:fuchsia.hardware.block_c",
# fsck.h includes block-client/cpp/block-device.h
- "//zircon/system/ulib/block-client",
-
- "//zircon/public/lib/zircon-internal",
"//src/lib/storage/vfs/cpp",
+ "//zircon/public/lib/zircon-internal",
+ "//zircon/system/ulib/block-client",
]
deps = [
- "//sdk/fidl/fuchsia.io:fuchsia.io_llcpp",
"//sdk/fidl/fuchsia.io",
+ "//sdk/fidl/fuchsia.io:fuchsia.io_llcpp",
+ "//sdk/lib/fdio",
+ "//sdk/lib/syslog/cpp",
+ "//src/lib/storage/vfs/cpp/metrics:metrics-cobalt",
"//zircon/public/lib/async",
"//zircon/public/lib/async-cpp",
"//zircon/public/lib/fidl",
"//zircon/public/lib/zx",
- "//sdk/lib/fdio",
"//zircon/system/ulib/async-default",
"//zircon/system/ulib/async-loop",
"//zircon/system/ulib/async-loop:async-loop-cpp",
@@ -83,14 +83,10 @@
"//zircon/system/ulib/trace",
"//zircon/system/ulib/trace-engine",
"//zircon/system/ulib/trace-provider:trace-provider-with-fdio",
- "//sdk/lib/syslog/cpp",
- "//src/lib/storage/vfs/cpp/metrics:metrics-cobalt",
]
if (f2fs_bu_debug) {
- defines = [
- "F2FS_BU_DEBUG",
- ]
+ defines = [ "F2FS_BU_DEBUG" ]
}
# TODO(fxbug.dev/69585): This target uses raw zx::channel with LLCPP which is deprecated.
diff --git a/bcache.cc b/bcache.cc
index 2312258..5f2a86b 100644
--- a/bcache.cc
+++ b/bcache.cc
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "f2fs.h"
-
#include <assert.h>
#include <fuchsia/device/c/fidl.h>
#include <fuchsia/io/llcpp/fidl.h>
@@ -24,6 +22,7 @@
#include <storage/buffer/vmo_buffer.h>
#include <storage/operation/operation.h>
+#include "f2fs.h"
namespace f2fs {
diff --git a/bcache.h b/bcache.h
index 346956b..2fd3193 100644
--- a/bcache.h
+++ b/bcache.h
@@ -5,29 +5,27 @@
// This file describes the in-memory structures which construct
// a F2FS filesystem.
-#ifndef F2FS_BCACHE_H_
-#define F2FS_BCACHE_H_
+#ifndef THIRD_PARTY_F2FS_BCACHE_H_
+#define THIRD_PARTY_F2FS_BCACHE_H_
#include <errno.h>
+#include <fuchsia/hardware/block/c/fidl.h>
#include <inttypes.h>
+#include <lib/zx/vmo.h>
#include <atomic>
#include <shared_mutex>
+#include <block-client/cpp/block-device.h>
+#include <block-client/cpp/client.h>
#include <fbl/algorithm.h>
#include <fbl/array.h>
#include <fbl/macros.h>
#include <fbl/unique_fd.h>
-
-#include <fuchsia/hardware/block/c/fidl.h>
-#include <lib/zx/vmo.h>
-
-#include <block-client/cpp/block-device.h>
-#include <block-client/cpp/client.h>
-#include "src/lib/storage/vfs/cpp/transaction/device_transaction_handler.h"
#include <storage/buffer/vmo_buffer.h>
#include <storage/buffer/vmoid_registry.h>
+#include "src/lib/storage/vfs/cpp/transaction/device_transaction_handler.h"
namespace f2fs {
@@ -189,4 +187,4 @@
} // namespace f2fs
-#endif // F2FS_BCACHE_H_
+#endif // THIRD_PARTY_F2FS_BCACHE_H_
diff --git a/checkpoint.cc b/checkpoint.cc
index 8aa9bc0..628274e 100644
--- a/checkpoint.cc
+++ b/checkpoint.cc
@@ -13,7 +13,7 @@
Page *F2fs::GrabMetaPage(pgoff_t index) {
Page *page;
- while(!(page = GrabCachePage(nullptr, MetaIno(sbi_.get()), index))) {
+ while (!(page = GrabCachePage(nullptr, MetaIno(sbi_.get()), index))) {
#if 0 // porting needed
// cond_resched();
#endif
@@ -437,18 +437,14 @@
#ifdef F2FS_BU_DEBUG
int i;
std::cout << std::endl << "F2fs::GetValidCheckpoint" << std::endl;
- for(i = 0; i < kMaxActiveNodeLogs; i++) {
- std::cout << "[" << i << "] cur_node_segno "<< cp_block->cur_node_segno[i]
- << ", cur_node_blkoff="
- << cp_block->cur_node_blkoff[i]
- << std::endl;
+ for (i = 0; i < kMaxActiveNodeLogs; i++) {
+ std::cout << "[" << i << "] cur_node_segno " << cp_block->cur_node_segno[i]
+ << ", cur_node_blkoff=" << cp_block->cur_node_blkoff[i] << std::endl;
}
- for(i = 0; i < kMaxActiveNodeLogs; i++) {
- std::cout << "[" << i << "] cur_data_segno "<< cp_block->cur_data_segno[i]
- << ", cur_data_blkoff="
- << cp_block->cur_data_blkoff[i]
- << std::endl;
+ for (i = 0; i < kMaxActiveNodeLogs; i++) {
+ std::cout << "[" << i << "] cur_data_segno " << cp_block->cur_data_segno[i]
+ << ", cur_data_blkoff=" << cp_block->cur_data_blkoff[i] << std::endl;
}
#endif
@@ -646,9 +642,12 @@
ckpt->valid_block_count = CpuToLe(ValidUserBlocks(&sbi));
ckpt->free_segment_count = CpuToLe(Segmgr().FreeSegments());
for (i = 0; i < 3; i++) {
- ckpt->cur_node_segno[i] = CpuToLe(Segmgr().CursegSegno(i + static_cast<int>(CursegType::kCursegHotNode)));
- ckpt->cur_node_blkoff[i] = CpuToLe(Segmgr().CursegBlkoff(i + static_cast<int>(CursegType::kCursegHotNode)));
- ckpt->alloc_type[i + static_cast<int>(CursegType::kCursegHotNode)] = Segmgr().CursegAllocType(i + static_cast<int>(CursegType::kCursegHotNode));
+ ckpt->cur_node_segno[i] =
+ CpuToLe(Segmgr().CursegSegno(i + static_cast<int>(CursegType::kCursegHotNode)));
+ ckpt->cur_node_blkoff[i] =
+ CpuToLe(Segmgr().CursegBlkoff(i + static_cast<int>(CursegType::kCursegHotNode)));
+ ckpt->alloc_type[i + static_cast<int>(CursegType::kCursegHotNode)] =
+ Segmgr().CursegAllocType(i + static_cast<int>(CursegType::kCursegHotNode));
}
for (i = 0; i < 3; i++) {
ckpt->cur_data_segno[i] =
@@ -659,14 +658,12 @@
Segmgr().CursegAllocType(i + static_cast<int>(CursegType::kCursegHotData));
#ifdef F2FS_BU_DEBUG
- std::cout << std::endl << "F2fs::DoCheckpoint " << std::endl;
- std::cout << "[" << i << "] cur_data_segno "<< ckpt->cur_data_segno[i]
- << ", cur_data_blkoff=" << ckpt->cur_data_blkoff[i]
- << std::endl;
+ std::cout << std::endl << "F2fs::DoCheckpoint " << std::endl;
+ std::cout << "[" << i << "] cur_data_segno " << ckpt->cur_data_segno[i]
+ << ", cur_data_blkoff=" << ckpt->cur_data_blkoff[i] << std::endl;
- std::cout << "[" << i << "] cur_node_segno "<< ckpt->cur_node_segno[i]
- << ", cur_node_blkoff=" << ckpt->cur_node_blkoff[i]
- << std::endl;
+ std::cout << "[" << i << "] cur_node_segno " << ckpt->cur_node_segno[i]
+ << ", cur_node_blkoff=" << ckpt->cur_node_blkoff[i] << std::endl;
#endif
}
@@ -705,7 +702,7 @@
crc32 = F2fsCrc32(ckpt, LeToCpu(ckpt->checksum_offset));
*reinterpret_cast<uint32_t *>(reinterpret_cast<uint8_t *>(ckpt) +
- LeToCpu(ckpt->checksum_offset)) = CpuToLe(crc32);
+ LeToCpu(ckpt->checksum_offset)) = CpuToLe(crc32);
start_blk = StartCpAddr(&sbi);
diff --git a/data.cc b/data.cc
index 9051440..c0c0d5d 100644
--- a/data.cc
+++ b/data.cc
@@ -9,8 +9,7 @@
namespace f2fs {
// Orinially in f2fs_internal.h
-static inline bool IncValidBlockCount(SbInfo *sbi, VnodeF2fs *vnode,
- blkcnt_t count) {
+static inline bool IncValidBlockCount(SbInfo *sbi, VnodeF2fs *vnode, blkcnt_t count) {
block_t valid_block_count;
SpinLock(&sbi->stat_lock);
@@ -195,7 +194,7 @@
}
WriteUnlock(&fi->ext.ext_lock);
return;
- } while(false);
+ } while (false);
WriteUnlock(&fi->ext.ext_lock);
Vfs()->Nodemgr().SyncInodePage(dn);
@@ -487,7 +486,8 @@
DnodeOfData dn;
SetNewDnode(&dn, this, NULL, NULL, 0);
- if (zx_status_t err = Vfs()->Nodemgr().GetDnodeOfData(&dn, page->index, kRdOnlyNode); err != ZX_OK)
+ if (zx_status_t err = Vfs()->Nodemgr().GetDnodeOfData(&dn, page->index, kRdOnlyNode);
+ err != ZX_OK)
return err;
old_blk_addr = dn.data_blkaddr;
@@ -525,15 +525,15 @@
if (page->index >= end_index) {
/*
- * If the offset is out-of-range of file size,
- * this page does not have to be written to disk.
- */
+ * If the offset is out-of-range of file size,
+ * this page does not have to be written to disk.
+ */
offset = i_size_ & (kPageCacheSize - 1);
if ((page->index >= end_index + 1) || !offset) {
if (S_ISDIR(i_mode_)) {
DecPageCount(&sbi, CountType::kDirtyDents);
#if 0 // porting needed
- // inode_dec_dirty_dents(inode);
+ // inode_dec_dirty_dents(inode);
#endif
}
@@ -577,7 +577,7 @@
#endif
FlushDirtyDataPage(Vfs(), page);
}
- } while(false);
+ } while (false);
#if 0 // porting needed
// if (wbc->for_reclaim)
@@ -664,7 +664,7 @@
}
}
F2fsPutDnode(&dn);
- } while(false);
+ } while (false);
if ((len == kPageCacheSize) || PageUptodate(*pagep))
return ZX_OK;
diff --git a/dir.cc b/dir.cc
index d6f8403..9f35f45 100644
--- a/dir.cc
+++ b/dir.cc
@@ -46,8 +46,7 @@
return bidx;
}
-bool Dir::EarlyMatchName(const char *name, int namelen, f2fs_hash_t namehash,
- DirEntry *de) {
+bool Dir::EarlyMatchName(const char *name, int namelen, f2fs_hash_t namehash, DirEntry *de) {
if (LeToCpu(de->name_len) != namelen)
return false;
@@ -57,8 +56,8 @@
return true;
}
-DirEntry *Dir::FindInBlock(Page *dentry_page, const char *name, int namelen,
- int *max_slots, f2fs_hash_t namehash, Page **res_page) {
+DirEntry *Dir::FindInBlock(Page *dentry_page, const char *name, int namelen, int *max_slots,
+ f2fs_hash_t namehash, Page **res_page) {
DirEntry *de;
uint64_t bit_pos, end_pos, next_pos;
#if 0 // porting needed
@@ -68,8 +67,7 @@
#endif
int slots;
- bit_pos =
- find_next_bit_le(&dentry_blk->dentry_bitmap, kNrDentryInBlock, 0);
+ bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, kNrDentryInBlock, 0);
while (bit_pos < kNrDentryInBlock) {
de = &dentry_blk->dentry[bit_pos];
slots = (LeToCpu(de->name_len) + kNameLen - 1) / kNameLen;
@@ -81,8 +79,7 @@
}
}
next_pos = bit_pos + slots;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, kNrDentryInBlock,
- next_pos);
+ bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, kNrDentryInBlock, next_pos);
if (bit_pos >= kNrDentryInBlock)
end_pos = kNrDentryInBlock;
else
@@ -99,7 +96,7 @@
}
DirEntry *Dir::FindInLevel(unsigned int level, fbl::StringPiece name, int namelen,
- f2fs_hash_t namehash, Page **res_page) {
+ f2fs_hash_t namehash, Page **res_page) {
int s = (namelen + kNameLen - 1) / kNameLen;
unsigned int nbucket, nblock;
unsigned int bidx, end_block;
@@ -123,7 +120,8 @@
continue;
}
- if (de = FindInBlock(dentry_page, name.data(), namelen, &max_slots, namehash, res_page); de != nullptr)
+ if (de = FindInBlock(dentry_page, name.data(), namelen, &max_slots, namehash, res_page);
+ de != nullptr)
break;
if (max_slots >= s)
@@ -395,44 +393,44 @@
bit_pos = RoomForFilename(dentry_blk, slots);
if (bit_pos < kNrDentryInBlock) {
#if 0 // porting needed
- // if (err = InitInodeMetadata(vnode, dentry); err == ZX_OK) {
+ // if (err = InitInodeMetadata(vnode, dentry); err == ZX_OK) {
#else
if (err = InitInodeMetadata(vnode); err == ZX_OK) {
#endif
- WaitOnPageWriteback(dentry_page);
+ WaitOnPageWriteback(dentry_page);
- de = &dentry_blk->dentry[bit_pos];
- de->hash_code = CpuToLe(dentry_hash);
- de->name_len = CpuToLe(static_cast<uint16_t>(namelen));
- memcpy(dentry_blk->filename[bit_pos], name.data(), namelen);
- de->ino = CpuToLe(vnode->Ino());
- SetDeType(de, vnode);
- for (i = 0; i < slots; i++)
- test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
+ de = &dentry_blk->dentry[bit_pos];
+ de->hash_code = CpuToLe(dentry_hash);
+ de->name_len = CpuToLe(static_cast<uint16_t>(namelen));
+ memcpy(dentry_blk->filename[bit_pos], name.data(), namelen);
+ de->ino = CpuToLe(vnode->Ino());
+ SetDeType(de, vnode);
+ for (i = 0; i < slots; i++)
+ test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
#if 0 // porting needed
- // set_page_dirty(dentry_page);
+ // set_page_dirty(dentry_page);
#else
FlushDirtyDataPage(Vfs(), dentry_page);
#endif
- UpdateParentMetadata(vnode, current_depth);
- }
+ UpdateParentMetadata(vnode, current_depth);
+ }
#if 0 // porting needed
- // kunmap(dentry_page);
+ // kunmap(dentry_page);
#endif
- F2fsPutPage(dentry_page, 1);
- return err;
- }
+ F2fsPutPage(dentry_page, 1);
+ return err;
+ }
#if 0 // porting needed
// kunmap(dentry_page);
#endif
- F2fsPutPage(dentry_page, 1);
- }
-
- /* Move to next level to find the empty slot for new dentry */
- ++level;
+ F2fsPutPage(dentry_page, 1);
}
+
+ /* Move to next level to find the empty slot for new dentry */
+ ++level;
+}
}
/**
@@ -569,7 +567,7 @@
for (bidx = 0; bidx < nblock; bidx++) {
void *kaddr;
-
+
if (zx_status_t ret = GetLockDataPage(bidx, &dentry_page); ret != ZX_OK) {
if (ret == ZX_ERR_NOT_FOUND)
continue;
@@ -634,8 +632,7 @@
#endif
while (bit_pos < kNrDentryInBlock) {
d_type = DT_UNKNOWN;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
- kNrDentryInBlock, bit_pos);
+ bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap, kNrDentryInBlock, bit_pos);
if (bit_pos >= kNrDentryInBlock)
break;
@@ -643,7 +640,8 @@
if (types && de->file_type < static_cast<uint8_t>(FileType::kFtMax))
d_type = types[de->file_type];
- fbl::StringPiece name(reinterpret_cast<char *>(dentry_blk->filename[bit_pos]), LeToCpu(de->name_len));
+ fbl::StringPiece name(reinterpret_cast<char *>(dentry_blk->filename[bit_pos]),
+ LeToCpu(de->name_len));
if ((ret = df.Next(name, d_type, LeToCpu(de->ino))) != ZX_OK) {
*pos_cookie += bit_pos - start_bit_pos;
diff --git a/dir.h b/dir.h
index fdd8bb0..c6fe2fb 100644
--- a/dir.h
+++ b/dir.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_DIR_H_
-#define F2FS_DIR_H_
+#ifndef THIRD_PARTY_F2FS_DIR_H_
+#define THIRD_PARTY_F2FS_DIR_H_
#include <dirent.h>
#include <sys/stat.h>
@@ -52,12 +52,11 @@
static unsigned int BucketBlocks(unsigned int level);
void SetDeType(DirEntry *de, VnodeF2fs *vnode);
static uint64_t DirBlockIndex(unsigned int level, unsigned int idx);
- bool EarlyMatchName(const char *name, int namelen, f2fs_hash_t namehash,
- DirEntry *de);
- DirEntry *FindInBlock(Page *dentry_page, const char *name, int namelen,
- int *max_slots, f2fs_hash_t namehash, Page **res_page);
+ bool EarlyMatchName(const char *name, int namelen, f2fs_hash_t namehash, DirEntry *de);
+ DirEntry *FindInBlock(Page *dentry_page, const char *name, int namelen, int *max_slots,
+ f2fs_hash_t namehash, Page **res_page);
DirEntry *FindInLevel(unsigned int level, fbl::StringPiece name, int namelen,
- f2fs_hash_t namehash, Page **res_page);
+ f2fs_hash_t namehash, Page **res_page);
DirEntry *FindEntry(fbl::StringPiece name, Page **res_page);
DirEntry *ParentDir(Page **p);
ino_t InodeByName(fbl::StringPiece name);
@@ -97,4 +96,4 @@
} // namespace f2fs
-#endif // F2FS_DIR_H_
+#endif // THIRD_PARTY_F2FS_DIR_H_
diff --git a/f2fs.cc b/f2fs.cc
index 3d7e85f..b120c87 100644
--- a/f2fs.cc
+++ b/f2fs.cc
@@ -2,33 +2,30 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "f2fs.h"
+
#include <fcntl.h>
#include <inttypes.h>
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/async-loop/default.h>
+#include <lib/async/dispatcher.h>
#include <lib/syslog/cpp/macros.h>
+#include <lib/trace-provider/provider.h>
+#include <lib/zx/event.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
-
-#include "src/lib/uuid/uuid.h"
+#include <zircon/assert.h>
#include <memory>
-#include <lib/zx/event.h>
-#include <zircon/assert.h>
-
-#include <lib/async/dispatcher.h>
-
-#include "zircon/errors.h"
-#include <lib/async-loop/cpp/loop.h>
-#include <lib/async-loop/default.h>
-#include <lib/trace-provider/provider.h>
#include "src/lib/storage/vfs/cpp/pseudo_dir.h"
#include "src/lib/storage/vfs/cpp/trace.h"
-
-#include "f2fs.h"
+#include "src/lib/uuid/uuid.h"
+#include "zircon/errors.h"
namespace f2fs {
@@ -67,15 +64,15 @@
zx_status_t Fsck(const MountOptions& options, std::unique_ptr<f2fs::Bcache> bc) { return ZX_OK; }
-F2fs::F2fs(std::unique_ptr<f2fs::Bcache> bc, SuperBlock* sb,
- const MountOptions& mount_options)
+F2fs::F2fs(std::unique_ptr<f2fs::Bcache> bc, SuperBlock* sb, const MountOptions& mount_options)
: bc_(std::move(bc)), mount_options_(mount_options) {
raw_sb_ = std::unique_ptr<SuperBlock>(sb);
zx::event event;
if (zx_status_t status = zx::event::create(0, &event); status == ZX_OK) {
zx_info_handle_basic_t info;
- if (status = event.get_info(ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr); status == ZX_OK) {
+ if (status = event.get_info(ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
+ status == ZX_OK) {
fs_id_ = info.koid;
}
}
@@ -147,19 +144,20 @@
TRACE_DURATION("f2fs", "CreateFsAndRoot");
f2fs::MountOptions options = mount_options;
- std::unique_ptr<F2fs> fs;
+ std::unique_ptr<F2fs> fs;
if (zx_status_t status = F2fs::Create(std::move(bcache), options, &fs); status != ZX_OK) {
FX_LOGS(ERROR) << "failed to create filesystem object " << status;
return status;
}
-
+
if (zx_status_t ret = fs->FillSuper(); ret != ZX_OK) {
std::cout << "FillSuper error " << ret << std::endl;
return ret;
}
- fbl::RefPtr<VnodeF2fs> data_root;
- if (zx_status_t status = VnodeF2fs::Vget(fs.get(), fs->RawSb().root_ino, &data_root); status != ZX_OK) {
+ fbl::RefPtr<VnodeF2fs> data_root;
+ if (zx_status_t status = VnodeF2fs::Vget(fs.get(), fs->RawSb().root_ino, &data_root);
+ status != ZX_OK) {
FX_LOGS(ERROR) << "cannot find root inode: " << status;
return status;
}
@@ -299,7 +297,7 @@
ZX_ASSERT(page->host != nullptr);
VnodeF2fs* vnode = static_cast<VnodeF2fs*>(page->host);
-
+
if (zx_status_t ret = vnode->WriteDataPageReq(page, nullptr); ret != ZX_OK) {
std::cout << "Data page write error " << ret << std::endl;
return ret;
diff --git a/f2fs.h b/f2fs.h
index dfef535..6259989 100644
--- a/f2fs.h
+++ b/f2fs.h
@@ -2,46 +2,45 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_H_
-#define F2FS_H_
+#ifndef THIRD_PARTY_F2FS_F2FS_H_
+#define THIRD_PARTY_F2FS_F2FS_H_
-#include <zircon/types.h>
-#include <zircon/errors.h>
+// clang-format off
+#include <lib/zircon-internal/fnv1hash.h>
+#include <lib/zircon-internal/thread_annotations.h>
#include <zircon/assert.h>
+#include <zircon/device/vfs.h>
+#include <zircon/errors.h>
#include <zircon/listnode.h>
+#include <zircon/types.h>
#include <iostream>
#include <fbl/algorithm.h>
+#include <fbl/auto_lock.h>
#include <fbl/function.h>
#include <fbl/intrusive_hash_table.h>
#include <fbl/intrusive_single_list.h>
#include <fbl/macros.h>
-#include <fbl/ref_ptr.h>
#include <fbl/mutex.h>
-#include <fbl/auto_lock.h>
+#include <fbl/ref_ptr.h>
-#include <zircon/device/vfs.h>
+#include "src/lib/storage/vfs/cpp/managed_vfs.h"
#include "src/lib/storage/vfs/cpp/vfs.h"
#include "src/lib/storage/vfs/cpp/vnode.h"
-#include "src/lib/storage/vfs/cpp/managed_vfs.h"
-
-#include <lib/zircon-internal/thread_annotations.h>
-#include <lib/zircon-internal/fnv1hash.h>
#include "f2fs_types.h"
#include "f2fs_lib.h"
#include "f2fs_layout.h"
#include "f2fs_internal.h"
+#include "bcache.h"
#include "vnode.h"
#include "dir.h"
#include "file.h"
-#include "bcache.h"
-#include "mkfs.h"
-#include "segment.h"
#include "node.h"
-
-
+#include "segment.h"
+#include "mkfs.h"
+// clang-format on
namespace f2fs {
@@ -82,7 +81,8 @@
F2fs(F2fs &&) = delete;
F2fs &operator=(F2fs &&) = delete;
- explicit F2fs(std::unique_ptr<f2fs::Bcache> bc, SuperBlock *sb, const MountOptions &mount_options);
+ explicit F2fs(std::unique_ptr<f2fs::Bcache> bc, SuperBlock *sb,
+ const MountOptions &mount_options);
~F2fs() override;
@@ -212,4 +212,4 @@
} // namespace f2fs
-#endif // F2FS_H_
+#endif // THIRD_PARTY_F2FS_F2FS_H_
diff --git a/f2fs_internal.h b/f2fs_internal.h
index 83769fe..90b18a1 100644
--- a/f2fs_internal.h
+++ b/f2fs_internal.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_INTERNAL_H_
-#define F2FS_INTERNAL_H_
+#ifndef THIRD_PARTY_F2FS_F2FS_INTERNAL_H_
+#define THIRD_PARTY_F2FS_F2FS_INTERNAL_H_
namespace f2fs {
@@ -32,33 +32,39 @@
/* for the list of orphan inodes */
struct OrphanInodeEntry {
list_node_t list; /* list head */
- nid_t ino = 0; /* inode number */
+ nid_t ino = 0; /* inode number */
};
/* for the list of directory inodes */
struct DirInodeEntry {
- list_node_t list; /* list head */
+ list_node_t list; /* list head */
VnodeF2fs *vnode = nullptr; /* vfs inode pointer */
};
/* for the list of fsync inodes, used only during recovery */
struct FsyncInodeEntry {
- list_node_t list; /* list head */
+ list_node_t list; /* list head */
VnodeF2fs *vnode = nullptr; /* vfs inode pointer */
- block_t blkaddr = 0; /* block address locating the last inode */
+ block_t blkaddr = 0; /* block address locating the last inode */
};
inline int NatsInCursum(SummaryBlock *sum) { return LeToCpu(sum->n_nats); }
inline int SitsInCursum(SummaryBlock *sum) { return LeToCpu(sum->n_sits); }
inline RawNatEntry NatInJournal(SummaryBlock *sum, int i) { return sum->nat_j.entries[i].ne; }
-inline void SetNatInJournal(SummaryBlock *sum, int i, RawNatEntry raw_ne) { sum->nat_j.entries[i].ne = raw_ne; }
+inline void SetNatInJournal(SummaryBlock *sum, int i, RawNatEntry raw_ne) {
+ sum->nat_j.entries[i].ne = raw_ne;
+}
inline nid_t NidInJournal(SummaryBlock *sum, int i) { return sum->nat_j.entries[i].nid; }
-inline void SetNidInJournal(SummaryBlock *sum, int i, nid_t nid) { sum->nat_j.entries[i].nid = nid; }
+inline void SetNidInJournal(SummaryBlock *sum, int i, nid_t nid) {
+ sum->nat_j.entries[i].nid = nid;
+}
inline SitEntry *SitInJournal(SummaryBlock *sum, int i) { return &sum->sit_j.entries[i].se; }
inline uint32_t SegnoInJournal(SummaryBlock *sum, int i) { return sum->sit_j.entries[i].segno; }
-inline void SetSegnoInJournal(SummaryBlock *sum, int i, uint32_t segno) { sum->sit_j.entries[i].segno = segno; }
+inline void SetSegnoInJournal(SummaryBlock *sum, int i, uint32_t segno) {
+ sum->sit_j.entries[i].segno = segno;
+}
static inline int UpdateNatsInCursum(SummaryBlock *rs, int i) {
int before = NatsInCursum(rs);
@@ -76,25 +82,25 @@
* For INODE and NODE manager
*/
constexpr int kXattrNodeOffset = -1;
- /* \
- * store xattrs to one node block per \
- * file keeping -1 as its node offset to \
- * distinguish from index node blocks. \
- */
-constexpr int kRdOnlyNode = 1;
- /* \
- * specify a read-only mode when getting \
- * a node block. 0 is read-write mode. \
- * used by get_DnodeOfData(). \
- */
+/* \
+ * store xattrs to one node block per \
+ * file keeping -1 as its node offset to \
+ * distinguish from index node blocks. \
+ */
+constexpr int kRdOnlyNode = 1;
+/* \
+ * specify a read-only mode when getting \
+ * a node block. 0 is read-write mode. \
+ * used by get_DnodeOfData(). \
+ */
constexpr int kLinkMax = 32000; /* maximum link count per file */
/* for in-memory extent cache entry */
struct ExtentInfo {
- rwlock_t ext_lock; /* rwlock for consistency */
- uint64_t fofs = 0; /* start offset in a file */
+ rwlock_t ext_lock; /* rwlock for consistency */
+ uint64_t fofs = 0; /* start offset in a file */
uint32_t blk_addr = 0; /* start block address of the extent */
- uint64_t len = 0; /* lenth of the extent */
+ uint64_t len = 0; /* lenth of the extent */
};
/*
@@ -104,19 +110,19 @@
struct InodeInfo {
// inode vfs_inode; /* serve a vfs inode */
- uint32_t i_flags = 0; /* keep an inode flags for ioctl */
- uint8_t i_advise = 0; /* use to give file attribute hints */
+ uint32_t i_flags = 0; /* keep an inode flags for ioctl */
+ uint8_t i_advise = 0; /* use to give file attribute hints */
uint64_t i_current_depth = 0; /* use only in directory structure */
umode_t i_acl_mode; /* keep file acl mode temporarily */
/* Use below internally in f2fs*/
- uint32_t flags = 0; /* use to pass per-file flags */
+ uint32_t flags = 0; /* use to pass per-file flags */
uint64_t data_version = 0; /* lastes version of data for fsync */
- atomic_t dirty_dents; /* # of dirty dentry pages */
- f2fs_hash_t chash; /* hash value of given file name */
- uint64_t clevel = 0; /* maximum level of given file name */
- nid_t i_xattr_nid = 0; /* node id that contains xattrs */
- ExtentInfo ext; /* in-memory extent cache entry */
+ atomic_t dirty_dents; /* # of dirty dentry pages */
+ f2fs_hash_t chash; /* hash value of given file name */
+ uint64_t clevel = 0; /* maximum level of given file name */
+ nid_t i_xattr_nid = 0; /* node id that contains xattrs */
+ ExtentInfo ext; /* in-memory extent cache entry */
};
static inline void GetExtentInfo(ExtentInfo *ext, Extent i_ext) {
@@ -142,11 +148,11 @@
nid_t next_scan_nid = 0; /* the next nid to be scanned */
/* NAT cache management */
- RadixTreeRoot nat_root; /* root of the nat entry cache */
- rwlock_t nat_tree_lock; /* protect nat_tree_lock */
- uint32_t nat_cnt = 0; /* the # of cached nat entries */
- list_node_t nat_entries; /* cached nat entry list (clean) */
- list_node_t dirty_nat_entries; /* cached nat entry list (dirty) */
+ RadixTreeRoot nat_root; /* root of the nat entry cache */
+ rwlock_t nat_tree_lock; /* protect nat_tree_lock */
+ uint32_t nat_cnt = 0; /* the # of cached nat entries */
+ list_node_t nat_entries; /* cached nat entry list (clean) */
+ list_node_t dirty_nat_entries; /* cached nat entry list (dirty) */
/* free node ids management */
list_node_t free_nid_list; /* a list for free nids */
@@ -157,7 +163,7 @@
/* for checkpoint */
char *nat_bitmap = nullptr; /* NAT bitmap pointer */
char *nat_prev_bitmap = nullptr; /* JY: NAT previous checkpoint bitmap pointer */
- int bitmap_size = 0; /* bitmap size */
+ int bitmap_size = 0; /* bitmap size */
};
/*
@@ -168,12 +174,12 @@
struct DnodeOfData {
// inode *inode; /* vfs inode pointer */
VnodeF2fs *vnode = nullptr;
- Page *inode_page = nullptr; /* its inode page, NULL is possible */
- Page *node_page = nullptr; /* cached direct node page */
- nid_t nid = 0; /* node id of the direct node block */
- uint64_t ofs_in_node = 0; /* data offset in the node page */
- bool inode_page_locked = false; /* inode page is locked or not */
- block_t data_blkaddr = 0; /* block address of the node block */
+ Page *inode_page = nullptr; /* its inode page, NULL is possible */
+ Page *node_page = nullptr; /* cached direct node page */
+ nid_t nid = 0; /* node id of the direct node block */
+ uint64_t ofs_in_node = 0; /* data offset in the node page */
+ bool inode_page_locked = false; /* inode page is locked or not */
+ block_t data_blkaddr = 0; /* block address of the node block */
};
static inline void SetNewDnode(DnodeOfData *dn, VnodeF2fs *vnode, Page *ipage, Page *npage,
@@ -216,7 +222,7 @@
struct SitInfo *SitInfo = nullptr; /* whole segment information */
struct FreeSegmapInfo *free_info = nullptr; /* free segment information */
struct DirtySeglistInfo *dirty_info = nullptr; /* dirty segment information */
- struct CursegInfo *curseg_array = nullptr; /* active segment information */
+ struct CursegInfo *curseg_array = nullptr; /* active segment information */
list_node_t wblist_head; /* list of under-writeback pages */
spinlock_t wblist_lock; /* lock for checkpoint */
@@ -265,14 +271,14 @@
* -> LockType::kDataTrunc -> LockType::kNodeWrite -> LockType::kNodeNew -> LockType::kNodeTrunc
*/
enum class LockType {
- kRename = 0, /* for renaming operations */
- kDentryOps, /* for directory operations */
- kDataWrtie, /* for data write */
- kDataNew, /* for data allocation */
- kDataTrunc, /* for data truncate */
- kNodeNew, /* for node allocation */
- kNodeTrunc, /* for node truncate */
- kNodeWrite, /* for node write */
+ kRename = 0, /* for renaming operations */
+ kDentryOps, /* for directory operations */
+ kDataWrtie, /* for data write */
+ kDataNew, /* for data allocation */
+ kDataTrunc, /* for data truncate */
+ kNodeNew, /* for node allocation */
+ kNodeTrunc, /* for node truncate */
+ kNodeWrite, /* for node write */
kNrLockType,
};
@@ -299,7 +305,7 @@
// super_block *sb; /* pointer to VFS super block */
// buffer_head *raw_super_buf; /* buffer head of raw sb */
const SuperBlock *raw_super; /* raw super block pointer */
- int s_dirty = 0; /* dirty flag for checkpoint */
+ int s_dirty = 0; /* dirty flag for checkpoint */
/* for node-related operations */
NmInfo *nm_info = nullptr; /* node manager */
@@ -307,8 +313,8 @@
fbl::RefPtr<VnodeF2fs> node_vnode;
/* for segment-related operations */
- SmInfo *sm_info = nullptr; /* segment manager */
- struct bio *bio[static_cast<int>(PageType::kNrPageType)]; /* bios to merge */
+ SmInfo *sm_info = nullptr; /* segment manager */
+ struct bio *bio[static_cast<int>(PageType::kNrPageType)]; /* bios to merge */
sector_t last_block_in_bio[static_cast<int>(PageType::kNrPageType)]; /* last block number */
// rw_semaphore bio_sem; /* IO semaphore */
@@ -316,11 +322,11 @@
Checkpoint *ckpt = nullptr; /* raw checkpoint pointer */
// inode *meta_inode; /* cache meta blocks */
fbl::RefPtr<VnodeF2fs> meta_vnode;
- mtx_t cp_mutex; /* for checkpoint procedure */
+ mtx_t cp_mutex; /* for checkpoint procedure */
mtx_t fs_lock[static_cast<int>(LockType::kNrLockType)]; /* for blocking FS operations */
- mtx_t write_inode; /* mutex for write inode */
- mtx_t writepages; /* mutex for writepages() */
- int por_doing = 0; /* recovery is doing or not */
+ mtx_t write_inode; /* mutex for write inode */
+ mtx_t writepages; /* mutex for writepages() */
+ int por_doing = 0; /* recovery is doing or not */
/* for orphan inode management */
list_node_t orphan_inode_list; /* orphan inode list */
@@ -347,19 +353,19 @@
uint64_t total_node_count = 0; /* total node block count */
uint64_t total_valid_node_count = 0; /* valid node block count */
uint64_t total_valid_inode_count = 0; /* valid inode count */
- int active_logs = 0; /* # of active logs */
+ int active_logs = 0; /* # of active logs */
- block_t user_block_count = 0; /* # of user blocks */
- block_t total_valid_block_count = 0; /* # of valid blocks */
- block_t alloc_valid_block_count = 0; /* # of allocated blocks */
- block_t last_valid_block_count = 0; /* for recovery */
- uint32_t s_next_generation = 0; /* for NFS support */
+ block_t user_block_count = 0; /* # of user blocks */
+ block_t total_valid_block_count = 0; /* # of valid blocks */
+ block_t alloc_valid_block_count = 0; /* # of allocated blocks */
+ block_t last_valid_block_count = 0; /* for recovery */
+ uint32_t s_next_generation = 0; /* for NFS support */
atomic_t nr_pages[static_cast<int>(CountType::kNrCountType)]; /* # of pages, see count_type */
MountInfo mount_opt; /* mount options */
/* for cleaning operations */
- mtx_t gc_mutex; /* mutex for GC */
+ mtx_t gc_mutex; /* mutex for GC */
struct F2fsGc_kthread *gc_thread = nullptr; /* GC thread */
/*
@@ -367,12 +373,12 @@
* one is for the LFS mode, and the other is for the SSR mode.
*/
struct f2fs_stat_info *stat_info = nullptr; /* FS status information */
- uint64_t segment_count[2]; /* # of allocated segments */
- uint64_t block_count[2]; /* # of allocated blocks */
- uint64_t last_victim[2]; /* last victim segment # */
- int total_hit_ext = 0, read_hit_ext = 0; /* extent cache hit ratio */
- int bg_gc = 0; /* background gc calls */
- spinlock_t stat_lock; /* lock for stat operations */
+ uint64_t segment_count[2]; /* # of allocated segments */
+ uint64_t block_count[2]; /* # of allocated blocks */
+ uint64_t last_victim[2]; /* last victim segment # */
+ int total_hit_ext = 0, read_hit_ext = 0; /* extent cache hit ratio */
+ int bg_gc = 0; /* background gc calls */
+ spinlock_t stat_lock; /* lock for stat operations */
};
/*
@@ -402,13 +408,9 @@
return static_cast<Checkpoint *>(sbi->ckpt);
}
-static inline NmInfo *GetNmInfo(SbInfo *sbi) {
- return static_cast<NmInfo *>(sbi->nm_info);
-}
+static inline NmInfo *GetNmInfo(SbInfo *sbi) { return static_cast<NmInfo *>(sbi->nm_info); }
-static inline SmInfo *GetSmInfo(SbInfo *sbi) {
- return static_cast<SmInfo *>(sbi->sm_info);
-}
+static inline SmInfo *GetSmInfo(SbInfo *sbi) { return static_cast<SmInfo *>(sbi->sm_info); }
static inline SitInfo *GetSitInfo(SbInfo *sbi) {
return static_cast<SitInfo *>((GetSmInfo(sbi)->SitInfo));
@@ -616,9 +618,8 @@
dn->inode_page = NULL;
}
-[[maybe_unused]] static inline struct kmem_cache *KmemCacheCreate(const char *name,
- size_t size,
- void (*ctor)(void *)) {
+[[maybe_unused]] static inline struct kmem_cache *KmemCacheCreate(const char *name, size_t size,
+ void (*ctor)(void *)) {
return nullptr;
}
@@ -674,10 +675,10 @@
/* used for InodeInfo->flags */
enum class InodeInfoFlag {
kNewInode = 0, /* indicate newly allocated inode */
- kNeedCp, /* need to do checkpoint during fsync */
- kIncLink, /* need to increment i_nlink */
- kAclMode, /* indicate acl mode */
- kNoAlloc, /* should not allocate any blocks */
+ kNeedCp, /* need to do checkpoint during fsync */
+ kIncLink, /* need to increment i_nlink */
+ kAclMode, /* indicate acl mode */
+ kNoAlloc, /* should not allocate any blocks */
};
static inline void SetInodeFlag(InodeInfo *fi, InodeInfoFlag flag) {
@@ -797,4 +798,4 @@
} // namespace f2fs
-#endif // F2FS_INTERNAL_H_
+#endif // THIRD_PARTY_F2FS_F2FS_INTERNAL_H_
diff --git a/f2fs_layout.h b/f2fs_layout.h
index b671ec2..356436b 100644
--- a/f2fs_layout.h
+++ b/f2fs_layout.h
@@ -2,18 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_LAYOUT_H_
-#define F2FS_LAYOUT_H_
+#ifndef THIRD_PARTY_F2FS_F2FS_LAYOUT_H_
+#define THIRD_PARTY_F2FS_F2FS_LAYOUT_H_
#include "f2fs_types.h"
namespace f2fs {
-constexpr uint64_t kSuperOffset = 1024; /* byte-size offset */
-constexpr uint32_t kLogSectorSize = 9; /* 9 bits for 512 byte */
+constexpr uint64_t kSuperOffset = 1024; /* byte-size offset */
+constexpr uint32_t kLogSectorSize = 9; /* 9 bits for 512 byte */
constexpr uint32_t kLogSectorsPerBlock = 3; /* 4KB: kBlkSize */
-constexpr size_t kBlkSize = 4096; /* support only 4KB block */
-constexpr int kMaxExtension = 64; /* # of extension entries */
+constexpr size_t kBlkSize = 4096; /* support only 4KB block */
+constexpr int kMaxExtension = 64; /* # of extension entries */
constexpr block_t kNullAddr = 0x0U;
constexpr block_t kNewAddr = -1U;
@@ -63,7 +63,9 @@
uint64_t total_sectors = 0;
uint32_t sectors_per_blk = 0;
uint32_t blks_per_seg = 0;
- uint8_t vol_label[16] = {0,};
+ uint8_t vol_label[16] = {
+ 0,
+ };
int heap = 0;
int32_t fd = 0;
char *device_name = nullptr;
@@ -76,36 +78,38 @@
inline uint32_t BitWord(uint32_t nr) { return nr / kBitsPerLong; };
struct SuperBlock {
- uint32_t magic = 0; /* Magic Number */
- uint16_t major_ver = 0; /* Major Version */
- uint16_t minor_ver = 0; /* Minor Version */
- uint32_t log_sectorsize = 0; /* log2 sector size in bytes */
- uint32_t log_sectors_per_block = 0; /* log2 # of sectors per block */
- uint32_t log_blocksize = 0; /* log2 block size in bytes */
- uint32_t log_blocks_per_seg = 0; /* log2 # of blocks per segment */
- uint32_t segs_per_sec = 0; /* # of segments per section */
- uint32_t secs_per_zone = 0; /* # of sections per zone */
- uint32_t checksum_offset = 0; /* checksum offset inside super block */
- uint64_t block_count = 0; /* total # of user blocks */
- uint32_t section_count = 0; /* total # of sections */
- uint32_t segment_count = 0; /* total # of segments */
- uint32_t segment_count_ckpt = 0; /* # of segments for checkpoint */
- uint32_t segment_count_sit = 0; /* # of segments for SIT */
- uint32_t segment_count_nat = 0; /* # of segments for NAT */
- uint32_t segment_count_ssa = 0; /* # of segments for SSA */
- uint32_t segment_count_main = 0; /* # of segments for main area */
- uint32_t segment0_blkaddr = 0; /* start block address of segment 0 */
- uint32_t cp_blkaddr = 0; /* start block address of checkpoint */
- uint32_t sit_blkaddr = 0; /* start block address of SIT */
- uint32_t nat_blkaddr = 0; /* start block address of NAT */
- uint32_t ssa_blkaddr = 0; /* start block address of SSA */
- uint32_t main_blkaddr = 0; /* start block address of main area */
- uint32_t root_ino = 0; /* root inode number */
- uint32_t node_ino = 0; /* node inode number */
- uint32_t meta_ino = 0; /* meta inode number */
- uint8_t uuid[16] = {0,}; /* 128-bit uuid for volume */
- uint16_t volume_name[512]; /* volume name */
- uint32_t extension_count = 0; /* # of extensions below */
+ uint32_t magic = 0; /* Magic Number */
+ uint16_t major_ver = 0; /* Major Version */
+ uint16_t minor_ver = 0; /* Minor Version */
+ uint32_t log_sectorsize = 0; /* log2 sector size in bytes */
+ uint32_t log_sectors_per_block = 0; /* log2 # of sectors per block */
+ uint32_t log_blocksize = 0; /* log2 block size in bytes */
+ uint32_t log_blocks_per_seg = 0; /* log2 # of blocks per segment */
+ uint32_t segs_per_sec = 0; /* # of segments per section */
+ uint32_t secs_per_zone = 0; /* # of sections per zone */
+ uint32_t checksum_offset = 0; /* checksum offset inside super block */
+ uint64_t block_count = 0; /* total # of user blocks */
+ uint32_t section_count = 0; /* total # of sections */
+ uint32_t segment_count = 0; /* total # of segments */
+ uint32_t segment_count_ckpt = 0; /* # of segments for checkpoint */
+ uint32_t segment_count_sit = 0; /* # of segments for SIT */
+ uint32_t segment_count_nat = 0; /* # of segments for NAT */
+ uint32_t segment_count_ssa = 0; /* # of segments for SSA */
+ uint32_t segment_count_main = 0; /* # of segments for main area */
+ uint32_t segment0_blkaddr = 0; /* start block address of segment 0 */
+ uint32_t cp_blkaddr = 0; /* start block address of checkpoint */
+ uint32_t sit_blkaddr = 0; /* start block address of SIT */
+ uint32_t nat_blkaddr = 0; /* start block address of NAT */
+ uint32_t ssa_blkaddr = 0; /* start block address of SSA */
+ uint32_t main_blkaddr = 0; /* start block address of main area */
+ uint32_t root_ino = 0; /* root inode number */
+ uint32_t node_ino = 0; /* node inode number */
+ uint32_t meta_ino = 0; /* meta inode number */
+ uint8_t uuid[16] = {
+ 0,
+ }; /* 128-bit uuid for volume */
+ uint16_t volume_name[512]; /* volume name */
+ uint32_t extension_count = 0; /* # of extensions below */
uint8_t extension_list[kMaxExtension][8]; /* extension array */
} __attribute__((packed));
@@ -155,11 +159,11 @@
struct OrphanBlock {
uint32_t ino[kOrphansPerBlock]; /* inode numbers */
- uint32_t reserved = 0; /* reserved */
- uint16_t blk_addr = 0; /* block index in current CP */
- uint16_t blk_count = 0; /* Number of orphan inode blocks in CP */
- uint32_t entry_count = 0; /* Total number of orphan nodes in current CP */
- uint32_t check_sum = 0; /* CRC32 for orphan inode block */
+ uint32_t reserved = 0; /* reserved */
+ uint16_t blk_addr = 0; /* block index in current CP */
+ uint16_t blk_count = 0; /* Number of orphan inode blocks in CP */
+ uint32_t entry_count = 0; /* Total number of orphan nodes in current CP */
+ uint32_t check_sum = 0; /* CRC32 for orphan inode block */
} __attribute__((packed));
/*
@@ -177,27 +181,27 @@
constexpr int kNidsPerBlock = 1018; /* Node IDs in an Indirect Block */
struct Inode {
- uint16_t i_mode = 0; /* file mode */
- uint8_t i_advise = 0; /* file hints */
- uint8_t i_reserved = 0; /* reserved */
- uint32_t i_uid = 0; /* user ID */
- uint32_t i_gid = 0; /* group ID */
- uint32_t i_links = 0; /* links count */
- uint64_t i_size = 0; /* file size in bytes */
- uint64_t i_blocks = 0; /* file size in blocks */
- uint64_t i_atime = 0; /* access time */
- uint64_t i_ctime = 0; /* change time */
- uint64_t i_mtime = 0; /* modification time */
- uint32_t i_atime_nsec = 0; /* access time in nano scale */
- uint32_t i_ctime_nsec = 0; /* change time in nano scale */
- uint32_t i_mtime_nsec = 0; /* modification time in nano scale */
- uint32_t i_generation = 0; /* file version (for NFS) */
- uint32_t i_current_depth = 0; /* only for directory depth */
- uint32_t i_xattr_nid = 0; /* nid to save xattr */
- uint32_t i_flags = 0; /* file attributes */
- uint32_t i_pino = 0; /* parent inode number */
- uint32_t i_namelen = 0; /* file name length */
- uint8_t i_name[kMaxNameLen]; /* file name for SPOR */
+ uint16_t i_mode = 0; /* file mode */
+ uint8_t i_advise = 0; /* file hints */
+ uint8_t i_reserved = 0; /* reserved */
+ uint32_t i_uid = 0; /* user ID */
+ uint32_t i_gid = 0; /* group ID */
+ uint32_t i_links = 0; /* links count */
+ uint64_t i_size = 0; /* file size in bytes */
+ uint64_t i_blocks = 0; /* file size in blocks */
+ uint64_t i_atime = 0; /* access time */
+ uint64_t i_ctime = 0; /* change time */
+ uint64_t i_mtime = 0; /* modification time */
+ uint32_t i_atime_nsec = 0; /* access time in nano scale */
+ uint32_t i_ctime_nsec = 0; /* change time in nano scale */
+ uint32_t i_mtime_nsec = 0; /* modification time in nano scale */
+ uint32_t i_generation = 0; /* file version (for NFS) */
+ uint32_t i_current_depth = 0; /* only for directory depth */
+ uint32_t i_xattr_nid = 0; /* nid to save xattr */
+ uint32_t i_flags = 0; /* file attributes */
+ uint32_t i_pino = 0; /* parent inode number */
+ uint32_t i_namelen = 0; /* file name length */
+ uint8_t i_name[kMaxNameLen]; /* file name for SPOR */
Extent i_ext; /* caching a largest extent */
@@ -239,7 +243,7 @@
* For NAT entries
*/
struct RawNatEntry {
- uint8_t version = 0; /* latest version of cached nat entry */
+ uint8_t version = 0; /* latest version of cached nat entry */
uint32_t ino = 0; /* inode number */
uint32_t block_addr = 0; /* block address */
} __attribute__((packed));
@@ -275,14 +279,16 @@
constexpr uint16_t kCurSegNull = 0x003f; /* use 6bit - 0x3f */
struct SitEntry {
- uint16_t vblocks = 0; /* reference above */
+ uint16_t vblocks = 0; /* reference above */
uint8_t valid_map[kSitVBlockMapSize]; /* bitmap for valid blocks */
- uint64_t mtime = 0; /* segment age for cleaning */
+ uint64_t mtime = 0; /* segment age for cleaning */
} __attribute__((packed));
constexpr uint32_t kSitEntryPerBlock = kPageCacheSize / sizeof(SitEntry);
-inline uint16_t GetSitVblocks(SitEntry *raw_sit) { return LeToCpu(raw_sit->vblocks) & kSitVblocksMask; }
+inline uint16_t GetSitVblocks(SitEntry *raw_sit) {
+ return LeToCpu(raw_sit->vblocks) & kSitVblocksMask;
+}
inline uint8_t GetSitType(SitEntry *raw_sit) {
return (LeToCpu(raw_sit->vblocks) & ~kSitVblocksMask) >> kSitVblocksShift;
}
@@ -313,7 +319,7 @@
union {
uint8_t reserved[3];
struct {
- uint8_t version; /* node version number */
+ uint8_t version; /* node version number */
uint16_t ofs_in_node; /* block index in parent node */
} __attribute__((packed));
};
@@ -329,7 +335,7 @@
struct SummaryFooter {
uint8_t entry_type = 0; /* SUM_TYPE_XXX */
- uint32_t check_sum = 0; /* summary checksum */
+ uint32_t check_sum = 0; /* summary checksum */
} __attribute__((packed));
constexpr uint32_t kSumFooterSize = sizeof(SummaryFooter);
@@ -404,14 +410,14 @@
constexpr size_t kSizeOfDirEntry = 11; /* by byte */
constexpr size_t kSizeOfDentryBitmap = (kNrDentryInBlock + kBitsPerByte - 1) / kBitsPerByte;
constexpr size_t kSizeOfReserved =
- kPageSize - ((kSizeOfDirEntry + kNameLen) * kNrDentryInBlock + kSizeOfDentryBitmap);
+ kPageSize - ((kSizeOfDirEntry + kNameLen) * kNrDentryInBlock + kSizeOfDentryBitmap);
/* One directory entry slot representing kNameLen-sized file name */
struct DirEntry {
uint32_t hash_code = 0; /* hash code of file name */
uint32_t ino = 0; /* inode number */
uint16_t name_len = 0; /* lengh of file name */
- uint8_t file_type = 0; /* file type */
+ uint8_t file_type = 0; /* file type */
} __attribute__((packed));
/* 4KB-sized directory entry block */
@@ -440,4 +446,4 @@
} // namespace f2fs
-#endif // F2FS_LAYOUT_H_
+#endif // THIRD_PARTY_F2FS_F2FS_LAYOUT_H_
diff --git a/f2fs_lib.h b/f2fs_lib.h
index 5a2f7ca..5f89f48 100644
--- a/f2fs_lib.h
+++ b/f2fs_lib.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_LIB_H_
-#define F2FS_LIB_H_
+#ifndef THIRD_PARTY_F2FS_F2FS_LIB_H_
+#define THIRD_PARTY_F2FS_F2FS_LIB_H_
#include "f2fs_types.h"
@@ -30,9 +30,7 @@
return 0;
}
-static inline int ClearPageDirtyForIo(Page *page) {
- return 0;
-}
+static inline int ClearPageDirtyForIo(Page *page) { return 0; }
struct WritebackControl {};
@@ -44,13 +42,10 @@
// TODO: Once Pager is availabe, it could be used for wb synchronization
}
-
/*
* Checkpoint
*/
-inline int64_t VerAfter(uint64_t a, uint64_t b) {
- return (static_cast<int64_t>(a - b) > 0);
-}
+inline int64_t VerAfter(uint64_t a, uint64_t b) { return (static_cast<int64_t>(a - b) > 0); }
/*
* CRC
@@ -77,7 +72,7 @@
/*
* Error code in pointer variables
* TODO: should remove them. there is no room for errno in Fuchsia.
- *
+ *
*/
inline bool IsErr(const void *ptr) { return (ptr == nullptr); }
@@ -109,12 +104,8 @@
* Bitmap operations
* TODO: some operations (e.g., test_and_set) requires atomicity
*/
-inline size_t DivRoundUp(size_t n, size_t d) {
- return (((n) + (d)-1) / (d));
-}
-inline size_t BitsToLongs(size_t nr) {
- return DivRoundUp(nr, kBitsPerByte * sizeof(long));
-}
+inline size_t DivRoundUp(size_t n, size_t d) { return (((n) + (d)-1) / (d)); }
+inline size_t BitsToLongs(size_t nr) { return DivRoundUp(nr, kBitsPerByte * sizeof(long)); }
static inline void set_bit(int nr, void *addr) {
uint64_t *bitmap = static_cast<uint64_t *>(addr);
@@ -217,9 +208,7 @@
return ret;
}
-static inline int test_and_set_bit(int nr, void *addr) {
- return test_and_set_bit_le(nr, addr);
-}
+static inline int test_and_set_bit(int nr, void *addr) { return test_and_set_bit_le(nr, addr); }
static inline int test_and_clear_bit_le(int nr, void *addr) {
uint64_t *bitmap = static_cast<uint64_t *>(addr);
@@ -235,9 +224,7 @@
return ret;
}
-static inline int test_and_clear_bit(int nr, void *addr) {
- return test_and_clear_bit_le(nr, addr);
-}
+static inline int test_and_clear_bit(int nr, void *addr) { return test_and_clear_bit_le(nr, addr); }
static inline void __clear_bit(int nr, void *addr) {
*((uint32_t *)addr + (nr >> 5)) &= ~(1 << (nr & 31));
@@ -255,13 +242,9 @@
return ret;
}
-static inline void AtomicInc(atomic_t *t) {
- atomic_fetch_add_explicit(t, 1, memory_order_relaxed);
-}
+static inline void AtomicInc(atomic_t *t) { atomic_fetch_add_explicit(t, 1, memory_order_relaxed); }
-static inline void AtomicDec(atomic_t *t) {
- atomic_fetch_sub_explicit(t, 1, memory_order_relaxed);
-}
+static inline void AtomicDec(atomic_t *t) { atomic_fetch_sub_explicit(t, 1, memory_order_relaxed); }
/*
* List operations
@@ -282,7 +265,7 @@
* Zero segment
*/
static inline void ZeroUserSegments(Page *page, unsigned start1, unsigned end1, unsigned start2,
- unsigned end2) {
+ unsigned end2) {
char *data = (char *)PageAddress(page);
ZX_ASSERT(end1 <= kPageSize && end2 <= kPageSize);
@@ -335,4 +318,4 @@
} // namespace f2fs
-#endif // F2FS_LIB_H_
+#endif // THIRD_PARTY_F2FS_F2FS_LIB_H_
diff --git a/f2fs_types.h b/f2fs_types.h
index 95b22fd..02b2092 100644
--- a/f2fs_types.h
+++ b/f2fs_types.h
@@ -63,7 +63,7 @@
constexpr size_t kSync = 0x10;
constexpr size_t kReadSync = (kRead | kSync);
constexpr size_t kWriteSync = (kWrite | kSync);
-constexpr size_t kWriteFlushFua = (kWrite | kSync | kFlush| kFua);
+constexpr size_t kWriteFlushFua = (kWrite | kSync | kFlush | kFua);
//#define MS_POSIXACL (1 << 16) /* VFS does not apply the umask */
//#define BUG_ON(a)
diff --git a/file.cc b/file.cc
index 7cceb9e..e17f251 100644
--- a/file.cc
+++ b/file.cc
@@ -2,8 +2,10 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <algorithm>
#include <sys/stat.h>
+
+#include <algorithm>
+
#include "f2fs.h"
namespace f2fs {
@@ -137,7 +139,7 @@
do {
fbl::AutoLock cplock(&sbi.cp_mutex);
cur_version = LeToCpu(GetCheckpoint(&sbi)->checkpoint_ver);
- } while(false);
+ } while (false);
#if 0 // porting needed
// if (fi.data_version != cur_version &&
@@ -160,7 +162,8 @@
// WriteInode(nullptr);
#endif
- // TODO(unknown): fsync recovery
+ // clang-format off
+ // TODO(unknown): fsync recovery
#if 0 // porting needed
// if (need_cp) {
#else
@@ -170,18 +173,20 @@
/* all the dirty node pages should be flushed for POR */
ret = Vfs()->SyncFs(1);
ClearInodeFlag(&fi_, InodeInfoFlag::kNeedCp);
- } else {
+ }
+ else {
Page *node_page = nullptr;
int mark = !Vfs()->Nodemgr().IsCheckpointedNode(Ino());
if (ret = Vfs()->Nodemgr().GetNodePage(Ino(), &node_page); ret != ZX_OK) {
return ret;
- }
+ }
+ // clang-format on
- Vfs()->Nodemgr().SetFsyncMark(node_page, 1);
- Vfs()->Nodemgr().SetDentryMark(node_page, mark);
+ Vfs()->Nodemgr().SetFsyncMark(node_page, 1);
+ Vfs()->Nodemgr().SetDentryMark(node_page, mark);
- UpdateInode(node_page);
- F2fsPutPage(node_page, 1);
+ UpdateInode(node_page);
+ F2fsPutPage(node_page, 1);
#if 0 // porting needed
// while (Vfs()->Nodemgr().SyncNodePages(Ino(), &wbc) == 0)
@@ -189,11 +194,11 @@
// filemap_fdatawait_range(nullptr,//sbi->node_inode->i_mapping,
// 0, LONG_MAX);
#endif
- }
+}
#if 0 // porting needed
// out:
#endif
- return ret;
+return ret;
}
#if 0 // porting needed
@@ -412,7 +417,6 @@
// }
#endif
-
zx_status_t File::Read(void *data, size_t len, size_t off, size_t *out_actual) {
uint64_t blk_start = off / kBlockSize;
uint64_t blk_end = (off + len) / kBlockSize;
@@ -479,7 +483,8 @@
for (n = blk_start; n <= blk_end; n++) {
size_t cur_len = std::min(static_cast<size_t>(kBlockSize - off_in_block), left);
- if (zx_status_t ret = WriteBegin(n * kBlockSize + off_in_block, cur_len, &data_page); ret != ZX_OK) {
+ if (zx_status_t ret = WriteBegin(n * kBlockSize + off_in_block, cur_len, &data_page);
+ ret != ZX_OK) {
if (off_in_buf > 0) {
auto cur_time = time(nullptr);
i_mtime_.tv_sec = cur_time;
@@ -495,7 +500,8 @@
}
data_buf = PageAddress(data_page);
- memcpy(static_cast<char *>(data_buf) + off_in_block, static_cast<const char *>(data) + off_in_buf, cur_len);
+ memcpy(static_cast<char *>(data_buf) + off_in_block,
+ static_cast<const char *>(data) + off_in_buf, cur_len);
off_in_buf += cur_len;
left -= cur_len;
diff --git a/file.h b/file.h
index c065e6f..29e9946 100644
--- a/file.h
+++ b/file.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_FILE_H_
-#define F2FS_FILE_H_
+#ifndef THIRD_PARTY_F2FS_FILE_H_
+#define THIRD_PARTY_F2FS_FILE_H_
namespace f2fs {
class File : public VnodeF2fs {
@@ -33,4 +33,4 @@
} // namespace f2fs
-#endif // F2FS_FILE_H_
+#endif // THIRD_PARTY_F2FS_FILE_H_
diff --git a/mkfs.cc b/mkfs.cc
index 2a62446..a5be15f 100644
--- a/mkfs.cc
+++ b/mkfs.cc
@@ -2,15 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <codecvt>
+
#include "f2fs.h"
#include "src/lib/uuid/uuid.h"
-#include <codecvt>
namespace f2fs {
const char *kMediaExtList[] = {"jpg", "gif", "png", "avi", "divx", "mp4", "mp3", "3gp",
- "wmv", "wma", "mpeg", "mkv", "mov", "asx", "asf", "wmx",
- "svi", "wvx", "wm", "mpg", "mpe", "rm", "ogg"};
+ "wmv", "wma", "mpeg", "mkv", "mov", "asx", "asf", "wmx",
+ "svi", "wvx", "wm", "mpg", "mpe", "rm", "ogg"};
F2fsMkfs::F2fsMkfs(std::unique_ptr<f2fs::Bcache> bc, const MkfsOptions &mkfs_options)
: bc_(std::move(bc)), mkfs_options_(mkfs_options) {}
@@ -48,7 +49,6 @@
* String must be less than 16 characters.
*/
void F2fsMkfs::AsciiToUnicode(const std::string &in_string, std::u16string *out_string) {
-
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> cvt16;
out_string->assign(cvt16.from_bytes(in_string));
@@ -251,13 +251,12 @@
super_block_.secs_per_zone = CpuToLe(params_.secs_per_zone);
blk_size_bytes = 1 << log_blocksize;
segment_size_bytes = blk_size_bytes * params_.blks_per_seg;
- zone_size_bytes = blk_size_bytes * params_.secs_per_zone * params_.segs_per_sec *
- params_.blks_per_seg;
+ zone_size_bytes =
+ blk_size_bytes * params_.secs_per_zone * params_.segs_per_sec * params_.blks_per_seg;
super_block_.checksum_offset = 0;
- super_block_.block_count =
- CpuToLe((params_.total_sectors * kDefaultSectorSize) / blk_size_bytes);
+ super_block_.block_count = CpuToLe((params_.total_sectors * kDefaultSectorSize) / blk_size_bytes);
zone_align_start_offset =
(params_.start_sector * kDefaultSectorSize + 2 * kBlkSize + zone_size_bytes - 1) /
@@ -272,7 +271,7 @@
super_block_.segment_count =
CpuToLe(((params_.total_sectors * kDefaultSectorSize) - zone_align_start_offset) /
- segment_size_bytes);
+ segment_size_bytes);
super_block_.segment0_blkaddr = CpuToLe(zone_align_start_offset / blk_size_bytes);
super_block_.cp_blkaddr = super_block_.segment0_blkaddr;
@@ -281,7 +280,7 @@
super_block_.sit_blkaddr =
CpuToLe(LeToCpu(super_block_.segment0_blkaddr) +
- (LeToCpu(super_block_.segment_count_ckpt) * (1 << log_blks_per_seg)));
+ (LeToCpu(super_block_.segment_count_ckpt) * (1 << log_blks_per_seg)));
blocks_for_sit =
(LeToCpu(super_block_.segment_count) + kSitEntryPerBlock - 1) / kSitEntryPerBlock;
@@ -292,7 +291,7 @@
super_block_.nat_blkaddr =
CpuToLe(LeToCpu(super_block_.sit_blkaddr) +
- (LeToCpu(super_block_.segment_count_sit) * params_.blks_per_seg));
+ (LeToCpu(super_block_.segment_count_sit) * params_.blks_per_seg));
total_valid_blks_available =
(LeToCpu(super_block_.segment_count) -
@@ -319,7 +318,7 @@
super_block_.ssa_blkaddr =
CpuToLe(LeToCpu(super_block_.nat_blkaddr) +
- LeToCpu(super_block_.segment_count_nat) * params_.blks_per_seg);
+ LeToCpu(super_block_.segment_count_nat) * params_.blks_per_seg);
total_valid_blks_available =
(LeToCpu(super_block_.segment_count) -
@@ -337,18 +336,17 @@
LeToCpu(super_block_.segment_count_nat) + LeToCpu(super_block_.segment_count_ssa);
diff = total_meta_segments % (params_.segs_per_sec * params_.secs_per_zone);
if (diff)
- super_block_.segment_count_ssa =
- CpuToLe(LeToCpu(super_block_.segment_count_ssa) +
- (params_.segs_per_sec * params_.secs_per_zone - diff));
+ super_block_.segment_count_ssa = CpuToLe(LeToCpu(super_block_.segment_count_ssa) +
+ (params_.segs_per_sec * params_.secs_per_zone - diff));
super_block_.main_blkaddr =
CpuToLe(LeToCpu(super_block_.ssa_blkaddr) +
- (LeToCpu(super_block_.segment_count_ssa) * params_.blks_per_seg));
+ (LeToCpu(super_block_.segment_count_ssa) * params_.blks_per_seg));
- super_block_.segment_count_main = CpuToLe(
- LeToCpu(super_block_.segment_count) -
- (LeToCpu(super_block_.segment_count_ckpt) + LeToCpu(super_block_.segment_count_sit) +
- LeToCpu(super_block_.segment_count_nat) + LeToCpu(super_block_.segment_count_ssa)));
+ super_block_.segment_count_main =
+ CpuToLe(LeToCpu(super_block_.segment_count) -
+ (LeToCpu(super_block_.segment_count_ckpt) + LeToCpu(super_block_.segment_count_sit) +
+ LeToCpu(super_block_.segment_count_nat) + LeToCpu(super_block_.segment_count_ssa)));
super_block_.section_count =
CpuToLe(LeToCpu(super_block_.segment_count_main) / params_.segs_per_sec);
@@ -358,18 +356,18 @@
if ((LeToCpu(super_block_.segment_count_main) - 2) < params_.reserved_segments) {
printf("Error: Device size is not sufficient for F2FS volume, more segment needed =%u",
- params_.reserved_segments - (LeToCpu(super_block_.segment_count_main) - 2));
+ params_.reserved_segments - (LeToCpu(super_block_.segment_count_main) - 2));
return ZX_ERR_NO_SPACE;
}
memcpy(super_block_.uuid, uuid::Uuid::Generate().bytes(), 16);
- std::string vol_label(reinterpret_cast<char const*>(params_.vol_label));
+ std::string vol_label(reinterpret_cast<char const *>(params_.vol_label));
std::u16string volume_name;
AsciiToUnicode(vol_label, &volume_name);
- volume_name.copy(reinterpret_cast<char16_t*>(super_block_.volume_name), vol_label.size());
+ volume_name.copy(reinterpret_cast<char16_t *>(super_block_.volume_name), vol_label.size());
super_block_.volume_name[vol_label.size()] = '\0';
super_block_.node_ino = CpuToLe(uint32_t{1});
@@ -388,7 +386,8 @@
(total_zones - 1) * params_.segs_per_sec * params_.secs_per_zone +
((params_.secs_per_zone - 1) * params_.segs_per_sec);
params_.cur_seg[static_cast<int>(CursegType::kCursegWarmNode)] =
- params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] - params_.segs_per_sec * params_.secs_per_zone;
+ params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] -
+ params_.segs_per_sec * params_.secs_per_zone;
params_.cur_seg[static_cast<int>(CursegType::kCursegColdNode)] =
params_.cur_seg[static_cast<int>(CursegType::kCursegWarmNode)] -
params_.segs_per_sec * params_.secs_per_zone;
@@ -525,18 +524,18 @@
ckp->cur_data_blkoff[0] = CpuToLe(uint16_t{1});
ckp->valid_block_count = CpuToLe(uint64_t{2});
ckp->rsvd_segment_count = CpuToLe(params_.reserved_segments);
- ckp->overprov_segment_count = CpuToLe(
- (LeToCpu(super_block_.segment_count_main) - LeToCpu(ckp->rsvd_segment_count)) *
- params_.overprovision / 100);
+ ckp->overprov_segment_count =
+ CpuToLe((LeToCpu(super_block_.segment_count_main) - LeToCpu(ckp->rsvd_segment_count)) *
+ params_.overprovision / 100);
ckp->overprov_segment_count =
CpuToLe(LeToCpu(ckp->overprov_segment_count) + LeToCpu(ckp->rsvd_segment_count));
/* main segments - reserved segments - (node + data segments) */
ckp->free_segment_count = CpuToLe(LeToCpu(super_block_.segment_count_main) - 6);
- ckp->user_block_count = CpuToLe(
- ((LeToCpu(ckp->free_segment_count) + 6 - LeToCpu(ckp->overprov_segment_count)) *
- params_.blks_per_seg));
+ ckp->user_block_count =
+ CpuToLe(((LeToCpu(ckp->free_segment_count) + 6 - LeToCpu(ckp->overprov_segment_count)) *
+ params_.blks_per_seg));
ckp->cp_pack_total_block_count = CpuToLe(uint32_t{8});
ckp->ckpt_flags |= kCpUmountFlag;
@@ -545,13 +544,13 @@
ckp->valid_inode_count = CpuToLe(uint32_t{1});
ckp->next_free_nid = CpuToLe(LeToCpu(super_block_.root_ino) + 1);
- ckp->sit_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block_.segment_count_sit) / 2)
- << LeToCpu(super_block_.log_blocks_per_seg)) /
- 8);
+ ckp->sit_ver_bitmap_bytesize = CpuToLe(
+ ((LeToCpu(super_block_.segment_count_sit) / 2) << LeToCpu(super_block_.log_blocks_per_seg)) /
+ 8);
- ckp->nat_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block_.segment_count_nat) / 2)
- << LeToCpu(super_block_.log_blocks_per_seg)) /
- 8);
+ ckp->nat_ver_bitmap_bytesize = CpuToLe(
+ ((LeToCpu(super_block_.segment_count_nat) / 2) << LeToCpu(super_block_.log_blocks_per_seg)) /
+ 8);
ckp->checksum_offset = CpuToLe(uint32_t{kChecksumOffset});
@@ -587,7 +586,7 @@
SetSumType((&sum->footer), kSumTypeData);
cp_seg_blk_offset += blk_size_bytes;
- ret = WriteToDisk(sum, cp_seg_blk_offset, kBlkSize);
+ ret = WriteToDisk(sum, cp_seg_blk_offset, kBlkSize);
if (ret < 0) {
printf("\n\tError: While writing the sum_blk to disk!!!\n");
return ret;
@@ -600,21 +599,27 @@
/* inode sit for root */
sum->n_sits = CpuToLe(uint16_t{6});
sum->sit_j.entries[0].segno = ckp->cur_node_segno[0];
- sum->sit_j.entries[0].se.vblocks = CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegHotNode) << 10) | 1});
+ sum->sit_j.entries[0].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegHotNode) << 10) | 1});
F2fsSetBit(0, sum->sit_j.entries[0].se.valid_map);
sum->sit_j.entries[1].segno = ckp->cur_node_segno[1];
- sum->sit_j.entries[1].se.vblocks = CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegWarmNode) << 10)});
+ sum->sit_j.entries[1].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegWarmNode) << 10)});
sum->sit_j.entries[2].segno = ckp->cur_node_segno[2];
- sum->sit_j.entries[2].se.vblocks = CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegColdNode) << 10)});
+ sum->sit_j.entries[2].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegColdNode) << 10)});
/* data sit for root */
sum->sit_j.entries[3].segno = ckp->cur_data_segno[0];
- sum->sit_j.entries[3].se.vblocks = CpuToLe(uint16_t{(static_cast<uint16_t>(CursegType::kCursegHotData) << 10) | 1});
+ sum->sit_j.entries[3].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<uint16_t>(CursegType::kCursegHotData) << 10) | 1});
F2fsSetBit(0, sum->sit_j.entries[3].se.valid_map);
sum->sit_j.entries[4].segno = ckp->cur_data_segno[1];
- sum->sit_j.entries[4].se.vblocks = CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegWarmData) << 10)});
+ sum->sit_j.entries[4].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegWarmData) << 10)});
sum->sit_j.entries[5].segno = ckp->cur_data_segno[2];
- sum->sit_j.entries[5].se.vblocks = CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegColdData) << 10)});
+ sum->sit_j.entries[5].se.vblocks =
+ CpuToLe(uint16_t{(static_cast<int>(CursegType::kCursegColdData) << 10)});
cp_seg_blk_offset += blk_size_bytes;
ret = WriteToDisk(sum, cp_seg_blk_offset, kBlkSize);
@@ -725,10 +730,9 @@
raw_node->footer.nid = super_block_.root_ino;
raw_node->footer.ino = super_block_.root_ino;
raw_node->footer.cp_ver = CpuToLe(uint64_t{1});
- raw_node->footer.next_blkaddr =
- CpuToLe(LeToCpu(super_block_.main_blkaddr) +
- params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] *
- params_.blks_per_seg + 1);
+ raw_node->footer.next_blkaddr = CpuToLe(
+ LeToCpu(super_block_.main_blkaddr) +
+ params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] * params_.blks_per_seg + 1);
raw_node->i.i_mode = CpuToLe(uint16_t{0x41ed});
raw_node->i.i_links = CpuToLe(uint32_t{2});
@@ -750,7 +754,8 @@
raw_node->i.i_flags = 0;
raw_node->i.i_current_depth = CpuToLe(uint32_t{1});
- data_blk_nor = LeToCpu(super_block_.main_blkaddr) +
+ data_blk_nor =
+ LeToCpu(super_block_.main_blkaddr) +
params_.cur_seg[static_cast<int>(CursegType::kCursegHotData)] * params_.blks_per_seg;
raw_node->i.i_addr[0] = CpuToLe(data_blk_nor);
@@ -765,7 +770,7 @@
ret = WriteToDisk(raw_node, main_area_node_seg_blk_offset, kBlkSize);
if (ret < 0) {
- printf("\n\tError: While writing the raw_node to disk!!!, size = %lu\n",sizeof(Node));
+ printf("\n\tError: While writing the raw_node to disk!!!, size = %lu\n", sizeof(Node));
return ret;
}
@@ -795,7 +800,7 @@
/* update root */
nat_blk->entries[super_block_.root_ino].block_addr =
CpuToLe(LeToCpu(super_block_.main_blkaddr) +
- params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] * params_.blks_per_seg);
+ params_.cur_seg[static_cast<int>(CursegType::kCursegHotNode)] * params_.blks_per_seg);
nat_blk->entries[super_block_.root_ino].ino = super_block_.root_ino;
/* update node nat */
@@ -847,9 +852,10 @@
/* bitmap for . and .. */
dent_blk->dentry_bitmap[0] = (1 << 1) | (1 << 0);
blk_size_bytes = 1 << LeToCpu(super_block_.log_blocksize);
- data_blk_offset = (LeToCpu(super_block_.main_blkaddr) +
- params_.cur_seg[static_cast<int>(CursegType::kCursegHotData)] * params_.blks_per_seg) *
- blk_size_bytes;
+ data_blk_offset =
+ (LeToCpu(super_block_.main_blkaddr) +
+ params_.cur_seg[static_cast<int>(CursegType::kCursegHotData)] * params_.blks_per_seg) *
+ blk_size_bytes;
ret = WriteToDisk(dent_blk, data_blk_offset, kBlkSize);
if (ret < 0) {
diff --git a/mkfs.h b/mkfs.h
index 3739d54..22f69eb 100644
--- a/mkfs.h
+++ b/mkfs.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_MKFS_H_
-#define F2FS_MKFS_H_
+#ifndef THIRD_PARTY_F2FS_MKFS_H_
+#define THIRD_PARTY_F2FS_MKFS_H_
namespace f2fs {
@@ -49,7 +49,7 @@
zx_status_t GetDeviceInfo();
zx_status_t FormatDevice();
- void AsciiToUnicode(const std::string &in_string, std::u16string *out_string);
+ void AsciiToUnicode(const std::string& in_string, std::u16string* out_string);
inline int F2fsSetBit(uint32_t nr, uint8_t* addr);
int8_t LogBase2(uint32_t num);
@@ -68,7 +68,6 @@
zx_status_t AddDefaultDentryRoot();
zx_status_t CreateRootDir();
-
#if 0 // porting needed
// TODO: Trim support
// int f2fs_trim_device()
@@ -77,4 +76,4 @@
} // namespace f2fs
-#endif // F2FS_MKFS_H_
+#endif // THIRD_PARTY_F2FS_MKFS_H_
diff --git a/namei.cc b/namei.cc
index 0eb2213..42e9281 100644
--- a/namei.cc
+++ b/namei.cc
@@ -21,7 +21,7 @@
Iput(vnode);
return ZX_ERR_NO_SPACE;
}
- } while(false);
+ } while (false);
VnodeF2fs::Allocate(Vfs(), ino, mode, &vnode_refptr);
@@ -405,13 +405,13 @@
if (zx_status_t err = VnodeF2fs::Vget(Vfs(), new_ino, &new_vn_ref); err != ZX_OK) {
if (old_dir_entry) {
#if 0 // porting needed
- // kunmap(old_dir_page);
+ // kunmap(old_dir_page);
#endif
F2fsPutPage(old_dir_page, 0);
}
#if 0 // porting needed
- // kunmap(old_page);
+ // kunmap(old_page);
#endif
F2fsPutPage(old_page, 0);
@@ -421,14 +421,15 @@
new_vnode = new_vn_ref.get();
new_vnode->i_name_sp_ = newname;
- if (old_dir_entry && (!S_ISDIR(new_vnode->i_mode_) || !(static_cast<Dir *>(new_vnode))->IsEmptyDir())) {
+ if (old_dir_entry &&
+ (!S_ISDIR(new_vnode->i_mode_) || !(static_cast<Dir *>(new_vnode))->IsEmptyDir())) {
#if 0 // porting needed
- // kunmap(old_dir_page);
+ // kunmap(old_dir_page);
#endif
F2fsPutPage(old_dir_page, 0);
#if 0 // porting needed
- // kunmap(old_page);
+ // kunmap(old_page);
#endif
F2fsPutPage(old_page, 0);
@@ -451,13 +452,13 @@
if (zx_status_t err = new_dir->AddLink(newname, old_vnode); err != ZX_OK) {
if (old_dir_entry) {
#if 0 // porting needed
- // kunmap(old_dir_page);
+ // kunmap(old_dir_page);
#endif
F2fsPutPage(old_dir_page, 0);
}
#if 0 // porting needed
- // kunmap(old_page);
+ // kunmap(old_page);
#endif
F2fsPutPage(old_page, 0);
@@ -488,7 +489,7 @@
(static_cast<Dir *>(old_vnode))->SetLink(old_dir_entry, old_dir_page, new_dir);
} else {
#if 0 // porting needed
- // kunmap(old_dir_page);
+ // kunmap(old_dir_page);
#endif
F2fsPutPage(old_dir_page, 0);
}
@@ -511,7 +512,7 @@
if (S_ISDIR(mode))
return Mkdir(name, mode, out);
-
+
return DoCreate(name, mode, out);
}
diff --git a/node.cc b/node.cc
index ba3f8fb..e123eda 100644
--- a/node.cc
+++ b/node.cc
@@ -6,7 +6,6 @@
namespace f2fs {
-
inline void SetNatCacheDirty(NmInfo *nm_i, NatEntry *ne) {
list_move_tail(&nm_i->dirty_nat_entries, &ne->list);
}
@@ -21,8 +20,7 @@
ni->version = raw_ne->version;
}
-inline bool NodeMgr::IncValidNodeCount(SbInfo *sbi, VnodeF2fs *vnode,
- uint32_t count) {
+inline bool NodeMgr::IncValidNodeCount(SbInfo *sbi, VnodeF2fs *vnode, uint32_t count) {
block_t valid_block_count;
uint32_t ValidNodeCount;
@@ -86,7 +84,7 @@
seg_off = block_off >> sbi.log_blocks_per_seg;
block_addr = static_cast<pgoff_t>(nm_i->nat_blkaddr + (seg_off << sbi.log_blocks_per_seg << 1) +
- (block_off & ((1 << sbi.log_blocks_per_seg) - 1)));
+ (block_off & ((1 << sbi.log_blocks_per_seg) - 1)));
if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
block_addr += sbi.blocks_per_seg;
@@ -127,8 +125,7 @@
f2fs_set_bit(block_off, nm_i->nat_bitmap);
}
-inline void NodeMgr::FillNodeFooter(Page *page, nid_t nid, nid_t ino, uint32_t ofs,
- bool reset) {
+inline void NodeMgr::FillNodeFooter(Page *page, nid_t nid, nid_t ino, uint32_t ofs, bool reset) {
void *kaddr = PageAddress(page);
Node *rn = static_cast<Node *>(kaddr);
if (reset)
@@ -320,8 +317,7 @@
rn->footer.flag = CpuToLe(flag);
}
-inline void NodeMgr::DecValidNodeCount(SbInfo *sbi, VnodeF2fs *vnode,
- uint32_t count) {
+inline void NodeMgr::DecValidNodeCount(SbInfo *sbi, VnodeF2fs *vnode, uint32_t count) {
SpinLock(&sbi->stat_lock);
// TODO: IMPL
@@ -463,8 +459,7 @@
return nullptr;
}
-uint32_t NodeMgr::GangLookupNatCache(NmInfo *nm_i, nid_t start, uint32_t nr,
- NatEntry **ep) {
+uint32_t NodeMgr::GangLookupNatCache(NmInfo *nm_i, nid_t start, uint32_t nr, NatEntry **ep) {
// TODO: IMPL
// TODO: need to be modified to use radix tree
@@ -587,8 +582,8 @@
ZX_ASSERT(!(NatGetBlkaddr(e) != ni->blk_addr));
ZX_ASSERT(!(NatGetBlkaddr(e) == kNullAddr && new_blkaddr == kNullAddr));
ZX_ASSERT(!(NatGetBlkaddr(e) == kNewAddr && new_blkaddr == kNewAddr));
- ZX_ASSERT(!(NatGetBlkaddr(e) != kNewAddr && NatGetBlkaddr(e) != kNullAddr &&
- new_blkaddr == kNewAddr));
+ ZX_ASSERT(
+ !(NatGetBlkaddr(e) != kNewAddr && NatGetBlkaddr(e) != kNullAddr && new_blkaddr == kNewAddr));
/* increament version no as node is removed */
if (NatGetBlkaddr(e) != kNewAddr && new_blkaddr == kNullAddr) {
@@ -840,10 +835,8 @@
#ifdef F2FS_BU_DEBUG
std::cout << "NodeMgr::GetDnodeOfData"
- << ", dn->nid=" << dn->nid
- << ", dn->node_page=" << dn->node_page
- << ", dn->ofs_in_node=" << dn->ofs_in_node
- << ", dn->data_blkaddr=" << dn->data_blkaddr
+ << ", dn->nid=" << dn->nid << ", dn->node_page=" << dn->node_page
+ << ", dn->ofs_in_node=" << dn->ofs_in_node << ", dn->data_blkaddr=" << dn->data_blkaddr
<< std::endl;
#endif
return ZX_OK;
@@ -972,8 +965,7 @@
return ret;
}
-zx_status_t NodeMgr::TruncatePartialNodes(DnodeOfData *dn, Inode *ri, int *offset,
- int depth) {
+zx_status_t NodeMgr::TruncatePartialNodes(DnodeOfData *dn, Inode *ri, int *offset, int depth) {
Page *pages[2];
nid_t nid[3];
nid_t child_nid;
@@ -1753,8 +1745,7 @@
AddFreeNid(GetNmInfo(&sbi), nid);
}
-void NodeMgr::RecoverNodePage(Page *page, Summary *sum, NodeInfo *ni,
- block_t new_blkaddr) {
+void NodeMgr::RecoverNodePage(Page *page, Summary *sum, NodeInfo *ni, block_t new_blkaddr) {
fs_->Segmgr().RewriteNodePage(page, sum, ni->blk_addr, new_blkaddr);
SetNodeAddr(ni, new_blkaddr);
ClearNodePageDirty(page);
@@ -1785,8 +1776,7 @@
src = static_cast<Node *>(PageAddress(page));
dst = static_cast<Node *>(PageAddress(ipage));
- memcpy(dst, src, reinterpret_cast<uint64_t>(&src->i.i_ext)
- - reinterpret_cast<uint64_t>(&src->i));
+ memcpy(dst, src, reinterpret_cast<uint64_t>(&src->i.i_ext) - reinterpret_cast<uint64_t>(&src->i));
dst->i.i_size = 0;
dst->i.i_blocks = 1;
dst->i.i_links = 1;
@@ -1945,7 +1935,7 @@
if (!page || (start_nid > nid || nid > end_nid)) {
if (page) {
#if 0 // porting needed
- // set_page_dirty(page, fs_);
+ // set_page_dirty(page, fs_);
#endif
FlushDirtyMetaPage(fs_, page);
F2fsPutPage(page, 1);
@@ -2102,7 +2092,7 @@
}
}
// TODO: Check nm_i->nat_cnt
- //ZX_ASSERT(!nm_i->nat_cnt);
+ // ZX_ASSERT(!nm_i->nat_cnt);
WriteUnlock(&nm_i->nat_tree_lock);
delete[] nm_i->nat_bitmap;
diff --git a/node.h b/node.h
index f6c8322..83b6ce3 100644
--- a/node.h
+++ b/node.h
@@ -2,20 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_NODE_H_
-#define F2FS_NODE_H_
+#ifndef THIRD_PARTY_F2FS_NODE_H_
+#define THIRD_PARTY_F2FS_NODE_H_
namespace f2fs {
/* start node id of a node block dedicated to the given node id */
-inline uint32_t StartNid(uint32_t nid) {
- return (nid / kNatEntryPerBlock) * kNatEntryPerBlock;
-}
+inline uint32_t StartNid(uint32_t nid) { return (nid / kNatEntryPerBlock) * kNatEntryPerBlock; }
/* node block offset on the NAT area dedicated to the given start node id */
-inline uint64_t NatBlockOffset(uint32_t start_nid) {
- return start_nid / kNatEntryPerBlock;
-}
+inline uint64_t NatBlockOffset(uint32_t start_nid) { return start_nid / kNatEntryPerBlock; }
/* # of pages to perform readahead before building free nids */
constexpr int kFreeNidPages = 4;
@@ -36,16 +32,16 @@
* For node information
*/
struct NodeInfo {
- nid_t nid = 0; /* node id */
- nid_t ino = 0; /* inode number of the node's owner */
- block_t blk_addr = 0; /* block address of the node */
- uint8_t version = 0; /* version of the node */
+ nid_t nid = 0; /* node id */
+ nid_t ino = 0; /* inode number of the node's owner */
+ block_t blk_addr = 0; /* block address of the node */
+ uint8_t version = 0; /* version of the node */
};
struct NatEntry {
- list_node_t list; /* for clean or dirty nat list */
- bool checkpointed = false; /* whether it is checkpointed or not */
- NodeInfo ni; /* in-memory node information */
+ list_node_t list; /* for clean or dirty nat list */
+ bool checkpointed = false; /* whether it is checkpointed or not */
+ NodeInfo ni; /* in-memory node information */
};
inline uint32_t NatGetNid(NatEntry *nat) { return nat->ni.nid; }
@@ -63,14 +59,14 @@
* For free nid mangement
*/
enum class NidState {
- kNidNew = 0, /* newly added to free nid list */
- kNidAlloc, /* it is allocated */
+ kNidNew = 0, /* newly added to free nid list */
+ kNidAlloc, /* it is allocated */
};
struct FreeNid {
list_node_t list; /* for free node id list */
- nid_t nid = 0; /* node id */
- int state = 0; /* in use or not: kNidNew or kNidAlloc */
+ nid_t nid = 0; /* node id */
+ int state = 0; /* in use or not: kNidNew or kNidAlloc */
};
class NodeMgr {
@@ -145,8 +141,7 @@
int F2fsWriteNodePage(Page *page, WritebackControl *wbc);
int F2fsWriteNodePages(struct address_space *mapping, WritebackControl *wbc);
zx_status_t RecoverInodePage(Page *page);
- void RecoverNodePage(Page *page, Summary *sum, NodeInfo *ni,
- block_t new_blkaddr);
+ void RecoverNodePage(Page *page, Summary *sum, NodeInfo *ni, block_t new_blkaddr);
private:
F2fs *fs_;
@@ -174,8 +169,7 @@
Page *GetNextNatPage(nid_t nid);
void RaNatPages(nid_t nid);
NatEntry *LookupNatCache(NmInfo *nm_i, nid_t n);
- uint32_t GangLookupNatCache(NmInfo *nm_i, nid_t start, uint32_t nr,
- NatEntry **ep);
+ uint32_t GangLookupNatCache(NmInfo *nm_i, nid_t start, uint32_t nr, NatEntry **ep);
void DelFromNatCache(NmInfo *nm_i, NatEntry *e);
NatEntry *GrabNatEntry(NmInfo *nm_i, nid_t nid);
@@ -192,7 +186,7 @@
zx_status_t NewNodePage(DnodeOfData *dn, uint32_t ofs, Page **out);
#if 0 // porting needed
void RaNodePage(nid_t nid);
- #endif
+#endif
Page *GetNodePageRa(Page *parent, int start);
#if 0 // porting needed
@@ -201,7 +195,7 @@
int F2fsSetNodePageDirty(Page *page);
void F2fsInvalidateNodePage(Page *page, uint64_t offset);
int F2fsReleaseNodePage(Page *page, gfp_t wait);
- #endif
+#endif
FreeNid *LookupFreeNidList(nid_t n, list_node_t *head);
void DelFromFreeNidList(FreeNid *i);
@@ -217,4 +211,4 @@
} // namespace f2fs
-#endif // F2FS_NODE_H_
+#endif // THIRD_PARTY_F2FS_NODE_H_
diff --git a/recovery.cc b/recovery.cc
index b65d83a..985e9f1 100644
--- a/recovery.cc
+++ b/recovery.cc
@@ -42,7 +42,7 @@
goto out;
}
- dir = static_cast<Dir *>(dir_refptr.get());
+ dir = static_cast<Dir *>(dir_refptr.get());
#if 0 // porting needed
// parent.d_inode = dir;
@@ -221,7 +221,8 @@
return;
/* Get the previous summary */
- for (i = static_cast<int>(CursegType::kCursegWarmData); i <= static_cast<int>(CursegType::kCursegColdData); i++) {
+ for (i = static_cast<int>(CursegType::kCursegWarmData);
+ i <= static_cast<int>(CursegType::kCursegColdData); i++) {
CursegInfo *curseg = Segmgr().CURSEG_I(&sbi, static_cast<CursegType>(i));
if (curseg->segno == segno) {
sum = curseg->sum_blk->entries[blkoff];
diff --git a/segment.cc b/segment.cc
index fea7c55..88c68ee 100644
--- a/segment.cc
+++ b/segment.cc
@@ -50,8 +50,7 @@
rs->mtime = CpuToLe(static_cast<uint64_t>(se->mtime));
}
-inline uint32_t SegMgr::FindNextInuse(FreeSegmapInfo *free_i, uint32_t max,
- uint32_t segno) {
+inline uint32_t SegMgr::FindNextInuse(FreeSegmapInfo *free_i, uint32_t max, uint32_t segno) {
uint32_t ret;
ReadLock(&free_i->segmap_lock);
ret = find_next_bit_le(free_i->free_segmap, max, segno);
@@ -178,11 +177,11 @@
inline uint32_t SegMgr::DirtySegments() {
SbInfo &sbi = fs_->GetSbInfo();
return GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyHotData)] +
- GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyWarmData)] +
- GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyColdData)] +
- GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyHotNode)] +
- GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyWarmNode)] +
- GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyColdNode)];
+ GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyWarmData)] +
+ GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyColdData)] +
+ GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyHotNode)] +
+ GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyWarmNode)] +
+ GetDirtyInfo(&sbi)->nr_dirty[static_cast<int>(DirtyType::kDirtyColdNode)];
}
inline int SegMgr::OverprovisionSegments() {
@@ -207,8 +206,9 @@
inline int SegMgr::GetSsrSegment(CursegType type) {
SbInfo &sbi = fs_->GetSbInfo();
CursegInfo *curseg = CURSEG_I(&sbi, type);
- return GetDirtyInfo(&sbi)->v_ops->get_victim(&sbi, &(curseg)->next_segno,
- static_cast<int>(GcType::kBgGc), static_cast<int>(type), static_cast<uint8_t>(AllocMode::kLFS));
+ return GetDirtyInfo(&sbi)->v_ops->get_victim(
+ &sbi, &(curseg)->next_segno, static_cast<int>(GcType::kBgGc), static_cast<int>(type),
+ static_cast<uint8_t>(AllocMode::kLFS));
}
inline bool SegMgr::HasNotEnoughFreeSecs() {
@@ -218,7 +218,7 @@
inline uint32_t SegMgr::Utilization() {
SbInfo &sbi = fs_->GetSbInfo();
return static_cast<uint32_t>(static_cast<int64_t>(ValidUserBlocks(&sbi)) * 100 /
- static_cast<int64_t>(sbi.user_block_count));
+ static_cast<int64_t>(sbi.user_block_count));
}
/*
@@ -261,7 +261,7 @@
ZX_ASSERT(!(segno > end_segno));
}
- #if 0 // porting needed
+#if 0 // porting needed
/*
* This function is used for only debugging.
* NOTE: In future, we have to remove this function.
@@ -347,8 +347,7 @@
return 0;
}
-inline void SegMgr::SetSummary(Summary *sum, nid_t nid, uint32_t ofs_in_node,
- uint8_t version) {
+inline void SegMgr::SetSummary(Summary *sum, nid_t nid, uint32_t ofs_in_node, uint8_t version) {
sum->nid = CpuToLe(nid);
sum->ofs_in_node = CpuToLe(ofs_in_node);
sum->version = version;
@@ -361,8 +360,8 @@
inline block_t SegMgr::SumBlkAddr(int base, int type) {
SbInfo &sbi = fs_->GetSbInfo();
- return StartCpAddr(&sbi) + LeToCpu(GetCheckpoint(&sbi)->cp_pack_total_block_count) -
- (base + 1) + type;
+ return StartCpAddr(&sbi) + LeToCpu(GetCheckpoint(&sbi)->cp_pack_total_block_count) - (base + 1) +
+ type;
}
/*
@@ -502,7 +501,8 @@
mtx_lock(&dirty_i->seglist_lock);
while (true) {
- segno = find_next_bit_le(dirty_i->dirty_segmap[static_cast<int>(DirtyType::kPre)], total_segs, offset);
+ segno = find_next_bit_le(dirty_i->dirty_segmap[static_cast<int>(DirtyType::kPre)], total_segs,
+ offset);
if (segno >= total_segs)
break;
SetTestAndFree(segno);
@@ -519,7 +519,8 @@
mtx_lock(&dirty_i->seglist_lock);
while (true) {
- segno = find_next_bit_le(dirty_i->dirty_segmap[static_cast<int>(DirtyType::kPre)], total_segs, offset);
+ segno = find_next_bit_le(dirty_i->dirty_segmap[static_cast<int>(DirtyType::kPre)], total_segs,
+ offset);
if (segno >= total_segs)
break;
@@ -640,7 +641,8 @@
int valid_sum_count = 0;
int i, sum_space;
- for (i = static_cast<int>(CursegType::kCursegHotData); i <= static_cast<int>(CursegType::kCursegColdData); i++) {
+ for (i = static_cast<int>(CursegType::kCursegHotData);
+ i <= static_cast<int>(CursegType::kCursegColdData); i++) {
if (sbi.ckpt->alloc_type[i] == static_cast<uint8_t>(AllocMode::kSSR)) {
valid_sum_count += sbi.blocks_per_seg;
} else {
@@ -648,8 +650,8 @@
}
}
- total_size_bytes = valid_sum_count * (kSummarySize + 1) + sizeof(NatJournal) + 2 +
- sizeof(SitJournal) + 2;
+ total_size_bytes =
+ valid_sum_count * (kSummarySize + 1) + sizeof(NatJournal) + 2 + sizeof(SitJournal) + 2;
sum_space = kPageCacheSize - kSumFooterSize;
if (total_size_bytes < sum_space) {
return 1;
@@ -790,7 +792,7 @@
for (i = 0; i < kNrCursegType; i++) {
if (CURSEG_I(&sbi, static_cast<CursegType>(i))->zone == zoneno)
break;
- }
+ }
if (i < kNrCursegType) {
/* zone is in user, try another */
@@ -949,13 +951,10 @@
#ifdef F2FS_BU_DEBUG
std::cout << "SegMgr::AllocateSegmentByDefault, type=" << type
- << ", curseg->segno =" << curseg->segno
- << ", FreeSections()=" << FreeSections()
+ << ", curseg->segno =" << curseg->segno << ", FreeSections()=" << FreeSections()
<< ", PrefreeSegments()=" << PrefreeSegments()
- << ", DirtySegments()=" << DirtySegments()
- << ", TotalSegs=" << TotalSegs(&sbi)
- << ", Utilization()=" << Utilization()
- << std::endl;
+ << ", DirtySegments()=" << DirtySegments() << ", TotalSegs=" << TotalSegs(&sbi)
+ << ", Utilization()=" << Utilization() << std::endl;
#endif
}
@@ -965,7 +964,8 @@
uint32_t old_curseg;
int i;
- for (i = static_cast<int>(CursegType::kCursegHotData); i <= static_cast<int>(CursegType::kCursegColdData); i++) {
+ for (i = static_cast<int>(CursegType::kCursegHotData);
+ i <= static_cast<int>(CursegType::kCursegColdData); i++) {
curseg = CURSEG_I(&sbi, static_cast<CursegType>(i));
old_curseg = curseg->segno;
GetSitInfo(&sbi)->s_ops->allocate_segment(&sbi, i, true);
@@ -1078,7 +1078,6 @@
#endif
void SegMgr::SubmitWritePage(Page *page, block_t blk_addr, PageType type) {
-
zx_status_t ret = fs_->bc_->Writeblk(blk_addr, page->data);
if (ret) {
std::cout << "SubmitWritePage error " << ret << std::endl;
@@ -1186,8 +1185,8 @@
}
}
-void SegMgr::DoWritePage(Page *page, block_t old_blkaddr, block_t *new_blkaddr,
- Summary *sum, PageType p_type) {
+void SegMgr::DoWritePage(Page *page, block_t old_blkaddr, block_t *new_blkaddr, Summary *sum,
+ PageType p_type) {
SbInfo &sbi = fs_->GetSbInfo();
SitInfo *sit_i = GetSitInfo(&sbi);
CursegInfo *curseg;
@@ -1248,15 +1247,14 @@
return ZX_OK;
}
-void SegMgr::WriteNodePage(Page *page, uint32_t nid, block_t old_blkaddr,
- block_t *new_blkaddr) {
+void SegMgr::WriteNodePage(Page *page, uint32_t nid, block_t old_blkaddr, block_t *new_blkaddr) {
Summary sum;
SetSummary(&sum, nid, 0, 0);
DoWritePage(page, old_blkaddr, new_blkaddr, &sum, PageType::kNode);
}
-void SegMgr::WriteDataPage(VnodeF2fs *vnode, Page *page, DnodeOfData *dn,
- block_t old_blkaddr, block_t *new_blkaddr) {
+void SegMgr::WriteDataPage(VnodeF2fs *vnode, Page *page, DnodeOfData *dn, block_t old_blkaddr,
+ block_t *new_blkaddr) {
Summary sum;
NodeInfo ni;
@@ -1271,8 +1269,7 @@
SubmitWritePage(page, old_blk_addr, PageType::kData);
}
-void SegMgr::RecoverDataPage(Page *page, Summary *sum, block_t old_blkaddr,
- block_t new_blkaddr) {
+void SegMgr::RecoverDataPage(Page *page, Summary *sum, block_t old_blkaddr, block_t new_blkaddr) {
SbInfo &sbi = fs_->GetSbInfo();
SitInfo *sit_i = GetSitInfo(&sbi);
CursegInfo *curseg;
@@ -1316,8 +1313,7 @@
mtx_unlock(&curseg->curseg_mutex);
}
-void SegMgr::RewriteNodePage(Page *page, Summary *sum, block_t old_blkaddr,
- block_t new_blkaddr) {
+void SegMgr::RewriteNodePage(Page *page, Summary *sum, block_t old_blkaddr, block_t new_blkaddr) {
SbInfo &sbi = fs_->GetSbInfo();
SitInfo *sit_i = GetSitInfo(&sbi);
CursegType type = CursegType::kCursegWarmNode;
@@ -1388,7 +1384,8 @@
offset = 2 * kSumJournalSize;
/* Step 3: restore summary entries */
- for (i = static_cast<int>(CursegType::kCursegHotData); i <= static_cast<int>(CursegType::kCursegColdData); i++) {
+ for (i = static_cast<int>(CursegType::kCursegHotData);
+ i <= static_cast<int>(CursegType::kCursegColdData); i++) {
uint16_t blk_off;
uint32_t segno;
@@ -1528,7 +1525,7 @@
/* Step 3: write summary entries */
for (i = static_cast<int>(CursegType::kCursegHotData);
- i <= static_cast<int>(CursegType::kCursegColdData); i++) {
+ i <= static_cast<int>(CursegType::kCursegColdData); i++) {
uint16_t blkoff;
seg_i = CURSEG_I(&sbi, static_cast<CursegType>(i));
if (sbi.ckpt->alloc_type[i] == static_cast<uint8_t>(AllocMode::kLFS)) {
@@ -1595,8 +1592,7 @@
WriteNormalSummaries(start_blk, CursegType::kCursegHotNode);
}
-int SegMgr::LookupJournalInCursum(SummaryBlock *sum, JournalType type, uint32_t val,
- int alloc) {
+int SegMgr::LookupJournalInCursum(SummaryBlock *sum, JournalType type, uint32_t val, int alloc) {
int i;
if (type == JournalType::kNatJournal) {
@@ -1792,19 +1788,16 @@
return ZX_ERR_NO_MEMORY;
for (start = 0; start < TotalSegs(&sbi); start++) {
- sit_i->sentries[start].cur_valid_map =
- static_cast<uint8_t *>(malloc(kSitVBlockMapSize));
+ sit_i->sentries[start].cur_valid_map = static_cast<uint8_t *>(malloc(kSitVBlockMapSize));
memset(sit_i->sentries[start].cur_valid_map, 0, kSitVBlockMapSize);
- sit_i->sentries[start].ckpt_valid_map =
- static_cast<uint8_t *>(malloc(kSitVBlockMapSize));
+ sit_i->sentries[start].ckpt_valid_map = static_cast<uint8_t *>(malloc(kSitVBlockMapSize));
memset(sit_i->sentries[start].ckpt_valid_map, 0, kSitVBlockMapSize);
if (!sit_i->sentries[start].cur_valid_map || !sit_i->sentries[start].ckpt_valid_map)
return ZX_ERR_NO_MEMORY;
}
if (sbi.segs_per_sec > 1) {
- sit_i->sec_entries =
- static_cast<SecEntry *>(calloc(sbi.total_sections, sizeof(SecEntry)));
+ sit_i->sec_entries = static_cast<SecEntry *>(calloc(sbi.total_sections, sizeof(SecEntry)));
if (!sit_i->sec_entries)
return ZX_ERR_NO_MEMORY;
}
@@ -1952,7 +1945,7 @@
/* set use the current segments */
for (type = static_cast<int>(CursegType::kCursegHotData);
- type <= static_cast<int>(CursegType::kCursegColdNode); type++) {
+ type <= static_cast<int>(CursegType::kCursegColdNode); type++) {
CursegInfo *curseg_t = CURSEG_I(&sbi, static_cast<CursegType>(type));
SetTestAndInuse(curseg_t->segno);
}
@@ -1994,12 +1987,15 @@
DirtySeglistInfo *dirty_i = GetDirtyInfo(&sbi);
uint32_t bitmap_size = BitmapSize(TotalSegs(&sbi));
- dirty_i->victim_segmap[static_cast<int>(GcType::kFgGc)] = static_cast<uint64_t *>(malloc(bitmap_size));
+ dirty_i->victim_segmap[static_cast<int>(GcType::kFgGc)] =
+ static_cast<uint64_t *>(malloc(bitmap_size));
memset(dirty_i->victim_segmap[static_cast<int>(GcType::kFgGc)], 0, bitmap_size);
- dirty_i->victim_segmap[static_cast<int>(GcType::kBgGc)] = static_cast<uint64_t *>(malloc(bitmap_size));
+ dirty_i->victim_segmap[static_cast<int>(GcType::kBgGc)] =
+ static_cast<uint64_t *>(malloc(bitmap_size));
memset(dirty_i->victim_segmap[static_cast<int>(GcType::kBgGc)], 0, bitmap_size);
- if (!dirty_i->victim_segmap[static_cast<int>(GcType::kFgGc)] || !dirty_i->victim_segmap[static_cast<int>(GcType::kBgGc)])
+ if (!dirty_i->victim_segmap[static_cast<int>(GcType::kFgGc)] ||
+ !dirty_i->victim_segmap[static_cast<int>(GcType::kBgGc)])
return ZX_ERR_NO_MEMORY;
return ZX_OK;
}
@@ -2104,8 +2100,7 @@
return err;
#ifdef F2FS_BU_DEBUG
- std::cout << "SegMgr::BuildSegmentManager(), TotalSegs(&sbi)=" << TotalSegs(&sbi)
- << std::endl;
+ std::cout << "SegMgr::BuildSegmentManager(), TotalSegs(&sbi)=" << TotalSegs(&sbi) << std::endl;
std::cout << "SegMgr::BuildSegmentManager(), ReservedSections()=" << ReservedSections()
<< std::endl;
std::cout << "SegMgr::BuildSegmentManager(), OverprovisionSections()=" << OverprovisionSections()
@@ -2209,7 +2204,7 @@
SbInfo &sbi = fs_->GetSbInfo();
SmInfo *sm_info = GetSmInfo(&sbi);
- DestroyDirtySegmap();
+ DestroyDirtySegmap();
DestroyCurseg();
DestroyFreeSegmap();
DestroySitInfo();
diff --git a/segment.h b/segment.h
index b315859..7e58259 100644
--- a/segment.h
+++ b/segment.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_SEGMENT_H_
-#define F2FS_SEGMENT_H_
+#ifndef THIRD_PARTY_F2FS_SEGMENT_H_
+#define THIRD_PARTY_F2FS_SEGMENT_H_
namespace f2fs {
@@ -21,7 +21,10 @@
* RIGHT means allocating new sections towards the end of volume.
* LEFT means the opposite direction.
*/
-enum class AllocDirection { kAllocRight = 0, kAllocLeft, };
+enum class AllocDirection {
+ kAllocRight = 0,
+ kAllocLeft,
+};
/*
* In the VictimSelPolicy->alloc_mode, there are two block allocation modes.
@@ -45,17 +48,17 @@
/* for a function parameter to select a victim segment */
struct VictimSelPolicy {
- int alloc_mode = 0; /* LFS or SSR */
- int gc_mode = 0; /* GC_CB or GC_GREEDY */
+ int alloc_mode = 0; /* LFS or SSR */
+ int gc_mode = 0; /* GC_CB or GC_GREEDY */
uint64_t *dirty_segmap = nullptr; /* dirty segment bitmap */
- uint32_t offset = 0; /* last scanned bitmap offset */
- uint32_t ofs_unit = 0; /* bitmap search unit */
- uint32_t min_cost = 0; /* minimum cost */
- uint32_t min_segno = 0; /* segment # having min. cost */
+ uint32_t offset = 0; /* last scanned bitmap offset */
+ uint32_t ofs_unit = 0; /* bitmap search unit */
+ uint32_t min_cost = 0; /* minimum cost */
+ uint32_t min_segno = 0; /* segment # having min. cost */
};
struct SegEntry {
- uint16_t valid_blocks = 0; /* # of valid blocks */
+ uint16_t valid_blocks = 0; /* # of valid blocks */
uint8_t *cur_valid_map = nullptr; /* validity bitmap of blocks */
/*
* # of valid blocks and the validity bitmap stored in the the last
@@ -63,7 +66,7 @@
*/
uint16_t ckpt_valid_blocks = 0;
uint8_t *ckpt_valid_map = nullptr;
- uint8_t type = 0; /* segment type like CURSEG_XXX_TYPE */
+ uint8_t type = 0; /* segment type like CURSEG_XXX_TYPE */
uint64_t mtime = 0; /* modification time of the segment */
};
@@ -81,15 +84,15 @@
block_t sit_base_addr = 0; /* start block address of SIT area */
block_t sit_blocks = 0; /* # of blocks used by SIT area */
block_t written_valid_blocks = 0; /* # of valid blocks in main area */
- char *sit_bitmap = nullptr; /* SIT bitmap pointer */
- uint32_t bitmap_size = 0; /* SIT bitmap size */
+ char *sit_bitmap = nullptr; /* SIT bitmap pointer */
+ uint32_t bitmap_size = 0; /* SIT bitmap size */
uint64_t *dirty_sentries_bitmap = nullptr; /* bitmap for dirty sentries */
- uint32_t dirty_sentries = 0; /* # of dirty sentries */
- uint32_t sents_per_block = 0; /* # of SIT entries per block */
- mtx_t sentry_lock; /* to protect SIT cache */
- SegEntry *sentries = nullptr; /* SIT segment-level cache */
- SecEntry *sec_entries = nullptr; /* SIT section-level cache */
+ uint32_t dirty_sentries = 0; /* # of dirty sentries */
+ uint32_t sents_per_block = 0; /* # of SIT entries per block */
+ mtx_t sentry_lock; /* to protect SIT cache */
+ SegEntry *sentries = nullptr; /* SIT segment-level cache */
+ SecEntry *sec_entries = nullptr; /* SIT section-level cache */
/* for cost-benefit algorithm in cleaning procedure */
uint64_t elapsed_time = 0; /* elapsed time after mount */
@@ -99,24 +102,24 @@
};
struct FreeSegmapInfo {
- uint32_t start_segno = 0; /* start segment number logically */
- uint32_t free_segments = 0; /* # of free segments */
- uint32_t free_sections = 0; /* # of free sections */
- rwlock_t segmap_lock; /* free segmap lock */
+ uint32_t start_segno = 0; /* start segment number logically */
+ uint32_t free_segments = 0; /* # of free segments */
+ uint32_t free_sections = 0; /* # of free sections */
+ rwlock_t segmap_lock; /* free segmap lock */
uint64_t *free_segmap = nullptr; /* free segment bitmap */
uint64_t *free_secmap = nullptr; /* free section bitmap */
};
/* Notice: The order of dirty type is same with CURSEG_XXX in f2fs.h */
enum class DirtyType {
- kDirtyHotData = 0, /* dirty segments assigned as hot data logs */
- kDirtyWarmData, /* dirty segments assigned as warm data logs */
- kDirtyColdData, /* dirty segments assigned as cold data logs */
- kDirtyHotNode, /* dirty segments assigned as hot node logs */
- kDirtyWarmNode, /* dirty segments assigned as warm node logs */
- kDirtyColdNode, /* dirty segments assigned as cold node logs */
- kDirty, /* to count # of dirty segments */
- kPre, /* to count # of entirely obsolete segments */
+ kDirtyHotData = 0, /* dirty segments assigned as hot data logs */
+ kDirtyWarmData, /* dirty segments assigned as warm data logs */
+ kDirtyColdData, /* dirty segments assigned as cold data logs */
+ kDirtyHotNode, /* dirty segments assigned as hot node logs */
+ kDirtyWarmNode, /* dirty segments assigned as warm node logs */
+ kDirtyColdNode, /* dirty segments assigned as cold node logs */
+ kDirty, /* to count # of dirty segments */
+ kPre, /* to count # of entirely obsolete segments */
kNrDirtytype
};
@@ -128,53 +131,61 @@
struct DirtySeglistInfo {
const VictimSelection *v_ops = nullptr; /* victim selction operation */
uint64_t *dirty_segmap[static_cast<int>(DirtyType::kNrDirtytype)] = {};
- mtx_t seglist_lock; /* lock for segment bitmaps */
- int nr_dirty[static_cast<int>(DirtyType::kNrDirtytype)] = {}; /* # of dirty segments */
- uint64_t *victim_segmap[2] = {}; /* BG_GC, FG_GC */
+ mtx_t seglist_lock; /* lock for segment bitmaps */
+ int nr_dirty[static_cast<int>(DirtyType::kNrDirtytype)] = {}; /* # of dirty segments */
+ uint64_t *victim_segmap[2] = {}; /* BG_GC, FG_GC */
};
/* for active log information */
struct CursegInfo {
- mtx_t curseg_mutex; /* lock for consistency */
+ mtx_t curseg_mutex; /* lock for consistency */
SummaryBlock *sum_blk = nullptr; /* cached summary block */
- uint8_t alloc_type = 0; /* current allocation type */
- uint32_t segno = 0; /* current segment number */
- uint16_t next_blkoff = 0; /* next block offset to write */
- uint32_t zone = 0; /* current zone number */
- uint32_t next_segno = 0; /* preallocated segment */
+ uint8_t alloc_type = 0; /* current allocation type */
+ uint32_t segno = 0; /* current segment number */
+ uint16_t next_blkoff = 0; /* next block offset to write */
+ uint32_t zone = 0; /* current zone number */
+ uint32_t next_segno = 0; /* preallocated segment */
};
/* V: Logical segment # in volume, R: Relative segment # in main area */
-inline uint32_t GetL2RSegNo(FreeSegmapInfo *free_i, uint32_t segno) { return (segno - free_i->start_segno); }
-inline uint32_t GetR2LSegNo(FreeSegmapInfo *free_i, uint32_t segno) { return (segno + free_i->start_segno); }
+inline uint32_t GetL2RSegNo(FreeSegmapInfo *free_i, uint32_t segno) {
+ return (segno - free_i->start_segno);
+}
+inline uint32_t GetR2LSegNo(FreeSegmapInfo *free_i, uint32_t segno) {
+ return (segno + free_i->start_segno);
+}
inline uint32_t IsDataSeg(CursegType t) {
- return ((t == CursegType::kCursegHotData) ||
- (t == CursegType::kCursegColdData) ||
- (t == CursegType::kCursegWarmData));
+ return ((t == CursegType::kCursegHotData) || (t == CursegType::kCursegColdData) ||
+ (t == CursegType::kCursegWarmData));
}
inline uint32_t IsNodeSeg(CursegType t) {
- return ((t == CursegType::kCursegHotNode) || (t == CursegType::kCursegColdNode) || (t == CursegType::kCursegWarmNode));
+ return ((t == CursegType::kCursegHotNode) || (t == CursegType::kCursegColdNode) ||
+ (t == CursegType::kCursegWarmNode));
}
inline block_t StartBlock(SbInfo *sbi, uint32_t segno) {
- return (GetSmInfo(sbi)->seg0_blkaddr + (GetR2LSegNo(GetFreeInfo(sbi), segno) << (sbi)->log_blocks_per_seg));
+ return (GetSmInfo(sbi)->seg0_blkaddr +
+ (GetR2LSegNo(GetFreeInfo(sbi), segno) << (sbi)->log_blocks_per_seg));
}
inline block_t NextFreeBlkAddr(SbInfo *sbi, CursegInfo *curseg) {
return (StartBlock(sbi, curseg->segno) + curseg->next_blkoff);
}
-inline block_t MainBaseBlock(SbInfo *sbi) { return GetSmInfo(sbi)->main_blkaddr;}
+inline block_t MainBaseBlock(SbInfo *sbi) { return GetSmInfo(sbi)->main_blkaddr; }
-inline block_t GetSegOffFromSeg0(SbInfo *sbi, block_t blk_addr) { return blk_addr - GetSmInfo(sbi)->seg0_blkaddr; }
+inline block_t GetSegOffFromSeg0(SbInfo *sbi, block_t blk_addr) {
+ return blk_addr - GetSmInfo(sbi)->seg0_blkaddr;
+}
inline uint32_t GetSegNoFromSeg0(SbInfo *sbi, block_t blk_addr) {
return GetSegOffFromSeg0(sbi, blk_addr) >> sbi->log_blocks_per_seg;
}
inline uint32_t GetSegNo(SbInfo *sbi, block_t blk_addr) {
- return ((blk_addr == kNullAddr) || (blk_addr == kNewAddr)) ? kNullSegNo
- : GetL2RSegNo(GetFreeInfo(sbi), GetSegNoFromSeg0(sbi, blk_addr));
+ return ((blk_addr == kNullAddr) || (blk_addr == kNewAddr))
+ ? kNullSegNo
+ : GetL2RSegNo(GetFreeInfo(sbi), GetSegNoFromSeg0(sbi, blk_addr));
}
inline uint32_t GetSecNo(SbInfo *sbi, uint32_t segno) { return segno / sbi->segs_per_sec; }
@@ -187,9 +198,13 @@
return (sbi->sm_info->ssa_blkaddr) + segno;
}
-inline uint32_t SitEntryOffset(SitInfo *sit_i, uint32_t segno) { return segno % sit_i->sents_per_block; }
+inline uint32_t SitEntryOffset(SitInfo *sit_i, uint32_t segno) {
+ return segno % sit_i->sents_per_block;
+}
inline uint32_t SitBlockOffset(SitInfo *sit_i, uint32_t segno) { return segno / kSitEntryPerBlock; }
-inline uint32_t StartSegNo(SitInfo *sit_i, uint32_t segno) { return SitBlockOffset(sit_i, segno) * kSitEntryPerBlock; }
+inline uint32_t StartSegNo(SitInfo *sit_i, uint32_t segno) {
+ return SitBlockOffset(sit_i, segno) * kSitEntryPerBlock;
+}
inline uint32_t BitmapSize(uint32_t nr) { return BitsToLongs(nr) * sizeof(uint64_t); }
inline uint32_t TotalSegs(SbInfo *sbi) { return GetSmInfo(sbi)->main_segments; }
@@ -209,14 +224,12 @@
// Static functions
static CursegInfo *CURSEG_I(SbInfo *sbi, CursegType type);
- static int LookupJournalInCursum(SummaryBlock *sum, JournalType type, uint32_t val,
- int alloc);
+ static int LookupJournalInCursum(SummaryBlock *sum, JournalType type, uint32_t val, int alloc);
// Public functions
zx_status_t BuildSegmentManager();
void DestroySegmentManager();
- void RewriteNodePage(Page *page, Summary *sum, block_t old_blkaddr,
- block_t new_blkaddr);
+ void RewriteNodePage(Page *page, Summary *sum, block_t old_blkaddr, block_t new_blkaddr);
private:
F2fs *fs_;
@@ -254,16 +267,15 @@
uint8_t CursegAllocType(int type);
uint16_t CursegBlkoff(int type);
void CheckSegRange(uint32_t segno);
- #if 0 // porting needed
+#if 0 // porting needed
void VerifyBlockAddr(block_t blk_addr);
- #endif
+#endif
void CheckBlockCount(int segno, SitEntry *raw_sit);
pgoff_t CurrentSitAddr(uint32_t start);
pgoff_t NextSitAddr(pgoff_t block_addr);
void SetToNextSit(SitInfo *sit_i, uint32_t start);
uint64_t GetMtime();
- void SetSummary(Summary *sum, nid_t nid, uint32_t ofs_in_node,
- uint8_t version);
+ void SetSummary(Summary *sum, nid_t nid, uint32_t ofs_in_node, uint8_t version);
block_t StartSumBlock();
block_t SumBlkAddr(int base, int type);
@@ -320,8 +332,7 @@
void WriteDataPage(VnodeF2fs *vnode, Page *page, DnodeOfData *dn, block_t old_blkaddr,
block_t *new_blkaddr);
void RewriteDataPage(Page *page, block_t old_blk_addr);
- void RecoverDataPage(Page *page, Summary *sum, block_t old_blkaddr,
- block_t new_blkaddr);
+ void RecoverDataPage(Page *page, Summary *sum, block_t old_blkaddr, block_t new_blkaddr);
int ReadCompactedSummaries();
int ReadNormalSummaries(int type);
@@ -365,22 +376,23 @@
inline bool IsCurSeg(SbInfo *sbi, uint32_t segno) {
return ((segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotData)->segno) ||
- (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmData)->segno) ||
- (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdData)->segno) ||
- (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotNode)->segno) ||
- (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmNode)->segno) ||
- (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdNode)->segno));
+ (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmData)->segno) ||
+ (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdData)->segno) ||
+ (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotNode)->segno) ||
+ (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmNode)->segno) ||
+ (segno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdNode)->segno));
}
inline bool IsCurSec(SbInfo *sbi, uint32_t secno) {
- return ((secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotData)->segno / (sbi)->segs_per_sec) ||
- (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmData)->segno / (sbi)->segs_per_sec) ||
- (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdData)->segno / (sbi)->segs_per_sec) ||
- (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotNode)->segno / (sbi)->segs_per_sec) ||
- (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmNode)->segno / (sbi)->segs_per_sec) ||
- (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdNode)->segno / (sbi)->segs_per_sec));
+ return (
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotData)->segno / (sbi)->segs_per_sec) ||
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmData)->segno / (sbi)->segs_per_sec) ||
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdData)->segno / (sbi)->segs_per_sec) ||
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegHotNode)->segno / (sbi)->segs_per_sec) ||
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegWarmNode)->segno / (sbi)->segs_per_sec) ||
+ (secno == SegMgr::CURSEG_I(sbi, CursegType::kCursegColdNode)->segno / (sbi)->segs_per_sec));
}
} // namespace f2fs
-#endif // F2FS_SEGMENT_H_
+#endif // THIRD_PARTY_F2FS_SEGMENT_H_
diff --git a/super.cc b/super.cc
index a97f760..e5ec589 100644
--- a/super.cc
+++ b/super.cc
@@ -2,8 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <sys/stat.h>
#include <string.h>
+#include <sys/stat.h>
+
#include "f2fs.h"
namespace f2fs {
@@ -480,8 +481,7 @@
#endif
/* recover fsynced data */
- if (!(sbi_->ckpt->ckpt_flags & kCpUmountFlag) &&
- !TestOpt(sbi_.get(), kMountDisableExtIdentify)) {
+ if (!(sbi_->ckpt->ckpt_flags & kCpUmountFlag) && !TestOpt(sbi_.get(), kMountDisableExtIdentify)) {
RecoverFsyncData();
}
diff --git a/third_party/ext2_hash/hash.h b/third_party/ext2_hash/hash.h
index 163296b..eb06f81 100644
--- a/third_party/ext2_hash/hash.h
+++ b/third_party/ext2_hash/hash.h
@@ -27,14 +27,14 @@
* SUCH DAMAGE.
*/
-#ifndef HASH_H_
-#define HASH_H_
+#ifndef THIRD_PARTY_F2FS_THIRD_PARTY_EXT2_HASH_HASH_H_
+#define THIRD_PARTY_F2FS_THIRD_PARTY_EXT2_HASH_HASH_H_
-namespace f2fs{
+namespace f2fs {
void TEATransform(unsigned int buf[4], unsigned int const in[]);
void Str2HashBuf(const char *msg, int len, unsigned int *buf, int num);
-}
+} // namespace f2fs
-#endif
+#endif // THIRD_PARTY_F2FS_THIRD_PARTY_EXT2_HASH_HASH_H_
diff --git a/tools/BUILD.gn b/tools/BUILD.gn
index 0b85d2c..af8a479 100644
--- a/tools/BUILD.gn
+++ b/tools/BUILD.gn
@@ -9,9 +9,7 @@
import("//src/sys/build/components.gni")
group("f2fs-tools") {
- deps = [
- ":package",
- ]
+ deps = [ ":package" ]
}
executable("bin") {
@@ -20,12 +18,12 @@
sources = [ "main.cc" ]
deps = [
- "//third_party/f2fs",
"//sdk/lib/sys/inspect/cpp",
"//sdk/lib/syslog/cpp",
+ "//src/lib/uuid",
+ "//third_party/f2fs",
"//zircon/public/lib/async",
"//zircon/public/lib/async-cpp",
- "//src/lib/uuid",
"//zircon/system/ulib/async-default",
"//zircon/system/ulib/async-loop:async-loop-cpp",
"//zircon/system/ulib/async-loop:async-loop-default",
@@ -42,4 +40,3 @@
package_name = "f2fs-tools"
deps = [ ":component" ]
}
-
diff --git a/tools/main.cc b/tools/main.cc
index d2802f8..66b43d3 100644
--- a/tools/main.cc
+++ b/tools/main.cc
@@ -4,19 +4,17 @@
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
-#include <lib/sys/cpp/component_context.h>
-#include <lib/sys/inspect/cpp/component.h>
-#include <lib/syslog/cpp/macros.h>
-#include <lib/syslog/cpp/log_settings.h>
-
#include <lib/fdio/directory.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fdio/limits.h>
#include <lib/fdio/vfs.h>
+#include <lib/sys/cpp/component_context.h>
+#include <lib/sys/inspect/cpp/component.h>
+#include <lib/syslog/cpp/log_settings.h>
+#include <lib/syslog/cpp/macros.h>
#include <lib/zx/channel.h>
-
#include <block-client/cpp/block-device.h>
#include <block-client/cpp/remote-block-device.h>
@@ -33,8 +31,8 @@
std::cout << "f2fs arg= ";
- for (int i=0; i < argc; i++) {
- std::cout<< argv[i] << " ";
+ for (int i = 0; i < argc; i++) {
+ std::cout << argv[i] << " ";
}
std::cout << std::endl;
@@ -47,7 +45,6 @@
return 0;
}
-
// Block device passed by handle
zx::channel device_channel = zx::channel(zx_take_startup_handle(FS_HANDLE_BLOCK_DEVICE_ID));
@@ -66,7 +63,7 @@
return -1;
}
- //TODO: implement the fsck logic
+ // TODO: implement the fsck logic
if (!strcmp(argv[1], "mkfs")) {
f2fs::Mkfs(mkfs_options, std::move(bc));
} else if (!strcmp(argv[1], "fsck")) {
diff --git a/tools/meta/f2fs-tools.cml b/tools/meta/f2fs-tools.cml
index ad9f824..a51cecb 100644
--- a/tools/meta/f2fs-tools.cml
+++ b/tools/meta/f2fs-tools.cml
@@ -19,6 +19,7 @@
program: {
// Use the built-in ELF runner to run native binaries.
runner: "elf",
+
// The binary to run for this component.
binary: "bin/f2fs",
},
diff --git a/vnode.cc b/vnode.cc
index d22c196..8388a96 100644
--- a/vnode.cc
+++ b/vnode.cc
@@ -3,7 +3,6 @@
// found in the LICENSE file.
#include <dirent.h>
-#include <sys/stat.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>
@@ -400,9 +399,7 @@
return nr_free;
}
-void VnodeF2fs::TruncateDataBlocks(DnodeOfData *dn) {
- TruncateDataBlocksRange(dn, kAddrsPerBlock);
-}
+void VnodeF2fs::TruncateDataBlocks(DnodeOfData *dn) { TruncateDataBlocksRange(dn, kAddrsPerBlock); }
void VnodeF2fs::TruncatePartialDataPage(uint64_t from) {
unsigned offset = from & (kPageCacheSize - 1);
@@ -536,7 +533,7 @@
void MarkInodeDirty(VnodeF2fs *vnode) { vnode->WriteInode(nullptr); }
void VnodeF2fs::Sync(SyncCallback closure) {
- File *file;
+ File *file;
if (closure) {
if (S_ISDIR(this->i_mode_)) {
diff --git a/vnode.h b/vnode.h
index 7d3214e..2e29ce1 100644
--- a/vnode.h
+++ b/vnode.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef F2FS_VNODE_H_
-#define F2FS_VNODE_H_
+#ifndef THIRD_PARTY_F2FS_VNODE_H_
+#define THIRD_PARTY_F2FS_VNODE_H_
namespace f2fs {
@@ -147,4 +147,4 @@
} // namespace f2fs
-#endif // F2FS_VNODE_H_
+#endif // THIRD_PARTY_F2FS_VNODE_H_
