diff --git a/admin.h b/admin.h
index beebf15..45eaa72 100644
--- a/admin.h
+++ b/admin.h
@@ -7,8 +7,6 @@
 
 namespace f2fs {
 
-class F2fs;
-
 class AdminService final : public fidl::WireServer<fuchsia_fs::Admin>, public fs::Service {
  public:
   AdminService(async_dispatcher_t* dispatcher, F2fs* f2fs);
diff --git a/checkpoint.cc b/checkpoint.cc
index 7c4cbc9..4c02787 100644
--- a/checkpoint.cc
+++ b/checkpoint.cc
@@ -571,7 +571,6 @@
  */
 void F2fs::BlockOperations() TA_NO_THREAD_SAFETY_ANALYSIS {
   SbInfo &sbi = GetSbInfo();
-  int t;
   struct WritebackControl wbc = {
 #if 0  // porting needed
       // .nr_to_write = LONG_MAX,
@@ -581,46 +580,34 @@
 #endif
   };
 
-  /* Stop renaming operation */
-  mutex_lock_op(&sbi, LockType::kRename);
-  mutex_lock_op(&sbi, LockType::kDentryOps);
-
 retry_dents:
-  /* write all the dirty dentry pages */
+  // write all the dirty dentry pages
   SyncDirtyDirInodes();
 
-  mutex_lock_op(&sbi, LockType::kDataWrtie);
+  // Stop file operation
+  mutex_lock_op(&sbi, LockType::kFileOp);
   if (GetPages(&sbi, CountType::kDirtyDents)) {
-    mutex_unlock_op(&sbi, LockType::kDataWrtie);
+    mutex_unlock_op(&sbi, LockType::kFileOp);
     goto retry_dents;
   }
 
-  /* block all the operations */
-  for (t = static_cast<int>(LockType::kDataNew); t <= static_cast<int>(LockType::kNodeTrunc); t++)
-    mutex_lock_op(&sbi, static_cast<LockType>(t));
-
-  fbl::AutoLock write_inode(&sbi.write_inode);
-
-  /*
-   * POR: we should ensure that there is no dirty node pages
-   * until finishing nat/sit flush.
-   */
+  // POR: we should ensure that there is no dirty node pages
+  // until finishing nat/sit flush.
 retry:
   Nodemgr().SyncNodePages(0, &wbc);
 
-  mutex_lock_op(&sbi, LockType::kNodeWrite);
+  mutex_lock_op(&sbi, LockType::kNodeOp);
 
   if (GetPages(&sbi, CountType::kDirtyNodes)) {
-    mutex_unlock_op(&sbi, LockType::kNodeWrite);
+    mutex_unlock_op(&sbi, LockType::kNodeOp);
     goto retry;
   }
 }
 
 void F2fs::UnblockOperations() TA_NO_THREAD_SAFETY_ANALYSIS {
   SbInfo &sbi = GetSbInfo();
-  int t;
-  for (t = static_cast<int>(LockType::kNodeWrite); t >= static_cast<int>(LockType::kRename); t--)
-    mutex_unlock_op(&sbi, static_cast<LockType>(t));
+  mutex_unlock_op(&sbi, LockType::kNodeOp);
+  mutex_unlock_op(&sbi, LockType::kFileOp);
 }
 
 void F2fs::DoCheckpoint(bool is_umount) {
diff --git a/data.cc b/data.cc
index a57b10c..5938411 100644
--- a/data.cc
+++ b/data.cc
@@ -516,7 +516,7 @@
 #endif
 
   do {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataWrtie)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
     if (IsDir()) {
       DecPageCount(&sbi, CountType::kDirtyDents);
 #if 0  // porting needed
@@ -601,10 +601,9 @@
     return ZX_ERR_NO_MEMORY;
 #endif
 
+  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+  std::lock_guard write_lock(io_lock_);
   do {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataNew)]);
-    std::lock_guard write_lock(io_lock_);
-
     SetNewDnode(&dn, this, NULL, NULL, 0);
     if (zx_status_t err = Vfs()->Nodemgr().GetDnodeOfData(&dn, index, 0); err != ZX_OK) {
       F2fsPutPage(*pagep, 1);
diff --git a/dir.cc b/dir.cc
index 627a9a0..71f92a0 100644
--- a/dir.cc
+++ b/dir.cc
@@ -207,9 +207,6 @@
 }
 
 void Dir::SetLink(DirEntry *de, Page *page, VnodeF2fs *vnode) {
-  SbInfo &sbi = Vfs()->GetSbInfo();
-
-  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
   std::lock_guard write_lock(io_lock_);
 #if 0  // porting needed
   // lock_page(page);
@@ -356,7 +353,6 @@
   f2fs_hash_t dentry_hash;
   DirEntry *de;
   unsigned int nbucket, nblock;
-  SbInfo &sbi = Vfs()->GetSbInfo();
   int namelen = name.length();
   Page *dentry_page = nullptr;
   DentryBlock *dentry_blk = nullptr;
@@ -366,7 +362,6 @@
 
   if (TestFlag(InodeInfoFlag::kInlineDentry)) {
     bool is_converted = false;
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
     std::lock_guard write_lock(io_lock_);
     if (err = AddInlineEntry(name, vnode, &is_converted); err != ZX_OK)
       return err;
@@ -397,63 +392,56 @@
     bidx = DirBlockIndex(level, (dentry_hash % nbucket));
 
     for (block = bidx; block <= (bidx + nblock - 1); block++) {
-      fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
       std::lock_guard write_lock(io_lock_);
       if (err = GetNewDataPage(block, true, &dentry_page); err != ZX_OK) {
         return err;
       }
 
-#if 0  // porting needed
+      // porting needed
       // dentry_blk = kmap(dentry_page);
-#else
       dentry_blk = reinterpret_cast<DentryBlock *>(dentry_page->data);
-#endif
       bit_pos = RoomForFilename(dentry_blk, slots);
       if (bit_pos < kNrDentryInBlock) {
-#if 0  // porting needed
-       // if (err = InitInodeMetadata(vnode, dentry); err == ZX_OK) {
-#else
+        // porting needed
+        // if (err = InitInodeMetadata(vnode, dentry); err == ZX_OK) {
         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);
 #else
           FlushDirtyDataPage(Vfs(), dentry_page);
 #endif
-        UpdateParentMetadata(vnode, current_depth);
+          UpdateParentMetadata(vnode, current_depth);
+        }
+
+        if (TestFlag(InodeInfoFlag::kUpdateDir)) {
+          WriteInode(nullptr);
+          ClearFlag(InodeInfoFlag::kUpdateDir);
+        }
+
+        // porting needed
+        // kunmap(dentry_page);
+        F2fsPutPage(dentry_page, 1);
+        return err;
       }
 
-      if (TestFlag(InodeInfoFlag::kUpdateDir)) {
-        WriteInode(nullptr);
-        ClearFlag(InodeInfoFlag::kUpdateDir);
-      }
-
-#if 0  // porting needed
-       // kunmap(dentry_page);
-#endif
+      // porting needed
+      // kunmap(dentry_page);
       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;
   }
-
-  /* Move to next level to find the empty slot for new dentry */
-  ++level;
-}
 }
 
 /**
@@ -471,7 +459,6 @@
   void *kaddr = PageAddress(page);
   int i;
 
-  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
   std::lock_guard write_lock(io_lock_);
 
   if (TestFlag(InodeInfoFlag::kInlineDentry)) {
diff --git a/dir.h b/dir.h
index 1b6059e..e2a97aa 100644
--- a/dir.h
+++ b/dir.h
@@ -42,72 +42,73 @@
   // Required for memory management, see the class comment above Vnode for more.
   void fbl_recycle() { RecycleNode(); }
 
+  // Lookup
   zx_status_t Lookup(std::string_view name, fbl::RefPtr<fs::Vnode> *out) final;
+  zx_status_t DoLookup(std::string_view name, fbl::RefPtr<fs::Vnode> *out);
+  DirEntry *FindEntry(std::string_view name, Page **res_page) __TA_EXCLUDES(io_lock_);
+  DirEntry *FindInInlineDir(const std::string_view &name, Page **res_page);
+  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, std::string_view name, int namelen,
+                        f2fs_hash_t namehash, Page **res_page);
   zx_status_t Readdir(fs::VdirCookie *cookie, void *dirents, size_t len, size_t *out_actual) final
       __TA_EXCLUDES(io_lock_);
-  zx_status_t Create(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out) final;
-  zx_status_t Link(std::string_view name, fbl::RefPtr<fs::Vnode> _target) final;
-  zx_status_t Unlink(std::string_view name, bool must_be_dir) final;
+  zx_status_t ReadInlineDir(fs::VdirCookie *cookie, void *dirents, size_t len, size_t *out_actual);
+
+  // delete & set link
   zx_status_t Rename(fbl::RefPtr<fs::Vnode> _newdir, std::string_view oldname,
                      std::string_view newname, bool src_must_be_dir, bool dst_must_be_dir);
+  void SetLink(DirEntry *de, Page *page, VnodeF2fs *inode) __TA_EXCLUDES(io_lock_)
+      __TA_EXCLUDES(io_lock_);
+  DirEntry *ParentDir(Page **p);
+  DirEntry *ParentInlineDir(Page **p);
+  bool IsEmptyDir();
+  bool IsEmptyInlineDir();
+  zx::status<bool> IsSubdir(Dir *possible_dir);
 
+  // create
+  zx_status_t Link(std::string_view name, fbl::RefPtr<fs::Vnode> _target) final;
+  zx_status_t Create(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out) final;
+  zx_status_t DoCreate(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out);
+  zx_status_t NewInode(uint32_t mode, fbl::RefPtr<VnodeF2fs> *out);
+  zx_status_t Mkdir(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out);
+  zx_status_t AddLink(std::string_view name, VnodeF2fs *vnode) __TA_EXCLUDES(io_lock_)
+      __TA_EXCLUDES(io_lock_);
+  zx_status_t AddInlineEntry(std::string_view name, VnodeF2fs *vnode, bool *is_converted);
+  unsigned int RoomInInlineDir(InlineDentry *dentry_blk, int slots);
+  zx_status_t ConvertInlineDir(InlineDentry *inline_dentry);
+  int RoomForFilename(DentryBlock *dentry_blk, int slots);
+  void UpdateParentMetadata(VnodeF2fs *inode, unsigned int current_depth);
+  zx_status_t InitInodeMetadata(VnodeF2fs *vnode);
+  zx_status_t MakeEmpty(VnodeF2fs *vnode, VnodeF2fs *parent);
+  zx_status_t MakeEmptyInlineDir(VnodeF2fs *vnode, VnodeF2fs *parent);
+  void InitDentInode(VnodeF2fs *vnode, Page *ipage);
+
+  // delete
+  zx_status_t Unlink(std::string_view name, bool must_be_dir) final;
+  zx_status_t Rmdir(Dir *vnode, std::string_view name);
+  zx_status_t DoUnlink(VnodeF2fs *vnode, std::string_view name);
+  void DeleteEntry(DirEntry *dentry, Page *page, VnodeF2fs *vnode) __TA_EXCLUDES(io_lock_)
+      __TA_EXCLUDES(io_lock_);
+  void DeleteInlineEntry(DirEntry *dentry, Page *page, VnodeF2fs *vnode);
+
+  // helper
+  ino_t InodeByName(std::string_view name);
+  int IsMultimediaFile(const char *s, const char *sub);
+  void SetColdFile(const char *name, VnodeF2fs *vnode);
   uint64_t DirBlocks();
   static unsigned int DirBuckets(unsigned int level);
   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);
-  DirEntry *FindInLevel(unsigned int level, std::string_view name, int namelen,
-                        f2fs_hash_t namehash, Page **res_page);
-  DirEntry *FindEntry(std::string_view name, Page **res_page) __TA_EXCLUDES(io_lock_);
-  DirEntry *ParentDir(Page **p);
-  ino_t InodeByName(std::string_view name);
-  void SetLink(DirEntry *de, Page *page, VnodeF2fs *inode) __TA_EXCLUDES(io_lock_);
-  void InitDentInode(VnodeF2fs *vnode, Page *ipage);
-#if 0  // porting needed
-  // zx_status_t InitInodeMetadata(VnodeF2fs *vnode, dentry *dentry);
-#else
-  zx_status_t InitInodeMetadata(VnodeF2fs *vnode);
-#endif
-  void UpdateParentMetadata(VnodeF2fs *inode, unsigned int current_depth);
-  int RoomForFilename(DentryBlock *dentry_blk, int slots);
-  zx_status_t AddLink(std::string_view name, VnodeF2fs *vnode) __TA_EXCLUDES(io_lock_);
-  void DeleteEntry(DirEntry *dentry, Page *page, VnodeF2fs *vnode) __TA_EXCLUDES(io_lock_);
-  zx_status_t MakeEmpty(VnodeF2fs *vnode, VnodeF2fs *parent);
-  bool IsEmptyDir();
 
-  zx_status_t NewInode(uint32_t mode, fbl::RefPtr<VnodeF2fs> *out);
-  int IsMultimediaFile(const char *s, const char *sub);
-  void SetColdFile(const char *name, VnodeF2fs *vnode);
-  zx_status_t DoCreate(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out);
 #if 0  // porting needed
 //   int F2fsLink(dentry *old_dentry, dentry *dentry);
 //   dentry *F2fsGetParent(dentry *child);
-#endif
-  zx_status_t DoUnlink(VnodeF2fs *vnode, std::string_view name);
-#if 0  // porting needed
 //   int F2fsSymlink(dentry *dentry, const char *symname);
-#endif
-  zx_status_t Mkdir(std::string_view name, uint32_t mode, fbl::RefPtr<fs::Vnode> *out);
-  zx_status_t Rmdir(Dir *vnode, std::string_view name);
-#if 0  // porting needed
 //   int F2fsMknod(dentry *dentry, umode_t mode, dev_t rdev);
 #endif
-  zx_status_t DoLookup(std::string_view name, fbl::RefPtr<fs::Vnode> *out);
-  // Check if possible_child is its subdir
-  zx::status<bool> IsSubdir(Dir *possible_dir);
-
-  DirEntry *FindInInlineDir(const std::string_view &name, Page **res_page);
-  DirEntry *ParentInlineDir(Page **p);
-  zx_status_t MakeEmptyInlineDir(VnodeF2fs *vnode, VnodeF2fs *parent);
-  unsigned int RoomInInlineDir(InlineDentry *dentry_blk, int slots);
-  zx_status_t ConvertInlineDir(InlineDentry *inline_dentry);
-  zx_status_t AddInlineEntry(std::string_view name, VnodeF2fs *vnode, bool *is_converted);
-  void DeleteInlineEntry(DirEntry *dentry, Page *page, VnodeF2fs *vnode);
-  bool IsEmptyInlineDir();
-  zx_status_t ReadInlineDir(fs::VdirCookie *cookie, void *dirents, size_t len, size_t *out_actual);
 };
 
 }  // namespace f2fs
diff --git a/f2fs.h b/f2fs.h
index 056b677..6b79972 100644
--- a/f2fs.h
+++ b/f2fs.h
@@ -39,7 +39,6 @@
 #include "src/lib/storage/vfs/cpp/shared_mutex.h"
 #include "src/lib/storage/vfs/cpp/service.h"
 
-#include "admin.h"
 #include "f2fs_types.h"
 #include "f2fs_lib.h"
 #include "f2fs_layout.h"
@@ -51,11 +50,12 @@
 #include "file.h"
 #include "vnode_cache.h"
 #include "node.h"
-#include "query.h"
 #include "segment.h"
 #include "mkfs.h"
 #include "mount.h"
 #include "fsck.h"
+#include "admin.h"
+#include "query.h"
 // clang-format on
 
 namespace f2fs {
diff --git a/f2fs_internal.h b/f2fs_internal.h
index 4aaeb7a..52c9824 100644
--- a/f2fs_internal.h
+++ b/f2fs_internal.h
@@ -210,20 +210,11 @@
   kNrCountType,
 };
 
-// FS_LOCK nesting subclasses for the lock validator:
-//
 // The locking order between these classes is
-// LockType::kRename -> LockType::kDentryOps -> LockType::kDataWrtie -> LockType::kDataNew
-//    -> LockType::kDataTrunc -> LockType::kNodeWrite -> LockType::kNodeNew -> LockType::kNodeTrunc
+// LockType::FileOp -> LockType::kNodeOp
 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
+  kFileOp,  // for file op
+  kNodeOp,  // for node op
   kNrLockType,
 };
 
@@ -267,7 +258,6 @@
   fbl::RefPtr<VnodeF2fs> meta_vnode;
   fbl::Mutex cp_mutex;                                               // for checkpoint procedure
   fs::SharedMutex fs_lock[static_cast<int>(LockType::kNrLockType)];  // for blocking FS operations
-  fbl::Mutex write_inode;                                            // mutex for write inode
   fbl::Mutex writepages;                                             // mutex for writepages()
   int por_doing = 0;                                                 // recovery is doing or not
 
@@ -352,8 +342,6 @@
 
 static inline void mutex_lock_op(SbInfo *sbi, LockType t)
     TA_ACQ(&sbi->fs_lock[static_cast<int>(t)]) {
-  // TODO: Too many locks.
-  // It seems that two locks (node/io) are enough to sync between cp and io path.
   sbi->fs_lock[static_cast<int>(t)].lock();
 }
 
diff --git a/namei.cc b/namei.cc
index 4be5915..8b0c28e 100644
--- a/namei.cc
+++ b/namei.cc
@@ -15,7 +15,7 @@
   VnodeF2fs *vnode = nullptr;
 
   do {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
     if (!Vfs()->Nodemgr().AllocNid(&ino)) {
       Iput(vnode);
       return ZX_ERR_NO_SPACE;
@@ -109,12 +109,15 @@
     SetColdFile(name.data(), vnode);
 
   vnode->SetFlag(InodeInfoFlag::kIncLink);
-  if (zx_status_t err = AddLink(name, vnode); err != ZX_OK) {
-    vnode->ClearNlink();
-    vnode->UnlockNewInode();
-    Iput(vnode);
-    Vfs()->Nodemgr().AllocNidFailed(vnode->Ino());
-    return err;
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+    if (zx_status_t err = AddLink(name, vnode); err != ZX_OK) {
+      vnode->ClearNlink();
+      vnode->UnlockNewInode();
+      Iput(vnode);
+      Vfs()->Nodemgr().AllocNidFailed(vnode->Ino());
+      return err;
+    }
   }
 
   Vfs()->Nodemgr().AllocNidDone(vnode->Ino());
@@ -152,12 +155,15 @@
 #if 0  // porting needed
   // AtomicInc(&inode->i_count);
 #endif
-
-  target->SetFlag(InodeInfoFlag::kIncLink);
-  if (zx_status_t err = AddLink(name, target); err != ZX_OK) {
-    target->ClearFlag(InodeInfoFlag::kIncLink);
-    Iput(target);
-    return err;
+  {
+    SbInfo &sbi = Vfs()->GetSbInfo();
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+    target->SetFlag(InodeInfoFlag::kIncLink);
+    if (zx_status_t err = AddLink(name, target); err != ZX_OK) {
+      target->ClearFlag(InodeInfoFlag::kIncLink);
+      Iput(target);
+      return err;
+    }
   }
 
 #if 0  // porting needed
@@ -221,16 +227,20 @@
     return ZX_ERR_NOT_FOUND;
   }
 
-  if (zx_status_t err = Vfs()->CheckOrphanSpace(); err != ZX_OK) {
+  {
+    SbInfo &sbi = Vfs()->GetSbInfo();
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+    if (zx_status_t err = Vfs()->CheckOrphanSpace(); err != ZX_OK) {
 #if 0  // porting needed
     // if (!f2fs_has_inline_dentry(dir))
     //   kunmap(page);
 #endif
-    F2fsPutPage(page, 0);
-    return err;
-  }
+      F2fsPutPage(page, 0);
+      return err;
+    }
 
-  DeleteEntry(de, page, vnode);
+    DeleteEntry(de, page, vnode);
+  }
 
   Vfs()->Segmgr().BalanceFs();
 
@@ -289,15 +299,18 @@
 #endif
 
   vnode->SetFlag(InodeInfoFlag::kIncLink);
-  if (zx_status_t err = AddLink(name, vnode); err != ZX_OK) {
-    vnode->ClearFlag(InodeInfoFlag::kIncLink);
-    vnode->ClearNlink();
-    vnode->UnlockNewInode();
-    Iput(vnode);
-    Vfs()->Nodemgr().AllocNidFailed(vnode->Ino());
-    return err;
+  {
+    SbInfo &sbi = Vfs()->GetSbInfo();
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+    if (zx_status_t err = AddLink(name, vnode); err != ZX_OK) {
+      vnode->ClearFlag(InodeInfoFlag::kIncLink);
+      vnode->ClearNlink();
+      vnode->UnlockNewInode();
+      Iput(vnode);
+      Vfs()->Nodemgr().AllocNidFailed(vnode->Ino());
+      return err;
+    }
   }
-
   Vfs()->Nodemgr().AllocNidDone(vnode->Ino());
 
 #if 0  // porting needed
@@ -434,7 +447,7 @@
   }
 
   do {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kRename)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
 
     new_entry = new_dir->FindEntry(newname, &new_page);
     if (new_entry) {
diff --git a/node.cc b/node.cc
index 18f7e3c..19ed1c9 100644
--- a/node.cc
+++ b/node.cc
@@ -732,7 +732,6 @@
 
 // Caller should call f2fs_put_dnode(dn).
 zx_status_t NodeMgr::GetDnodeOfData(DnodeOfData *dn, pgoff_t index, int ro) {
-  SbInfo &sbi = fs_->GetSbInfo();
   Page *npage[4];
   Page *parent;
   int offset[4];
@@ -763,8 +762,6 @@
     bool done = false;
 
     if (!nids[i] && !ro) {
-      fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
-
       /* alloc new node */
       if (!AllocNid(&(nids[i]))) {
         err = ZX_ERR_NO_SPACE;
@@ -1103,13 +1100,11 @@
 }
 
 zx_status_t NodeMgr::RemoveInodePage(VnodeF2fs *vnode) {
-  SbInfo &sbi = fs_->GetSbInfo();
   Page *page = nullptr;
   nid_t ino = vnode->Ino();
   DnodeOfData dn;
   zx_status_t err = 0;
 
-  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeTrunc)]);
   err = GetNodePage(ino, &page);
   if (err) {
     return err;
@@ -1147,18 +1142,15 @@
 }
 
 zx_status_t NodeMgr::NewInodePage(Dir *parent, VnodeF2fs *child) {
-  SbInfo &sbi = fs_->GetSbInfo();
   Page *page = nullptr;
   DnodeOfData dn;
   zx_status_t err = 0;
 
   /* allocate inode page for new inode */
   SetNewDnode(&dn, child, nullptr, nullptr, child->Ino());
-  {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
-    err = NewNodePage(&dn, 0, &page);
-    parent->InitDentInode(child, page);
-  }
+  err = NewNodePage(&dn, 0, &page);
+  parent->InitDentInode(child, page);
+
   if (err)
     return err;
   F2fsPutPage(page, 1);
@@ -1440,8 +1432,6 @@
 #endif
   WaitOnPageWriteback(page);
 
-  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeWrite)]);
-
   /* get old block addr of this node page */
   nid = NidOfNode(page);
   nofs = OfsOfNode(page);
