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>

7 files changed, 93 insertions, 93 deletions

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 719e1ce1c609..97315f2f6816 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1326,7 +1326,7 @@ static int ecryptfs_read_headers_virt(char *page_virt,
         if (rc)
                 goto out;
         if (!(crypt_stat->flags & ECRYPTFS_I_SIZE_INITIALIZED))
-                ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode);
+                ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry));
         offset += MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
         rc = ecryptfs_process_flags(crypt_stat, (page_virt + offset),
                                     &bytes_read);
@@ -1425,7 +1425,7 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
 {
         int rc;
         char *page_virt;
-        struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode;
+        struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry);
         struct ecryptfs_crypt_stat *crypt_stat =
             &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index 4000f6b3a750..8db0b464483f 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -54,11 +54,11 @@ static int ecryptfs_d_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         rc = lower_dentry->d_op->d_revalidate(lower_dentry, flags);
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 struct inode *lower_inode =
-                        ecryptfs_inode_to_lower(dentry->d_inode);
+                        ecryptfs_inode_to_lower(d_inode(dentry));
 
-                fsstack_copy_attr_all(dentry->d_inode, lower_inode);
+                fsstack_copy_attr_all(d_inode(dentry), lower_inode);
         }
         return rc;
 }
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index a65786e26b05..72afcc629d7b 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -130,7 +130,7 @@ struct kmem_cache *ecryptfs_file_info_cache;
 
 static int read_or_initialize_metadata(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
         struct ecryptfs_crypt_stat *crypt_stat;
         int rc;
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index b08b5187f662..fc850b55db67 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -41,13 +41,13 @@ static struct dentry *lock_parent(struct dentry *dentry)
         struct dentry *dir;
 
         dir = dget_parent(dentry);
-        mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT);
+        mutex_lock_nested(&(d_inode(dir)->i_mutex), I_MUTEX_PARENT);
         return dir;
 }
 
 static void unlock_dir(struct dentry *dir)
 {
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(dir);
 }
 
@@ -131,7 +131,7 @@ struct inode *ecryptfs_get_inode(struct inode *lower_inode,
 static int ecryptfs_interpose(struct dentry *lower_dentry,
                               struct dentry *dentry, struct super_block *sb)
 {
-        struct inode *inode = ecryptfs_get_inode(lower_dentry->d_inode, sb);
+        struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
 
         if (IS_ERR(inode))
                 return PTR_ERR(inode);
@@ -189,21 +189,21 @@ ecryptfs_do_create(struct inode *directory_inode,
 
         lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
         lower_dir_dentry = lock_parent(lower_dentry);
-        rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true);
+        rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);
         if (rc) {
                 printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                        "rc = [%d]\n", __func__, rc);
                 inode = ERR_PTR(rc);
                 goto out_lock;
         }
-        inode = __ecryptfs_get_inode(lower_dentry->d_inode,
+        inode = __ecryptfs_get_inode(d_inode(lower_dentry),
                                      directory_inode->i_sb);
         if (IS_ERR(inode)) {
-                vfs_unlink(lower_dir_dentry->d_inode, lower_dentry, NULL);
+                vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);
                 goto out_lock;
         }
-        fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);
-        fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
+        fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
 out_lock:
         unlock_dir(lower_dir_dentry);
         return inode;
@@ -332,7 +332,7 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
                                      struct dentry *lower_dentry,
                                      struct inode *dir_inode)
 {
-        struct inode *inode, *lower_inode = lower_dentry->d_inode;
+        struct inode *inode, *lower_inode = d_inode(lower_dentry);
         struct ecryptfs_dentry_info *dentry_info;
         struct vfsmount *lower_mnt;
         int rc = 0;
@@ -347,14 +347,14 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
         }
 
         lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));
-        fsstack_copy_attr_atime(dir_inode, lower_dentry->d_parent->d_inode);
+        fsstack_copy_attr_atime(dir_inode, d_inode(lower_dentry->d_parent));
         BUG_ON(!d_count(lower_dentry));
 
         ecryptfs_set_dentry_private(dentry, dentry_info);
         dentry_info->lower_path.mnt = lower_mnt;
         dentry_info->lower_path.dentry = lower_dentry;
 
-        if (!lower_dentry->d_inode) {
+        if (d_really_is_negative(lower_dentry)) {
                 /* We want to add because we couldn't find in lower */
                 d_add(dentry, NULL);
                 return 0;
@@ -400,11 +400,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
         int rc = 0;
 
         lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
-        mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
         lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name,
                                       lower_dir_dentry,
                                       ecryptfs_dentry->d_name.len);
-        mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
         if (IS_ERR(lower_dentry)) {
                 rc = PTR_ERR(lower_dentry);
                 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -412,7 +412,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                                 ecryptfs_dentry);
                 goto out;
         }
