diff --git a/admin.cc b/admin.cc
index 93591e2..190b639 100644
--- a/admin.cc
+++ b/admin.cc
@@ -14,8 +14,7 @@
 
 void AdminService::Shutdown(ShutdownRequestView request, ShutdownCompleter::Sync& completer) {
   f2fs_->PutSuper();
-  f2fs_->bc_.reset();
-
+  f2fs_->ResetBc();
   completer.Reply();
 }
 
diff --git a/checkpoint.cc b/checkpoint.cc
index eac0e48..3290833 100644
--- a/checkpoint.cc
+++ b/checkpoint.cc
@@ -160,10 +160,9 @@
    * for cp pack we can have max 1020*507 orphan entries
    */
   max_orphans = (sbi.blocks_per_seg - 5) * kOrphansPerBlock;
-  mtx_lock(&sbi.orphan_inode_mutex);
+  std::lock_guard lock(sbi.orphan_inode_mutex);
   if (sbi.n_orphans >= max_orphans)
     err = ZX_ERR_NO_SPACE;
-  mtx_unlock(&sbi.orphan_inode_mutex);
   return err;
 }
 
@@ -178,42 +177,34 @@
 }
 void F2fs::AddOrphanInode(nid_t ino) {
   SbInfo &sbi = GetSbInfo();
-  list_node_t *head, *this_node;
   OrphanInodeEntry *new_entry = nullptr, *orphan = nullptr;
 
-  mtx_lock(&sbi.orphan_inode_mutex);
-  head = &sbi.orphan_inode_list;
+  std::lock_guard lock(sbi.orphan_inode_mutex);
+  list_node_t *head = &sbi.orphan_inode_list, *this_node;
   list_for_every(head, this_node) {
     orphan = containerof(this_node, OrphanInodeEntry, list);
     if (orphan->ino == ino)
-      goto out;
+      return;
     if (orphan->ino > ino)
       break;
     orphan = nullptr;
   }
-retry:
-#if 0  // porting needed
-  // new_entry = kmem_cache_alloc(orphan_entry_slab, GFP_ATOMIC);
-#else
+
+  // TODO: it never fails
   new_entry = new OrphanInodeEntry;
-#endif
-  if (!new_entry) {
-#if 0  // porting needed
-    // cond_resched();
-#endif
-    goto retry;
-  }
+  ZX_ASSERT(new_entry != nullptr);
+
   new_entry->ino = ino;
   list_initialize(&new_entry->list);
 
-  /* add new_oentry into list which is sorted by inode number */
+  // add new_entry into list which is sorted by inode number
   if (orphan) {
     OrphanInodeEntry *prev;
 
-    /* get previous entry */
+    // get previous entry
     prev = containerof(orphan->list.prev, OrphanInodeEntry, list);
     if (&prev->list != head) {
-      /* insert new orphan inode entry */
+      // insert new orphan inode entry
       list_add(&prev->list, &new_entry->list);
     } else {
       list_add(head, &new_entry->list);
@@ -222,8 +213,6 @@
     list_add_tail(head, &new_entry->list);
   }
   sbi.n_orphans++;
-out:
-  mtx_unlock(&sbi.orphan_inode_mutex);
 }
 
 void F2fs::RemoveOrphanInode(nid_t ino) {
@@ -231,7 +220,7 @@
   list_node_t *this_node, *next, *head;
   OrphanInodeEntry *orphan;
 
-  mtx_lock(&sbi.orphan_inode_mutex);
+  std::lock_guard lock(sbi.orphan_inode_mutex);
   head = &sbi.orphan_inode_list;
   list_for_every_safe(head, this_node, next) {
     orphan = containerof(this_node, OrphanInodeEntry, list);
@@ -245,7 +234,6 @@
       break;
     }
   }
-  mtx_unlock(&sbi.orphan_inode_mutex);
 }
 
 void F2fs::RecoverOrphanInode(nid_t ino) {
@@ -300,7 +288,7 @@
   orphan_blocks =
       static_cast<uint16_t>((sbi.n_orphans + (kOrphansPerBlock - 1)) / kOrphansPerBlock);
 
-  mtx_lock(&sbi.orphan_inode_mutex);
+  std::lock_guard lock(sbi.orphan_inode_mutex);
   head = &sbi.orphan_inode_list;
 
   /* loop for each orphan inode entry and write them in Jornal block */
@@ -329,29 +317,24 @@
       nentries = 0;
       page = nullptr;
     }
-    if (page)
-      goto page_exist;
-
-    page = GrabMetaPage(start_blk);
-    orphan_blk = static_cast<OrphanBlock *>(PageAddress(page));
-    memset(orphan_blk, 0, sizeof(*orphan_blk));
-  page_exist:
+    if (!page) {
+      page = GrabMetaPage(start_blk);
+      orphan_blk = static_cast<OrphanBlock *>(PageAddress(page));
+      memset(orphan_blk, 0, sizeof(*orphan_blk));
+    }
     orphan_blk->ino[nentries++] = CpuToLe(orphan->ino);
   }
-  if (!page)
-    goto end;
-
-  orphan_blk->blk_addr = CpuToLe(index);
-  orphan_blk->blk_count = CpuToLe(orphan_blocks);
-  orphan_blk->entry_count = CpuToLe(nentries);
+  if (page) {
+    orphan_blk->blk_addr = CpuToLe(index);
+    orphan_blk->blk_count = CpuToLe(orphan_blocks);
+    orphan_blk->entry_count = CpuToLe(nentries);
 #if 0  // porting needed
   // set_page_dirty(page, this);
 #else
-  FlushDirtyMetaPage(this, page);
+    FlushDirtyMetaPage(this, page);
 #endif
-  F2fsPutPage(page, 1);
-end:
-  mtx_unlock(&sbi.orphan_inode_mutex);
+    F2fsPutPage(page, 1);
+  }
 }
 
 Page *F2fs::ValidateCheckpoint(block_t cp_addr, uint64_t *version) {
@@ -616,7 +599,7 @@
   for (t = static_cast<int>(LockType::kDataNew); t <= static_cast<int>(LockType::kNodeTrunc); t++)
     mutex_lock_op(&sbi, static_cast<LockType>(t));
 
-  mtx_lock(&sbi.write_inode);
+  fbl::AutoLock write_inode(&sbi.write_inode);
 
   /*
    * POR: we should ensure that there is no dirty node pages
@@ -631,7 +614,6 @@
     mutex_unlock_op(&sbi, LockType::kNodeWrite);
     goto retry;
   }
-  mtx_unlock(&sbi.write_inode);
 }
 
 void F2fs::UnblockOperations() TA_NO_THREAD_SAFETY_ANALYSIS {
@@ -789,19 +771,14 @@
   ResetSbDirt(&sbi);
 }
 
-/**
- * We guarantee that this checkpoint procedure should not fail.
- */
+// We guarantee that this checkpoint procedure should not fail.
 void F2fs::WriteCheckpoint(bool blocked, bool is_umount) {
   SbInfo &sbi = GetSbInfo();
   Checkpoint *ckpt = GetCheckpoint(&sbi);
   uint64_t ckpt_ver;
 
-  // TODO(unknown): Need to confirm if blocked is true
-  // if (!blocked) {
-  mtx_lock(&sbi.cp_mutex);
+  fbl::AutoLock cp_lock(&sbi.cp_mutex);
   BlockOperations();
-  //}
 
 #if 0  // porting needed (bio[type] is empty)
   // Segmgr().SubmitBio(PageType::kData, true);
@@ -809,30 +786,26 @@
   // Segmgr().SubmitBio(PageType::kMeta, true);
 #endif
 
-  /*
-   * update checkpoint pack index
-   * Increase the version number so that
-   * SIT entries and seg summaries are written at correct place
-   */
+  // update checkpoint pack index
+  // Increase the version number so that
+  // SIT entries and seg summaries are written at correct place
   ckpt_ver = LeToCpu(ckpt->checkpoint_ver);
   ckpt->checkpoint_ver = CpuToLe(static_cast<uint64_t>(++ckpt_ver));
 
-  /* write cached NAT/SIT entries to NAT/SIT area */
+  // write cached NAT/SIT entries to NAT/SIT area
   Nodemgr().FlushNatEntries();
   Segmgr().FlushSitEntries();
 
   Segmgr().ResetVictimSegmap();
 
-  /* unlock all the fs_lock[] in do_checkpoint() */
+  // unlock all the fs_lock[] in do_checkpoint()
   DoCheckpoint(is_umount);
 
   UnblockOperations();
-  mtx_unlock(&sbi.cp_mutex);
 }
 
 void F2fs::InitOrphanInfo() {
   SbInfo &sbi = GetSbInfo();
-  mtx_init(&sbi.orphan_inode_mutex, mtx_plain);
   list_initialize(&sbi.orphan_inode_list);
   sbi.n_orphans = 0;
 }
diff --git a/data.cc b/data.cc
index b9b50c3..a57b10c 100644
--- a/data.cc
+++ b/data.cc
@@ -100,18 +100,18 @@
   /* Update the page address in the parent node */
   SetDataBlkaddr(dn, blk_addr);
 
-  WriteLock(&fi->ext.ext_lock);
-
-  start_fofs = fi->ext.fofs;
-  end_fofs = fi->ext.fofs + fi->ext.len - 1;
-  start_blkaddr = fi->ext.blk_addr;
-  end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
-
-  /* Drop and initialize the matched extent */
-  if (fi->ext.len == 1 && fofs == start_fofs)
-    fi->ext.len = 0;
-
   do {
+    std::lock_guard ext_lock(fi->ext.ext_lock);
+
+    start_fofs = fi->ext.fofs;
+    end_fofs = fi->ext.fofs + fi->ext.len - 1;
+    start_blkaddr = fi->ext.blk_addr;
+    end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
+
+    /* Drop and initialize the matched extent */
+    if (fi->ext.len == 1 && fofs == start_fofs)
+      fi->ext.len = 0;
+
     /* Initial extent */
     if (fi->ext.len == 0) {
       if (blk_addr != kNullAddr) {
@@ -147,11 +147,9 @@
       }
       break;
     }
-    WriteUnlock(&fi->ext.ext_lock);
     return;
   } while (false);
 
-  WriteUnlock(&fi->ext.ext_lock);
   Vfs()->Nodemgr().SyncInodePage(dn);
 }
 