@@ -1454,12 +1444,15 @@
     return ZX_OK;
   }
 
-  SetPageWriteback(page);
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeOp)]);
+    SetPageWriteback(page);
 
-  /* insert node offset */
-  fs_->Segmgr().WriteNodePage(page, nid, ni.blk_addr, &new_addr);
-  SetNodeAddr(&ni, new_addr);
-  DecPageCount(&sbi, CountType::kDirtyNodes);
+    /* insert node offset */
+    fs_->Segmgr().WriteNodePage(page, nid, ni.blk_addr, &new_addr);
+    SetNodeAddr(&ni, new_addr);
+    DecPageCount(&sbi, CountType::kDirtyNodes);
+  }
 
   // TODO: IMPL
   // unlock_page(page);
diff --git a/node.h b/node.h
index 9341581..cfc2b18 100644
--- a/node.h
+++ b/node.h
@@ -95,6 +95,7 @@
   zx_status_t ReadNodePage(Page *page, nid_t nid, int type);
   zx_status_t GetNodePage(pgoff_t nid, Page **out);
 
+  // Caller should acquire LockType:kFileOp when |ro| = 0.
   zx_status_t GetDnodeOfData(DnodeOfData *dn, pgoff_t index, int ro);
 
   void FillNodeFooter(Page *page, nid_t nid, nid_t ino, uint32_t ofs, bool reset);