-        if (lower_dentry->d_inode)
+        if (d_really_is_positive(lower_dentry))
                 goto interpose;
         mount_crypt_stat = &ecryptfs_superblock_to_private(
                                 ecryptfs_dentry->d_sb)->mount_crypt_stat;
@@ -429,11 +429,11 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                        "filename; rc = [%d]\n", __func__, rc);
                 goto out;
         }
-        mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(lower_dir_dentry)->i_mutex);
         lower_dentry = lookup_one_len(encrypted_and_encoded_name,
                                       lower_dir_dentry,
                                       encrypted_and_encoded_name_size);
-        mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex);
         if (IS_ERR(lower_dentry)) {
                 rc = PTR_ERR(lower_dentry);
                 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
@@ -458,24 +458,24 @@ static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
         u64 file_size_save;
         int rc;
 
-        file_size_save = i_size_read(old_dentry->d_inode);
+        file_size_save = i_size_read(d_inode(old_dentry));
         lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
         lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
         dget(lower_old_dentry);
         dget(lower_new_dentry);
         lower_dir_dentry = lock_parent(lower_new_dentry);
-        rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
+        rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
                       lower_new_dentry, NULL);
-        if (rc || !lower_new_dentry->d_inode)
+        if (rc || d_really_is_negative(lower_new_dentry))
                 goto out_lock;
         rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
         if (rc)
                 goto out_lock;
-        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-        set_nlink(old_dentry->d_inode,
-                  ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);
-        i_size_write(new_dentry->d_inode, file_size_save);
+        fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+        fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+        set_nlink(d_inode(old_dentry),
+                  ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
+        i_size_write(d_inode(new_dentry), file_size_save);
 out_lock:
         unlock_dir(lower_dir_dentry);
         dput(lower_new_dentry);
@@ -485,7 +485,7 @@ out_lock:
 
 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        return ecryptfs_do_unlink(dir, dentry, dentry->d_inode);
+        return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
 }
 
 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
@@ -510,20 +510,20 @@ static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
                                                   strlen(symname));
         if (rc)
                 goto out_lock;
-        rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry,
+        rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry,
                          encoded_symname);
         kfree(encoded_symname);
-        if (rc || !lower_dentry->d_inode)
+        if (rc || d_really_is_negative(lower_dentry))
                 goto out_lock;
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
         if (rc)
                 goto out_lock;
-        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+        fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out_lock:
         unlock_dir(lower_dir_dentry);
         dput(lower_dentry);
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 d_drop(dentry);
         return rc;
 }
@@ -536,18 +536,18 @@ static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
         lower_dir_dentry = lock_parent(lower_dentry);
-        rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode);
-        if (rc || !lower_dentry->d_inode)
+        rc = vfs_mkdir(d_inode(lower_dir_dentry), lower_dentry, mode);
+        if (rc || d_really_is_negative(lower_dentry))
                 goto out;
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
         if (rc)
                 goto out;
-        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
-        set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+        fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+        fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
+        set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
 out:
         unlock_dir(lower_dir_dentry);
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 d_drop(dentry);
         return rc;
 }
@@ -562,12 +562,12 @@ static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
         dget(dentry);
         lower_dir_dentry = lock_parent(lower_dentry);
         dget(lower_dentry);
-        rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);
+        rc = vfs_rmdir(d_inode(lower_dir_dentry), lower_dentry);
         dput(lower_dentry);
-        if (!rc && dentry->d_inode)
-                clear_nlink(dentry->d_inode);
-        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-        set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
+        if (!rc && d_really_is_positive(dentry))
+                clear_nlink(d_inode(dentry));
+        fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+        set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
         unlock_dir(lower_dir_dentry);
         if (!rc)
                 d_drop(dentry);
@@ -584,17 +584,17 @@ ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
         lower_dir_dentry = lock_parent(lower_dentry);
-        rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev);
-        if (rc || !lower_dentry->d_inode)
+        rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev);
+        if (rc || d_really_is_negative(lower_dentry))
                 goto out;
         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
         if (rc)
                 goto out;
-        fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
-        fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
+        fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
+        fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 out:
         unlock_dir(lower_dir_dentry);
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 d_drop(dentry);
         return rc;
 }
