7 files changed, 52 insertions, 52 deletions

diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index 37d164540c3a..8d052209f473 100644
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -152,7 +152,7 @@ static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
 
 static struct dentry *btrfs_get_parent(struct dentry *child)
 {
-        struct inode *dir = child->d_inode;
+        struct inode *dir = d_inode(child);
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_path *path;
         struct extent_buffer *leaf;
@@ -220,8 +220,8 @@ fail:
 static int btrfs_get_name(struct dentry *parent, char *name,
                           struct dentry *child)
 {
-        struct inode *inode = child->d_inode;
-        struct inode *dir = parent->d_inode;
+        struct inode *inode = d_inode(child);
+        struct inode *dir = d_inode(parent);
         struct btrfs_path *path;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_inode_ref *iref;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 467620a3b1f9..b072e17479aa 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1862,7 +1862,7 @@ static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         struct btrfs_log_ctx ctx;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 56f00a25c003..ada4d24ed11b 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4020,16 +4020,16 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_trans_handle *trans;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int ret;
 
         trans = __unlink_start_trans(dir);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
+        btrfs_record_unlink_dir(trans, dir, d_inode(dentry), 0);
 
-        ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
+        ret = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
                                  dentry->d_name.name, dentry->d_name.len);
         if (ret)
                 goto out;
@@ -4128,7 +4128,7 @@ out:
 
 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int err = 0;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_trans_handle *trans;
@@ -4155,7 +4155,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
                 goto out;
 
         /* now the directory is empty */
-        err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
+        err = btrfs_unlink_inode(trans, root, dir, d_inode(dentry),
                                  dentry->d_name.name, dentry->d_name.len);
         if (!err)
                 btrfs_i_size_write(inode, 0);
@@ -4915,7 +4915,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
 
 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int err;
 
@@ -5547,10 +5547,10 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
 static int btrfs_dentry_delete(const struct dentry *dentry)
 {
         struct btrfs_root *root;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (!inode && !IS_ROOT(dentry))
-                inode = dentry->d_parent->d_inode;
+                inode = d_inode(dentry->d_parent);
 
         if (inode) {
                 root = BTRFS_I(inode)->root;
@@ -6357,7 +6357,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         u64 index;
         int err;
         int drop_inode = 0;
@@ -8260,7 +8260,7 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
         if (check_direct_IO(BTRFS_I(inode)->root, iocb, iter, offset))
                 return 0;
 
-        atomic_inc(&inode->i_dio_count);
+        inode_dio_begin(inode);
         smp_mb__after_atomic();
 
         /*
@@ -8300,7 +8300,7 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
                 current->journal_info = &outstanding_extents;
         } else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
                                      &BTRFS_I(inode)->runtime_flags)) {
-                inode_dio_done(inode);
+                inode_dio_end(inode);
                 flags = DIO_LOCKING | DIO_SKIP_HOLES;
                 wakeup = false;
         }
@@ -8319,7 +8319,7 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
         }
 out:
         if (wakeup)
-                inode_dio_done(inode);
+                inode_dio_end(inode);
         if (relock)
                 mutex_lock(&inode->i_mutex);
 
@@ -9006,7 +9006,7 @@ static int btrfs_getattr(struct vfsmount *mnt,
                          struct dentry *dentry, struct kstat *stat)
 {
         u64 delalloc_bytes;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         u32 blocksize = inode->i_sb->s_blocksize;
 
         generic_fillattr(inode, stat);
@@ -9027,8 +9027,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(old_dir)->root;
         struct btrfs_root *dest = BTRFS_I(new_dir)->root;
-        struct inode *new_inode = new_dentry->d_inode;
-        struct inode *old_inode = old_dentry->d_inode;
+        struct inode *new_inode = d_inode(new_dentry);
+        struct inode *old_inode = d_inode(old_dentry);
         struct timespec ctime = CURRENT_TIME;
         u64 index = 0;
         u64 root_objectid;
@@ -9140,7 +9140,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                         old_dentry->d_name.len);
         } else {
                 ret = __btrfs_unlink_inode(trans, root, old_dir,
-                                        old_dentry->d_inode,
+                                        d_inode(old_dentry),
                                         old_dentry->d_name.name,
                                         old_dentry->d_name.len);
                 if (!ret)
@@ -9164,12 +9164,12 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         BUG_ON(new_inode->i_nlink == 0);
                 } else {
                         ret = btrfs_unlink_inode(trans, dest, new_dir,
-                                                 new_dentry->d_inode,
+                                                 d_inode(new_dentry),
                                                  new_dentry->d_name.name,
                                                  new_dentry->d_name.len);
                 }
                 if (!ret && new_inode->i_nlink == 0)
-                        ret = btrfs_orphan_add(trans, new_dentry->d_inode);
+                        ret = btrfs_orphan_add(trans, d_inode(new_dentry));
                 if (ret) {
                         btrfs_abort_transaction(trans, root, ret);
                         goto out_fail;
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index ca5d968f4c37..b05653f182c2 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -724,7 +724,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
         if (ret)
                 goto fail;
 
-        inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry);
+        inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry);
         if (IS_ERR(inode)) {
                 ret = PTR_ERR(inode);
                 goto fail;
@@ -768,10 +768,10 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
 {
         int error;
 
-        if (!victim->d_inode)
+        if (d_really_is_negative(victim))
                 return -ENOENT;
 
-        BUG_ON(victim->d_parent->d_inode != dir);
+        BUG_ON(d_inode(victim->d_parent) != dir);
         audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
 
         error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
@@ -779,8 +779,8 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
                 return error;
         if (IS_APPEND(dir))
                 return -EPERM;
-        if (check_sticky(dir, victim->d_inode) || IS_APPEND(victim->d_inode) ||
-            IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
+        if (check_sticky(dir, d_inode(victim)) || IS_APPEND(d_inode(victim)) ||
+            IS_IMMUTABLE(d_inode(victim)) || IS_SWAPFILE(d_inode(victim)))
                 return -EPERM;
         if (isdir) {
                 if (!d_is_dir(victim))
@@ -799,7 +799,7 @@ static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
 /* copy of may_create in fs/namei.c() */
 static inline int btrfs_may_create(struct inode *dir, struct dentry *child)
 {
-        if (child->d_inode)
+        if (d_really_is_positive(child))
                 return -EEXIST;
         if (IS_DEADDIR(dir))
                 return -ENOENT;
@@ -817,7 +817,7 @@ static noinline int btrfs_mksubvol(struct path *parent,
                                    u64 *async_transid, bool readonly,
                                    struct btrfs_qgroup_inherit *inherit)
 {
-        struct inode *dir  = parent->dentry->d_inode;
+        struct inode *dir  = d_inode(parent->dentry);
         struct dentry *dentry;
         int error;
 
@@ -831,7 +831,7 @@ static noinline int btrfs_mksubvol(struct path *parent,
                 goto out_unlock;
 
         error = -EEXIST;
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 goto out_dput;
 
         error = btrfs_may_create(dir, dentry);
@@ -2301,7 +2301,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
 {
         struct dentry *parent = file->f_path.dentry;
         struct dentry *dentry;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct inode *inode;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_root *dest = NULL;
@@ -2340,12 +2340,12 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                 goto out_unlock_dir;
         }
 
-        if (!dentry->d_inode) {
+        if (d_really_is_negative(dentry)) {
                 err = -ENOENT;
                 goto out_dput;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         dest = BTRFS_I(inode)->root;
         if (!capable(CAP_SYS_ADMIN)) {
                 /*
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index f2c9f9db3b19..9e66f5e724db 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -925,7 +925,7 @@ setup_root:
          * a reference to the dentry.  We will have already gotten a reference
          * to the inode in btrfs_fill_super so we're good to go.
          */
-        if (!new && sb->s_root->d_inode == inode) {
+        if (!new && d_inode(sb->s_root) == inode) {
                 iput(inode);
                 return dget(sb->s_root);
         }
@@ -1230,7 +1230,7 @@ static struct dentry *mount_subvol(const char *subvol_name, int flags,
 
         root = mount_subtree(mnt, subvol_name);
 
-        if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
+        if (!IS_ERR(root) && !is_subvolume_inode(d_inode(root))) {
                 struct super_block *s = root->d_sb;
                 dput(root);
                 root = ERR_PTR(-EINVAL);
@@ -1895,8 +1895,8 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
         buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
         buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
         /* Mask in the root object ID too, to disambiguate subvols */
-        buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
-        buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
+        buf->f_fsid.val[0] ^= BTRFS_I(d_inode(dentry))->root->objectid >> 32;
+        buf->f_fsid.val[1] ^= BTRFS_I(d_inode(dentry))->root->objectid;
 
         return 0;
 }
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index a089b5944efc..d04968374e9d 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4474,9 +4474,9 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                         goto out;
 
         if (!S_ISDIR(inode->i_mode)) {
-                if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                         goto out;
-                inode = parent->d_inode;
+                inode = d_inode(parent);
         }
 
         while (1) {
@@ -4502,7 +4502,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                         break;
                 }
 
-                if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                         break;
 
                 if (IS_ROOT(parent))
@@ -4511,7 +4511,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
                 parent = dget_parent(parent);
                 dput(old_parent);
                 old_parent = parent;
-                inode = parent->d_inode;
+                inode = d_inode(parent);
 
         }
         dput(old_parent);
@@ -4777,10 +4777,10 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
                 log_dentries = true;
 
         while (1) {
-                if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
+                if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
                         break;
 
-                inode = parent->d_inode;
+                inode = d_inode(parent);
                 if (root != BTRFS_I(inode)->root)
                         break;
 
@@ -4845,7 +4845,7 @@ int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
         struct dentry *parent = dget_parent(dentry);
         int ret;
 
-        ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent,
+        ret = btrfs_log_inode_parent(trans, root, d_inode(dentry), parent,
                                      start, end, 0, ctx);
         dput(parent);
 
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 45ea704be030..6f518c90e1c1 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -261,7 +261,7 @@ out:
 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
         struct btrfs_key key, found_key;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_path *path;
         struct extent_buffer *leaf;
@@ -411,13 +411,13 @@ ssize_t btrfs_getxattr(struct dentry *dentry, const char *name,
         ret = btrfs_is_valid_xattr(name);
         if (ret)
                 return ret;
-        return __btrfs_getxattr(dentry->d_inode, name, buffer, size);
+        return __btrfs_getxattr(d_inode(dentry), name, buffer, size);
 }
 
 int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                    size_t size, int flags)
 {
-        struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root;
         int ret;
 
         /*
@@ -440,19 +440,19 @@ int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                 return ret;
 
         if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
-                return btrfs_set_prop(dentry->d_inode, name,
+                return btrfs_set_prop(d_inode(dentry), name,
                                       value, size, flags);
 
         if (size == 0)
                 value = "";  /* empty EA, do not remove */
 
-        return __btrfs_setxattr(NULL, dentry->d_inode, name, value, size,
+        return __btrfs_setxattr(NULL, d_inode(dentry), name, value, size,
                                 flags);
 }
 
 int btrfs_removexattr(struct dentry *dentry, const char *name)
 {
-        struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root;
         int ret;
 
         /*
@@ -475,10 +475,10 @@ int btrfs_removexattr(struct dentry *dentry, const char *name)
                 return ret;
 
         if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN))
-                return btrfs_set_prop(dentry->d_inode, name,
+                return btrfs_set_prop(d_inode(dentry), name,
                                       NULL, 0, XATTR_REPLACE);
 
-        return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0,
+        return __btrfs_setxattr(NULL, d_inode(dentry), name, NULL, 0,
                                 XATTR_REPLACE);
 }