@@ -127,8 +128,11 @@
   void AllocNidDone(nid_t nid);
   zx_status_t TruncateInodeBlocks(VnodeF2fs *vnode, pgoff_t from);
 
+  // Caller should acquire LockType:kFileOp.
   zx_status_t RemoveInodePage(VnodeF2fs *vnode);
+  // Caller should acquire LockType:kFileOp.
   zx_status_t NewInodePage(Dir *parent, VnodeF2fs *child);
+
   int IsCheckpointedNode(nid_t nid);
 
   void ClearColdData(Page *page);
diff --git a/vnode.cc b/vnode.cc
index 0e461ac..8d5b6f3 100644
--- a/vnode.cc
+++ b/vnode.cc
@@ -304,29 +304,28 @@
 #endif
 }
 
-int VnodeF2fs::WriteInode(WritebackControl *wbc) TA_NO_THREAD_SAFETY_ANALYSIS {
+int VnodeF2fs::WriteInode(WritebackControl *wbc) {
   SbInfo &sbi = Vfs()->GetSbInfo();
   Page *node_page = nullptr;
   zx_status_t ret = ZX_OK;
 
-  if (ino_ == NodeIno(&sbi) || ino_ == MetaIno(&sbi))
+  if (ino_ == NodeIno(&sbi) || ino_ == MetaIno(&sbi)) {
     return ret;
+  }
 
-  if (ret = Vfs()->Nodemgr().GetNodePage(ino_, &node_page); ret != ZX_OK)
-    return ret;
+  if (!IsDirty()) {
+    return ZX_OK;
+  }
 
-  if (PageDirty(node_page) || IsDirty()) {
-    UpdateInode(node_page);
-    F2fsPutPage(node_page, 1);
-  } else {
-    F2fsPutPage(node_page, 1);
-    fbl::AutoLock lock(&sbi.write_inode);
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeOp)]);
     if (ret = Vfs()->Nodemgr().GetNodePage(ino_, &node_page); ret != ZX_OK)
       return ret;
     UpdateInode(node_page);