@@ -617,7 +617,7 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dget(lower_new_dentry);
         lower_old_dir_dentry = dget_parent(lower_old_dentry);
         lower_new_dir_dentry = dget_parent(lower_new_dentry);
-        target_inode = new_dentry->d_inode;
+        target_inode = d_inode(new_dentry);
         trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
         /* source should not be ancestor of target */
         if (trap == lower_old_dentry) {
@@ -629,17 +629,17 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 rc = -ENOTEMPTY;
                 goto out_lock;
         }
-        rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
-                        lower_new_dir_dentry->d_inode, lower_new_dentry,
+        rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
+                        d_inode(lower_new_dir_dentry), lower_new_dentry,
                         NULL, 0);
         if (rc)
                 goto out_lock;
         if (target_inode)
                 fsstack_copy_attr_all(target_inode,
                                       ecryptfs_inode_to_lower(target_inode));
-        fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
+        fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
         if (new_dir != old_dir)
-                fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);
+                fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
 out_lock:
         unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
         dput(lower_new_dir_dentry);
@@ -662,7 +662,7 @@ static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
                 return ERR_PTR(-ENOMEM);
         old_fs = get_fs();
         set_fs(get_ds());
-        rc = lower_dentry->d_inode->i_op->readlink(lower_dentry,
+        rc = d_inode(lower_dentry)->i_op->readlink(lower_dentry,
                                                    (char __user *)lower_buf,
                                                    PATH_MAX);
         set_fs(old_fs);
@@ -681,8 +681,8 @@ static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd)
         char *buf = ecryptfs_readlink_lower(dentry, &len);
         if (IS_ERR(buf))
                 goto out;
-        fsstack_copy_attr_atime(dentry->d_inode,
-                                ecryptfs_dentry_to_lower(dentry)->d_inode);
+        fsstack_copy_attr_atime(d_inode(dentry),
+                                d_inode(ecryptfs_dentry_to_lower(dentry)));
         buf[len] = '\0';
 out:
         nd_set_link(nd, buf);
@@ -738,7 +738,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
                           struct iattr *lower_ia)
 {
         int rc = 0;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ecryptfs_crypt_stat *crypt_stat;
         loff_t i_size = i_size_read(inode);
         loff_t lower_size_before_truncate;
@@ -751,7 +751,7 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
         rc = ecryptfs_get_lower_file(dentry, inode);
         if (rc)
                 return rc;
-        crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+        crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
         /* Switch on growing or shrinking file */
         if (ia->ia_size > i_size) {
                 char zero[] = { 0x00 };
@@ -858,7 +858,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
         struct iattr lower_ia = { .ia_valid = 0 };
         int rc;
 
-        rc = ecryptfs_inode_newsize_ok(dentry->d_inode, new_length);
+        rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
         if (rc)
                 return rc;
 
@@ -866,9 +866,9 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
         if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
                 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 
-                mutex_lock(&lower_dentry->d_inode->i_mutex);
+                mutex_lock(&d_inode(lower_dentry)->i_mutex);
                 rc = notify_change(lower_dentry, &lower_ia, NULL);
-                mutex_unlock(&lower_dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(lower_dentry)->i_mutex);
         }
         return rc;
 }
@@ -900,10 +900,10 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
         struct inode *lower_inode;
         struct ecryptfs_crypt_stat *crypt_stat;
 
-        crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
+        crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
         if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
                 ecryptfs_init_crypt_stat(crypt_stat);
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         lower_inode = ecryptfs_inode_to_lower(inode);
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
         mutex_lock(&crypt_stat->cs_mutex);
@@ -967,9 +967,9 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
         if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
                 lower_ia.ia_valid &= ~ATTR_MODE;
 
-        mutex_lock(&lower_dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(lower_dentry)->i_mutex);
         rc = notify_change(lower_dentry, &lower_ia, NULL);
