VFS: normal filesystems (and lustre): d_inode() annotations

that's the bulk of filesystem drivers dealing with inodes of their own

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

14 files changed, 78 insertions, 78 deletions

diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index b8602f199815..430e0348c99e 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -301,7 +301,7 @@ static struct vfsmount *cifs_dfs_do_automount(struct dentry *mntpt)
         if (full_path == NULL)
                 goto cdda_exit;
 
-        cifs_sb = CIFS_SB(mntpt->d_inode->i_sb);
+        cifs_sb = CIFS_SB(d_inode(mntpt)->i_sb);
         tlink = cifs_sb_tlink(cifs_sb);
         if (IS_ERR(tlink)) {
                 mnt = ERR_CAST(tlink);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index eaab4b2a0595..f5089bde3635 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -607,7 +607,7 @@ cifs_get_root(struct smb_vol *vol, struct super_block *sb)
         p = s = full_path;
 
         do {
-                struct inode *dir = dentry->d_inode;
+                struct inode *dir = d_inode(dentry);
                 struct dentry *child;
 
                 if (!dir) {
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index fa13d5e79f64..84650a51c7c4 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1898,7 +1898,7 @@ static void
 cifs_writev_requeue(struct cifs_writedata *wdata)
 {
         int i, rc = 0;
-        struct inode *inode = wdata->cfile->dentry->d_inode;
+        struct inode *inode = d_inode(wdata->cfile->dentry);
         struct TCP_Server_Info *server;
         unsigned int rest_len;
 
@@ -1981,7 +1981,7 @@ cifs_writev_complete(struct work_struct *work)
 {
         struct cifs_writedata *wdata = container_of(work,
                                                 struct cifs_writedata, work);
-        struct inode *inode = wdata->cfile->dentry->d_inode;
+        struct inode *inode = d_inode(wdata->cfile->dentry);
         int i = 0;
 
         if (wdata->result == 0) {
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index b72bc29cba23..338d56936f6a 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -745,13 +745,13 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
                 goto lookup_out;
         }
 
-        if (direntry->d_inode != NULL) {
+        if (d_really_is_positive(direntry)) {
                 cifs_dbg(FYI, "non-NULL inode in lookup\n");
         } else {
                 cifs_dbg(FYI, "NULL inode in lookup\n");
         }
         cifs_dbg(FYI, "Full path: %s inode = 0x%p\n",
-                 full_path, direntry->d_inode);
+                 full_path, d_inode(direntry));
 
         if (pTcon->unix_ext) {
                 rc = cifs_get_inode_info_unix(&newInode, full_path,
@@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        if (direntry->d_inode) {
+        if (d_really_is_positive(direntry)) {
                 if (cifs_revalidate_dentry(direntry))
                         return 0;
                 else {
@@ -803,7 +803,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
                          * attributes will have been updated by
                          * cifs_revalidate_dentry().
                          */
-                        if (IS_AUTOMOUNT(direntry->d_inode) &&
+                        if (IS_AUTOMOUNT(d_inode(direntry)) &&
                            !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
                                 spin_lock(&direntry->d_lock);
                                 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index ca2bc5406306..cafbf10521d5 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -273,7 +273,7 @@ cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
                   struct tcon_link *tlink, __u32 oplock)
 {
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct cifsInodeInfo *cinode = CIFS_I(inode);
         struct cifsFileInfo *cfile;
         struct cifs_fid_locks *fdlocks;
@@ -357,7 +357,7 @@ cifsFileInfo_get(struct cifsFileInfo *cifs_file)
  */
 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 {
-        struct inode *inode = cifs_file->dentry->d_inode;
+        struct inode *inode = d_inode(cifs_file->dentry);
         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
         struct TCP_Server_Info *server = tcon->ses->server;
         struct cifsInodeInfo *cifsi = CIFS_I(inode);
@@ -386,7 +386,7 @@ void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 
         if (list_empty(&cifsi->openFileList)) {
                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
-                         cifs_file->dentry->d_inode);
+                         d_inode(cifs_file->dentry));
                 /*
                  * In strict cache mode we need invalidate mapping on the last
                  * close  because it may cause a error when we open this file
@@ -572,7 +572,7 @@ static int
 cifs_relock_file(struct cifsFileInfo *cfile)
 {
         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         int rc = 0;
 
@@ -620,7 +620,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
                 return rc;
         }
 
-        inode = cfile->dentry->d_inode;
+        inode = d_inode(cfile->dentry);
         cifs_sb = CIFS_SB(inode->i_sb);
         tcon = tlink_tcon(cfile->tlink);
         server = tcon->ses->server;
@@ -874,7 +874,7 @@ cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 {
         bool rc = false;
         struct cifs_fid_locks *cur;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 
         list_for_each_entry(cur, &cinode->llist, llist) {
                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
@@ -899,7 +899,7 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 {
         int rc = 0;
         struct cifsLockInfo *conf_lock;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
         bool exist;
 
@@ -927,7 +927,7 @@ cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 static void
 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
 {
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         down_write(&cinode->lock_sem);
         list_add_tail(&lock->llist, &cfile->llist->locks);
         up_write(&cinode->lock_sem);
@@ -944,7 +944,7 @@ cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
                  bool wait)
 {
         struct cifsLockInfo *conf_lock;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         bool exist;
         int rc = 0;
 
@@ -1125,7 +1125,7 @@ struct lock_to_push {
 static int
 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 {
-        struct inode *inode = cfile->dentry->d_inode;
+        struct inode *inode = d_inode(cfile->dentry);
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         struct file_lock *flock;
         struct file_lock_context *flctx = inode->i_flctx;
@@ -1214,7 +1214,7 @@ static int
 cifs_push_locks(struct cifsFileInfo *cfile)
 {
         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         int rc = 0;
 
@@ -1382,7 +1382,7 @@ cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
         unsigned int max_num, num, max_buf;
         LOCKING_ANDX_RANGE *buf, *cur;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct cifsLockInfo *li, *tmp;
         __u64 length = 1 + flock->fl_end - flock->fl_start;
         struct list_head tmp_llist;
@@ -1488,7 +1488,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         struct TCP_Server_Info *server = tcon->ses->server;
-        struct inode *inode = cfile->dentry->d_inode;
+        struct inode *inode = d_inode(cfile->dentry);
 
         if (posix_lck) {
                 int posix_lock_type;
@@ -1643,7 +1643,7 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
         struct TCP_Server_Info *server;
         unsigned int xid;
         struct dentry *dentry = open_file->dentry;
-        struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
+        struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
         struct cifs_io_parms io_parms;
 
         cifs_sb = CIFS_SB(dentry->d_sb);
@@ -1676,7 +1676,7 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
                                         break;
                         }
 
-                        len = min(server->ops->wp_retry_size(dentry->d_inode),
+                        len = min(server->ops->wp_retry_size(d_inode(dentry)),
                                   (unsigned int)write_size - total_written);
                         /* iov[0] is reserved for smb header */
                         iov[1].iov_base = (char *)write_data + total_written;
@@ -1696,9 +1696,9 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
                                 return rc;
                         }
                 } else {
-                        spin_lock(&dentry->d_inode->i_lock);
+                        spin_lock(&d_inode(dentry)->i_lock);
                         cifs_update_eof(cifsi, *offset, bytes_written);
-                        spin_unlock(&dentry->d_inode->i_lock);
+                        spin_unlock(&d_inode(dentry)->i_lock);
                         *offset += bytes_written;
                 }
         }
@@ -1706,12 +1706,12 @@ cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
         cifs_stats_bytes_written(tcon, total_written);
 
         if (total_written > 0) {
-                spin_lock(&dentry->d_inode->i_lock);
-                if (*offset > dentry->d_inode->i_size)
-                        i_size_write(dentry->d_inode, *offset);
-                spin_unlock(&dentry->d_inode->i_lock);
+                spin_lock(&d_inode(dentry)->i_lock);
+                if (*offset > d_inode(dentry)->i_size)
+                        i_size_write(d_inode(dentry), *offset);
+                spin_unlock(&d_inode(dentry)->i_lock);
         }
-        mark_inode_dirty_sync(dentry->d_inode);
+        mark_inode_dirty_sync(d_inode(dentry));
         free_xid(xid);
         return total_written;
 }
@@ -2406,7 +2406,7 @@ cifs_uncached_writev_complete(struct work_struct *work)
 {
         struct cifs_writedata *wdata = container_of(work,
                                         struct cifs_writedata, work);
-        struct inode *inode = wdata->cfile->dentry->d_inode;
+        struct inode *inode = d_inode(wdata->cfile->dentry);
         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 
         spin_lock(&inode->i_lock);
@@ -3794,7 +3794,7 @@ void cifs_oplock_break(struct work_struct *work)
 {
         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
                                                   oplock_break);
-        struct inode *inode = cfile->dentry->d_inode;
+        struct inode *inode = d_inode(cfile->dentry);
         struct cifsInodeInfo *cinode = CIFS_I(inode);
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
         struct TCP_Server_Info *server = tcon->ses->server;
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 3e126d7bb2ea..55b58112d122 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -1067,7 +1067,7 @@ cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
         int rc;
         struct cifs_fid fid;
         struct cifs_open_parms oparms;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
@@ -1196,7 +1196,7 @@ cifs_drop_nlink(struct inode *inode)
 }
 
 /*
- * If dentry->d_inode is null (usually meaning the cached dentry
+ * If d_inode(dentry) is null (usually meaning the cached dentry
  * is a negative dentry) then we would attempt a standard SMB delete, but
  * if that fails we can not attempt the fall back mechanisms on EACCESS
  * but will return the EACCESS to the caller. Note that the VFS does not call
@@ -1207,7 +1207,7 @@ int cifs_unlink(struct inode *dir, struct dentry *dentry)
         int rc = 0;
         unsigned int xid;
         char *full_path = NULL;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct cifsInodeInfo *cifs_inode;
         struct super_block *sb = dir->i_sb;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
@@ -1551,13 +1551,13 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
         cifs_put_tlink(tlink);
 
         if (!rc) {
-                spin_lock(&direntry->d_inode->i_lock);
-                i_size_write(direntry->d_inode, 0);
-                clear_nlink(direntry->d_inode);
-                spin_unlock(&direntry->d_inode->i_lock);
+                spin_lock(&d_inode(direntry)->i_lock);
+                i_size_write(d_inode(direntry), 0);
+                clear_nlink(d_inode(direntry));
+                spin_unlock(&d_inode(direntry)->i_lock);
         }
 
-        cifsInode = CIFS_I(direntry->d_inode);
+        cifsInode = CIFS_I(d_inode(direntry));
         /* force revalidate to go get info when needed */
         cifsInode->time = 0;
 
@@ -1568,7 +1568,7 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
          */
         cifsInode->time = 0;
 
-        direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
+        d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
                 current_fs_time(inode->i_sb);
 
 rmdir_exit:
@@ -1727,7 +1727,7 @@ cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
 
 unlink_target:
         /* Try unlinking the target dentry if it's not negative */
-        if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
+        if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
                 if (d_is_dir(target_dentry))
                         tmprc = cifs_rmdir(target_dir, target_dentry);
                 else
@@ -1867,7 +1867,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
 {
         unsigned int xid;
         int rc = 0;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = dentry->d_sb;
         char *full_path = NULL;
 
@@ -1919,7 +1919,7 @@ int cifs_revalidate_file(struct file *filp)
 int cifs_revalidate_dentry(struct dentry *dentry)
 {
         int rc;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         rc = cifs_revalidate_dentry_attr(dentry);
         if (rc)
@@ -1933,7 +1933,7 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 {
         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int rc;
 
         /*
@@ -2110,7 +2110,7 @@ cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
         int rc;
         unsigned int xid;
         char *full_path = NULL;
-        struct inode *inode = direntry->d_inode;
+        struct inode *inode = d_inode(direntry);
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct tcon_link *tlink;
@@ -2251,7 +2251,7 @@ cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
         unsigned int xid;
         kuid_t uid = INVALID_UID;
         kgid_t gid = INVALID_GID;
-        struct inode *inode = direntry->d_inode;
+        struct inode *inode = d_inode(direntry);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
         char *full_path = NULL;
@@ -2409,7 +2409,7 @@ cifs_setattr_exit:
 int
 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
 {
-        struct inode *inode = direntry->d_inode;
+        struct inode *inode = d_inode(direntry);
         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
 
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 2ec6037f61c7..252e672d5604 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -586,12 +586,12 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
          * if source file is cached (oplocked) revalidate will not go to server
          * until the file is closed or oplock broken so update nlinks locally
          */
-        if (old_file->d_inode) {
-                cifsInode = CIFS_I(old_file->d_inode);
+        if (d_really_is_positive(old_file)) {
+                cifsInode = CIFS_I(d_inode(old_file));
                 if (rc == 0) {
-                        spin_lock(&old_file->d_inode->i_lock);
-                        inc_nlink(old_file->d_inode);
-                        spin_unlock(&old_file->d_inode->i_lock);
+                        spin_lock(&d_inode(old_file)->i_lock);
+                        inc_nlink(d_inode(old_file));
+                        spin_unlock(&d_inode(old_file)->i_lock);
 
                         /*
                          * parent dir timestamps will update from srv within a
@@ -629,7 +629,7 @@ cifs_hl_exit:
 void *
 cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 {
-        struct inode *inode = direntry->d_inode;
+        struct inode *inode = d_inode(direntry);
         int rc = -ENOMEM;
         unsigned int xid;
         char *full_path = NULL;
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 337946355b29..8442b8b8e0be 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -473,7 +473,7 @@ is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
                                         continue;
 
                                 cifs_dbg(FYI, "file id match, oplock break\n");
-                                pCifsInode = CIFS_I(netfile->dentry->d_inode);
+                                pCifsInode = CIFS_I(d_inode(netfile->dentry));
 
                                 set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK,
                                         &pCifsInode->flags);
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index c295338e0a98..b4a47237486b 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -78,7 +78,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
 {
         struct dentry *dentry, *alias;
         struct inode *inode;
-        struct super_block *sb = parent->d_inode->i_sb;
+        struct super_block *sb = d_inode(parent)->i_sb;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 
         cifs_dbg(FYI, "%s: for %s\n", __func__, name->name);
@@ -88,7 +88,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
                 return;
 
         if (dentry) {
-                inode = dentry->d_inode;
+                inode = d_inode(dentry);
                 if (inode) {
                         /*
                          * If we're generating inode numbers, then we don't
diff --git a/fs/cifs/smb1ops.c b/fs/cifs/smb1ops.c
index d2979036a4c7..7bfdd6066276 100644
--- a/fs/cifs/smb1ops.c
+++ b/fs/cifs/smb1ops.c
@@ -722,7 +722,7 @@ cifs_open_file(const unsigned int xid, struct cifs_open_parms *oparms,
 static void
 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
 {
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         cfile->fid.netfid = fid->netfid;
         cifs_set_oplock_level(cinode, oplock);
         cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
diff --git a/fs/cifs/smb2file.c b/fs/cifs/smb2file.c
index 7198eac5dddd..2ab297dae5a7 100644
--- a/fs/cifs/smb2file.c
+++ b/fs/cifs/smb2file.c
@@ -95,7 +95,7 @@ smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
         unsigned int max_num, num = 0, max_buf;
         struct smb2_lock_element *buf, *cur;
         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct cifsLockInfo *li, *tmp;
         __u64 length = 1 + flock->fl_end - flock->fl_start;
         struct list_head tmp_llist;
@@ -231,7 +231,7 @@ smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
         unsigned int xid;
         unsigned int max_num, max_buf;
         struct smb2_lock_element *buf;
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct cifs_fid_locks *fdlocks;
 
         xid = get_xid();
diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c
index 22dfdf17d065..1c5907019045 100644
--- a/fs/cifs/smb2misc.c
+++ b/fs/cifs/smb2misc.c
@@ -453,7 +453,7 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
 
         list_for_each(tmp, &tcon->openFileList) {
                 cfile = list_entry(tmp, struct cifsFileInfo, tlist);
-                cinode = CIFS_I(cfile->dentry->d_inode);
+                cinode = CIFS_I(d_inode(cfile->dentry));
 
                 if (memcmp(cinode->lease_key, rsp->LeaseKey,
                                                         SMB2_LEASE_KEY_SIZE))
@@ -590,7 +590,7 @@ smb2_is_valid_oplock_break(char *buffer, struct TCP_Server_Info *server)
                                         continue;
 
                                 cifs_dbg(FYI, "file id match, oplock break\n");
-                                cinode = CIFS_I(cfile->dentry->d_inode);
+                                cinode = CIFS_I(d_inode(cfile->dentry));
 
                                 if (!CIFS_CACHE_WRITE(cinode) &&
                                     rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE)
diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
index eab05e1aa587..54daee5ad4c1 100644
--- a/fs/cifs/smb2ops.c
+++ b/fs/cifs/smb2ops.c
@@ -524,7 +524,7 @@ smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
 static void
 smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
 {
-        struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
+        struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 
         cfile->fid.persistent_fid = fid->persistent_fid;
@@ -793,7 +793,7 @@ smb2_set_file_size(const unsigned int xid, struct cifs_tcon *tcon,
          * If extending file more than one page make sparse. Many Linux fs
          * make files sparse by default when extending via ftruncate
          */
-        inode = cfile->dentry->d_inode;
+        inode = d_inode(cfile->dentry);
 
         if (!set_alloc && (size > inode->i_size + 8192)) {
                 __u8 set_sparse = 1;
@@ -1032,7 +1032,7 @@ static long smb3_zero_range(struct file *file, struct cifs_tcon *tcon,
 
         xid = get_xid();
 
-        inode = cfile->dentry->d_inode;
+        inode = d_inode(cfile->dentry);
         cifsi = CIFS_I(inode);
 
         /* if file not oplocked can't be sure whether asking to extend size */
@@ -1083,7 +1083,7 @@ static long smb3_punch_hole(struct file *file, struct cifs_tcon *tcon,
 
         xid = get_xid();
 
-        inode = cfile->dentry->d_inode;
+        inode = d_inode(cfile->dentry);
         cifsi = CIFS_I(inode);
 
         /* Need to make file sparse, if not already, before freeing range. */
@@ -1115,7 +1115,7 @@ static long smb3_simple_falloc(struct file *file, struct cifs_tcon *tcon,
 
         xid = get_xid();
 
-        inode = cfile->dentry->d_inode;
+        inode = d_inode(cfile->dentry);
         cifsi = CIFS_I(inode);
 
         /* if file not oplocked can't be sure whether asking to extend size */
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 72a4d10653d6..ff9e1f8b16a4 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -50,9 +50,9 @@ int cifs_removexattr(struct dentry *direntry, const char *ea_name)
 
         if (direntry == NULL)
                 return -EIO;
-        if (direntry->d_inode == NULL)
+        if (d_really_is_negative(direntry))
                 return -EIO;
-        sb = direntry->d_inode->i_sb;
+        sb = d_inode(direntry)->i_sb;
         if (sb == NULL)
                 return -EIO;
 
@@ -111,9 +111,9 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 
         if (direntry == NULL)
                 return -EIO;
-        if (direntry->d_inode == NULL)
+        if (d_really_is_negative(direntry))
                 return -EIO;
-        sb = direntry->d_inode->i_sb;
+        sb = d_inode(direntry)->i_sb;
         if (sb == NULL)
                 return -EIO;
 
@@ -177,12 +177,12 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
                         memcpy(pacl, ea_value, value_size);
                         if (pTcon->ses->server->ops->set_acl)
                                 rc = pTcon->ses->server->ops->set_acl(pacl,
-                                                value_size, direntry->d_inode,
+                                                value_size, d_inode(direntry),
                                                 full_path, CIFS_ACL_DACL);
                         else
                                 rc = -EOPNOTSUPP;
                         if (rc == 0) /* force revalidate of the inode */
-                                CIFS_I(direntry->d_inode)->time = 0;
+                                CIFS_I(d_inode(direntry))->time = 0;
                         kfree(pacl);
                 }
 #else
@@ -246,9 +246,9 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 
         if (direntry == NULL)
                 return -EIO;
-        if (direntry->d_inode == NULL)
+        if (d_really_is_negative(direntry))
                 return -EIO;
-        sb = direntry->d_inode->i_sb;
+        sb = d_inode(direntry)->i_sb;
         if (sb == NULL)
                 return -EIO;
 
@@ -324,7 +324,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                                 goto get_ea_exit; /* rc already EOPNOTSUPP */
 
                         pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
-                                        direntry->d_inode, full_path, &acllen);
+                                        d_inode(direntry), full_path, &acllen);
                         if (IS_ERR(pacl)) {
                                 rc = PTR_ERR(pacl);
                                 cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
@@ -382,9 +382,9 @@ ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 
         if (direntry == NULL)
                 return -EIO;
-        if (direntry->d_inode == NULL)
+        if (d_really_is_negative(direntry))
                 return -EIO;
-        sb = direntry->d_inode->i_sb;
+        sb = d_inode(direntry)->i_sb;
         if (sb == NULL)
                 return -EIO;