-    F2fsPutPage(node_page, 1);
   }
 
+  F2fsPutPage(node_page, 1);
+
   return ZX_OK;
 }
 
@@ -414,7 +413,7 @@
   pgoff_t free_from = static_cast<pgoff_t>((from + blocksize - 1) >> (sbi.log_blocksize));
 
   {
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataTrunc)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
     std::lock_guard write_lock(io_lock_);
 
     do {
@@ -454,9 +453,7 @@
 
   for (index = pg_start; index < pg_end; index++) {
     DnodeOfData dn;
-    SbInfo &sbi = Vfs()->GetSbInfo();
 
-    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataTrunc)]);
     SetNewDnode(&dn, this, NULL, NULL, 0);
     if (zx_status_t err = Vfs()->Nodemgr().GetDnodeOfData(&dn, index, kRdOnlyNode); err != ZX_OK) {
       if (err == ZX_ERR_NOT_FOUND)
@@ -504,7 +501,10 @@
   if (HasBlocks())
     TruncateToSize();
 
-  Vfs()->Nodemgr().RemoveInodePage(this);
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kFileOp)]);
+    Vfs()->Nodemgr().RemoveInodePage(this);
+  }
   Vfs()->EvictVnode(this);
   //  no_delete:
   //  ClearInode(this);