@@ -360,7 +358,7 @@
   //   }
   // return 0;
 #else
-  return fs->bc_->Readblk(blk_addr, page->data);
+  return fs->GetBc().Readblk(blk_addr, page->data);
 #endif
 }
 
@@ -518,7 +516,7 @@
 #endif
 
   do {
-    fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDataWrtie)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataWrtie)]);
     if (IsDir()) {
       DecPageCount(&sbi, CountType::kDirtyDents);
 #if 0  // porting needed
@@ -531,7 +529,7 @@
       // wbc->pages_skipped++;
       // set_page_dirty(page);
 #endif
-      FlushDirtyDataPage(Vfs(), page);
+      ZX_ASSERT(0);
     }
   } while (false);
 
@@ -604,7 +602,8 @@
 #endif
 
   do {
-    fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDataNew)]);
+    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) {
diff --git a/dir.cc b/dir.cc
index 15ee24b..627a9a0 100644
--- a/dir.cc
+++ b/dir.cc
@@ -143,8 +143,10 @@
   unsigned int max_depth;
   unsigned int level;
 
-  if (TestFlag(InodeInfoFlag::kInlineDentry))
+  fs::SharedLock read_lock(io_lock_);
+  if (TestFlag(InodeInfoFlag::kInlineDentry)) {
     return FindInInlineDir(name, res_page);
+  }
 
   if (npages == 0)
     return nullptr;
@@ -207,7 +209,8 @@
 void Dir::SetLink(DirEntry *de, Page *page, VnodeF2fs *vnode) {
   SbInfo &sbi = Vfs()->GetSbInfo();
 
-  fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
+  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);
 #endif
@@ -363,6 +366,8 @@
 
   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;
 
@@ -392,7 +397,8 @@
     bidx = DirBlockIndex(level, (dentry_hash % nbucket));
 
     for (block = bidx; block <= (bidx + nblock - 1); block++) {
-      fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
+      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;
       }
@@ -465,13 +471,14 @@
   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)) {
     DeleteInlineEntry(dentry, page, vnode);
     return;
   }
 
-  fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDentryOps)]);
-
 #if 0  // porting needed
   // lock_page(page);
 #endif
@@ -637,6 +644,8 @@
   zx_status_t ret = ZX_OK;
   bool done = false;
 
+  fs::SharedLock read_lock(io_lock_);
+
   if (TestFlag(InodeInfoFlag::kInlineDentry))
     return ReadInlineDir(cookie, dirents, len, out_actual);
 
diff --git a/dir.h b/dir.h
index ec210c0..1b6059e 100644
--- a/dir.h
+++ b/dir.h
@@ -43,7 +43,8 @@
   void fbl_recycle() { RecycleNode(); }
 
   zx_status_t Lookup(std::string_view name, fbl::RefPtr<fs::Vnode> *out) final;
-  zx_status_t Readdir(fs::VdirCookie *cookie, void *dirents, size_t len, size_t *out_actual) final;
+  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;
@@ -60,10 +61,10 @@
                         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);
+  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);
+  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);
@@ -72,8 +73,8 @@
 #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);
-  void DeleteEntry(DirEntry *dentry, Page *page, VnodeF2fs *vnode);
+  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();
 
diff --git a/f2fs.h b/f2fs.h
index c3361fa..056b677 100644
--- a/f2fs.h
+++ b/f2fs.h
@@ -97,72 +97,67 @@
   [[nodiscard]] static zx_status_t Create(std::unique_ptr<f2fs::Bcache> bc,
                                           const MountOptions &options, std::unique_ptr<F2fs> *out);
 
+  void SetUnmountCallback(fbl::Closure closure) { on_unmount_ = std::move(closure); }
+  void Shutdown(fs::Vfs::ShutdownCallback cb) final;
+
+  void SetQueryService(fbl::RefPtr<QueryService> svc) { query_svc_ = std::move(svc); }
+  void SetAdminService(fbl::RefPtr<AdminService> svc) { admin_svc_ = std::move(svc); }
+
+  void CheckNidRange(const nid_t &nid);
+  zx_status_t GetFsId(zx::event *out_fs_id) const;
+  uint64_t GetFsIdLegacy() const { return fs_id_legacy_; }
+
+  VnodeCache &GetVCache() { return vnode_cache_; }
   inline zx_status_t InsertVnode(VnodeF2fs *vn) { return vnode_cache_.Add(vn); }
-
   inline void EvictVnode(VnodeF2fs *vn) { __UNUSED zx_status_t status = vnode_cache_.Evict(vn); }
-
   inline zx_status_t LookupVnode(ino_t ino, fbl::RefPtr<VnodeF2fs> *out) {
     return vnode_cache_.Lookup(ino, out);
   }
 
-  void GetNodeInfo(nid_t nid, NodeInfo *ni);
-
-  void SetUnmountCallback(fbl::Closure closure) { on_unmount_ = std::move(closure); }
-  void Shutdown(fs::Vfs::ShutdownCallback cb) final;
-
-  // TODO(unknown): non-public member variables
-  std::unique_ptr<f2fs::Bcache> bc_;
-
+  void ResetBc(std::unique_ptr<f2fs::Bcache> *out = nullptr) {
+    if (out == nullptr) {
+      bc_.reset();
+      return;
+    }
+    *out = std::move(bc_);
+  };
+  Bcache &GetBc() { return *bc_; }
   SuperBlock &RawSb() { return *raw_sb_; }
   SbInfo &GetSbInfo() { return *sbi_; }
   SegMgr &Segmgr() { return *seg_mgr_; }
   NodeMgr &Nodemgr() { return *node_mgr_; }
 
-  zx_status_t GetFsId(zx::event *out_fs_id) const;
-  uint64_t GetFsIdLegacy() const { return fs_id_legacy_; }
-
-#if 0  // porting needed
-  // void InitOnce(void *foo);
-  // VnodeF2fs *F2fsAllocInode();
-  // static void F2fsICallback(rcu_head *head);
-  // void F2fsDestroyInode(inode *inode);
-#endif
-
+  // super.cc
   void PutSuper();
   zx_status_t SyncFs(int sync);
-#if 0  // porting needed
-  // int F2fsStatfs(dentry *dentry /*, kstatfs *buf*/);
-  // int F2fsShowOptions(/*seq_file *seq*/);
-  // VnodeF2fs *F2fsNfsGetInode(uint64_t ino, uint32_t generation);
-  // dentry *F2fsFhToDentry(fid *fid, int fh_len, int fh_type);
-  // dentry *F2fsFhToParent(fid *fid, int fh_len, int fh_type);
-#endif
-  loff_t MaxFileSize(unsigned bits);
   int SanityCheckRawSuper();
   int SanityCheckCkpt();
   void InitSbInfo();
   zx_status_t FillSuper();
   void ParseOptions();
 #if 0  // porting needed
-  // dentry *F2fsMount(file_system_type *fs_type, int flags,
-  //     const char *dev_name, void *data);
-  // int InitInodecache(void);
-  // void DestroyInodecache(void);
-  // int /*__init*/ initF2fsFs(void);
-  // void /*__exit*/ exitF2fsFs(void);
+  void InitOnce(void *foo);
+  VnodeF2fs *F2fsAllocInode();
+  static void F2fsICallback(rcu_head *head);
+  void F2fsDestroyInode(inode *inode);
+  int F2fsStatfs(dentry *dentry /*, kstatfs *buf*/);
+  int F2fsShowOptions(/*seq_file *seq*/);
+  VnodeF2fs *F2fsNfsGetInode(uint64_t ino, uint32_t generation);
+  dentry *F2fsFhToDentry(fid *fid, int fh_len, int fh_type);
+  dentry *F2fsFhToParent(fid *fid, int fh_len, int fh_type);
+  dentry *F2fsMount(file_system_type *fs_type, int flags,
+       const char *dev_name, void *data);
+  int InitInodecache(void);
+  void DestroyInodecache(void);
+  int /*__init*/ initF2fsFs(void);
+  void /*__exit*/ exitF2fsFs(void);
 #endif
 
   // checkpoint.cc
   Page *GetMetaPage(pgoff_t index);
   Page *GrabMetaPage(pgoff_t index);
   zx_status_t F2fsWriteMetaPage(Page *page, WritebackControl *wbc);
-#if 0  // porting needed
-  // int F2fsWriteMetaPages(address_space *mapping, WritebackControl *wbc);
-#endif
   int64_t SyncMetaPages(PageType type, long nr_to_write);
-#if 0  // porting needed
-  // int F2fsSetMetaPageDirty(Page *page);
-#endif
   zx_status_t CheckOrphanSpace();
   void AddOrphanInode(VnodeF2fs *vnode);
   void AddOrphanInode(nid_t ino);
@@ -172,10 +167,6 @@
   void WriteOrphanInodes(block_t start_blk);
   zx_status_t GetValidCheckpoint();
   Page *ValidateCheckpoint(block_t cp_addr, uint64_t *version);
-#if 0  // porting needed
-  // void SetDirtyDirPage(VnodeF2fs *vnode, Page *page);
-  // void RemoveDirtyDirInode(VnodeF2fs *vnode);
-#endif
   void SyncDirtyDirInodes();
   void BlockOperations();
   void UnblockOperations();
@@ -183,6 +174,10 @@
   void WriteCheckpoint(bool blocked, bool is_umount);
   void InitOrphanInfo();
 #if 0  // porting needed
+  int F2fsWriteMetaPages(address_space *mapping, WritebackControl *wbc);
+  int F2fsSetMetaPageDirty(Page *page);
+  void SetDirtyDirPage(VnodeF2fs *vnode, Page *page);
+  void RemoveDirtyDirInode(VnodeF2fs *vnode);
   int CreateCheckpointCaches();
   void DestroyCheckpointCaches();
 #endif
@@ -202,20 +197,16 @@
   // block count
   void DecValidBlockCount(VnodeF2fs *vnode, block_t count);
   zx_status_t IncValidBlockCount(VnodeF2fs *vnode, block_t count);
-
   block_t ValidUserBlocks();
   uint64_t ValidNodeCount();
   void IncValidInodeCount();
   void DecValidInodeCount();
   uint64_t ValidInodeCount();
-
-  void CheckNidRange(const nid_t &nid);
-
-  VnodeCache &GetVCache() { return vnode_cache_; }
-  void SetQueryService(fbl::RefPtr<QueryService> svc) { query_svc_ = std::move(svc); }
-  void SetAdminService(fbl::RefPtr<AdminService> svc) { admin_svc_ = std::move(svc); }
+  loff_t MaxFileSize(unsigned bits);
 
  private:
+  std::unique_ptr<f2fs::Bcache> bc_;
+
   fbl::RefPtr<VnodeF2fs> root_vnode_;
   fbl::Closure on_unmount_{};
   MountOptions mount_options_;
diff --git a/f2fs_internal.h b/f2fs_internal.h
index 54a7160..4aaeb7a 100644
--- a/f2fs_internal.h
+++ b/f2fs_internal.h
@@ -74,10 +74,10 @@
 
 // for in-memory extent cache entry
 struct ExtentInfo {
-  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
+  fs::SharedMutex 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
 };
 
 // i_advise uses Fadvise:xxx bit. We can add additional hints later.
@@ -108,16 +108,16 @@
 
   // NAT cache management
   RadixTreeRoot nat_root;         // root of the nat entry cache
-  rwlock_t nat_tree_lock;         // protect nat_tree_lock
+  fs::SharedMutex 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
-  spinlock_t free_nid_list_lock;  // protect free nid list
-  uint64_t fcnt = 0;              // the number of free node id
-  mtx_t build_lock;               // lock for build free nids
+  list_node_t free_nid_list;           // a list for free nids
+  fs::SharedMutex free_nid_list_lock;  // protect free nid list
+  uint64_t fcnt = 0;                   // the number of free node id
+  fbl::Mutex build_lock;               // lock for build free nids
 
   // for checkpoint
   char *nat_bitmap = nullptr;       // NAT bitmap pointer
@@ -179,9 +179,6 @@
   struct DirtySeglistInfo *dirty_info = nullptr;  // dirty 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
-
   block_t seg0_blkaddr = 0;  // block address of 0'th segment
   block_t main_blkaddr = 0;  // start block address of main area
   block_t ssa_blkaddr = 0;   // start block address of SSA area
@@ -268,20 +265,20 @@
   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 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
+  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
 
   // for orphan inode management
-  list_node_t orphan_inode_list;  // orphan inode list
-  mtx_t orphan_inode_mutex;       // for orphan inode list
-  uint64_t n_orphans = 0;         // # of orphan inodes
+  list_node_t orphan_inode_list;       // orphan inode list
+  fs::SharedMutex orphan_inode_mutex;  // for orphan inode list
+  uint64_t n_orphans = 0;              // # of orphan inodes
 
   // for directory inode management
   list_node_t dir_inode_list;  // dir inode list
-  spinlock_t dir_inode_lock;   // for dir inode list lock
+  fbl::Mutex dir_inode_lock;   // for dir inode list lock
   uint64_t n_dirty_dirs = 0;   // # of dir inodes
 
   // basic file system units
@@ -311,7 +308,7 @@
   uint64_t mount_opt = 0;  // set with kMountOptxxxx bits according to F2fs::mount_options_
 
   // for cleaning operations
-  mtx_t gc_mutex;                              // mutex for GC
+  fs::SharedMutex gc_mutex;                    // mutex for GC
   struct F2fsGc_kthread *gc_thread = nullptr;  // GC thread
 
   // for stat information.
@@ -322,23 +319,9 @@
   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
+  fbl::Mutex stat_lock;                        // lock for stat operations
 };
 
-// Inline functions
-
-// static inline InodeInfo *F2FS_I(VnodeF2fs *vnode)
-// {
-//   // TODO: IMPL
-// 	//return container_of(inode, InodeInfo, vfs_inode);
-//   return &vnode->fi;
-// }
-
-// static inline SbInfo *F2FS_SB(super_block *sb)
-//{
-//  return (SbInfo *)sb->s_fs_info;
-//}
-
 static inline const SuperBlock *RawSuper(SbInfo *sbi) {
   return static_cast<const SuperBlock *>(sbi->raw_super);
 }