-        mutex_unlock(&lower_dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
         fsstack_copy_attr_all(inode, lower_inode);
         return rc;
@@ -983,7 +983,7 @@ static int ecryptfs_getattr_link(struct vfsmount *mnt, struct dentry *dentry,
 
         mount_crypt_stat = &ecryptfs_superblock_to_private(
                                                 dentry->d_sb)->mount_crypt_stat;
-        generic_fillattr(dentry->d_inode, stat);
+        generic_fillattr(d_inode(dentry), stat);
         if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
                 char *target;
                 size_t targetsiz;
@@ -1007,9 +1007,9 @@ static int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
         rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat);
         if (!rc) {
-                fsstack_copy_attr_all(dentry->d_inode,
-                                      ecryptfs_inode_to_lower(dentry->d_inode));
-                generic_fillattr(dentry->d_inode, stat);
+                fsstack_copy_attr_all(d_inode(dentry),
+                                      ecryptfs_inode_to_lower(d_inode(dentry)));
+                generic_fillattr(d_inode(dentry), stat);
                 stat->blocks = lower_stat.blocks;
         }
         return rc;
@@ -1023,14 +1023,14 @@ ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value,
         struct dentry *lower_dentry;
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
-        if (!lower_dentry->d_inode->i_op->setxattr) {
+        if (!d_inode(lower_dentry)->i_op->setxattr) {
                 rc = -EOPNOTSUPP;
                 goto out;
         }
 
         rc = vfs_setxattr(lower_dentry, name, value, size, flags);
-        if (!rc && dentry->d_inode)
-                fsstack_copy_attr_all(dentry->d_inode, lower_dentry->d_inode);
+        if (!rc && d_really_is_positive(dentry))
+                fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));
 out:
         return rc;
 }
@@ -1041,14 +1041,14 @@ ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
 {
         int rc = 0;
 
-        if (!lower_dentry->d_inode->i_op->getxattr) {
+        if (!d_inode(lower_dentry)->i_op->getxattr) {
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&lower_dentry->d_inode->i_mutex);
-        rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value,
+        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value,
                                                    size);
-        mutex_unlock(&lower_dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
         return rc;
 }
@@ -1068,13 +1068,13 @@ ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
         struct dentry *lower_dentry;
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
-        if (!lower_dentry->d_inode->i_op->listxattr) {
+        if (!d_inode(lower_dentry)->i_op->listxattr) {
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&lower_dentry->d_inode->i_mutex);
-        rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size);
-        mutex_unlock(&lower_dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
+        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
         return rc;
 }
@@ -1085,13 +1085,13 @@ static int ecryptfs_removexattr(struct dentry *dentry, const char *name)
         struct dentry *lower_dentry;
 
         lower_dentry = ecryptfs_dentry_to_lower(dentry);
-        if (!lower_dentry->d_inode->i_op->removexattr) {
+        if (!d_inode(lower_dentry)->i_op->removexattr) {
                 rc = -EOPNOTSUPP;
                 goto out;
         }
-        mutex_lock(&lower_dentry->d_inode->i_mutex);
-        rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name);
-        mutex_unlock(&lower_dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(lower_dentry)->i_mutex);
+        rc = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name);
+        mutex_unlock(&d_inode(lower_dentry)->i_mutex);
 out:
         return rc;
 }
diff --git a/fs/ecryptfs/kthread.c b/fs/ecryptfs/kthread.c
index f1ea610362c6..866bb18efefe 100644
--- a/fs/ecryptfs/kthread.c
+++ b/fs/ecryptfs/kthread.c
@@ -144,7 +144,7 @@ int ecryptfs_privileged_open(struct file **lower_file,
         /* Corresponding dput() and mntput() are done when the
          * lower file is fput() when all eCryptfs files for the inode are
          * released. */
-        flags |= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR;
+        flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR;
         (*lower_file) = dentry_open(&req.path, flags, cred);
         if (!IS_ERR(*lower_file))
                 goto out;
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index c095d3264259..4f4d0474bee9 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -546,11 +546,11 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                 goto out_free;
         }
 
-        if (check_ruid && !uid_eq(path.dentry->d_inode->i_uid, current_uid())) {
+        if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
                 rc = -EPERM;
                 printk(KERN_ERR "Mount of device (uid: %d) not owned by "
                        "requested user (uid: %d)\n",
-                        i_uid_read(path.dentry->d_inode),
+                        i_uid_read(d_inode(path.dentry)),
                         from_kuid(&init_user_ns, current_uid()));
                 goto out_free;
         }
@@ -584,7 +584,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                 goto out_free;
         }
 
-        inode = ecryptfs_get_inode(path.dentry->d_inode, s);
+        inode = ecryptfs_get_inode(d_inode(path.dentry), s);
         rc = PTR_ERR(inode);
         if (IS_ERR(inode))
                 goto out_free;
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 4626976794e7..cf208522998e 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -420,7 +420,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
         void *xattr_virt;
         struct dentry *lower_dentry =
                 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
-        struct inode *lower_inode = lower_dentry->d_inode;
+        struct inode *lower_inode = d_inode(lower_dentry);
         int rc;
 
         if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {