return 0;
 }
 
-static int erofs_fill_inode(struct inode *inode, int isdir)
+static int erofs_fill_inode(struct inode *inode)
 {
        struct erofs_inode *vi = EROFS_I(inode);
        struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
        unsigned int ofs;
        int err = 0;
 
-       trace_erofs_fill_inode(inode, isdir);
+       trace_erofs_fill_inode(inode);
 
        /* read inode base data from disk */
        kaddr = erofs_read_inode(&buf, inode, &ofs);
        return 0;
 }
 
-static inline struct inode *erofs_iget_locked(struct super_block *sb,
-                                             erofs_nid_t nid)
+struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid)
 {
        const unsigned long hashval = erofs_inode_hash(nid);
+       struct inode *inode;
 
-       return iget5_locked(sb, hashval, erofs_ilookup_test_actor,
+       inode = iget5_locked(sb, hashval, erofs_ilookup_test_actor,
                erofs_iget_set_actor, &nid);
-}
-
-struct inode *erofs_iget(struct super_block *sb,
-                        erofs_nid_t nid,
-                        bool isdir)
-{
-       struct inode *inode = erofs_iget_locked(sb, nid);
-
        if (!inode)
                return ERR_PTR(-ENOMEM);
 
 
                vi->nid = nid;
 
-               err = erofs_fill_inode(inode, isdir);
-               if (!err)
+               err = erofs_fill_inode(inode);
+               if (!err) {
                        unlock_new_inode(inode);
-               else {
+               } else {
                        iget_failed(inode);
                        inode = ERR_PTR(err);
                }
 
 extern const struct inode_operations erofs_symlink_iops;
 extern const struct inode_operations erofs_fast_symlink_iops;
 
-struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid, bool dir);
+struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid);
 int erofs_getattr(struct user_namespace *mnt_userns, const struct path *path,
                  struct kstat *stat, u32 request_mask,
                  unsigned int query_flags);
 
        } else {
                erofs_dbg("%s, %pd (nid %llu) found, d_type %u", __func__,
                          dentry, nid, d_type);
-               inode = erofs_iget(dir->i_sb, nid, d_type == FT_DIR);
+               inode = erofs_iget(dir->i_sb, nid);
        }
        return d_splice_alias(inode, dentry);
 }
 
        sbi->packed_inode = NULL;
        if (erofs_sb_has_fragments(sbi) && dsb->packed_nid) {
                sbi->packed_inode =
-                       erofs_iget(sb, le64_to_cpu(dsb->packed_nid), false);
+                       erofs_iget(sb, le64_to_cpu(dsb->packed_nid));
                if (IS_ERR(sbi->packed_inode)) {
                        ret = PTR_ERR(sbi->packed_inode);
                        goto out;
 static struct inode *erofs_nfs_get_inode(struct super_block *sb,
                                         u64 ino, u32 generation)
 {
-       return erofs_iget(sb, ino, false);
+       return erofs_iget(sb, ino);
 }
 
 static struct dentry *erofs_fh_to_dentry(struct super_block *sb,
        err = erofs_namei(d_inode(child), &dotdot_name, &nid, &d_type);
        if (err)
                return ERR_PTR(err);
-       return d_obtain_alias(erofs_iget(child->d_sb, nid, d_type == FT_DIR));
+       return d_obtain_alias(erofs_iget(child->d_sb, nid));
 }
 
 static const struct export_operations erofs_export_ops = {
 #endif
 
        /* get the root inode */
-       inode = erofs_iget(sb, ROOT_NID(sbi), true);
+       inode = erofs_iget(sb, ROOT_NID(sbi));
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
 
 );
 
 TRACE_EVENT(erofs_fill_inode,
-       TP_PROTO(struct inode *inode, int isdir),
-       TP_ARGS(inode, isdir),
+       TP_PROTO(struct inode *inode),
+       TP_ARGS(inode),
 
        TP_STRUCT__entry(
                __field(dev_t,          dev     )
                __field(erofs_nid_t,    nid     )
                __field(erofs_blk_t,    blkaddr )
                __field(unsigned int,   ofs     )
-               __field(int,            isdir   )
        ),
 
        TP_fast_assign(
                __entry->nid            = EROFS_I(inode)->nid;
                __entry->blkaddr        = erofs_blknr(iloc(EROFS_I_SB(inode), __entry->nid));
                __entry->ofs            = erofs_blkoff(iloc(EROFS_I_SB(inode), __entry->nid));
-               __entry->isdir          = isdir;
        ),
 
-       TP_printk("dev = (%d,%d), nid = %llu, blkaddr %u ofs %u, isdir %d",
+       TP_printk("dev = (%d,%d), nid = %llu, blkaddr %u ofs %u",
                  show_dev_nid(__entry),
-                 __entry->blkaddr, __entry->ofs,
-                 __entry->isdir)
+                 __entry->blkaddr, __entry->ofs)
 );
 
 TRACE_EVENT(erofs_readpage,