@@ -369,29 +352,18 @@
 
 static inline void mutex_lock_op(SbInfo *sbi, LockType t)
     TA_ACQ(&sbi->fs_lock[static_cast<int>(t)]) {
-  // TODO: IMPL
-  // mutex_lock_nested(&sbi->fs_lock[static_cast<int>(t)], t);
-  mtx_lock(&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();
 }
 
 static inline void mutex_unlock_op(SbInfo *sbi, LockType t)
     TA_REL(&sbi->fs_lock[static_cast<int>(t)]) {
-  mtx_unlock(&sbi->fs_lock[static_cast<int>(t)]);
+  sbi->fs_lock[static_cast<int>(t)].unlock();
 }
 
 constexpr uint32_t kDefaultAllocatedBlocks = 1;
 
-// Check whether the inode has blocks or not
-
-// [[maybe_unused]]
-// static inline int HasBlocks(inode *inode)
-// {
-// 	if (F2FS_I(inode)->i_xattr_nid)
-// 		return (inode->i_blocks > kDefaultAllocatedBlocks + 1);
-// 	else
-// 		return (inode->i_blocks > kDefaultAllocatedBlocks);
-// }
-
 [[maybe_unused]] static inline void IncPageCount(SbInfo *sbi, int count_type) {
   // TODO: IMPL
   // AtomicInc(&sbi->nr_pages[count_type]);
diff --git a/f2fs_lib.h b/f2fs_lib.h
index 44acc5f..53f7b1b 100644
--- a/f2fs_lib.h
+++ b/f2fs_lib.h
@@ -8,10 +8,9 @@
 #include "f2fs_types.h"
 
 namespace f2fs {
-/*
- * Page cache helper
- * TODO: Need to be changed once Pager is available
- */
+
+// Page cache helper
+// TODO: Need to be changed once Pager is available
 inline Page *GrabCachePage(void *vnode, uint32_t nid, uint32_t /*TODO pgoff_t*/ index) {
   Page *page = new Page();
   page->index = index;
@@ -42,14 +41,10 @@
   // TODO: Once Pager is availabe, it could be used for wb synchronization
 }
 
-/*
- * Checkpoint
- */
+// Checkpoint
 inline int64_t VerAfter(uint64_t a, uint64_t b) { return (static_cast<int64_t>(a - b) > 0); }
 
-/*
- * CRC
- */
+// CRC
 inline unsigned int F2fsCalCrc32(unsigned int crc, void *buff, unsigned int len) {
   int i;
   unsigned char *p = static_cast<unsigned char *>(buff);
@@ -69,41 +64,15 @@
   return F2fsCrc32(buff, buff_size) == blk_crc;
 }
 
-/*
- * Error code in pointer variables
- * TODO: should remove them. there is no room for errno in Fuchsia.
- *
- */
+// Error code in pointer variable
+// TODO: should remove them. there is no room for errno in Fuchsia.
 inline bool IsErr(const void *ptr) { return (ptr == nullptr); }
 
 inline long PtrErr(const void *ptr) { return 0; }
 
 inline void *ErrPtr(long error) { return nullptr; }
 
-/*
- * Every lock is using mutex.
- * TODO: need to find more appropriate methods for rw lock.
- */
-static inline void SpinLockInit(spinlock_t *lock) { mtx_init(lock, mtx_plain); }
-
-static inline void SpinLock(spinlock_t *lock) TA_ACQ(lock) { mtx_lock(lock); }
-
-static inline void SpinUnlock(spinlock_t *lock) TA_REL(lock) { mtx_unlock(lock); }
-
-static inline void RwlockInit(rwlock_t *lock) { mtx_init(lock, mtx_plain); }
-
-static inline void ReadLock(rwlock_t *lock) TA_ACQ(lock) { mtx_lock(lock); }
-
-static inline void WriteLock(rwlock_t *lock) TA_ACQ(lock) { mtx_lock(lock); }
-
-static inline void ReadUnlock(rwlock_t *lock) TA_REL(lock) { mtx_unlock(lock); }
-
-static inline void WriteUnlock(rwlock_t *lock) TA_REL(lock) { mtx_unlock(lock); }
-
-/*
- * Bitmap operations
- * TODO: some operations (e.g., test_and_set) requires atomicity
- */
+// Bitmap operations
 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)); }
 
@@ -250,9 +219,7 @@
   atomic_fetch_sub_explicit(t, 1, std::memory_order_relaxed);
 }
 
-/*
- * List operations
- */
+// List operations
 inline void list_move_tail(list_node_t *list, list_node_t *item) {
   list_delete(item);
   list_add_tail(list, item);
@@ -265,9 +232,7 @@
   list->next = item;
 }
 
-/*
- * Zero segment
- */
+// Zero segment
 static inline void ZeroUserSegments(Page *page, unsigned start1, unsigned end1, unsigned start2,
                                     unsigned end2) {
   char *data = (char *)PageAddress(page);
@@ -289,9 +254,7 @@
   ZeroUserSegments(page, start, start + size, 0, 0);
 }
 
-/*
- * Inode
- */
+// Inode
 static inline void *Igrab(void *vnode) {
   // TODO: need to add ref. count if vnode is valid
   return vnode;
diff --git a/f2fs_types.h b/f2fs_types.h
index 4d70081..b8089b6 100644
--- a/f2fs_types.h
+++ b/f2fs_types.h
@@ -23,8 +23,6 @@
 using pgoff_t = unsigned long;
 using atomic_t = std::atomic_int;
 using umode_t = uint16_t;
-using spinlock_t = mtx_t;
-using rwlock_t = mtx_t;
 // Radix Tree
 struct RadixTreeRoot {};
 
diff --git a/file.cc b/file.cc
index 2325ab5..52f34d1 100644
--- a/file.cc
+++ b/file.cc
@@ -323,7 +323,7 @@
 
   for (n = blk_start; n <= blk_end; n++) {
     bool is_empty_page = false;
-
+    fs::SharedLock read_lock(io_lock_);
     if (zx_status_t ret = GetLockDataPage(n, &data_page); ret != ZX_OK) {
       if (ret == ZX_ERR_NOT_FOUND) {  // truncated page
         is_empty_page = true;
@@ -433,6 +433,7 @@
     off_in_buf += cur_len;
     left -= cur_len;
 
+    std::lock_guard write_lock(io_lock_);
     SetSize(std::max(static_cast<size_t>(GetSize()), offset + off_in_buf));
 #if 0  // porting needed
     // set_page_dirty(data_page, Vfs());
diff --git a/namei.cc b/namei.cc
index 338f1b1..4be5915 100644
--- a/namei.cc
+++ b/namei.cc
@@ -15,7 +15,7 @@
   VnodeF2fs *vnode = nullptr;
 
   do {
-    fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
     if (!Vfs()->Nodemgr().AllocNid(&ino)) {
       Iput(vnode);
       return ZX_ERR_NO_SPACE;
@@ -51,7 +51,7 @@
   if (TestOpt(&sbi, kMountInlineDentry) && vnode->IsDir())
     vnode->SetFlag(InodeInfoFlag::kInlineDentry);
 
-  SetFlag(InodeInfoFlag::kNewInode);
+  vnode->SetFlag(InodeInfoFlag::kNewInode);
   Vfs()->InsertVnode(vnode);
   vnode->MarkInodeDirty();
 
@@ -434,7 +434,7 @@
   }
 
   do {
-    fbl::AutoLock rlock(&sbi.fs_lock[static_cast<int>(LockType::kRename)]);
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kRename)]);
 
     new_entry = new_dir->FindEntry(newname, &new_page);
     if (new_entry) {
diff --git a/node.cc b/node.cc
index 8d21b9a..18f7e3c 100644
--- a/node.cc
+++ b/node.cc
@@ -24,19 +24,17 @@
   block_t valid_block_count;
   uint32_t ValidNodeCount;
 
-  SpinLock(&sbi->stat_lock);
+  fbl::AutoLock stat_lock(&sbi->stat_lock);
 
   valid_block_count = sbi->total_valid_block_count + static_cast<block_t>(count);
   sbi->alloc_valid_block_count += static_cast<block_t>(count);
   ValidNodeCount = sbi->total_valid_node_count + count;
 
   if (valid_block_count > sbi->user_block_count) {
-    SpinUnlock(&sbi->stat_lock);
     return false;
   }
 
   if (ValidNodeCount > sbi->total_node_count) {
-    SpinUnlock(&sbi->stat_lock);
     return false;
   }
 
@@ -44,7 +42,6 @@
     vnode->IncBlocks(count);
   sbi->total_valid_node_count = ValidNodeCount;
   sbi->total_valid_block_count = valid_block_count;
-  SpinUnlock(&sbi->stat_lock);
 
   return true;
 }
@@ -59,10 +56,10 @@
 
   if (nm_i->fcnt <= 0)
     return ZX_ERR_OUT_OF_RANGE;
-  SpinLock(&nm_i->free_nid_list_lock);
+
+  std::lock_guard free_nid_lock(nm_i->free_nid_list_lock);
   fnid = containerof(nm_i->free_nid_list.next, FreeNid, list);
   *nid = fnid->nid;
-  SpinUnlock(&nm_i->free_nid_list_lock);
   return ZX_OK;
 }
 
@@ -318,7 +315,7 @@
 }
 
 inline void NodeMgr::DecValidNodeCount(SbInfo *sbi, VnodeF2fs *vnode, uint32_t count) {
-  SpinLock(&sbi->stat_lock);
+  fbl::AutoLock stat_lock(&sbi->stat_lock);
 
   // TODO: IMPL
   ZX_ASSERT(!(sbi->total_valid_block_count < count));
@@ -327,8 +324,6 @@
   vnode->DecBlocks(count);
   sbi->total_valid_node_count -= count;
   sbi->total_valid_block_count -= count;
-
-  SpinUnlock(&sbi->stat_lock);
 }
 
 /*
@@ -499,11 +494,10 @@
   NatEntry *e;
   int is_cp = 1;
 
-  ReadLock(&nm_i->nat_tree_lock);
+  fs::SharedLock nat_lock(nm_i->nat_tree_lock);
   e = LookupNatCache(nm_i, nid);
   if (e && !e->checkpointed)
     is_cp = 0;
-  ReadUnlock(&nm_i->nat_tree_lock);
   return is_cp;
 }
 
@@ -532,12 +526,11 @@
 void NodeMgr::CacheNatEntry(NmInfo *nm_i, nid_t nid, RawNatEntry *ne) {
   NatEntry *e;
 retry:
-  WriteLock(&nm_i->nat_tree_lock);
+  std::lock_guard lock(nm_i->nat_tree_lock);
   e = LookupNatCache(nm_i, nid);
   if (!e) {
     e = GrabNatEntry(nm_i, nid);
     if (!e) {
-      WriteUnlock(&nm_i->nat_tree_lock);
       goto retry;
     }
     NatSetBlkaddr(e, LeToCpu(ne->block_addr));
@@ -545,7 +538,6 @@
     NatSetVersion(e, ne->version);
     e->checkpointed = true;
   }
-  WriteUnlock(&nm_i->nat_tree_lock);
 }
 
 void NodeMgr::SetNodeAddr(NodeInfo *ni, block_t new_blkaddr) {
@@ -553,12 +545,11 @@
   NmInfo *nm_i = GetNmInfo(&sbi);
   NatEntry *e;
 retry:
-  WriteLock(&nm_i->nat_tree_lock);
+  std::lock_guard nat_lock(nm_i->nat_tree_lock);
   e = LookupNatCache(nm_i, ni->nid);
   if (!e) {
     e = GrabNatEntry(nm_i, ni->nid);
     if (!e) {
-      WriteUnlock(&nm_i->nat_tree_lock);
       goto retry;
     }
     e->ni = *ni;
@@ -593,7 +584,6 @@
   /* change address */
   NatSetBlkaddr(e, new_blkaddr);
   SetNatCacheDirty(nm_i, e);
-  WriteUnlock(&nm_i->nat_tree_lock);
 }
 
 int NodeMgr::TryToFreeNats(int nr_shrink) {
@@ -603,7 +593,7 @@
   if (nm_i->nat_cnt < 2 * kNmWoutThreshold)
     return 0;
 
-  WriteLock(&nm_i->nat_tree_lock);
+  std::lock_guard nat_lock(nm_i->nat_tree_lock);
   while (nr_shrink && !list_is_empty(&nm_i->nat_entries)) {
     NatEntry *ne;
     // ne = list_first_entry(&nm_i->nat_entries,
@@ -612,7 +602,6 @@
     DelFromNatCache(nm_i, ne);
     nr_shrink--;
   }
-  WriteUnlock(&nm_i->nat_tree_lock);
   return nr_shrink;
 }
 
@@ -633,38 +622,36 @@
 
   ni->nid = nid;
 
-  /* Check nat cache */
-  ReadLock(&nm_i->nat_tree_lock);
-  e = LookupNatCache(nm_i, nid);
-  if (e) {
-    ni->ino = NatGetIno(e);
-    ni->blk_addr = NatGetBlkaddr(e);
-    ni->version = NatGetVersion(e);
+  {
+    /* Check nat cache */
+    fs::SharedLock nat_lock(nm_i->nat_tree_lock);
+    e = LookupNatCache(nm_i, nid);
+    if (e) {
+      ni->ino = NatGetIno(e);
+      ni->blk_addr = NatGetBlkaddr(e);
+      ni->version = NatGetVersion(e);
+      return;
+    }
   }
-  ReadUnlock(&nm_i->nat_tree_lock);
-  if (e)
-    return;
 
-  /* Check current segment summary */
-  mtx_lock(&curseg->curseg_mutex);
-  i = SegMgr::LookupJournalInCursum(sum, JournalType::kNatJournal, nid, 0);
-  if (i >= 0) {
-    ne = NatInJournal(sum, i);
+  {
+    /* Check current segment summary */
+    fbl::AutoLock curseg_lock(&curseg->curseg_mutex);
+    i = SegMgr::LookupJournalInCursum(sum, JournalType::kNatJournal, nid, 0);
+    if (i >= 0) {
+      ne = NatInJournal(sum, i);
+      NodeInfoFromRawNat(ni, &ne);
+    }
+  }
+  if (i < 0) {
+    /* Fill NodeInfo from nat page */
+    page = GetCurrentNatPage(start_nid);
+    nat_blk = static_cast<NatBlock *>(PageAddress(page));
+    ne = nat_blk->entries[nid - start_nid];
+
     NodeInfoFromRawNat(ni, &ne);
+    F2fsPutPage(page, 1);
   }
-  mtx_unlock(&curseg->curseg_mutex);
-  if (i >= 0)
-    goto cache;
-
-  /* Fill NodeInfo from nat page */
-  page = GetCurrentNatPage(start_nid);
-  nat_blk = static_cast<NatBlock *>(PageAddress(page));
-  ne = nat_blk->entries[nid - start_nid];
-
-  NodeInfoFromRawNat(ni, &ne);
-  F2fsPutPage(page, 1);
-
-cache:
   /* cache nat entry */
   CacheNatEntry(GetNmInfo(&sbi), nid, &ne);
 }
@@ -743,9 +730,7 @@
   return zx::ok(level);
 }
 
-/*
- * Caller should call f2fs_put_dnode(dn).
- */
+// 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];
@@ -778,11 +763,10 @@
     bool done = false;
 
     if (!nids[i] && !ro) {
-      mutex_lock_op(&sbi, LockType::kNodeNew);
+      fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
 
       /* alloc new node */
       if (!AllocNid(&(nids[i]))) {
-        mutex_unlock_op(&sbi, LockType::kNodeNew);
         err = ZX_ERR_NO_SPACE;
         goto release_pages;
       }
@@ -792,13 +776,11 @@
       err = NewNodePage(dn, noffset[i], &npage[i]);
       if (err) {
         AllocNidFailed(nids[i]);
-        mutex_unlock_op(&sbi, LockType::kNodeNew);
         goto release_pages;
       }
 
       SetNid(parent, offset[i - 1], nids[i], i == 1);
       AllocNidDone(nids[i]);
-      mutex_unlock_op(&sbi, LockType::kNodeNew);
       done = true;
     } else if (ro && i == level && level > 1) {
 #if 0  // porting needed
@@ -1127,10 +1109,9 @@
   DnodeOfData dn;
   zx_status_t err = 0;
 
-  mutex_lock_op(&sbi, LockType::kNodeTrunc);
+  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeTrunc)]);
   err = GetNodePage(ino, &page);
   if (err) {
-    mutex_unlock_op(&sbi, LockType::kNodeTrunc);
     return err;
   }
 
@@ -1139,7 +1120,6 @@
     err = GetNodePage(nid, &npage);
 
     if (err) {
-      mutex_unlock_op(&sbi, LockType::kNodeTrunc);
       return err;
     }
 
@@ -1163,7 +1143,6 @@
   } else {
     ZX_ASSERT(0);
   }
-  mutex_unlock_op(&sbi, LockType::kNodeTrunc);
   return ZX_OK;
 }
 
@@ -1175,10 +1154,11 @@
 
   /* allocate inode page for new inode */
   SetNewDnode(&dn, child, nullptr, nullptr, child->Ino());
-  mutex_lock_op(&sbi, LockType::kNodeNew);
-  err = NewNodePage(&dn, 0, &page);
-  parent->InitDentInode(child, page);
-  mutex_unlock_op(&sbi, LockType::kNodeNew);
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeNew)]);
+    err = NewNodePage(&dn, 0, &page);
+    parent->InitDentInode(child, page);
+  }
   if (err)
     return err;
   F2fsPutPage(page, 1);
@@ -1460,7 +1440,7 @@
 #endif
   WaitOnPageWriteback(page);
 
-  mutex_lock_op(&sbi, LockType::kNodeWrite);
+  fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kNodeWrite)]);
 
   /* get old block addr of this node page */
   nid = NidOfNode(page);
@@ -1471,7 +1451,6 @@
 
   /* This page is already truncated */
   if (ni.blk_addr == kNullAddr) {
-    mutex_unlock_op(&sbi, LockType::kNodeWrite);
     return ZX_OK;
   }
 
@@ -1482,7 +1461,6 @@
   SetNodeAddr(&ni, new_addr);
   DecPageCount(&sbi, CountType::kDirtyNodes);
 
-  mutex_unlock_op(&sbi, LockType::kNodeWrite);
   // TODO: IMPL
   // unlock_page(page);
   return ZX_OK;
@@ -1587,9 +1565,8 @@
   i->nid = nid;
   i->state = static_cast<int>(NidState::kNidNew);
 
-  SpinLock(&nm_i->free_nid_list_lock);
+  std::lock_guard free_nid_lock(nm_i->free_nid_list_lock);
   if (LookupFreeNidList(nid, &nm_i->free_nid_list)) {
-    SpinUnlock(&nm_i->free_nid_list_lock);
 #if 0  // porting needed
     // kmem_cache_free(free_nid_slab, i);
 #endif
@@ -1598,19 +1575,17 @@
   }
   list_add_tail(&nm_i->free_nid_list, &i->list);
   nm_i->fcnt++;
-  SpinUnlock(&nm_i->free_nid_list_lock);
   return 1;
 }
 
 void NodeMgr::RemoveFreeNid(NmInfo *nm_i, nid_t nid) {
   FreeNid *i;
-  SpinLock(&nm_i->free_nid_list_lock);
+  std::lock_guard free_nid_lock(nm_i->free_nid_list_lock);
   i = LookupFreeNidList(nid, &nm_i->free_nid_list);
   if (i && i->state == static_cast<int>(NidState::kNidNew)) {
     DelFromFreeNidList(i);
     nm_i->fcnt--;
   }
-  SpinUnlock(&nm_i->free_nid_list_lock);
 }
 
 int NodeMgr::ScanNatPage(NmInfo *nm_i, Page *nat_page, nid_t start_nid) {
@@ -1670,28 +1645,28 @@
 
   nm_i->next_scan_nid = nid;
 
-  /* find free nids from current sum_pages */
-  mtx_lock(&curseg->curseg_mutex);
-  for (i = 0; i < NatsInCursum(sum); i++) {
-    block_t addr = LeToCpu(NatInJournal(sum, i).block_addr);
-    nid = LeToCpu(NidInJournal(sum, i));
-    if (addr == kNullAddr) {
-      AddFreeNid(nm_i, nid);
-    } else {
-      RemoveFreeNid(nm_i, nid);
+  {
+    // find free nids from current sum_pages
+    fbl::AutoLock curseg_lock(&curseg->curseg_mutex);
+    for (i = 0; i < NatsInCursum(sum); i++) {
+      block_t addr = LeToCpu(NatInJournal(sum, i).block_addr);
+      nid = LeToCpu(NidInJournal(sum, i));
+      if (addr == kNullAddr) {
+        AddFreeNid(nm_i, nid);
+      } else {
+        RemoveFreeNid(nm_i, nid);
+      }
     }
   }
-  mtx_unlock(&curseg->curseg_mutex);
 
   /* remove the free nids from current allocated nids */
   list_for_every_entry_safe (&nm_i->free_nid_list, fnid, next_fnid, FreeNid, list) {
     NatEntry *ne;
 
-    ReadLock(&nm_i->nat_tree_lock);
+    fs::SharedLock lock(nm_i->nat_tree_lock);
     ne = LookupNatCache(nm_i, fnid->nid);
     if (ne && NatGetBlkaddr(ne) != kNullAddr)
       RemoveFreeNid(nm_i, fnid->nid);
-    ReadUnlock(&nm_i->nat_tree_lock);
   }
 }
 
@@ -1705,29 +1680,27 @@
   NmInfo *nm_i = GetNmInfo(&sbi);
   FreeNid *i = nullptr;
   list_node_t *this_list;
-retry:
-  mtx_lock(&nm_i->build_lock);
+retry : {
+  fbl::AutoLock lock(&nm_i->build_lock);
   if (!nm_i->fcnt) {
     /* scan NAT in order to build free nid list */
     BuildFreeNids();
     if (!nm_i->fcnt) {
-      mtx_unlock(&nm_i->build_lock);
       return false;
     }
   }
-  mtx_unlock(&nm_i->build_lock);
+}
 
   /*
    * We check fcnt again since previous check is racy as
    * we didn't hold free_nid_list_lock. So other thread
    * could consume all of free nids.
    */
-  SpinLock(&nm_i->free_nid_list_lock);
   if (!nm_i->fcnt) {
-    SpinUnlock(&nm_i->free_nid_list_lock);
     goto retry;
   }
 
+  std::lock_guard lock(nm_i->free_nid_list_lock);
   ZX_ASSERT(!list_is_empty(&nm_i->free_nid_list));
 
   list_for_every(&nm_i->free_nid_list, this_list) {
@@ -1740,7 +1713,6 @@
   *nid = i->nid;
   i->state = static_cast<int>(NidState::kNidAlloc);
   nm_i->fcnt--;
-  SpinUnlock(&nm_i->free_nid_list_lock);
   return true;
 }
 
@@ -1752,13 +1724,12 @@
   NmInfo *nm_i = GetNmInfo(&sbi);
   FreeNid *i;
 
-  SpinLock(&nm_i->free_nid_list_lock);
+  std::lock_guard free_nid_lock(nm_i->free_nid_list_lock);
   i = LookupFreeNidList(nid, &nm_i->free_nid_list);
   if (i) {
     ZX_ASSERT(i->state == static_cast<int>(NidState::kNidAlloc));
     DelFromFreeNidList(i);
   }
-  SpinUnlock(&nm_i->free_nid_list_lock);
 }
 
 /**
@@ -1875,15 +1846,15 @@
   SummaryBlock *sum = curseg->sum_blk;
   int i;
 
-  fbl::AutoLock lock(&curseg->curseg_mutex);
+  fbl::AutoLock curseg_lock(&curseg->curseg_mutex);
 
-  ReadLock(&nm_i->nat_tree_lock);
-  size_t dirty_nat_cnt = list_length(&nm_i->dirty_nat_entries);
-  if ((NatsInCursum(sum) + dirty_nat_cnt) <= kNatJournalEntries) {
-    ReadUnlock(&nm_i->nat_tree_lock);
-    return false;
+  {
+    fs::SharedLock nat_lock(nm_i->nat_tree_lock);
+    size_t dirty_nat_cnt = list_length(&nm_i->dirty_nat_entries);
+    if ((NatsInCursum(sum) + dirty_nat_cnt) <= kNatJournalEntries) {
+      return false;
+    }
   }
-  ReadUnlock(&nm_i->nat_tree_lock);
 
   for (i = 0; i < NatsInCursum(sum); i++) {
     NatEntry *ne = nullptr;
@@ -1891,22 +1862,19 @@
     nid_t nid = LeToCpu(NidInJournal(sum, i));
 
     while (!ne) {
-      WriteLock(&nm_i->nat_tree_lock);
+      std::lock_guard nat_lock(nm_i->nat_tree_lock);
       ne = LookupNatCache(nm_i, nid);
       if (ne) {
         SetNatCacheDirty(nm_i, ne);
-        WriteUnlock(&nm_i->nat_tree_lock);
       } else {
         ne = GrabNatEntry(nm_i, nid);
         if (!ne) {
-          WriteUnlock(&nm_i->nat_tree_lock);
           continue;
         }
         NatSetBlkaddr(ne, LeToCpu(raw_ne.block_addr));
         NatSetIno(ne, LeToCpu(raw_ne.ino));
         NatSetVersion(ne, raw_ne.version);
         SetNatCacheDirty(nm_i, ne);
-        WriteUnlock(&nm_i->nat_tree_lock);
       }
     }
   }
@@ -1931,7 +1899,7 @@
 #if 0  // porting needed
   //	if (!flushed)
 #endif
-  fbl::AutoLock lock(&curseg->curseg_mutex);
+  fbl::AutoLock curseg_lock(&curseg->curseg_mutex);
 
   // 1) flush dirty nat caches
   list_for_every_safe(&nm_i->dirty_nat_entries, cur, n) {
@@ -1993,17 +1961,17 @@
     }
 
     if (NatGetBlkaddr(ne) == kNullAddr) {
-      WriteLock(&nm_i->nat_tree_lock);
-      DelFromNatCache(nm_i, ne);
-      WriteUnlock(&nm_i->nat_tree_lock);
+      {
+        std::lock_guard nat_lock(nm_i->nat_tree_lock);
+        DelFromNatCache(nm_i, ne);
+      }
 
       // We can reuse this freed nid at this point
       AddFreeNid(GetNmInfo(&sbi), nid);
     } else {
-      WriteLock(&nm_i->nat_tree_lock);
+      std::lock_guard nat_lock(nm_i->nat_tree_lock);
       ClearNatCacheDirty(nm_i, ne);
       ne->checkpointed = true;
-      WriteUnlock(&nm_i->nat_tree_lock);
     }
   }
 #if 0  // porting needed
@@ -2042,10 +2010,6 @@
   list_initialize(&nm_i->nat_entries);
   list_initialize(&nm_i->dirty_nat_entries);
 
-  mtx_init(&nm_i->build_lock, mtx_plain);
-  SpinLockInit(&nm_i->free_nid_list_lock);
-  RwlockInit(&nm_i->nat_tree_lock);
-
   nm_i->bitmap_size = BitmapSize(&sbi, MetaBitmap::kNatBitmap);
   nm_i->init_scan_nid = LeToCpu(sbi.ckpt->next_free_nid);
   nm_i->next_scan_nid = LeToCpu(sbi.ckpt->next_free_nid);
@@ -2094,18 +2058,17 @@
   if (!nm_i)
     return;
 
-  /* destroy free nid list */
-  SpinLock(&nm_i->free_nid_list_lock);
+  // destroy free nid list
+  std::lock_guard free_nid_lock(nm_i->free_nid_list_lock);
   list_for_every_entry_safe (&nm_i->free_nid_list, i, next_i, FreeNid, list) {
     ZX_ASSERT(i->state != static_cast<int>(NidState::kNidAlloc));
     DelFromFreeNidList(i);
     nm_i->fcnt--;
   }
   ZX_ASSERT(!nm_i->fcnt);
-  SpinUnlock(&nm_i->free_nid_list_lock);
 
   /* destroy nat cache */
-  WriteLock(&nm_i->nat_tree_lock);
+  std::lock_guard nat_lock(nm_i->nat_tree_lock);
   while ((found = GangLookupNatCache(nm_i, nid, kNatvecSize, natvec))) {
     uint32_t idx;
     for (idx = 0; idx < found; idx++) {
@@ -2116,7 +2079,6 @@
   }
   // TODO: Check nm_i->nat_cnt
   // ZX_ASSERT(!nm_i->nat_cnt);
-  WriteUnlock(&nm_i->nat_tree_lock);
 
   delete[] nm_i->nat_bitmap;
   delete[] nm_i->nat_prev_bitmap;
diff --git a/query.cc b/query.cc
index e66ccf2..8aa265c 100644
--- a/query.cc
+++ b/query.cc
@@ -68,8 +68,8 @@
   char name_buf[fuchsia_io2::wire::kMaxPathLength];
   if (request->query & FilesystemInfoQuery::kDevicePath) {
     size_t name_len;
-    zx_status_t status =
-        f2fs_->bc_->device()->GetDevicePath(fuchsia_io2::wire::kMaxPathLength, name_buf, &name_len);
+    zx_status_t status = f2fs_->GetBc().device()->GetDevicePath(fuchsia_io2::wire::kMaxPathLength,
+                                                                name_buf, &name_len);
     if (status != ZX_OK) {
       completer.ReplyError(status);
       return;
diff --git a/segment.cc b/segment.cc
index d208195..f8db681 100644
--- a/segment.cc
+++ b/segment.cc
@@ -47,9 +47,8 @@
 
 inline uint32_t SegMgr::FindNextInuse(FreeSegmapInfo *free_i, uint32_t max, uint32_t segno) {
   uint32_t ret;
-  ReadLock(&free_i->segmap_lock);
+  fs::SharedLock segmap_lock(free_i->segmap_lock);
   ret = find_next_bit_le(free_i->free_segmap, max, segno);
-  ReadUnlock(&free_i->segmap_lock);
   return ret;
 }
 
@@ -60,7 +59,7 @@
   uint32_t start_segno = secno * sbi.segs_per_sec;
   uint32_t next;
 
-  WriteLock(&free_i->segmap_lock);
+  std::lock_guard segmap_lock(free_i->segmap_lock);
   clear_bit(segno, free_i->free_segmap);
   free_i->free_segments++;
 
@@ -69,7 +68,6 @@
     clear_bit(secno, free_i->free_secmap);
     free_i->free_sections++;
   }
-  WriteUnlock(&free_i->segmap_lock);
 }
 
 inline void SegMgr::SetInuse(uint32_t segno) {
@@ -89,7 +87,7 @@
   uint32_t start_segno = secno * sbi.segs_per_sec;
   uint32_t next;
 
-  WriteLock(&free_i->segmap_lock);
+  std::lock_guard segmap_lock(free_i->segmap_lock);
   if (test_and_clear_bit(segno, free_i->free_segmap)) {
     free_i->free_segments++;
 
@@ -99,20 +97,18 @@
         free_i->free_sections++;
     }
   }
-  WriteUnlock(&free_i->segmap_lock);
 }
 
 inline void SegMgr::SetTestAndInuse(uint32_t segno) {
   SbInfo &sbi = fs_->GetSbInfo();
   FreeSegmapInfo *free_i = GetFreeInfo(&sbi);
   uint32_t secno = segno / sbi.segs_per_sec;
-  WriteLock(&free_i->segmap_lock);
+  std::lock_guard segmap_lock(free_i->segmap_lock);
   if (!test_and_set_bit(segno, free_i->free_segmap)) {
     free_i->free_segments--;
     if (!test_and_set_bit(secno, free_i->free_secmap))
       free_i->free_sections--;
   }
-  WriteUnlock(&free_i->segmap_lock);
 }
 
 void SegMgr::GetSitBitmap(void *dst_addr) {
@@ -140,9 +136,8 @@
   FreeSegmapInfo *free_i = GetFreeInfo(&sbi);
   uint32_t free_segs;
 
-  ReadLock(&free_i->segmap_lock);
+  fs::SharedLock segmap_lock(free_i->segmap_lock);
   free_segs = free_i->free_segments;
-  ReadUnlock(&free_i->segmap_lock);
 
   return free_segs;
 }
@@ -157,9 +152,8 @@
   FreeSegmapInfo *free_i = GetFreeInfo(&sbi);
   uint32_t free_secs;
 
-  ReadLock(&free_i->segmap_lock);
+  fs::SharedLock segmap_lock(free_i->segmap_lock);
   free_secs = free_i->free_sections;
-  ReadUnlock(&free_i->segmap_lock);
 
   return free_secs;
 }
@@ -508,7 +502,7 @@
       dirty_i->nr_dirty[static_cast<int>(DirtyType::kPre)]--;
 
     if (TestOpt(&sbi, kMountDiscard))
-      fs_->bc_->Trim(StartBlock(&sbi, segno), (1 << sbi.log_blocks_per_seg));
+      fs_->GetBc().Trim(StartBlock(&sbi, segno), (1 << sbi.log_blocks_per_seg));
   }
 }
 
@@ -658,7 +652,7 @@
   int i;
   bool got_it = false;
 
-  WriteLock(&free_i->segmap_lock);
+  std::lock_guard segmap_lock(free_i->segmap_lock);
 
   auto find_other_zone = [&]() -> bool {
     secno = find_next_zero_bit(free_i->free_secmap, total_secs, hint);
@@ -743,7 +737,6 @@
   ZX_ASSERT(!test_bit(segno, free_i->free_segmap));
   SetInuse(segno);
   *newseg = segno;
-  WriteUnlock(&free_i->segmap_lock);
 }
 
 void SegMgr::ResetCurseg(CursegType type, int modified) {
@@ -983,7 +976,7 @@
 #endif
 
 void SegMgr::SubmitWritePage(Page *page, block_t blk_addr, PageType type) {
-  zx_status_t ret = fs_->bc_->Writeblk(blk_addr, page->data);
+  zx_status_t ret = fs_->GetBc().Writeblk(blk_addr, page->data);
   if (ret) {
     FX_LOGS(ERROR) << "SubmitWritePage error " << ret;
   }
@@ -1714,7 +1707,6 @@
   sit_i->sents_per_block = kSitEntryPerBlock;
   sit_i->elapsed_time = LeToCpu(sbi.ckpt->elapsed_time);
   sit_i->mounted_time = cur_time;
-  mtx_init(&sit_i->sentry_lock, mtx_plain);
   return ZX_OK;
 }
 
@@ -1752,7 +1744,6 @@
   free_i->free_segments = 0;
   free_i->free_sections = 0;
 
-  RwlockInit(&free_i->segmap_lock);
   return ZX_OK;
 }
 
@@ -1768,7 +1759,6 @@
   GetSmInfo(&sbi)->curseg_array = array;
 
   for (i = 0; i < kNrCursegType; i++) {
-    mtx_init(&array[i].curseg_mutex, mtx_plain);
     array[i].sum_blk = static_cast<SummaryBlock *>(malloc(kPageCacheSize));
     memset(array[i].sum_blk, 0, kPageCacheSize);
     if (!array[i].sum_blk)
@@ -1894,7 +1884,6 @@
     return ZX_ERR_NO_MEMORY;
 
   GetSmInfo(&sbi)->dirty_info = dirty_i;
-  mtx_init(&dirty_i->seglist_lock, mtx_plain);
 
   bitmap_size = BitmapSize(TotalSegs(&sbi));
 
@@ -1949,8 +1938,6 @@
   // init sm info
   sbi.sm_info = sm_info;
 
-  list_initialize(&sm_info->wblist_head);
-  SpinLockInit(&sm_info->wblist_lock);
   sm_info->seg0_blkaddr = LeToCpu(raw_super->segment0_blkaddr);
   sm_info->main_blkaddr = LeToCpu(raw_super->main_blkaddr);
   sm_info->segment_count = LeToCpu(raw_super->segment_count);
diff --git a/segment.h b/segment.h
index 2050130..9027012 100644
--- a/segment.h
+++ b/segment.h
@@ -92,7 +92,7 @@
   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 */
+  fbl::Mutex sentry_lock;                    /* to protect SIT cache */
   SegEntry *sentries = nullptr;              /* SIT segment-level cache */
   SecEntry *sec_entries = nullptr;           /* SIT section-level cache */
 
@@ -107,7 +107,7 @@
   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 */
+  fs::SharedMutex segmap_lock;     /* free segmap lock */
   uint64_t *free_segmap = nullptr; /* free segment bitmap */
   uint64_t *free_secmap = nullptr; /* free section bitmap */
 };
@@ -133,14 +133,14 @@
 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 */
+  fbl::Mutex 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 */
+  fbl::Mutex 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 */
diff --git a/super.cc b/super.cc
index bffe834..448237c 100644
--- a/super.cc
+++ b/super.cc
@@ -301,7 +301,6 @@
   //   sbi_->raw_super_buf = raw_super_buf;
 #endif
   sbi_->por_doing = 0;
-  SpinLockInit(&sbi_->stat_lock);
 #if 0  // porting needed
   // init_rwsem(&sbi->bio_sem);
 #endif
@@ -331,7 +330,6 @@
   sbi_->last_valid_block_count = sbi_->total_valid_block_count;
   sbi_->alloc_valid_block_count = 0;
   list_initialize(&sbi_->dir_inode_list);
-  SpinLockInit(&sbi_->dir_inode_lock);
 
   /* init super block */
 #if 0  // porting needed
@@ -437,53 +435,4 @@
   return err;
 }
 
-#if 0  // porting needed
-// dentry *F2fs::F2fsMount(file_system_type *fs_type, int flags,
-//       const char *dev_name, void *data)
-// {
-// //   return mount_bdev(fs_type, flags, dev_name, data, F2fs::FillSuper);
-//   return mount_bdev(fs_type, flags, dev_name, data, NULL);
-// }
-
-// int F2fs::InitInodecache(void) {
-//   Inode_cachep = KmemCacheCreate("Inode_cache",
-//       sizeof(InodeInfo), NULL);
-//   if (Inode_cachep == NULL)
-//     return -ENOMEM;
-// }
-
-// void F2fs::DestroyInodecache(void) {
-//   /*
-//    * Make sure all delayed rcu free inodes are flushed before we
-//    * destroy cache.
-//    */
-//   rcu_barrier();
-//   kmem_cache_destroy(Inode_cachep);
-// }
-
-// int /*__init*/ F2fs::initF2fsFs(void)
-// {
-//   int err;
-
-//   err = InitInodecache();
-//   if (err)
-//     goto fail;
-//   // TODO(unknown): should decide how to use slab cache before it
-//   //err = CreateNodeManagerCaches();
-//   if (err)
-//     goto fail;
-//   return register_filesystem(&f2fs_fs_type);
-// fail:
-//   return err;
-// }
-
-// void /*__exit*/ F2fs::exitF2fsFs(void)
-// {
-//   unregister_filesystem(&f2fs_fs_type);
-//   // TODO(unknown): should decide how to use slab cache before it
-//   //DestroyNodeManagerCaches();
-//   DestroyInodecache();
-// }
-#endif
-
 }  // namespace f2fs
diff --git a/test/unit/segment.cc b/test/unit/segment.cc
index 62a037e..d6a5ebe 100644
--- a/test/unit/segment.cc
+++ b/test/unit/segment.cc
@@ -51,7 +51,7 @@
     fs->Segmgr().WriteNodePage(root_node_page, RootIno(&sbi), old_addr, &alloc_addr);
     blk_chain.push_back(alloc_addr);
     ASSERT_NE(alloc_addr, kNullAddr);
-    ASSERT_EQ(fs->bc_->Readblk(blk_chain[i], read_page->data), ZX_OK);
+    ASSERT_EQ(fs->GetBc().Readblk(blk_chain[i], read_page->data), ZX_OK);
     ASSERT_EQ(alloc_addr, fs->Nodemgr().NextBlkaddrOfNode(read_page));
     F2fsPutPage(read_page, 0);
   }
diff --git a/test/unit/unit_lib.cc b/test/unit/unit_lib.cc
index b4781e8..0e6004e 100644
--- a/test/unit/unit_lib.cc
+++ b/test/unit/unit_lib.cc
@@ -32,7 +32,7 @@
 
 void Unmount(std::unique_ptr<F2fs> fs, std::unique_ptr<Bcache> *bc) {
   fs->PutSuper();
-  *bc = std::move(fs->bc_);
+  fs->ResetBc(bc);
   fs.reset();
 }
 
@@ -210,7 +210,7 @@
   SbInfo &sbi = fs->GetSbInfo();
   NmInfo *nm_i = GetNmInfo(&sbi);
 
-  fbl::AutoLock lock(&nm_i->free_nid_list_lock);
+  std::lock_guard lock(nm_i->free_nid_list_lock);
   for (auto nid : nids) {
     bool found = false;
     list_node_t *iter;
@@ -229,7 +229,7 @@
   SbInfo &sbi = fs->GetSbInfo();
   NmInfo *nm_i = GetNmInfo(&sbi);
 
-  fbl::AutoLock lock(&nm_i->free_nid_list_lock);
+  std::lock_guard lock(nm_i->free_nid_list_lock);
   for (auto nid : nids) {
     bool found = false;
     list_node_t *iter;
diff --git a/vnode.cc b/vnode.cc
index 4fa48c2..0e461ac 100644
--- a/vnode.cc
+++ b/vnode.cc
@@ -413,37 +413,37 @@
 
   pgoff_t free_from = static_cast<pgoff_t>((from + blocksize - 1) >> (sbi.log_blocksize));
 
-  mutex_lock_op(&sbi, LockType::kDataTrunc);
+  {
+    fs::SharedLock rlock(sbi.fs_lock[static_cast<int>(LockType::kDataTrunc)]);
+    std::lock_guard write_lock(io_lock_);
 
-  do {
-    SetNewDnode(&dn, this, nullptr, nullptr, 0);
-    err = Vfs()->Nodemgr().GetDnodeOfData(&dn, free_from, kRdOnlyNode);
-    if (err) {
-      if (err == ZX_ERR_NOT_FOUND)
-        break;
-      mutex_unlock_op(&sbi, LockType::kDataTrunc);
-      return err;
-    }
+    do {
+      SetNewDnode(&dn, this, nullptr, nullptr, 0);
+      err = Vfs()->Nodemgr().GetDnodeOfData(&dn, free_from, kRdOnlyNode);
+      if (err) {
+        if (err == ZX_ERR_NOT_FOUND)
+          break;
+        return err;
+      }
 
-    if (IsInode(dn.node_page))
-      count = kAddrsPerInode;
-    else
-      count = kAddrsPerBlock;
+      if (IsInode(dn.node_page))
+        count = kAddrsPerInode;
+      else
+        count = kAddrsPerBlock;
 
-    count -= dn.ofs_in_node;
-    ZX_ASSERT(count >= 0);
-    if (dn.ofs_in_node || IsInode(dn.node_page)) {
-      TruncateDataBlocksRange(&dn, count);
-      free_from += count;
-    }
+      count -= dn.ofs_in_node;
+      ZX_ASSERT(count >= 0);
+      if (dn.ofs_in_node || IsInode(dn.node_page)) {
+        TruncateDataBlocksRange(&dn, count);
+        free_from += count;
+      }
 
-    F2fsPutDnode(&dn);
-  } while (false);
+      F2fsPutDnode(&dn);
+    } while (false);
 
-  err = Vfs()->Nodemgr().TruncateInodeBlocks(this, free_from);
-  mutex_unlock_op(&sbi, LockType::kDataTrunc);
-
-  /* lastly zero out the first data page */
+    err = Vfs()->Nodemgr().TruncateInodeBlocks(this, free_from);
+  }
+  // lastly zero out the first data page
   TruncatePartialDataPage(from);
 
   return err;
@@ -456,7 +456,7 @@
     DnodeOfData dn;
     SbInfo &sbi = Vfs()->GetSbInfo();
 
-    fbl::AutoLock lock(&sbi.fs_lock[static_cast<int>(LockType::kDataTrunc)]);
+    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)
@@ -517,7 +517,6 @@
 #endif
   AtomicSet(&fi_.dirty_dents, 0);
   SetCurDirDepth(1);
-  RwlockInit(&fi_.ext.ext_lock);
   SetFlag(InodeInfoFlag::kInit);
   Activate();
 }
@@ -664,19 +663,17 @@
 }
 
 inline void VnodeF2fs::GetExtentInfo(const Extent &i_ext) {
-  WriteLock(&fi_.ext.ext_lock);
+  std::lock_guard lock(fi_.ext.ext_lock);
   fi_.ext.fofs = LeToCpu(i_ext.fofs);
   fi_.ext.blk_addr = LeToCpu(i_ext.blk_addr);
   fi_.ext.len = LeToCpu(i_ext.len);
-  WriteUnlock(&fi_.ext.ext_lock);
 }
 
 inline void VnodeF2fs::SetRawExtent(Extent &i_ext) {
-  ReadLock(&fi_.ext.ext_lock);
+  fs::SharedLock lock(fi_.ext.ext_lock);
   i_ext.fofs = CpuToLe(fi_.ext.fofs);
   i_ext.blk_addr = CpuToLe(fi_.ext.blk_addr);
   i_ext.len = CpuToLe(fi_.ext.len);
-  ReadUnlock(&fi_.ext.ext_lock);
 }
 
 }  // namespace f2fs
diff --git a/vnode.h b/vnode.h
index 60de4d4..18c30c3 100644
--- a/vnode.h
+++ b/vnode.h
@@ -294,6 +294,7 @@
  protected:
   void RecycleNode() override;
   std::condition_variable_any flag_cvar_{};
+  fs::SharedMutex io_lock_;
 
  private:
   zx_status_t OpenNode(ValidatedOptions options, fbl::RefPtr<Vnode> *out_redirect) final