398 files changed, 3202 insertions, 2897 deletions

diff --git a/Makefile b/Makefile
index 6cc5b2434224..7ff1239f9cd2 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 4
-PATCHLEVEL = 0
+PATCHLEVEL = 1
 SUBLEVEL = 0
-EXTRAVERSION =
+EXTRAVERSION = -rc1
 NAME = Hurr durr I'ma sheep
 
 # *DOCUMENTATION*
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 5f4243f0acfa..60e02f7747ff 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -2159,7 +2159,7 @@ static const struct file_operations pfm_file_ops = {
 static char *pfmfs_dname(struct dentry *dentry, char *buffer, int buflen)
 {
         return dynamic_dname(dentry, buffer, buflen, "pfm:[%lu]",
-                             dentry->d_inode->i_ino);
+                             d_inode(dentry)->i_ino);
 }
 
 static const struct dentry_operations pfmfs_dentry_operations = {
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 1a3429e1ccb5..1ba6307be4db 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -111,7 +111,7 @@ out:
 static int
 spufs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if ((attr->ia_valid & ATTR_SIZE) &&
             (attr->ia_size != inode->i_size))
@@ -163,14 +163,14 @@ static void spufs_prune_dir(struct dentry *dir)
 {
         struct dentry *dentry, *tmp;
 
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
         list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
                 spin_lock(&dentry->d_lock);
-                if (!(d_unhashed(dentry)) && dentry->d_inode) {
+                if (!(d_unhashed(dentry)) && d_really_is_positive(dentry)) {
                         dget_dlock(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
-                        simple_unlink(dir->d_inode, dentry);
+                        simple_unlink(d_inode(dir), dentry);
                         /* XXX: what was dcache_lock protecting here? Other
                          * filesystems (IB, configfs) release dcache_lock
                          * before unlink */
@@ -180,7 +180,7 @@ static void spufs_prune_dir(struct dentry *dir)
                 }
         }
         shrink_dcache_parent(dir);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 }
 
 /* Caller must hold parent->i_mutex */
@@ -192,7 +192,7 @@ static int spufs_rmdir(struct inode *parent, struct dentry *dir)
         d_drop(dir);
         res = simple_rmdir(parent, dir);
         /* We have to give up the mm_struct */
-        spu_forget(SPUFS_I(dir->d_inode)->i_ctx);
+        spu_forget(SPUFS_I(d_inode(dir))->i_ctx);
         return res;
 }
 
@@ -222,8 +222,8 @@ static int spufs_dir_close(struct inode *inode, struct file *file)
         int ret;
 
         dir = file->f_path.dentry;
-        parent = dir->d_parent->d_inode;
-        ctx = SPUFS_I(dir->d_inode)->i_ctx;
+        parent = d_inode(dir->d_parent);
+        ctx = SPUFS_I(d_inode(dir))->i_ctx;
 
         mutex_lock_nested(&parent->i_mutex, I_MUTEX_PARENT);
         ret = spufs_rmdir(parent, dir);
@@ -460,7 +460,7 @@ spufs_create_context(struct inode *inode, struct dentry *dentry,
                 goto out_aff_unlock;
 
         if (affinity) {
-                spufs_set_affinity(flags, SPUFS_I(dentry->d_inode)->i_ctx,
+                spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx,
                                                                 neighbor);
                 if (neighbor)
                         put_spu_context(neighbor);
@@ -504,7 +504,7 @@ spufs_mkgang(struct inode *dir, struct dentry *dentry, umode_t mode)
 
         d_instantiate(dentry, inode);
         inc_nlink(dir);
-        inc_nlink(dentry->d_inode);
+        inc_nlink(d_inode(dentry));
         return ret;
 
 out_iput:
@@ -561,7 +561,7 @@ static struct file_system_type spufs_type;
 long spufs_create(struct path *path, struct dentry *dentry,
                 unsigned int flags, umode_t mode, struct file *filp)
 {
-        struct inode *dir = path->dentry->d_inode;
+        struct inode *dir = d_inode(path->dentry);
         int ret;
 
         /* check if we are on spufs */
diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
index 3f5c799b7fb5..d3f896a35b98 100644
--- a/arch/s390/hypfs/inode.c
+++ b/arch/s390/hypfs/inode.c
@@ -48,7 +48,7 @@ static struct dentry *hypfs_last_dentry;
 static void hypfs_update_update(struct super_block *sb)
 {
         struct hypfs_sb_info *sb_info = sb->s_fs_info;
-        struct inode *inode = sb_info->update_file->d_inode;
+        struct inode *inode = d_inode(sb_info->update_file);
 
         sb_info->last_update = get_seconds();
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
@@ -64,7 +64,7 @@ static void hypfs_add_dentry(struct dentry *dentry)
 
 static inline int hypfs_positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 static void hypfs_remove(struct dentry *dentry)
@@ -72,16 +72,16 @@ static void hypfs_remove(struct dentry *dentry)
         struct dentry *parent;
 
         parent = dentry->d_parent;
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         if (hypfs_positive(dentry)) {
                 if (d_is_dir(dentry))
-                        simple_rmdir(parent->d_inode, dentry);
+                        simple_rmdir(d_inode(parent), dentry);
                 else
-                        simple_unlink(parent->d_inode, dentry);
+                        simple_unlink(d_inode(parent), dentry);
         }
         d_delete(dentry);
         dput(dentry);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 }
 
 static void hypfs_delete_tree(struct dentry *root)
@@ -336,7 +336,7 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         dentry = lookup_one_len(name, parent, strlen(name));
         if (IS_ERR(dentry)) {
                 dentry = ERR_PTR(-ENOMEM);
@@ -357,14 +357,14 @@ static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
         } else if (S_ISDIR(mode)) {
                 inode->i_op = &simple_dir_inode_operations;
                 inode->i_fop = &simple_dir_operations;
-                inc_nlink(parent->d_inode);
+                inc_nlink(d_inode(parent));
         } else
                 BUG();
         inode->i_private = data;
         d_instantiate(dentry, inode);
         dget(dentry);
 fail:
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         return dentry;
 }
 
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index a821b1cd4fa7..72bf2680f819 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -427,6 +427,13 @@ sysretl_from_sys_call:
          * cs and ss are loaded from MSRs.
          * (Note: 32bit->32bit SYSRET is different: since r11
          * does not exist, it merely sets eflags.IF=1).
+         *
+         * NB: On AMD CPUs with the X86_BUG_SYSRET_SS_ATTRS bug, the ss
+         * descriptor is not reinitialized.  This means that we must
+         * avoid SYSRET with SS == NULL, which could happen if we schedule,
+         * exit the kernel, and re-enter using an interrupt vector.  (All
+         * interrupt entries on x86_64 set SS to NULL.)  We prevent that
+         * from happening by reloading SS in __switch_to.
          */
         USERGS_SYSRET32
 
diff --git a/arch/x86/include/asm/cpufeature.h b/arch/x86/include/asm/cpufeature.h
index 7ee9b94d9921..3d6606fb97d0 100644
--- a/arch/x86/include/asm/cpufeature.h
+++ b/arch/x86/include/asm/cpufeature.h
@@ -265,6 +265,7 @@
 #define X86_BUG_11AP            X86_BUG(5) /* Bad local APIC aka 11AP */
 #define X86_BUG_FXSAVE_LEAK     X86_BUG(6) /* FXSAVE leaks FOP/FIP/FOP */
 #define X86_BUG_CLFLUSH_MONITOR X86_BUG(7) /* AAI65, CLFLUSH required before MONITOR */
+#define X86_BUG_SYSRET_SS_ATTRS X86_BUG(8) /* SYSRET doesn't fix up SS attrs */
 
 #if defined(__KERNEL__) && !defined(__ASSEMBLY__)
 
diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
index fd470ebf924e..e4cf63301ff4 100644
--- a/arch/x86/kernel/cpu/amd.c
+++ b/arch/x86/kernel/cpu/amd.c
@@ -720,6 +720,9 @@ static void init_amd(struct cpuinfo_x86 *c)
         if (!cpu_has(c, X86_FEATURE_3DNOWPREFETCH))
                 if (cpu_has(c, X86_FEATURE_3DNOW) || cpu_has(c, X86_FEATURE_LM))
                         set_cpu_cap(c, X86_FEATURE_3DNOWPREFETCH);
+
+        /* AMD CPUs don't reset SS attributes on SYSRET */
+        set_cpu_bug(c, X86_BUG_SYSRET_SS_ATTRS);
 }
 
 #ifdef CONFIG_X86_32
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index c7b238494b31..02c2eff7478d 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -295,6 +295,15 @@ system_call_fastpath:
          * rflags from r11 (but RF and VM bits are forced to 0),
          * cs and ss are loaded from MSRs.
          * Restoration of rflags re-enables interrupts.
+         *
+         * NB: On AMD CPUs with the X86_BUG_SYSRET_SS_ATTRS bug, the ss
+         * descriptor is not reinitialized.  This means that we should
+         * avoid SYSRET with SS == NULL, which could happen if we schedule,
+         * exit the kernel, and re-enter using an interrupt vector.  (All
+         * interrupt entries on x86_64 set SS to NULL.)  We prevent that
+         * from happening by reloading SS in __switch_to.  (Actually
+         * detecting the failure in 64-bit userspace is tricky but can be
+         * done.)
          */
         USERGS_SYSRET64
 
diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
index 4baaa972f52a..ddfdbf74f174 100644
--- a/arch/x86/kernel/process_64.c
+++ b/arch/x86/kernel/process_64.c
@@ -419,6 +419,34 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
                 __switch_to_xtra(prev_p, next_p, tss);
 
+        if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) {
+                /*
+                 * AMD CPUs have a misfeature: SYSRET sets the SS selector but
+                 * does not update the cached descriptor.  As a result, if we
+                 * do SYSRET while SS is NULL, we'll end up in user mode with
+                 * SS apparently equal to __USER_DS but actually unusable.
+                 *
+                 * The straightforward workaround would be to fix it up just
+                 * before SYSRET, but that would slow down the system call
+                 * fast paths.  Instead, we ensure that SS is never NULL in
+                 * system call context.  We do this by replacing NULL SS
+                 * selectors at every context switch.  SYSCALL sets up a valid
+                 * SS, so the only way to get NULL is to re-enter the kernel
+                 * from CPL 3 through an interrupt.  Since that can't happen
+                 * in the same task as a running syscall, we are guaranteed to
+                 * context switch between every interrupt vector entry and a
+                 * subsequent SYSRET.
+                 *
+                 * We read SS first because SS reads are much faster than
+                 * writes.  Out of caution, we force SS to __KERNEL_DS even if
+                 * it previously had a different non-NULL value.
+                 */
+                unsigned short ss_sel;
+                savesegment(ss, ss_sel);
+                if (ss_sel != __KERNEL_DS)
+                        loadsegment(ss, __KERNEL_DS);
+        }
+
         return prev_p;
 }
 
diff --git a/arch/x86/kvm/assigned-dev.c b/arch/x86/kvm/assigned-dev.c
index 6eb5c20ee373..d090ecf08809 100644
--- a/arch/x86/kvm/assigned-dev.c
+++ b/arch/x86/kvm/assigned-dev.c
@@ -666,7 +666,7 @@ static int probe_sysfs_permissions(struct pci_dev *dev)
                 if (r)
                         return r;
 
-                inode = path.dentry->d_inode;
+                inode = d_backing_inode(path.dentry);
 
                 r = inode_permission(inode, MAY_READ | MAY_WRITE | MAY_ACCESS);
                 path_put(&path);
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 25798db14553..68f03141e432 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -157,10 +157,10 @@ static int dev_mkdir(const char *name, umode_t mode)
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        err = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+        err = vfs_mkdir(d_inode(path.dentry), dentry, mode);
         if (!err)
                 /* mark as kernel-created inode */
-                dentry->d_inode->i_private = &thread;
+                d_inode(dentry)->i_private = &thread;
         done_path_create(&path, dentry);
         return err;
 }
@@ -207,7 +207,7 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        err = vfs_mknod(path.dentry->d_inode, dentry, mode, dev->devt);
+        err = vfs_mknod(d_inode(path.dentry), dentry, mode, dev->devt);
         if (!err) {
                 struct iattr newattrs;
 
@@ -215,12 +215,12 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
                 newattrs.ia_uid = uid;
                 newattrs.ia_gid = gid;
                 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID;
-                mutex_lock(&dentry->d_inode->i_mutex);
+                mutex_lock(&d_inode(dentry)->i_mutex);
                 notify_change(dentry, &newattrs, NULL);
-                mutex_unlock(&dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dentry)->i_mutex);
 
                 /* mark as kernel-created inode */
-                dentry->d_inode->i_private = &thread;
+                d_inode(dentry)->i_private = &thread;
         }
         done_path_create(&path, dentry);
         return err;
@@ -235,16 +235,16 @@ static int dev_rmdir(const char *name)
         dentry = kern_path_locked(name, &parent);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
-        if (dentry->d_inode) {
-                if (dentry->d_inode->i_private == &thread)
-                        err = vfs_rmdir(parent.dentry->d_inode, dentry);
+        if (d_really_is_positive(dentry)) {
+                if (d_inode(dentry)->i_private == &thread)
+                        err = vfs_rmdir(d_inode(parent.dentry), dentry);
                 else
                         err = -EPERM;
         } else {
                 err = -ENOENT;
         }
         dput(dentry);
-        mutex_unlock(&parent.dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent.dentry)->i_mutex);
         path_put(&parent);
         return err;
 }
@@ -306,11 +306,11 @@ static int handle_remove(const char *nodename, struct device *dev)
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 struct kstat stat;
                 struct path p = {.mnt = parent.mnt, .dentry = dentry};
                 err = vfs_getattr(&p, &stat);
-                if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
+                if (!err && dev_mynode(dev, d_inode(dentry), &stat)) {
                         struct iattr newattrs;
                         /*
                          * before unlinking this node, reset permissions
@@ -321,10 +321,10 @@ static int handle_remove(const char *nodename, struct device *dev)
                         newattrs.ia_mode = stat.mode & ~0777;
                         newattrs.ia_valid =
                                 ATTR_UID|ATTR_GID|ATTR_MODE;
-                        mutex_lock(&dentry->d_inode->i_mutex);
+                        mutex_lock(&d_inode(dentry)->i_mutex);
                         notify_change(dentry, &newattrs, NULL);
-                        mutex_unlock(&dentry->d_inode->i_mutex);
-                        err = vfs_unlink(parent.dentry->d_inode, dentry, NULL);
+                        mutex_unlock(&d_inode(dentry)->i_mutex);
+                        err = vfs_unlink(d_inode(parent.dentry), dentry, NULL);
                         if (!err || err == -ENOENT)
                                 deleted = 1;
                 }
@@ -332,7 +332,7 @@ static int handle_remove(const char *nodename, struct device *dev)
                 err = -ENOENT;
         }
         dput(dentry);
-        mutex_unlock(&parent.dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent.dentry)->i_mutex);
 
         path_put(&parent);
         if (deleted && strchr(nodename, '/'))
diff --git a/drivers/block/drbd/drbd_debugfs.c b/drivers/block/drbd/drbd_debugfs.c
index 9a950022ff88..a6ee3d750c30 100644
--- a/drivers/block/drbd/drbd_debugfs.c
+++ b/drivers/block/drbd/drbd_debugfs.c
@@ -424,7 +424,7 @@ static int in_flight_summary_show(struct seq_file *m, void *pos)
  * So we have our own inline version of it above.  :-( */
 static inline int debugfs_positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 /* make sure at *open* time that the respective object won't go away. */
@@ -439,15 +439,15 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo
          * or has debugfs_remove() already been called? */
         parent = file->f_path.dentry->d_parent;
         /* not sure if this can happen: */
-        if (!parent || !parent->d_inode)
+        if (!parent || d_really_is_negative(parent))
                 goto out;
         /* serialize with d_delete() */
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         /* Make sure the object is still alive */
         if (debugfs_positive(file->f_path.dentry)
         && kref_get_unless_zero(kref))
                 ret = 0;
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         if (!ret) {
                 ret = single_open(file, show, data);
                 if (ret)
diff --git a/drivers/i2c/busses/i2c-digicolor.c b/drivers/i2c/busses/i2c-digicolor.c
index 03f1e5549896..9604024e0eb0 100644
--- a/drivers/i2c/busses/i2c-digicolor.c
+++ b/drivers/i2c/busses/i2c-digicolor.c
@@ -12,11 +12,10 @@
 
 #include <linux/clk.h>
 #include <linux/completion.h>
+#include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
-#include <linux/clk.h>
-#include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
diff --git a/drivers/i2c/busses/i2c-mxs.c b/drivers/i2c/busses/i2c-mxs.c
index 56fceff6ba14..3e84f6c090a5 100644
--- a/drivers/i2c/busses/i2c-mxs.c
+++ b/drivers/i2c/busses/i2c-mxs.c
@@ -913,7 +913,7 @@ static void __exit mxs_i2c_exit(void)
 module_exit(mxs_i2c_exit);
 
 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
-MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
+MODULE_AUTHOR("Wolfram Sang <kernel@pengutronix.de>");
 MODULE_DESCRIPTION("MXS I2C Bus Driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index 6336f02ec566..3bd2e7d06e4b 100644
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -285,6 +285,6 @@ static struct platform_driver i2c_pca_pf_driver = {
 
 module_platform_driver(i2c_pca_pf_driver);
 
-MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
+MODULE_AUTHOR("Wolfram Sang <kernel@pengutronix.de>");
 MODULE_DESCRIPTION("I2C-PCA9564/PCA9665 platform driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/i2c/busses/i2c-rk3x.c b/drivers/i2c/busses/i2c-rk3x.c
index 5f96b1b3e3a5..019d5426fe52 100644
--- a/drivers/i2c/busses/i2c-rk3x.c
+++ b/drivers/i2c/busses/i2c-rk3x.c
@@ -833,7 +833,7 @@ static int rk3x_i2c_xfer(struct i2c_adapter *adap,
         clk_disable(i2c->clk);
         spin_unlock_irqrestore(&i2c->lock, flags);
 
-        return ret;
+        return ret < 0 ? ret : num;
 }
 
 static u32 rk3x_i2c_func(struct i2c_adapter *adap)
diff --git a/drivers/i2c/busses/i2c-st.c b/drivers/i2c/busses/i2c-st.c
index 88057fad9dfe..ea72dca32fdf 100644
--- a/drivers/i2c/busses/i2c-st.c
+++ b/drivers/i2c/busses/i2c-st.c
@@ -10,17 +10,18 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/i2c.h>
 #include <linux/clk.h>
-#include <linux/io.h>
 #include <linux/delay.h>
-#include <linux/interrupt.h>
 #include <linux/err.h>
-#include <linux/of.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
+#include <linux/of.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/platform_device.h>
 
 /* SSC registers */
 #define SSC_BRG                         0x000
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 098f698fe8f4..987c124432c5 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -1413,6 +1413,8 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
 
         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 
+        pm_runtime_no_callbacks(&adap->dev);
+
 #ifdef CONFIG_I2C_COMPAT
         res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
                                        adap->dev.parent);
diff --git a/drivers/i2c/i2c-mux.c b/drivers/i2c/i2c-mux.c
index 593f7ca9adc7..06cc1ff088f1 100644
--- a/drivers/i2c/i2c-mux.c
+++ b/drivers/i2c/i2c-mux.c
@@ -32,8 +32,9 @@ struct i2c_mux_priv {
         struct i2c_algorithm algo;
 
         struct i2c_adapter *parent;
-        void *mux_priv; /* the mux chip/device */
-        u32  chan_id;   /* the channel id */
+        struct device *mux_dev;
+        void *mux_priv;
+        u32 chan_id;
 
         int (*select)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
         int (*deselect)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
@@ -119,6 +120,7 @@ struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
 
         /* Set up private adapter data */
         priv->parent = parent;
+        priv->mux_dev = mux_dev;
         priv->mux_priv = mux_priv;
         priv->chan_id = chan_id;
         priv->select = select;
@@ -203,7 +205,7 @@ void i2c_del_mux_adapter(struct i2c_adapter *adap)
         char symlink_name[20];
 
         snprintf(symlink_name, sizeof(symlink_name), "channel-%u", priv->chan_id);
-        sysfs_remove_link(&adap->dev.parent->kobj, symlink_name);
+        sysfs_remove_link(&priv->mux_dev->kobj, symlink_name);
 
         sysfs_remove_link(&priv->adap.dev.kobj, "mux_device");
         i2c_del_adapter(adap);
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index 33c45dfcbd88..1ca8e32a9592 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -82,14 +82,14 @@ static int create_file(const char *name, umode_t mode,
 {
         int error;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         *dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(*dentry))
-                error = ipathfs_mknod(parent->d_inode, *dentry,
+                error = ipathfs_mknod(d_inode(parent), *dentry,
                                       mode, fops, data);
         else
                 error = PTR_ERR(*dentry);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 
         return error;
 }
@@ -277,11 +277,11 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!d_unhashed(tmp) && tmp->d_inode) {
+        if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {
                 dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
-                simple_unlink(parent->d_inode, tmp);
+                simple_unlink(d_inode(parent), tmp);
         } else
                 spin_unlock(&tmp->d_lock);
 
@@ -302,7 +302,7 @@ static int remove_device_files(struct super_block *sb,
         int ret;
 
         root = dget(sb->s_root);
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
         snprintf(unit, sizeof unit, "%02d", dd->ipath_unit);
         dir = lookup_one_len(unit, root, strlen(unit));
 
@@ -315,10 +315,10 @@ static int remove_device_files(struct super_block *sb,
         remove_file(dir, "flash");
         remove_file(dir, "atomic_counters");
         d_delete(dir);
-        ret = simple_rmdir(root->d_inode, dir);
+        ret = simple_rmdir(d_inode(root), dir);
 
 bail:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         dput(root);
         return ret;
 }
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 650897a8591e..bdd5d3857203 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -89,14 +89,14 @@ static int create_file(const char *name, umode_t mode,
 {
         int error;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         *dentry = lookup_one_len(name, parent, strlen(name));
         if (!IS_ERR(*dentry))
-                error = qibfs_mknod(parent->d_inode, *dentry,
+                error = qibfs_mknod(d_inode(parent), *dentry,
                                     mode, fops, data);
         else
                 error = PTR_ERR(*dentry);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 
         return error;
 }
@@ -455,10 +455,10 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!d_unhashed(tmp) && tmp->d_inode) {
+        if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
-                simple_unlink(parent->d_inode, tmp);
+                simple_unlink(d_inode(parent), tmp);
         } else {
                 spin_unlock(&tmp->d_lock);
         }
@@ -481,7 +481,7 @@ static int remove_device_files(struct super_block *sb,
         int ret, i;
 
         root = dget(sb->s_root);
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
         snprintf(unit, sizeof(unit), "%u", dd->unit);
         dir = lookup_one_len(unit, root, strlen(unit));
 
@@ -491,7 +491,7 @@ static int remove_device_files(struct super_block *sb,
                 goto bail;
         }
 
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
         remove_file(dir, "counters");
         remove_file(dir, "counter_names");
         remove_file(dir, "portcounter_names");
@@ -506,13 +506,13 @@ static int remove_device_files(struct super_block *sb,
                 }
         }
         remove_file(dir, "flash");
-        mutex_unlock(&dir->d_inode->i_mutex);
-        ret = simple_rmdir(root->d_inode, dir);
+        mutex_unlock(&d_inode(dir)->i_mutex);
+        ret = simple_rmdir(d_inode(root), dir);
         d_delete(dir);
         dput(dir);
 
 bail:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         dput(root);
         return ret;
 }
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index a35927cd42e5..68d43beccb7e 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -50,6 +50,7 @@
 #define CONTEXT_SIZE            VTD_PAGE_SIZE
 
 #define IS_GFX_DEVICE(pdev) ((pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
+#define IS_USB_DEVICE(pdev) ((pdev->class >> 8) == PCI_CLASS_SERIAL_USB)
 #define IS_ISA_DEVICE(pdev) ((pdev->class >> 8) == PCI_CLASS_BRIDGE_ISA)
 #define IS_AZALIA(pdev) ((pdev)->vendor == 0x8086 && (pdev)->device == 0x3a3e)
 
@@ -184,32 +185,11 @@ static int force_on = 0;
  * 64-127: Reserved
  */
 struct root_entry {
-        u64     val;
-        u64     rsvd1;
+        u64     lo;
+        u64     hi;
 };
 #define ROOT_ENTRY_NR (VTD_PAGE_SIZE/sizeof(struct root_entry))
-static inline bool root_present(struct root_entry *root)
-{
-        return (root->val & 1);
-}
-static inline void set_root_present(struct root_entry *root)
-{
-        root->val |= 1;
-}
-static inline void set_root_value(struct root_entry *root, unsigned long value)
-{
-        root->val &= ~VTD_PAGE_MASK;
-        root->val |= value & VTD_PAGE_MASK;
-}
 
-static inline struct context_entry *
-get_context_addr_from_root(struct root_entry *root)
-{
-        return (struct context_entry *)
-                (root_present(root)?phys_to_virt(
-                root->val & VTD_PAGE_MASK) :
-                NULL);
-}
 
 /*
  * low 64 bits:
@@ -682,6 +662,40 @@ static void domain_update_iommu_cap(struct dmar_domain *domain)
         domain->iommu_superpage = domain_update_iommu_superpage(NULL);
 }
 
+static inline struct context_entry *iommu_context_addr(struct intel_iommu *iommu,
+                                                       u8 bus, u8 devfn, int alloc)
+{
+        struct root_entry *root = &iommu->root_entry[bus];
+        struct context_entry *context;
+        u64 *entry;
+
+        if (ecap_ecs(iommu->ecap)) {
+                if (devfn >= 0x80) {
+                        devfn -= 0x80;
+                        entry = &root->hi;
+                }
+                devfn *= 2;
+        }
+        entry = &root->lo;
+        if (*entry & 1)
+                context = phys_to_virt(*entry & VTD_PAGE_MASK);
+        else {
+                unsigned long phy_addr;
+                if (!alloc)
+                        return NULL;
+
+                context = alloc_pgtable_page(iommu->node);
+                if (!context)
+                        return NULL;
+
+                __iommu_flush_cache(iommu, (void *)context, CONTEXT_SIZE);
+                phy_addr = virt_to_phys((void *)context);
+                *entry = phy_addr | 1;
+                __iommu_flush_cache(iommu, entry, sizeof(*entry));
+        }
+        return &context[devfn];
+}
+
 static struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devfn)
 {
         struct dmar_drhd_unit *drhd = NULL;
@@ -741,75 +755,36 @@ static void domain_flush_cache(struct dmar_domain *domain,
                 clflush_cache_range(addr, size);
 }
 
-/* Gets context entry for a given bus and devfn */
-static struct context_entry * device_to_context_entry(struct intel_iommu *iommu,
-                u8 bus, u8 devfn)
-{
-        struct root_entry *root;
-        struct context_entry *context;
-        unsigned long phy_addr;
-        unsigned long flags;
-
-        spin_lock_irqsave(&iommu->lock, flags);
-        root = &iommu->root_entry[bus];
-        context = get_context_addr_from_root(root);
-        if (!context) {
-                context = (struct context_entry *)
-                                alloc_pgtable_page(iommu->node);
-                if (!context) {
-                        spin_unlock_irqrestore(&iommu->lock, flags);
-                        return NULL;
-                }
-                __iommu_flush_cache(iommu, (void *)context, CONTEXT_SIZE);
-                phy_addr = virt_to_phys((void *)context);
-                set_root_value(root, phy_addr);
-                set_root_present(root);
-                __iommu_flush_cache(iommu, root, sizeof(*root));
-        }
-        spin_unlock_irqrestore(&iommu->lock, flags);
-        return &context[devfn];
-}
-
 static int device_context_mapped(struct intel_iommu *iommu, u8 bus, u8 devfn)
 {
-        struct root_entry *root;
         struct context_entry *context;
-        int ret;
+        int ret = 0;
         unsigned long flags;
 
         spin_lock_irqsave(&iommu->lock, flags);
-        root = &iommu->root_entry[bus];
-        context = get_context_addr_from_root(root);
-        if (!context) {
-                ret = 0;
-                goto out;
-        }
-        ret = context_present(&context[devfn]);
-out:
+        context = iommu_context_addr(iommu, bus, devfn, 0);
+        if (context)
+                ret = context_present(context);
         spin_unlock_irqrestore(&iommu->lock, flags);
         return ret;
 }
 
 static void clear_context_table(struct intel_iommu *iommu, u8 bus, u8 devfn)
 {
-        struct root_entry *root;
         struct context_entry *context;
         unsigned long flags;
 
         spin_lock_irqsave(&iommu->lock, flags);
-        root = &iommu->root_entry[bus];
-        context = get_context_addr_from_root(root);
+        context = iommu_context_addr(iommu, bus, devfn, 0);
         if (context) {
-                context_clear_entry(&context[devfn]);
-                __iommu_flush_cache(iommu, &context[devfn], \
-                        sizeof(*context));
+                context_clear_entry(context);
+                __iommu_flush_cache(iommu, context, sizeof(*context));
         }
         spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
 static void free_context_table(struct intel_iommu *iommu)
 {
-        struct root_entry *root;
         int i;
         unsigned long flags;
         struct context_entry *context;
@@ -819,10 +794,17 @@ static void free_context_table(struct intel_iommu *iommu)
                 goto out;
         }
         for (i = 0; i < ROOT_ENTRY_NR; i++) {
-                root = &iommu->root_entry[i];
-                context = get_context_addr_from_root(root);
+                context = iommu_context_addr(iommu, i, 0, 0);
+                if (context)
+                        free_pgtable_page(context);
+
+                if (!ecap_ecs(iommu->ecap))
+                        continue;
+
+                context = iommu_context_addr(iommu, i, 0x80, 0);
                 if (context)
                         free_pgtable_page(context);
+
         }
         free_pgtable_page(iommu->root_entry);
         iommu->root_entry = NULL;
@@ -1146,14 +1128,16 @@ static int iommu_alloc_root_entry(struct intel_iommu *iommu)
 
 static void iommu_set_root_entry(struct intel_iommu *iommu)
 {
-        void *addr;
+        u64 addr;
         u32 sts;
         unsigned long flag;
 
-        addr = iommu->root_entry;
+        addr = virt_to_phys(iommu->root_entry);
+        if (ecap_ecs(iommu->ecap))
+                addr |= DMA_RTADDR_RTT;
 
         raw_spin_lock_irqsave(&iommu->register_lock, flag);
-        dmar_writeq(iommu->reg + DMAR_RTADDR_REG, virt_to_phys(addr));
+        dmar_writeq(iommu->reg + DMAR_RTADDR_REG, addr);
 
         writel(iommu->gcmd | DMA_GCMD_SRTP, iommu->reg + DMAR_GCMD_REG);
 
@@ -1800,7 +1784,9 @@ static int domain_context_mapping_one(struct dmar_domain *domain,
         BUG_ON(translation != CONTEXT_TT_PASS_THROUGH &&
                translation != CONTEXT_TT_MULTI_LEVEL);
 
-        context = device_to_context_entry(iommu, bus, devfn);
+        spin_lock_irqsave(&iommu->lock, flags);
+        context = iommu_context_addr(iommu, bus, devfn, 1);
+        spin_unlock_irqrestore(&iommu->lock, flags);
         if (!context)
                 return -ENOMEM;
         spin_lock_irqsave(&iommu->lock, flags);
@@ -2564,6 +2550,10 @@ static bool device_has_rmrr(struct device *dev)
  * In both cases we assume that PCI USB devices with RMRRs have them largely
  * for historical reasons and that the RMRR space is not actively used post
  * boot.  This exclusion may change if vendors begin to abuse it.
+ *
+ * The same exception is made for graphics devices, with the requirement that
+ * any use of the RMRR regions will be torn down before assigning the device
+ * to a guest.
  */
 static bool device_is_rmrr_locked(struct device *dev)
 {
@@ -2573,7 +2563,7 @@ static bool device_is_rmrr_locked(struct device *dev)
         if (dev_is_pci(dev)) {
                 struct pci_dev *pdev = to_pci_dev(dev);
 
-                if ((pdev->class >> 8) == PCI_CLASS_SERIAL_USB)
+                if (IS_USB_DEVICE(pdev) || IS_GFX_DEVICE(pdev))
                         return false;
         }
 
diff --git a/drivers/iommu/intel_irq_remapping.c b/drivers/iommu/intel_irq_remapping.c
index 6c25b3c5b729..5709ae9c3e77 100644
--- a/drivers/iommu/intel_irq_remapping.c
+++ b/drivers/iommu/intel_irq_remapping.c
@@ -637,10 +637,7 @@ static int __init intel_enable_irq_remapping(void)
         if (x2apic_supported()) {
                 eim = !dmar_x2apic_optout();
                 if (!eim)
-                        printk(KERN_WARNING
-                                "Your BIOS is broken and requested that x2apic be disabled.\n"
-                                "This will slightly decrease performance.\n"
-                                "Use 'intremap=no_x2apic_optout' to override BIOS request.\n");
+                        pr_info("x2apic is disabled because BIOS sets x2apic opt out bit. You can use 'intremap=no_x2apic_optout' to override the BIOS setting.\n");
         }
 
         for_each_iommu(iommu, drhd) {
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 9690cf9aaef5..b7f824d5ee88 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -1169,9 +1169,9 @@ static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
                 return ERR_PTR(err);
 
         /* MTD device number is defined by the major / minor numbers */
-        major = imajor(path.dentry->d_inode);
-        minor = iminor(path.dentry->d_inode);
-        mode = path.dentry->d_inode->i_mode;
+        major = imajor(d_backing_inode(path.dentry));
+        minor = iminor(d_backing_inode(path.dentry));
+        mode = d_backing_inode(path.dentry)->i_mode;
         path_put(&path);
         if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
                 return ERR_PTR(-EINVAL);
diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c
index 478e00cf2d9e..e844887732fb 100644
--- a/drivers/mtd/ubi/kapi.c
+++ b/drivers/mtd/ubi/kapi.c
@@ -314,7 +314,7 @@ struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode)
         if (error)
                 return ERR_PTR(error);
 
-        inode = path.dentry->d_inode;
+        inode = d_backing_inode(path.dentry);
         mod = inode->i_mode;
         ubi_num = ubi_major2num(imajor(inode));
         vol_id = iminor(inode) - 1;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
index f0285bcbe598..371f75e782e5 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
@@ -538,7 +538,7 @@ static ssize_t tp_la_write(struct file *file, const char __user *buf,
         char s[32];
         unsigned long val;
         size_t size = min(sizeof(s) - 1, count);
-        struct adapter *adap = FILE_DATA(file)->i_private;
+        struct adapter *adap = file_inode(file)->i_private;
 
         if (copy_from_user(s, buf, size))
                 return -EFAULT;
@@ -647,7 +647,7 @@ static int pm_stats_open(struct inode *inode, struct file *file)
 static ssize_t pm_stats_clear(struct file *file, const char __user *buf,
                               size_t count, loff_t *pos)
 {
-        struct adapter *adap = FILE_DATA(file)->i_private;
+        struct adapter *adap = file_inode(file)->i_private;
 
         t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0);
         t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0);
@@ -1005,7 +1005,7 @@ static ssize_t mbox_write(struct file *file, const char __user *buf,
                    &data[7], &c) < 8 || c != '\n')
                 return -EINVAL;
 
-        ino = FILE_DATA(file);
+        ino = file_inode(file);
         mbox = (uintptr_t)ino->i_private & 7;
         adap = ino->i_private - mbox;
         addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
@@ -1034,7 +1034,7 @@ static ssize_t flash_read(struct file *file, char __user *buf, size_t count,
                           loff_t *ppos)
 {
         loff_t pos = *ppos;
-        loff_t avail = FILE_DATA(file)->i_size;
+        loff_t avail = file_inode(file)->i_size;
         struct adapter *adap = file->private_data;
 
         if (pos < 0)
@@ -1479,7 +1479,7 @@ static ssize_t rss_key_write(struct file *file, const char __user *buf,
         int i, j;
         u32 key[10];
         char s[100], *p;
-        struct adapter *adap = FILE_DATA(file)->i_private;
+        struct adapter *adap = file_inode(file)->i_private;
 
         if (count > sizeof(s) - 1)
                 return -EINVAL;
@@ -1951,12 +1951,6 @@ static const struct file_operations mem_debugfs_fops = {
         .llseek  = default_llseek,
 };
 
-static void set_debugfs_file_size(struct dentry *de, loff_t size)
-{
-        if (!IS_ERR(de) && de->d_inode)
-                de->d_inode->i_size = size;
-}
-
 static void add_debugfs_mem(struct adapter *adap, const char *name,
                             unsigned int idx, unsigned int size_mb)
 {
@@ -2072,9 +2066,8 @@ int t4_setup_debugfs(struct adapter *adap)
                 }
         }
 
-        de = debugfs_create_file("flash", S_IRUSR, adap->debugfs_root, adap,
-                                 &flash_debugfs_fops);
-        set_debugfs_file_size(de, adap->params.sf_size);
+        de = debugfs_create_file_size("flash", S_IRUSR, adap->debugfs_root, adap,
+                                      &flash_debugfs_fops, adap->params.sf_size);
 
         return 0;
 }
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
index 8f418ba868bd..23f43a0f8950 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h
@@ -37,8 +37,6 @@
 
 #include <linux/export.h>
 
-#define FILE_DATA(_file) ((_file)->f_path.dentry->d_inode)
-
 #define DEFINE_SIMPLE_DEBUGFS_FILE(name) \
 static int name##_open(struct inode *inode, struct file *file) \
 { \
diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index 3f493459378f..dd92c5edf219 100644
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -138,22 +138,22 @@ static int __oprofilefs_create_file(struct dentry *root, char const *name,
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
         dentry = d_alloc_name(root, name);
         if (!dentry) {
-                mutex_unlock(&root->d_inode->i_mutex);
+                mutex_unlock(&d_inode(root)->i_mutex);
                 return -ENOMEM;
         }
         inode = oprofilefs_get_inode(root->d_sb, S_IFREG | perm);
         if (!inode) {
                 dput(dentry);
-                mutex_unlock(&root->d_inode->i_mutex);
+                mutex_unlock(&d_inode(root)->i_mutex);
                 return -ENOMEM;
         }
         inode->i_fop = fops;
         inode->i_private = priv;
         d_add(dentry, inode);
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         return 0;
 }
 
@@ -215,22 +215,22 @@ struct dentry *oprofilefs_mkdir(struct dentry *parent, char const *name)
         struct dentry *dentry;
         struct inode *inode;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         dentry = d_alloc_name(parent, name);
         if (!dentry) {
-                mutex_unlock(&parent->d_inode->i_mutex);
+                mutex_unlock(&d_inode(parent)->i_mutex);
                 return NULL;
         }
         inode = oprofilefs_get_inode(parent->d_sb, S_IFDIR | 0755);
         if (!inode) {
                 dput(dentry);
-                mutex_unlock(&parent->d_inode->i_mutex);
+                mutex_unlock(&d_inode(parent)->i_mutex);
                 return NULL;
         }
         inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
         d_add(dentry, inode);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         return dentry;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/dcache.c b/drivers/staging/lustre/lustre/llite/dcache.c
index fe1fd05423e9..5af01351306d 100644
--- a/drivers/staging/lustre/lustre/llite/dcache.c
+++ b/drivers/staging/lustre/lustre/llite/dcache.c
@@ -153,7 +153,7 @@ static int ll_ddelete(const struct dentry *de)
 
         CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
                d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
-               de, de, de->d_parent, de->d_inode,
+               de, de, de->d_parent, d_inode(de),
                d_unhashed(de) ? "" : "hashed,",
                list_empty(&de->d_subdirs) ? "" : "subdirs");
 
@@ -167,8 +167,8 @@ static int ll_ddelete(const struct dentry *de)
 #if 0
         /* if not ldlm lock for this inode, set i_nlink to 0 so that
          * this inode can be recycled later b=20433 */
-        if (de->d_inode && !find_cbdata(de->d_inode))
-                clear_nlink(de->d_inode);
+        if (d_really_is_positive(de) && !find_cbdata(d_inode(de)))
+                clear_nlink(d_inode(de));
 #endif
 
         if (d_lustre_invalid((struct dentry *)de))
@@ -181,7 +181,7 @@ int ll_d_init(struct dentry *de)
         LASSERT(de != NULL);
 
         CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
-                de, de, de->d_parent, de->d_inode,
+                de, de, de->d_parent, d_inode(de),
                 d_count(de));
 
         if (de->d_fsdata == NULL) {
@@ -261,7 +261,7 @@ void ll_invalidate_aliases(struct inode *inode)
         ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_u.d_alias) {
                 CDEBUG(D_DENTRY, "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
                        dentry, dentry, dentry->d_parent,
-                       dentry->d_inode, dentry->d_flags);
+                       d_inode(dentry), dentry->d_flags);
 
                 d_lustre_invalidate(dentry, 0);
         }
@@ -309,7 +309,7 @@ void ll_lookup_finish_locks(struct lookup_intent *it, struct inode *inode)
 static int ll_revalidate_dentry(struct dentry *dentry,
                                 unsigned int lookup_flags)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
 
         /*
          * if open&create is set, talk to MDS to make sure file is created if
@@ -329,7 +329,7 @@ static int ll_revalidate_dentry(struct dentry *dentry,
         if (lookup_flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        do_statahead_enter(dir, &dentry, dentry->d_inode == NULL);
+        do_statahead_enter(dir, &dentry, d_inode(dentry) == NULL);
         ll_statahead_mark(dir, dentry);
         return 1;
 }
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index 529062ea112b..4b44c634fcc3 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -388,7 +388,7 @@ int ll_file_release(struct inode *inode, struct file *file)
 static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                                int lmmsize, struct lookup_intent *itp)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct dentry *parent = dentry->d_parent;
         const char *name = dentry->d_name.name;
@@ -413,7 +413,7 @@ static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                         opc = LUSTRE_OPC_CREATE;
         }
 
-        op_data  = ll_prep_md_op_data(NULL, parent->d_inode,
+        op_data  = ll_prep_md_op_data(NULL, d_inode(parent),
                                       inode, name, len,
                                       O_RDWR, opc, NULL);
         if (IS_ERR(op_data))
@@ -2896,7 +2896,7 @@ static int ll_inode_revalidate_fini(struct inode *inode, int rc)
 
 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ptlrpc_request *req = NULL;
         struct obd_export *exp;
         int rc = 0;
@@ -2948,12 +2948,12 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
                    here to preserve get_cwd functionality on 2.6.
                    Bug 10503 */
-                if (!dentry->d_inode->i_nlink)
+                if (!d_inode(dentry)->i_nlink)
                         d_lustre_invalidate(dentry, 0);
 
                 ll_lookup_finish_locks(&oit, inode);
-        } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
-                struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
+        } else if (!ll_have_md_lock(d_inode(dentry), &ibits, LCK_MINMODE)) {
+                struct ll_sb_info *sbi = ll_i2sbi(d_inode(dentry));
                 u64 valid = OBD_MD_FLGETATTR;
                 struct md_op_data *op_data;
                 int ealen = 0;
@@ -2991,7 +2991,7 @@ out:
 
 static int ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int rc;
 
         rc = __ll_inode_revalidate(dentry, ibits);
@@ -3019,7 +3019,7 @@ static int ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 
 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
 {
-        struct inode *inode = de->d_inode;
+        struct inode *inode = d_inode(de);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct ll_inode_info *lli = ll_i2info(inode);
         int res = 0;
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index e7422f5c9c6f..5f918e3c4683 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -1488,7 +1488,7 @@ static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
 {
         CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n",
                dentry, dentry,
-               dentry->d_parent, dentry->d_inode, d_count(dentry));
+               dentry->d_parent, d_inode(dentry), d_count(dentry));
 
         spin_lock_nested(&dentry->d_lock,
                          nested ? DENTRY_D_LOCK_NESTED : DENTRY_D_LOCK_NORMAL);
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index bf1ec277a1dc..a27af7882170 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -1166,7 +1166,7 @@ static int ll_md_setattr(struct dentry *dentry, struct md_op_data *op_data,
                   struct md_open_data **mod)
 {
         struct lustre_md md;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct ptlrpc_request *request = NULL;
         int rc, ia_valid;
@@ -1290,7 +1290,7 @@ static int ll_setattr_ost(struct inode *inode, struct iattr *attr)
  */
 int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ll_inode_info *lli = ll_i2info(inode);
         struct md_op_data *op_data = NULL;
         struct md_open_data *mod = NULL;
@@ -1465,7 +1465,7 @@ out:
 
 int ll_setattr(struct dentry *de, struct iattr *attr)
 {
-        int mode = de->d_inode->i_mode;
+        int mode = d_inode(de)->i_mode;
 
         if ((attr->ia_valid & (ATTR_CTIME|ATTR_SIZE|ATTR_MODE)) ==
                               (ATTR_CTIME|ATTR_SIZE|ATTR_MODE))
diff --git a/drivers/staging/lustre/lustre/llite/llite_nfs.c b/drivers/staging/lustre/lustre/llite/llite_nfs.c
index 243a7840457f..db43b81386f7 100644
--- a/drivers/staging/lustre/lustre/llite/llite_nfs.c
+++ b/drivers/staging/lustre/lustre/llite/llite_nfs.c
@@ -230,11 +230,11 @@ static int ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name,
 static int ll_get_name(struct dentry *dentry, char *name,
                        struct dentry *child)
 {
-        struct inode *dir = dentry->d_inode;
+        struct inode *dir = d_inode(dentry);
         int rc;
         struct ll_getname_data lgd = {
                 .lgd_name = name,
-                .lgd_fid = ll_i2info(child->d_inode)->lli_fid,
+                .lgd_fid = ll_i2info(d_inode(child))->lli_fid,
                 .ctx.actor = ll_nfs_get_name_filldir,
         };
 
@@ -282,7 +282,7 @@ static struct dentry *ll_fh_to_parent(struct super_block *sb, struct fid *fid,
 static struct dentry *ll_get_parent(struct dentry *dchild)
 {
         struct ptlrpc_request *req = NULL;
-        struct inode      *dir = dchild->d_inode;
+        struct inode      *dir = d_inode(dchild);
         struct ll_sb_info     *sbi;
         struct dentry    *result = NULL;
         struct mdt_body       *body;
diff --git a/drivers/staging/lustre/lustre/llite/namei.c b/drivers/staging/lustre/lustre/llite/namei.c
index 49f1cb067ea2..5a25dcd10126 100644
--- a/drivers/staging/lustre/lustre/llite/namei.c
+++ b/drivers/staging/lustre/lustre/llite/namei.c
@@ -155,7 +155,7 @@ static void ll_invalidate_negative_children(struct inode *dir)
                         list_for_each_entry_safe(child, tmp_subdir,
                                                  &dentry->d_subdirs,
                                                  d_child) {
-                                if (child->d_inode == NULL)
+                                if (d_really_is_negative(child))
                                         d_lustre_invalidate(child, 1);
                         }
                 }
@@ -392,7 +392,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
                         iput(inode);
                         CDEBUG(D_DENTRY,
                                "Reuse dentry %p inode %p refc %d flags %#x\n",
-                              new, new->d_inode, d_count(new), new->d_flags);
+                              new, d_inode(new), d_count(new), new->d_flags);
                         return new;
                 }
         }
@@ -401,7 +401,7 @@ struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de)
                 return ERR_PTR(rc);
         d_add(de, inode);
         CDEBUG(D_DENTRY, "Add dentry %p inode %p refc %d flags %#x\n",
-               de, de->d_inode, d_count(de), de->d_flags);
+               de, d_inode(de), d_count(de), de->d_flags);
         return de;
 }
 
@@ -448,7 +448,7 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request,
                    !it_disposition(it, DISP_OPEN_CREATE)) {
                 /* With DISP_OPEN_CREATE dentry will
                    instantiated in ll_create_it. */
-                LASSERT((*de)->d_inode == NULL);
+                LASSERT(d_inode(*de) == NULL);
                 d_instantiate(*de, inode);
         }
 
@@ -541,7 +541,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
                 goto out;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         if ((it->it_op & IT_OPEN) && inode &&
             !S_ISREG(inode->i_mode) &&
             !S_ISDIR(inode->i_mode)) {
@@ -638,9 +638,9 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
 
                         *opened |= FILE_CREATED;
                 }
-                if (dentry->d_inode && it_disposition(it, DISP_OPEN_OPEN)) {
+                if (d_really_is_positive(dentry) && it_disposition(it, DISP_OPEN_OPEN)) {
                         /* Open dentry. */
-                        if (S_ISFIFO(dentry->d_inode->i_mode)) {
+                        if (S_ISFIFO(d_inode(dentry)->i_mode)) {
                                 /* We cannot call open here as it would
                                  * deadlock.
                                  */
@@ -862,8 +862,8 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 
 static inline void ll_get_child_fid(struct dentry *child, struct lu_fid *fid)
 {
-        if (child->d_inode)
-                *fid = *ll_inode2fid(child->d_inode);
+        if (d_really_is_positive(child))
+                *fid = *ll_inode2fid(d_inode(child));
 }
 
 /**
@@ -1076,7 +1076,7 @@ static int ll_symlink(struct inode *dir, struct dentry *dentry,
 static int ll_link(struct dentry *old_dentry, struct inode *dir,
                    struct dentry *new_dentry)
 {
-        struct inode *src = old_dentry->d_inode;
+        struct inode *src = d_inode(old_dentry);
         struct ll_sb_info *sbi = ll_i2sbi(dir);
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
diff --git a/drivers/staging/lustre/lustre/llite/statahead.c b/drivers/staging/lustre/lustre/llite/statahead.c
index b75562c6b5de..7f8071242f23 100644
--- a/drivers/staging/lustre/lustre/llite/statahead.c
+++ b/drivers/staging/lustre/lustre/llite/statahead.c
@@ -880,7 +880,7 @@ static int do_sa_lookup(struct inode *dir, struct ll_sa_entry *entry)
 static int do_sa_revalidate(struct inode *dir, struct ll_sa_entry *entry,
                             struct dentry *dentry)
 {
-        struct inode         *inode = dentry->d_inode;
+        struct inode         *inode = d_inode(dentry);
         struct lookup_intent      it = { .it_op = IT_GETATTR,
                                          .d.lustre.it_lock_handle = 0 };
         struct md_enqueue_info   *minfo;
@@ -926,7 +926,7 @@ static int do_sa_revalidate(struct inode *dir, struct ll_sa_entry *entry,
 static void ll_statahead_one(struct dentry *parent, const char *entry_name,
                              int entry_name_len)
 {
-        struct inode         *dir    = parent->d_inode;
+        struct inode         *dir    = d_inode(parent);
         struct ll_inode_info     *lli    = ll_i2info(dir);
         struct ll_statahead_info *sai    = lli->lli_sai;
         struct dentry       *dentry = NULL;
@@ -944,8 +944,8 @@ static void ll_statahead_one(struct dentry *parent, const char *entry_name,
                 rc = do_sa_lookup(dir, entry);
         } else {
                 rc = do_sa_revalidate(dir, entry, dentry);
-                if (rc == 1 && agl_should_run(sai, dentry->d_inode))
-                        ll_agl_add(sai, dentry->d_inode, entry->se_index);
+                if (rc == 1 && agl_should_run(sai, d_inode(dentry)))
+                        ll_agl_add(sai, d_inode(dentry), entry->se_index);
         }
 
         if (dentry != NULL)
@@ -968,7 +968,7 @@ static void ll_statahead_one(struct dentry *parent, const char *entry_name,
 static int ll_agl_thread(void *arg)
 {
         struct dentry       *parent = (struct dentry *)arg;
-        struct inode         *dir    = parent->d_inode;
+        struct inode         *dir    = d_inode(parent);
         struct ll_inode_info     *plli   = ll_i2info(dir);
         struct ll_inode_info     *clli;
         struct ll_sb_info       *sbi    = ll_i2sbi(dir);
@@ -1042,7 +1042,7 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
         CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n",
                sai, parent);
 
-        plli = ll_i2info(parent->d_inode);
+        plli = ll_i2info(d_inode(parent));
         task = kthread_run(ll_agl_thread, parent,
                                "ll_agl_%u", plli->lli_opendir_pid);
         if (IS_ERR(task)) {
@@ -1059,7 +1059,7 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
 static int ll_statahead_thread(void *arg)
 {
         struct dentry       *parent = (struct dentry *)arg;
-        struct inode         *dir    = parent->d_inode;
+        struct inode         *dir    = d_inode(parent);
         struct ll_inode_info     *plli   = ll_i2info(dir);
         struct ll_inode_info     *clli;
         struct ll_sb_info       *sbi    = ll_i2sbi(dir);
@@ -1604,7 +1604,7 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                         rc = md_revalidate_lock(ll_i2mdexp(dir), &it,
                                                 ll_inode2fid(inode), &bits);
                         if (rc == 1) {
-                                if ((*dentryp)->d_inode == NULL) {
+                                if (d_inode(*dentryp) == NULL) {
                                         struct dentry *alias;
 
                                         alias = ll_splice_alias(inode,
@@ -1614,13 +1614,13 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                                                 return PTR_ERR(alias);
                                         }
                                         *dentryp = alias;
-                                } else if ((*dentryp)->d_inode != inode) {
+                                } else if (d_inode(*dentryp) != inode) {
                                         /* revalidate, but inode is recreated */
                                         CDEBUG(D_READA,
                                               "stale dentry %pd inode %lu/%u, statahead inode %lu/%u\n",
                                               *dentryp,
-                                              (*dentryp)->d_inode->i_ino,
-                                              (*dentryp)->d_inode->i_generation,
+                                              d_inode(*dentryp)->i_ino,
+                                              d_inode(*dentryp)->i_generation,
                                               inode->i_ino,
                                               inode->i_generation);
                                         ll_sai_unplug(sai, entry);
@@ -1666,8 +1666,8 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
 
         /* get parent reference count here, and put it in ll_statahead_thread */
         parent = dget((*dentryp)->d_parent);
-        if (unlikely(sai->sai_inode != parent->d_inode)) {
-                struct ll_inode_info *nlli = ll_i2info(parent->d_inode);
+        if (unlikely(sai->sai_inode != d_inode(parent))) {
+                struct ll_inode_info *nlli = ll_i2info(d_inode(parent));
 
                 CWARN("Race condition, someone changed %pd just now: old parent "DFID", new parent "DFID"\n",
                       *dentryp,
@@ -1689,7 +1689,7 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
         ll_sai_get(sai);
         lli->lli_sai = sai;
 
-        plli = ll_i2info(parent->d_inode);
+        plli = ll_i2info(d_inode(parent));
         rc = PTR_ERR(kthread_run(ll_statahead_thread, parent,
                                  "ll_sa_%u", plli->lli_opendir_pid));
         thread = &sai->sai_thread;
diff --git a/drivers/staging/lustre/lustre/llite/symlink.c b/drivers/staging/lustre/lustre/llite/symlink.c
index 686b6a574cc5..3711e671a4df 100644
--- a/drivers/staging/lustre/lustre/llite/symlink.c
+++ b/drivers/staging/lustre/lustre/llite/symlink.c
@@ -120,7 +120,7 @@ failed:
 
 static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ptlrpc_request *request = NULL;
         int rc;
         char *symname = NULL;
diff --git a/drivers/staging/lustre/lustre/llite/xattr.c b/drivers/staging/lustre/lustre/llite/xattr.c
index b439936b4524..e0fcbe1395fd 100644
--- a/drivers/staging/lustre/lustre/llite/xattr.c
+++ b/drivers/staging/lustre/lustre/llite/xattr.c
@@ -214,7 +214,7 @@ int ll_setxattr_common(struct inode *inode, const char *name,
 int ll_setxattr(struct dentry *dentry, const char *name,
                 const void *value, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         LASSERT(inode);
         LASSERT(name);
@@ -267,7 +267,7 @@ int ll_setxattr(struct dentry *dentry, const char *name,
 
 int ll_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         LASSERT(inode);
         LASSERT(name);
@@ -457,7 +457,7 @@ out:
 ssize_t ll_getxattr(struct dentry *dentry, const char *name,
                     void *buffer, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         LASSERT(inode);
         LASSERT(name);
@@ -545,7 +545,7 @@ out:
 
 ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int rc = 0, rc2 = 0;
         struct lov_mds_md *lmm = NULL;
         struct ptlrpc_request *request = NULL;
diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c
index 6af58c6dba5e..2030565c6789 100644
--- a/drivers/usb/gadget/legacy/inode.c
+++ b/drivers/usb/gadget/legacy/inode.c
@@ -1505,7 +1505,7 @@ static void destroy_ep_files (struct dev_data *dev)
                 list_del_init (&ep->epfiles);
                 dentry = ep->dentry;
                 ep->dentry = NULL;
-                parent = dentry->d_parent->d_inode;
+                parent = d_inode(dentry->d_parent);
 
                 /* break link to controller */
                 if (ep->state == STATE_EP_ENABLED)
diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 8482f2d11606..31c010372660 100644
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -247,7 +247,7 @@ static int v9fs_xattr_get_acl(struct dentry *dentry, const char *name,
         if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
                 return v9fs_remote_get_acl(dentry, name, buffer, size, type);
 
-        acl = v9fs_get_cached_acl(dentry->d_inode, type);
+        acl = v9fs_get_cached_acl(d_inode(dentry), type);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl == NULL)
@@ -285,7 +285,7 @@ static int v9fs_xattr_set_acl(struct dentry *dentry, const char *name,
         int retval;
         struct posix_acl *acl;
         struct v9fs_session_info *v9ses;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (strcmp(name, "") != 0)
                 return -EINVAL;
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index a345b2d659cc..bd456c668d39 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -53,7 +53,7 @@ static int v9fs_cached_dentry_delete(const struct dentry *dentry)
                  dentry, dentry);
 
         /* Don't cache negative dentries */
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 return 1;
         return 0;
 }
@@ -83,7 +83,7 @@ static int v9fs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         if (!inode)
                 goto out_valid;
 
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 76c3b1ab6361..5cc00e56206e 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -138,6 +138,8 @@ static int v9fs_dir_readdir(struct file *file, struct dir_context *ctx)
                                            &err);
                         if (err)
                                 return err;
+                        if (n == 0)
+                                return 0;
 
                         rdir->head = 0;
                         rdir->tail = n;
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 3662f1d1d9cf..703342e309f5 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -595,7 +595,7 @@ static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
                  dir, dentry, flags);
 
         v9ses = v9fs_inode2v9ses(dir);
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         dfid = v9fs_fid_lookup(dentry->d_parent);
         if (IS_ERR(dfid)) {
                 retval = PTR_ERR(dfid);
@@ -864,7 +864,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
         }
 
         /* Only creates */
-        if (!(flags & O_CREAT) || dentry->d_inode)
+        if (!(flags & O_CREAT) || d_really_is_positive(dentry))
                 return finish_no_open(file, res);
 
         err = 0;
@@ -881,7 +881,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
         }
 
         v9fs_invalidate_inode_attr(dir);
-        v9inode = V9FS_I(dentry->d_inode);
+        v9inode = V9FS_I(d_inode(dentry));
         mutex_lock(&v9inode->v_mutex);
         if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) &&
             !v9inode->writeback_fid &&
@@ -908,7 +908,7 @@ v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
 
         file->private_data = fid;
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
-                v9fs_cache_inode_set_cookie(dentry->d_inode, file);
+                v9fs_cache_inode_set_cookie(d_inode(dentry), file);
 
         *opened |= FILE_CREATED;
 out:
@@ -969,8 +969,8 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         p9_debug(P9_DEBUG_VFS, "\n");
         retval = 0;
-        old_inode = old_dentry->d_inode;
-        new_inode = new_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
+        new_inode = d_inode(new_dentry);
         v9ses = v9fs_inode2v9ses(old_inode);
         oldfid = v9fs_fid_lookup(old_dentry);
         if (IS_ERR(oldfid))
@@ -1061,7 +1061,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
         v9ses = v9fs_dentry2v9ses(dentry);
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                generic_fillattr(dentry->d_inode, stat);
+                generic_fillattr(d_inode(dentry), stat);
                 return 0;
         }
         fid = v9fs_fid_lookup(dentry);
@@ -1072,8 +1072,8 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         if (IS_ERR(st))
                 return PTR_ERR(st);
 
-        v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
-        generic_fillattr(dentry->d_inode, stat);
+        v9fs_stat2inode(st, d_inode(dentry), d_inode(dentry)->i_sb);
+        generic_fillattr(d_inode(dentry), stat);
 
         p9stat_free(st);
         kfree(st);
@@ -1095,7 +1095,7 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
         struct p9_wstat wstat;
 
         p9_debug(P9_DEBUG_VFS, "\n");
-        retval = inode_change_ok(dentry->d_inode, iattr);
+        retval = inode_change_ok(d_inode(dentry), iattr);
         if (retval)
                 return retval;
 
@@ -1128,20 +1128,20 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 
         /* Write all dirty data */
         if (d_is_reg(dentry))
-                filemap_write_and_wait(dentry->d_inode->i_mapping);
+                filemap_write_and_wait(d_inode(dentry)->i_mapping);
 
         retval = p9_client_wstat(fid, &wstat);
         if (retval < 0)
                 return retval;
 
         if ((iattr->ia_valid & ATTR_SIZE) &&
-            iattr->ia_size != i_size_read(dentry->d_inode))
-                truncate_setsize(dentry->d_inode, iattr->ia_size);
+            iattr->ia_size != i_size_read(d_inode(dentry)))
+                truncate_setsize(d_inode(dentry), iattr->ia_size);
 
-        v9fs_invalidate_inode_attr(dentry->d_inode);
+        v9fs_invalidate_inode_attr(d_inode(dentry));
 
-        setattr_copy(dentry->d_inode, iattr);
-        mark_inode_dirty(dentry->d_inode);
+        setattr_copy(d_inode(dentry), iattr);
+        mark_inode_dirty(d_inode(dentry));
         return 0;
 }
 
@@ -1403,7 +1403,7 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
         retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
         __putname(name);
         if (!retval) {
-                v9fs_refresh_inode(oldfid, old_dentry->d_inode);
+                v9fs_refresh_inode(oldfid, d_inode(old_dentry));
                 v9fs_invalidate_inode_attr(dir);
         }
 clunk_fid:
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 6054c16b8fae..9861c7c951a6 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -265,7 +265,7 @@ v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
         }
 
         /* Only creates */
-        if (!(flags & O_CREAT) || dentry->d_inode)
+        if (!(flags & O_CREAT) || d_really_is_positive(dentry))
                 return  finish_no_open(file, res);
 
         v9ses = v9fs_inode2v9ses(dir);
@@ -481,7 +481,7 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
         p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
         v9ses = v9fs_dentry2v9ses(dentry);
         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
-                generic_fillattr(dentry->d_inode, stat);
+                generic_fillattr(d_inode(dentry), stat);
                 return 0;
         }
         fid = v9fs_fid_lookup(dentry);
@@ -496,8 +496,8 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
         if (IS_ERR(st))
                 return PTR_ERR(st);
 
-        v9fs_stat2inode_dotl(st, dentry->d_inode);
-        generic_fillattr(dentry->d_inode, stat);
+        v9fs_stat2inode_dotl(st, d_inode(dentry));
+        generic_fillattr(d_inode(dentry), stat);
         /* Change block size to what the server returned */
         stat->blksize = st->st_blksize;
 
@@ -557,7 +557,7 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
         int retval;
         struct p9_fid *fid;
         struct p9_iattr_dotl p9attr;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         p9_debug(P9_DEBUG_VFS, "\n");
 
@@ -795,10 +795,10 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
                 if (IS_ERR(fid))
                         return PTR_ERR(fid);
 
-                v9fs_refresh_inode_dotl(fid, old_dentry->d_inode);
+                v9fs_refresh_inode_dotl(fid, d_inode(old_dentry));
         }
-        ihold(old_dentry->d_inode);
-        d_instantiate(dentry, old_dentry->d_inode);
+        ihold(d_inode(old_dentry));
+        d_instantiate(dentry, d_inode(old_dentry));
 
         return err;
 }
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 0afd0382822b..e99a338a4638 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -168,8 +168,8 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                         retval = PTR_ERR(st);
                         goto release_sb;
                 }
-                root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
-                v9fs_stat2inode_dotl(st, root->d_inode);
+                d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
+                v9fs_stat2inode_dotl(st, d_inode(root));
                 kfree(st);
         } else {
                 struct p9_wstat *st = NULL;
@@ -179,8 +179,8 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                         goto release_sb;
                 }
 
-                root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
-                v9fs_stat2inode(st, root->d_inode, sb);
+                d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
+                v9fs_stat2inode(st, d_inode(root), sb);
 
                 p9stat_free(st);
                 kfree(st);
diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index b9acadafa4a1..335055d828e4 100644
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -298,7 +298,7 @@ out:
 int
 adfs_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = inode->i_sb;
         unsigned int ia_valid = attr->ia_valid;
         int error;
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 5022ac96aa40..a8f463c028ce 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -138,7 +138,7 @@ affs_fix_dcache(struct inode *inode, u32 entry_ino)
 static int
 affs_remove_link(struct dentry *dentry)
 {
-        struct inode *dir, *inode = dentry->d_inode;
+        struct inode *dir, *inode = d_inode(dentry);
         struct super_block *sb = inode->i_sb;
         struct buffer_head *bh = NULL, *link_bh = NULL;
         u32 link_ino, ino;
@@ -268,11 +268,11 @@ affs_remove_header(struct dentry *dentry)
         struct buffer_head *bh = NULL;
         int retval;
 
-        dir = dentry->d_parent->d_inode;
+        dir = d_inode(dentry->d_parent);
         sb = dir->i_sb;
 
         retval = -ENOENT;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         if (!inode)
                 goto done;
 
@@ -471,10 +471,9 @@ affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
 bool
 affs_nofilenametruncate(const struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         return affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_NO_TRUNCATE);
-
 }
 
 /* Check if the name is valid for a affs object. */
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 9628003ccd2f..a022f4accd76 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -213,7 +213,7 @@ affs_write_inode(struct inode *inode, struct writeback_control *wbc)
 int
 affs_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index ec8ca0efb960..181e05b46e72 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -251,7 +251,7 @@ int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
         pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
-                 dentry->d_inode->i_ino, dentry);
+                 d_inode(dentry)->i_ino, dentry);
 
         return affs_remove_header(dentry);
 }
@@ -320,7 +320,7 @@ int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
         pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
-                 dentry->d_inode->i_ino, dentry);
+                 d_inode(dentry)->i_ino, dentry);
 
         return affs_remove_header(dentry);
 }
@@ -403,7 +403,7 @@ err:
 int
 affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
                  dentry);
@@ -430,13 +430,13 @@ affs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 return retval;
 
         /* Unlink destination if it already exists */
-        if (new_dentry->d_inode) {
+        if (d_really_is_positive(new_dentry)) {
                 retval = affs_remove_header(new_dentry);
                 if (retval)
                         return retval;
         }
 
-        bh = affs_bread(sb, old_dentry->d_inode->i_ino);
+        bh = affs_bread(sb, d_inode(old_dentry)->i_ino);
         if (!bh)
                 return -EIO;
 
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 4ec35e9130e1..e10e17788f06 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -505,7 +505,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
         _enter("{%x:%u},%p{%pd},",
                vnode->fid.vid, vnode->fid.vnode, dentry, dentry);
 
-        ASSERTCMP(dentry->d_inode, ==, NULL);
+        ASSERTCMP(d_inode(dentry), ==, NULL);
 
         if (dentry->d_name.len >= AFSNAMEMAX) {
                 _leave(" = -ENAMETOOLONG");
@@ -563,8 +563,8 @@ success:
         _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",
                fid.vnode,
                fid.unique,
-               dentry->d_inode->i_ino,
-               dentry->d_inode->i_generation);
+               d_inode(dentry)->i_ino,
+               d_inode(dentry)->i_generation);
 
         return NULL;
 }
@@ -586,9 +586,9 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        vnode = AFS_FS_I(dentry->d_inode);
+        vnode = AFS_FS_I(d_inode(dentry));
 
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 _enter("{v={%x:%u} n=%pd fl=%lx},",
                        vnode->fid.vid, vnode->fid.vnode, dentry,
                        vnode->flags);
@@ -601,7 +601,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
 
         /* lock down the parent dentry so we can peer at it */
         parent = dget_parent(dentry);
-        dir = AFS_FS_I(parent->d_inode);
+        dir = AFS_FS_I(d_inode(parent));
 
         /* validate the parent directory */
         if (test_bit(AFS_VNODE_MODIFIED, &dir->flags))
@@ -623,9 +623,9 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
         switch (ret) {
         case 0:
                 /* the filename maps to something */
-                if (!dentry->d_inode)
+                if (d_really_is_negative(dentry))
                         goto out_bad;
-                if (is_bad_inode(dentry->d_inode)) {
+                if (is_bad_inode(d_inode(dentry))) {
                         printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
                                dentry);
                         goto out_bad;
@@ -647,7 +647,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
                         _debug("%pd: file deleted (uq %u -> %u I:%u)",
                                dentry, fid.unique,
                                vnode->fid.unique,
-                               dentry->d_inode->i_generation);
+                               d_inode(dentry)->i_generation);
                         spin_lock(&vnode->lock);
                         set_bit(AFS_VNODE_DELETED, &vnode->flags);
                         spin_unlock(&vnode->lock);
@@ -658,7 +658,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
         case -ENOENT:
                 /* the filename is unknown */
                 _debug("%pd: dirent not found", dentry);
-                if (dentry->d_inode)
+                if (d_really_is_positive(dentry))
                         goto not_found;
                 goto out_valid;
 
@@ -703,9 +703,9 @@ static int afs_d_delete(const struct dentry *dentry)
         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
                 goto zap;
 
-        if (dentry->d_inode &&
-            (test_bit(AFS_VNODE_DELETED,   &AFS_FS_I(dentry->d_inode)->flags) ||
-             test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(dentry->d_inode)->flags)))
+        if (d_really_is_positive(dentry) &&
+            (test_bit(AFS_VNODE_DELETED,   &AFS_FS_I(d_inode(dentry))->flags) ||
+             test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))
                 goto zap;
 
         _leave(" = 0 [keep]");
@@ -814,8 +814,8 @@ static int afs_rmdir(struct inode *dir, struct dentry *dentry)
         if (ret < 0)
                 goto rmdir_error;
 
-        if (dentry->d_inode) {
-                vnode = AFS_FS_I(dentry->d_inode);
+        if (d_really_is_positive(dentry)) {
+                vnode = AFS_FS_I(d_inode(dentry));
                 clear_nlink(&vnode->vfs_inode);
                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
                 afs_discard_callback_on_delete(vnode);
@@ -856,8 +856,8 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
                 goto error;
         }
 
-        if (dentry->d_inode) {
-                vnode = AFS_FS_I(dentry->d_inode);
+        if (d_really_is_positive(dentry)) {
+                vnode = AFS_FS_I(d_inode(dentry));
 
                 /* make sure we have a callback promise on the victim */
                 ret = afs_validate(vnode, key);
@@ -869,7 +869,7 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
         if (ret < 0)
                 goto remove_error;
 
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 /* if the file wasn't deleted due to excess hard links, the
                  * fileserver will break the callback promise on the file - if
                  * it had one - before it returns to us, and if it was deleted,
@@ -879,7 +879,7 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
                  * or it was outstanding on a different server, then it won't
                  * break it either...
                  */
-                vnode = AFS_FS_I(dentry->d_inode);
+                vnode = AFS_FS_I(d_inode(dentry));
                 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
                         _debug("AFS_VNODE_DELETED");
                 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
@@ -977,7 +977,7 @@ static int afs_link(struct dentry *from, struct inode *dir,
         struct key *key;
         int ret;
 
-        vnode = AFS_FS_I(from->d_inode);
+        vnode = AFS_FS_I(d_inode(from));
         dvnode = AFS_FS_I(dir);
 
         _enter("{%x:%u},{%x:%u},{%pd}",
@@ -1089,7 +1089,7 @@ static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct key *key;
         int ret;
 
-        vnode = AFS_FS_I(old_dentry->d_inode);
+        vnode = AFS_FS_I(d_inode(old_dentry));
         orig_dvnode = AFS_FS_I(old_dir);
         new_dvnode = AFS_FS_I(new_dir);
 
diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index 8a1d38ef0fc2..e06f5a23352a 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -379,7 +379,7 @@ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 {
         struct inode *inode;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
 
@@ -458,7 +458,7 @@ void afs_evict_inode(struct inode *inode)
  */
 int afs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
         struct key *key;
         int ret;
 
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 938c5ab06d5a..ccd0b212e82a 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -134,7 +134,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
 
         _enter("{%pd}", mntpt);
 
-        BUG_ON(!mntpt->d_inode);
+        BUG_ON(!d_inode(mntpt));
 
         ret = -ENOMEM;
         devname = (char *) get_zeroed_page(GFP_KERNEL);
@@ -145,7 +145,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
         if (!options)
                 goto error_no_options;
 
-        vnode = AFS_FS_I(mntpt->d_inode);
+        vnode = AFS_FS_I(d_inode(mntpt));
         if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) {
                 /* if the directory is a pseudo directory, use the d_name */
                 static const char afs_root_cell[] = ":root.cell.";
@@ -169,14 +169,14 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
                 }
         } else {
                 /* read the contents of the AFS special symlink */
-                loff_t size = i_size_read(mntpt->d_inode);
+                loff_t size = i_size_read(d_inode(mntpt));
                 char *buf;
 
                 ret = -EINVAL;
                 if (size > PAGE_SIZE - 1)
                         goto error_no_page;
 
-                page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL);
+                page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL);
                 if (IS_ERR(page)) {
                         ret = PTR_ERR(page);
                         goto error_no_page;
diff --git a/fs/afs/super.c b/fs/afs/super.c
index c4861557e385..1fb4a5129f7d 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -529,7 +529,7 @@ static void afs_destroy_inode(struct inode *inode)
 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct afs_volume_status vs;
-        struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
         struct key *key;
         int ret;
 
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index d10e619632ab..5b700ef1e59d 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -235,12 +235,12 @@ static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
 
 static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
 {
-        return sbi->sb->s_root->d_inode->i_ino;
+        return d_inode(sbi->sb->s_root)->i_ino;
 }
 
 static inline int simple_positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 static inline void __autofs4_add_expiring(struct dentry *dentry)
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index 11dd118f75e2..1cebc3c52fa5 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -374,7 +374,7 @@ static struct dentry *should_expire(struct dentry *dentry,
                 return NULL;
         }
 
-        if (dentry->d_inode && d_is_symlink(dentry)) {
+        if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
                 DPRINTK("checking symlink %p %pd", dentry, dentry);
                 /*
                  * A symlink can't be "busy" in the usual sense so
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 1c55388ae633..a3ae0b2aeb5a 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -71,7 +71,7 @@ void autofs4_kill_sb(struct super_block *sb)
 static int autofs4_show_options(struct seq_file *m, struct dentry *root)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
-        struct inode *root_inode = root->d_sb->s_root->d_inode;
+        struct inode *root_inode = d_inode(root->d_sb->s_root);
 
         if (!sbi)
                 return 0;
@@ -352,8 +352,8 @@ struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode)
 
         inode->i_mode = mode;
         if (sb->s_root) {
-                inode->i_uid = sb->s_root->d_inode->i_uid;
-                inode->i_gid = sb->s_root->d_inode->i_gid;
+                inode->i_uid = d_inode(sb->s_root)->i_uid;
+                inode->i_gid = d_inode(sb->s_root)->i_gid;
         }
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         inode->i_ino = get_next_ino();
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 7e44fdd03e2d..c6d7d3dbd52a 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -240,7 +240,7 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry,
                 spin_lock(&expiring->d_lock);
 
                 /* We've already been dentry_iput or unlinked */
-                if (!expiring->d_inode)
+                if (d_really_is_negative(expiring))
                         goto next;
 
                 qstr = &expiring->d_name;
@@ -371,7 +371,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
          * having d_mountpoint() true, so there's no need to call back
          * to the daemon.
          */
-        if (dentry->d_inode && d_is_symlink(dentry)) {
+        if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
                 spin_unlock(&sbi->fs_lock);
                 goto done;
         }
@@ -459,7 +459,7 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
                         return 0;
                 if (d_mountpoint(dentry))
                         return 0;
-                inode = ACCESS_ONCE(dentry->d_inode);
+                inode = d_inode_rcu(dentry);
                 if (inode && S_ISLNK(inode->i_mode))
                         return -EISDIR;
                 if (list_empty(&dentry->d_subdirs))
@@ -485,7 +485,7 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
                  * an incorrect ELOOP error return.
                  */
                 if ((!d_mountpoint(dentry) && !simple_empty(dentry)) ||
-                    (dentry->d_inode && d_is_symlink(dentry)))
+                    (d_really_is_positive(dentry) && d_is_symlink(dentry)))
                         status = -EISDIR;
         }
         spin_unlock(&sbi->fs_lock);
@@ -625,8 +625,8 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
         }
         dput(ino->dentry);
 
-        dentry->d_inode->i_size = 0;
-        clear_nlink(dentry->d_inode);
+        d_inode(dentry)->i_size = 0;
+        clear_nlink(d_inode(dentry));
 
         dir->i_mtime = CURRENT_TIME;
 
@@ -719,8 +719,8 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
                         atomic_dec(&p_ino->count);
         }
         dput(ino->dentry);
-        dentry->d_inode->i_size = 0;
-        clear_nlink(dentry->d_inode);
+        d_inode(dentry)->i_size = 0;
+        clear_nlink(d_inode(dentry));
 
         if (dir->i_nlink)
                 drop_nlink(dir);
@@ -839,7 +839,7 @@ static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
 */
 int is_autofs4_dentry(struct dentry *dentry)
 {
-        return dentry && dentry->d_inode &&
+        return dentry && d_really_is_positive(dentry) &&
                 dentry->d_op == &autofs4_dentry_operations &&
                 dentry->d_fsdata != NULL;
 }
diff --git a/fs/autofs4/symlink.c b/fs/autofs4/symlink.c
index 1e8ea192be2b..de58cc7b8076 100644
--- a/fs/autofs4/symlink.c
+++ b/fs/autofs4/symlink.c
@@ -18,7 +18,7 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         if (ino && !autofs4_oz_mode(sbi))
                 ino->last_used = jiffies;
-        nd_set_link(nd, dentry->d_inode->i_private);
+        nd_set_link(nd, d_inode(dentry)->i_private);
         return NULL;
 }
 
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index 2ad05ab93db8..35b755e79c2d 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -322,7 +322,7 @@ static int validate_request(struct autofs_wait_queue **wait,
                  * continue on and create a new request.
                  */
                 if (!IS_ROOT(dentry)) {
-                        if (dentry->d_inode && d_unhashed(dentry)) {
+                        if (d_really_is_positive(dentry) && d_unhashed(dentry)) {
                                 struct dentry *parent = dentry->d_parent;
                                 new = d_lookup(parent, &dentry->d_name);
                                 if (new)
@@ -364,7 +364,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
         if (pid == 0 || tgid == 0)
                 return -ENOENT;
 
-        if (!dentry->d_inode) {
+        if (d_really_is_negative(dentry)) {
                 /*
                  * A wait for a negative dentry is invalid for certain
                  * cases. A direct or offset mount "always" has its mount
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 16e0a48bfccd..7943533c3868 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -471,7 +471,7 @@ static void *
 befs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
         struct super_block *sb = dentry->d_sb;
-        struct befs_inode_info *befs_ino = BEFS_I(dentry->d_inode);
+        struct befs_inode_info *befs_ino = BEFS_I(d_inode(dentry));
         befs_data_stream *data = &befs_ino->i_data.ds;
         befs_off_t len = data->size;
         char *link;
@@ -501,7 +501,7 @@ befs_follow_link(struct dentry *dentry, struct nameidata *nd)
 static void *
 befs_fast_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct befs_inode_info *befs_ino = BEFS_I(dentry->d_inode);
+        struct befs_inode_info *befs_ino = BEFS_I(d_inode(dentry));
 
         nd_set_link(nd, befs_ino->i_data.symlink);
         return NULL;
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 7a8182770649..3ec6113146c0 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -153,7 +153,7 @@ static struct dentry *bfs_lookup(struct inode *dir, struct dentry *dentry,
 static int bfs_link(struct dentry *old, struct inode *dir,
                                                 struct dentry *new)
 {
-        struct inode *inode = old->d_inode;
+        struct inode *inode = d_inode(old);
         struct bfs_sb_info *info = BFS_SB(inode->i_sb);
         int err;
 
@@ -176,7 +176,7 @@ static int bfs_link(struct dentry *old, struct inode *dir,
 static int bfs_unlink(struct inode *dir, struct dentry *dentry)
 {
         int error = -ENOENT;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct buffer_head *bh;
         struct bfs_dirent *de;
         struct bfs_sb_info *info = BFS_SB(inode->i_sb);
@@ -216,7 +216,7 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         int error = -ENOENT;
 
         old_bh = new_bh = NULL;
-        old_inode = old_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
         if (S_ISDIR(old_inode->i_mode))
                 return -EINVAL;
 
@@ -231,7 +231,7 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 goto end_rename;
 
         error = -EPERM;
-        new_inode = new_dentry->d_inode;
+        new_inode = d_inode(new_dentry);
         new_bh = bfs_find_entry(new_dir, 
                                 new_dentry->d_name.name, 
                                 new_dentry->d_name.len, &new_de);
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 9dcb05409ba7..78f005f37847 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -591,7 +591,7 @@ static void kill_node(Node *e)
         write_unlock(&entries_lock);
 
         if (dentry) {
-                drop_nlink(dentry->d_inode);
+                drop_nlink(d_inode(dentry));
                 d_drop(dentry);
                 dput(dentry);
                 simple_release_fs(&bm_mnt, &entry_count);
@@ -638,11 +638,11 @@ static ssize_t bm_entry_write(struct file *file, const char __user *buffer,
         case 3:
                 /* Delete this handler. */
                 root = dget(file->f_path.dentry->d_sb->s_root);
-                mutex_lock(&root->d_inode->i_mutex);
+                mutex_lock(&d_inode(root)->i_mutex);
 
                 kill_node(e);
 
-                mutex_unlock(&root->d_inode->i_mutex);
+                mutex_unlock(&d_inode(root)->i_mutex);
                 dput(root);
                 break;
         default:
@@ -675,14 +675,14 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
                 return PTR_ERR(e);
 
         root = dget(sb->s_root);
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
         dentry = lookup_one_len(e->name, root, strlen(e->name));
         err = PTR_ERR(dentry);
         if (IS_ERR(dentry))
                 goto out;
 
         err = -EEXIST;
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 goto out2;
 
         inode = bm_get_inode(sb, S_IFREG | 0644);
@@ -711,7 +711,7 @@ static ssize_t bm_register_write(struct file *file, const char __user *buffer,
 out2:
         dput(dentry);
 out:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         dput(root);
 
         if (err) {
@@ -754,12 +754,12 @@ static ssize_t bm_status_write(struct file *file, const char __user *buffer,
         case 3:
                 /* Delete all handlers. */
                 root = dget(file->f_path.dentry->d_sb->s_root);
-                mutex_lock(&root->d_inode->i_mutex);
+                mutex_lock(&d_inode(root)->i_mutex);
 
                 while (!list_empty(&entries))
                         kill_node(list_entry(entries.next, Node, list));
 
-                mutex_unlock(&root->d_inode->i_mutex);
+                mutex_unlock(&d_inode(root)->i_mutex);
                 dput(root);
                 break;
         default:
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 897ee0503932..c7e4163ede87 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -152,7 +152,8 @@ blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
         struct inode *inode = file->f_mapping->host;
 
         return __blockdev_direct_IO(iocb, inode, I_BDEV(inode), iter, offset,
-                                    blkdev_get_block, NULL, NULL, 0);
+                                    blkdev_get_block, NULL, NULL,
+                                    DIO_SKIP_DIO_COUNT);
 }
 
 int __sync_blockdev(struct block_device *bdev, int wait)
@@ -1716,7 +1717,7 @@ struct block_device *lookup_bdev(const char *pathname)
         if (error)
                 return ERR_PTR(error);
 
-        inode = path.dentry->d_inode;
+        inode = d_backing_inode(path.dentry);
         error = -ENOTBLK;
         if (!S_ISBLK(inode->i_mode))
                 goto fail;
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/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 253cb74b0e27..81fa75a8e1f3 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -1119,10 +1119,7 @@ static int flush_dirty_cache(struct inode *inode)
 }
 
 static void noinline_for_stack
-cleanup_write_cache_enospc(struct inode *inode,
-                           struct btrfs_io_ctl *io_ctl,
-                           struct extent_state **cached_state,
-                           struct list_head *bitmap_list)
+cleanup_bitmap_list(struct list_head *bitmap_list)
 {
         struct list_head *pos, *n;
 
@@ -1131,6 +1128,14 @@ cleanup_write_cache_enospc(struct inode *inode,
                         list_entry(pos, struct btrfs_free_space, list);
                 list_del_init(&entry->list);
         }
+}
+
+static void noinline_for_stack
+cleanup_write_cache_enospc(struct inode *inode,
+                           struct btrfs_io_ctl *io_ctl,
+                           struct extent_state **cached_state,
+                           struct list_head *bitmap_list)
+{
         io_ctl_drop_pages(io_ctl);
         unlock_extent_cached(&BTRFS_I(inode)->io_tree, 0,
                              i_size_read(inode) - 1, cached_state,
@@ -1149,7 +1154,8 @@ int btrfs_wait_cache_io(struct btrfs_root *root,
         if (!inode)
                 return 0;
 
-        root = root->fs_info->tree_root;
+        if (block_group)
+                root = root->fs_info->tree_root;
 
         /* Flush the dirty pages in the cache file. */
         ret = flush_dirty_cache(inode);
@@ -1265,11 +1271,8 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
         ret = write_cache_extent_entries(io_ctl, ctl,
                                          block_group, &entries, &bitmaps,
                                          &bitmap_list);
-        spin_unlock(&ctl->tree_lock);
-        if (ret) {
-                mutex_unlock(&ctl->cache_writeout_mutex);
-                goto out_nospc;
-        }
+        if (ret)
+                goto out_nospc_locked;
 
         /*
          * Some spaces that are freed in the current transaction are pinned,
@@ -1280,17 +1283,14 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
          * the dirty list and redo it.  No locking needed
          */
         ret = write_pinned_extent_entries(root, block_group, io_ctl, &entries);
-        if (ret) {
-                mutex_unlock(&ctl->cache_writeout_mutex);
-                goto out_nospc;
-        }
+        if (ret)
+                goto out_nospc_locked;
 
         /*
          * At last, we write out all the bitmaps and keep cache_writeout_mutex
          * locked while doing it because a concurrent trim can be manipulating
          * or freeing the bitmap.
          */
-        spin_lock(&ctl->tree_lock);
         ret = write_bitmap_entries(io_ctl, &bitmap_list);
         spin_unlock(&ctl->tree_lock);
         mutex_unlock(&ctl->cache_writeout_mutex);
@@ -1343,6 +1343,11 @@ out:
                 iput(inode);
         return ret;
 
+out_nospc_locked:
+        cleanup_bitmap_list(&bitmap_list);
+        spin_unlock(&ctl->tree_lock);
+        mutex_unlock(&ctl->cache_writeout_mutex);
+
 out_nospc:
         cleanup_write_cache_enospc(inode, io_ctl, &cached_state, &bitmap_list);
 
@@ -3463,9 +3468,12 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root,
         if (!btrfs_test_opt(root, INODE_MAP_CACHE))
                 return 0;
 
+        memset(&io_ctl, 0, sizeof(io_ctl));
         ret = __btrfs_write_out_cache(root, inode, ctl, NULL, &io_ctl,
-                                      trans, path, 0) ||
-                btrfs_wait_cache_io(root, trans, NULL, &io_ctl, path, 0);
+                                      trans, path, 0);
+        if (!ret)
+                ret = btrfs_wait_cache_io(root, trans, NULL, &io_ctl, path, 0);
+
         if (ret) {
                 btrfs_delalloc_release_metadata(inode, inode->i_size);
 #ifdef DEBUG
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);
 }
 
diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index fbb08e97438d..6af790fc3df8 100644
--- a/fs/cachefiles/bind.c
+++ b/fs/cachefiles/bind.c
@@ -123,11 +123,11 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
 
         /* check parameters */
         ret = -EOPNOTSUPP;
-        if (!root->d_inode ||
-            !root->d_inode->i_op->lookup ||
-            !root->d_inode->i_op->mkdir ||
-            !root->d_inode->i_op->setxattr ||
-            !root->d_inode->i_op->getxattr ||
+        if (d_is_negative(root) ||
+            !d_backing_inode(root)->i_op->lookup ||
+            !d_backing_inode(root)->i_op->mkdir ||
+            !d_backing_inode(root)->i_op->setxattr ||
+            !d_backing_inode(root)->i_op->getxattr ||
             !root->d_sb->s_op->statfs ||
             !root->d_sb->s_op->sync_fs)
                 goto error_unsupported;
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 232426214fdd..afa023dded5b 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -441,12 +441,12 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
 
         fscache_set_store_limit(&object->fscache, ni_size);
 
-        oi_size = i_size_read(object->backer->d_inode);
+        oi_size = i_size_read(d_backing_inode(object->backer));
         if (oi_size == ni_size)
                 return 0;
 
         cachefiles_begin_secure(cache, &saved_cred);
-        mutex_lock(&object->backer->d_inode->i_mutex);
+        mutex_lock(&d_inode(object->backer)->i_mutex);
 
         /* if there's an extension to a partial page at the end of the backing
          * file, we need to discard the partial page so that we pick up new
@@ -465,7 +465,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
         ret = notify_change(object->backer, &newattrs, NULL);
 
 truncate_failed:
-        mutex_unlock(&object->backer->d_inode->i_mutex);
+        mutex_unlock(&d_inode(object->backer)->i_mutex);
         cachefiles_end_secure(cache, saved_cred);
 
         if (ret == -EIO) {
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 1e51714eb33e..ab857ab9f40d 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -286,13 +286,13 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
                 if (ret < 0) {
                         cachefiles_io_error(cache, "Unlink security error");
                 } else {
-                        ret = vfs_unlink(dir->d_inode, rep, NULL);
+                        ret = vfs_unlink(d_inode(dir), rep, NULL);
 
                         if (preemptive)
                                 cachefiles_mark_object_buried(cache, rep);
                 }
 
-                mutex_unlock(&dir->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dir)->i_mutex);
 
                 if (ret == -EIO)
                         cachefiles_io_error(cache, "Unlink failed");
@@ -303,7 +303,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
 
         /* directories have to be moved to the graveyard */
         _debug("move stale object to graveyard");
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 
 try_again:
         /* first step is to make up a grave dentry in the graveyard */
@@ -355,7 +355,7 @@ try_again:
                 return -EIO;
         }
 
-        if (grave->d_inode) {
+        if (d_is_positive(grave)) {
                 unlock_rename(cache->graveyard, dir);
                 dput(grave);
                 grave = NULL;
@@ -387,8 +387,8 @@ try_again:
         if (ret < 0) {
                 cachefiles_io_error(cache, "Rename security error %d", ret);
         } else {
-                ret = vfs_rename(dir->d_inode, rep,
-                                 cache->graveyard->d_inode, grave, NULL, 0);
+                ret = vfs_rename(d_inode(dir), rep,
+                                 d_inode(cache->graveyard), grave, NULL, 0);
                 if (ret != 0 && ret != -ENOMEM)
                         cachefiles_io_error(cache,
                                             "Rename failed with error %d", ret);
@@ -415,18 +415,18 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
         _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry);
 
         ASSERT(object->dentry);
-        ASSERT(object->dentry->d_inode);
+        ASSERT(d_backing_inode(object->dentry));
         ASSERT(object->dentry->d_parent);
 
         dir = dget_parent(object->dentry);
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
 
         if (test_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
                 /* object allocation for the same key preemptively deleted this
                  * object's file so that it could create its own file */
                 _debug("object preemptively buried");
-                mutex_unlock(&dir->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dir)->i_mutex);
                 ret = 0;
         } else {
                 /* we need to check that our parent is _still_ our parent - it
@@ -438,7 +438,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
                         /* it got moved, presumably by cachefilesd culling it,
                          * so it's no longer in the key path and we can ignore
                          * it */
-                        mutex_unlock(&dir->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(dir)->i_mutex);
                         ret = 0;
                 }
         }
@@ -473,7 +473,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
         path.mnt = cache->mnt;
 
         ASSERT(parent->dentry);
-        ASSERT(parent->dentry->d_inode);
+        ASSERT(d_backing_inode(parent->dentry));
 
         if (!(d_is_dir(parent->dentry))) {
                 // TODO: convert file to dir
@@ -497,7 +497,7 @@ lookup_again:
         /* search the current directory for the element name */
         _debug("lookup '%s'", name);
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
 
         start = jiffies;
         next = lookup_one_len(name, dir, nlen);
@@ -505,21 +505,21 @@ lookup_again:
         if (IS_ERR(next))
                 goto lookup_error;
 
-        _debug("next -> %p %s", next, next->d_inode ? "positive" : "negative");
+        _debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative");
 
         if (!key)
-                object->new = !next->d_inode;
+                object->new = !d_backing_inode(next);
 
         /* if this element of the path doesn't exist, then the lookup phase
          * failed, and we can release any readers in the certain knowledge that
          * there's nothing for them to actually read */
-        if (!next->d_inode)
+        if (d_is_negative(next))
                 fscache_object_lookup_negative(&object->fscache);
 
         /* we need to create the object if it's negative */
         if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) {
                 /* index objects and intervening tree levels must be subdirs */
-                if (!next->d_inode) {
+                if (d_is_negative(next)) {
                         ret = cachefiles_has_space(cache, 1, 0);
                         if (ret < 0)
                                 goto create_error;
@@ -529,26 +529,26 @@ lookup_again:
                         if (ret < 0)
                                 goto create_error;
                         start = jiffies;
-                        ret = vfs_mkdir(dir->d_inode, next, 0);
+                        ret = vfs_mkdir(d_inode(dir), next, 0);
                         cachefiles_hist(cachefiles_mkdir_histogram, start);
                         if (ret < 0)
                                 goto create_error;
 
-                        ASSERT(next->d_inode);
+                        ASSERT(d_backing_inode(next));
 
                         _debug("mkdir -> %p{%p{ino=%lu}}",
-                               next, next->d_inode, next->d_inode->i_ino);
+                               next, d_backing_inode(next), d_backing_inode(next)->i_ino);
 
                 } else if (!d_can_lookup(next)) {
                         pr_err("inode %lu is not a directory\n",
-                               next->d_inode->i_ino);
+                               d_backing_inode(next)->i_ino);
                         ret = -ENOBUFS;
                         goto error;
                 }
 
         } else {
                 /* non-index objects start out life as files */
-                if (!next->d_inode) {
+                if (d_is_negative(next)) {
                         ret = cachefiles_has_space(cache, 1, 0);
                         if (ret < 0)
                                 goto create_error;
@@ -558,21 +558,21 @@ lookup_again:
                         if (ret < 0)
                                 goto create_error;
                         start = jiffies;
-                        ret = vfs_create(dir->d_inode, next, S_IFREG, true);
+                        ret = vfs_create(d_inode(dir), next, S_IFREG, true);
                         cachefiles_hist(cachefiles_create_histogram, start);
                         if (ret < 0)
                                 goto create_error;
 
-                        ASSERT(next->d_inode);
+                        ASSERT(d_backing_inode(next));
 
                         _debug("create -> %p{%p{ino=%lu}}",
-                               next, next->d_inode, next->d_inode->i_ino);
+                               next, d_backing_inode(next), d_backing_inode(next)->i_ino);
 
                 } else if (!d_can_lookup(next) &&
                            !d_is_reg(next)
                            ) {
                         pr_err("inode %lu is not a file or directory\n",
-                               next->d_inode->i_ino);
+                               d_backing_inode(next)->i_ino);
                         ret = -ENOBUFS;
                         goto error;
                 }
@@ -581,7 +581,7 @@ lookup_again:
         /* process the next component */
         if (key) {
                 _debug("advance");
-                mutex_unlock(&dir->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dir)->i_mutex);
                 dput(dir);
                 dir = next;
                 next = NULL;
@@ -617,7 +617,7 @@ lookup_again:
         /* note that we're now using this object */
         ret = cachefiles_mark_object_active(cache, object);
 
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(dir);
         dir = NULL;
 
@@ -646,7 +646,7 @@ lookup_again:
                         const struct address_space_operations *aops;
 
                         ret = -EPERM;
-                        aops = object->dentry->d_inode->i_mapping->a_ops;
+                        aops = d_backing_inode(object->dentry)->i_mapping->a_ops;
                         if (!aops->bmap)
                                 goto check_error;
 
@@ -659,7 +659,7 @@ lookup_again:
         object->new = 0;
         fscache_obtained_object(&object->fscache);
 
-        _leave(" = 0 [%lu]", object->dentry->d_inode->i_ino);
+        _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
         return 0;
 
 create_error:
@@ -695,7 +695,7 @@ lookup_error:
                 cachefiles_io_error(cache, "Lookup failed");
         next = NULL;
 error:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(next);
 error_out2:
         dput(dir);
@@ -719,7 +719,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         _enter(",,%s", dirname);
 
         /* search the current directory for the element name */
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
 
         start = jiffies;
         subdir = lookup_one_len(dirname, dir, strlen(dirname));
@@ -731,10 +731,10 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         }
 
         _debug("subdir -> %p %s",
-               subdir, subdir->d_inode ? "positive" : "negative");
+               subdir, d_backing_inode(subdir) ? "positive" : "negative");
 
         /* we need to create the subdir if it doesn't exist yet */
-        if (!subdir->d_inode) {
+        if (d_is_negative(subdir)) {
                 ret = cachefiles_has_space(cache, 1, 0);
                 if (ret < 0)
                         goto mkdir_error;
@@ -746,22 +746,22 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
                 ret = security_path_mkdir(&path, subdir, 0700);
                 if (ret < 0)
                         goto mkdir_error;
-                ret = vfs_mkdir(dir->d_inode, subdir, 0700);
+                ret = vfs_mkdir(d_inode(dir), subdir, 0700);
                 if (ret < 0)
                         goto mkdir_error;
 
-                ASSERT(subdir->d_inode);
+                ASSERT(d_backing_inode(subdir));
 
                 _debug("mkdir -> %p{%p{ino=%lu}}",
                        subdir,
-                       subdir->d_inode,
-                       subdir->d_inode->i_ino);
+                       d_backing_inode(subdir),
+                       d_backing_inode(subdir)->i_ino);
         }
 
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 
         /* we need to make sure the subdir is a directory */
-        ASSERT(subdir->d_inode);
+        ASSERT(d_backing_inode(subdir));
 
         if (!d_can_lookup(subdir)) {
                 pr_err("%s is not a directory\n", dirname);
@@ -770,18 +770,18 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
         }
 
         ret = -EPERM;
-        if (!subdir->d_inode->i_op->setxattr ||
-            !subdir->d_inode->i_op->getxattr ||
-            !subdir->d_inode->i_op->lookup ||
-            !subdir->d_inode->i_op->mkdir ||
-            !subdir->d_inode->i_op->create ||
-            (!subdir->d_inode->i_op->rename &&
-             !subdir->d_inode->i_op->rename2) ||
-            !subdir->d_inode->i_op->rmdir ||
-            !subdir->d_inode->i_op->unlink)
+        if (!d_backing_inode(subdir)->i_op->setxattr ||
+            !d_backing_inode(subdir)->i_op->getxattr ||
+            !d_backing_inode(subdir)->i_op->lookup ||
+            !d_backing_inode(subdir)->i_op->mkdir ||
+            !d_backing_inode(subdir)->i_op->create ||
+            (!d_backing_inode(subdir)->i_op->rename &&
+             !d_backing_inode(subdir)->i_op->rename2) ||
+            !d_backing_inode(subdir)->i_op->rmdir ||
+            !d_backing_inode(subdir)->i_op->unlink)
                 goto check_error;
 
-        _leave(" = [%lu]", subdir->d_inode->i_ino);
+        _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
         return subdir;
 
 check_error:
@@ -790,19 +790,19 @@ check_error:
         return ERR_PTR(ret);
 
 mkdir_error:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(subdir);
         pr_err("mkdir %s failed with error %d\n", dirname, ret);
         return ERR_PTR(ret);
 
 lookup_error:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         ret = PTR_ERR(subdir);
         pr_err("Lookup %s failed with error %d\n", dirname, ret);
         return ERR_PTR(ret);
 
 nomem_d_alloc:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         _leave(" = -ENOMEM");
         return ERR_PTR(-ENOMEM);
 }
@@ -827,7 +827,7 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
         //       dir, filename);
 
         /* look up the victim */
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
 
         start = jiffies;
         victim = lookup_one_len(filename, dir, strlen(filename));
@@ -836,13 +836,13 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
                 goto lookup_error;
 
         //_debug("victim -> %p %s",
-        //       victim, victim->d_inode ? "positive" : "negative");
+        //       victim, d_backing_inode(victim) ? "positive" : "negative");
 
         /* if the object is no longer there then we probably retired the object
          * at the netfs's request whilst the cull was in progress
          */
-        if (!victim->d_inode) {
-                mutex_unlock(&dir->d_inode->i_mutex);
+        if (d_is_negative(victim)) {
+                mutex_unlock(&d_inode(dir)->i_mutex);
                 dput(victim);
                 _leave(" = -ENOENT [absent]");
                 return ERR_PTR(-ENOENT);
@@ -871,13 +871,13 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
 
 object_in_use:
         read_unlock(&cache->active_lock);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(victim);
         //_leave(" = -EBUSY [in use]");
         return ERR_PTR(-EBUSY);
 
 lookup_error:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         ret = PTR_ERR(victim);
         if (ret == -ENOENT) {
                 /* file or dir now absent - probably retired by netfs */
@@ -913,7 +913,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
                 return PTR_ERR(victim);
 
         _debug("victim -> %p %s",
-               victim, victim->d_inode ? "positive" : "negative");
+               victim, d_backing_inode(victim) ? "positive" : "negative");
 
         /* okay... the victim is not being used so we can cull it
          * - start by marking it as stale
@@ -936,7 +936,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
         return 0;
 
 error_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 error:
         dput(victim);
         if (ret == -ENOENT) {
@@ -971,7 +971,7 @@ int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
         if (IS_ERR(victim))
                 return PTR_ERR(victim);
 
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         dput(victim);
         //_leave(" = 0");
         return 0;
diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c
index c6cd8d7a4eef..3cbb0e834694 100644
--- a/fs/cachefiles/rdwr.c
+++ b/fs/cachefiles/rdwr.c
@@ -74,12 +74,12 @@ static int cachefiles_read_waiter(wait_queue_t *wait, unsigned mode,
 static int cachefiles_read_reissue(struct cachefiles_object *object,
                                    struct cachefiles_one_read *monitor)
 {
-        struct address_space *bmapping = object->backer->d_inode->i_mapping;
+        struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
         struct page *backpage = monitor->back_page, *backpage2;
         int ret;
 
         _enter("{ino=%lx},{%lx,%lx}",
-               object->backer->d_inode->i_ino,
+               d_backing_inode(object->backer)->i_ino,
                backpage->index, backpage->flags);
 
         /* skip if the page was truncated away completely */
@@ -157,7 +157,7 @@ static void cachefiles_read_copier(struct fscache_operation *_op)
         object = container_of(op->op.object,
                               struct cachefiles_object, fscache);
 
-        _enter("{ino=%lu}", object->backer->d_inode->i_ino);
+        _enter("{ino=%lu}", d_backing_inode(object->backer)->i_ino);
 
         max = 8;
         spin_lock_irq(&object->work_lock);
@@ -247,7 +247,7 @@ static int cachefiles_read_backing_file_one(struct cachefiles_object *object,
         init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter);
 
         /* attempt to get hold of the backing page */
-        bmapping = object->backer->d_inode->i_mapping;
+        bmapping = d_backing_inode(object->backer)->i_mapping;
         newpage = NULL;
 
         for (;;) {
@@ -408,7 +408,7 @@ int cachefiles_read_or_alloc_page(struct fscache_retrieval *op,
         if (!object->backer)
                 goto enobufs;
 
-        inode = object->backer->d_inode;
+        inode = d_backing_inode(object->backer);
         ASSERT(S_ISREG(inode->i_mode));
         ASSERT(inode->i_mapping->a_ops->bmap);
         ASSERT(inode->i_mapping->a_ops->readpages);
@@ -468,7 +468,7 @@ static int cachefiles_read_backing_file(struct cachefiles_object *object,
                                         struct list_head *list)
 {
         struct cachefiles_one_read *monitor = NULL;
-        struct address_space *bmapping = object->backer->d_inode->i_mapping;
+        struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping;
         struct page *newpage = NULL, *netpage, *_n, *backpage = NULL;
         int ret = 0;
 
@@ -705,7 +705,7 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op,
         if (cachefiles_has_space(cache, 0, *nr_pages) < 0)
                 space = 0;
 
-        inode = object->backer->d_inode;
+        inode = d_backing_inode(object->backer);
         ASSERT(S_ISREG(inode->i_mode));
         ASSERT(inode->i_mapping->a_ops->bmap);
         ASSERT(inode->i_mapping->a_ops->readpages);
diff --git a/fs/cachefiles/security.c b/fs/cachefiles/security.c
index 396c18ea2764..31bbc0528b11 100644
--- a/fs/cachefiles/security.c
+++ b/fs/cachefiles/security.c
@@ -55,14 +55,14 @@ static int cachefiles_check_cache_dir(struct cachefiles_cache *cache,
 {
         int ret;
 
-        ret = security_inode_mkdir(root->d_inode, root, 0);
+        ret = security_inode_mkdir(d_backing_inode(root), root, 0);
         if (ret < 0) {
                 pr_err("Security denies permission to make dirs: error %d",
                        ret);
                 return ret;
         }
 
-        ret = security_inode_create(root->d_inode, root, 0);
+        ret = security_inode_create(d_backing_inode(root), root, 0);
         if (ret < 0)
                 pr_err("Security denies permission to create files: error %d",
                        ret);
@@ -95,7 +95,7 @@ int cachefiles_determine_cache_security(struct cachefiles_cache *cache,
 
         /* use the cache root dir's security context as the basis with
          * which create files */
-        ret = set_create_files_as(new, root->d_inode);
+        ret = set_create_files_as(new, d_backing_inode(root));
         if (ret < 0) {
                 abort_creds(new);
                 cachefiles_begin_secure(cache, _saved_cred);
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index a8a68745e11d..d31c1a72d8a5 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -33,7 +33,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
         int ret;
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
 
         if (!object->fscache.cookie)
                 strcpy(type, "C3");
@@ -52,7 +52,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
 
         if (ret != -EEXIST) {
                 pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
-                       dentry, dentry->d_inode->i_ino,
+                       dentry, d_backing_inode(dentry)->i_ino,
                        -ret);
                 goto error;
         }
@@ -64,7 +64,7 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
                         goto bad_type_length;
 
                 pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
-                       dentry, dentry->d_inode->i_ino,
+                       dentry, d_backing_inode(dentry)->i_ino,
                        -ret);
                 goto error;
         }
@@ -84,14 +84,14 @@ error:
 
 bad_type_length:
         pr_err("Cache object %lu type xattr length incorrect\n",
-               dentry->d_inode->i_ino);
+               d_backing_inode(dentry)->i_ino);
         ret = -EIO;
         goto error;
 
 bad_type:
         xtype[2] = 0;
         pr_err("Cache object %pd [%lu] type %s not %s\n",
-               dentry, dentry->d_inode->i_ino,
+               dentry, d_backing_inode(dentry)->i_ino,
                xtype, type);
         ret = -EIO;
         goto error;
@@ -165,7 +165,7 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
         int ret;
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
         ASSERT(object->fscache.cookie->def->check_aux);
 
         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
@@ -204,7 +204,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
         _enter("%p,#%d", object, auxdata->len);
 
         ASSERT(dentry);
-        ASSERT(dentry->d_inode);
+        ASSERT(d_backing_inode(dentry));
 
         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
         if (!auxbuf) {
@@ -225,7 +225,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
 
                 cachefiles_io_error_obj(object,
                                         "Can't read xattr on %lu (err %d)",
-                                        dentry->d_inode->i_ino, -ret);
+                                        d_backing_inode(dentry)->i_ino, -ret);
                 goto error;
         }
 
@@ -276,7 +276,7 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
                         cachefiles_io_error_obj(object,
                                                 "Can't update xattr on %lu"
                                                 " (error %d)",
-                                                dentry->d_inode->i_ino, -ret);
+                                                d_backing_inode(dentry)->i_ino, -ret);
                         goto error;
                 }
         }
@@ -291,7 +291,7 @@ error:
 
 bad_type_length:
         pr_err("Cache object %lu xattr length incorrect\n",
-               dentry->d_inode->i_ino);
+               d_backing_inode(dentry)->i_ino);
         ret = -EIO;
         goto error;
 
@@ -316,7 +316,7 @@ int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
                         cachefiles_io_error(cache,
                                             "Can't remove xattr from %lu"
                                             " (error %d)",
-                                            dentry->d_inode->i_ino, -ret);
+                                            d_backing_inode(dentry)->i_ino, -ret);
         }
 
         _leave(" = %d", ret);
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 11631c4c7d14..be5ea6af8366 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -3422,7 +3422,7 @@ int ceph_encode_inode_release(void **p, struct inode *inode,
 int ceph_encode_dentry_release(void **p, struct dentry *dentry,
                                int mds, int drop, int unless)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct ceph_mds_request_release *rel = *p;
         struct ceph_dentry_info *di = ceph_dentry(dentry);
         int force = 0;
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 1b2355109b9f..31f831471ed2 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -84,7 +84,7 @@ static int mdsc_show(struct seq_file *s, void *p)
                                 path = NULL;
                         spin_lock(&req->r_dentry->d_lock);
                         seq_printf(s, " #%llx/%pd (%s)",
-                                   ceph_ino(req->r_dentry->d_parent->d_inode),
+                                   ceph_ino(d_inode(req->r_dentry->d_parent)),
                                    req->r_dentry,
                                    path ? path : "");
                         spin_unlock(&req->r_dentry->d_lock);
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index e729b79812b4..4248307fea90 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -49,9 +49,9 @@ int ceph_init_dentry(struct dentry *dentry)
                 goto out_unlock;
         }
 
-        if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP)
                 d_set_d_op(dentry, &ceph_dentry_ops);
-        else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR)
+        else if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_SNAPDIR)
                 d_set_d_op(dentry, &ceph_snapdir_dentry_ops);
         else
                 d_set_d_op(dentry, &ceph_snap_dentry_ops);
@@ -77,7 +77,7 @@ struct inode *ceph_get_dentry_parent_inode(struct dentry *dentry)
 
         spin_lock(&dentry->d_lock);
         if (!IS_ROOT(dentry)) {
-                inode = dentry->d_parent->d_inode;
+                inode = d_inode(dentry->d_parent);
                 ihold(inode);
         }
         spin_unlock(&dentry->d_lock);
@@ -122,7 +122,7 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
 {
         struct ceph_file_info *fi = file->private_data;
         struct dentry *parent = file->f_path.dentry;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct list_head *p;
         struct dentry *dentry, *last;
         struct ceph_dentry_info *di;
@@ -161,15 +161,15 @@ more:
                 }
                 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
                 if (di->lease_shared_gen == shared_gen &&
-                    !d_unhashed(dentry) && dentry->d_inode &&
-                    ceph_snap(dentry->d_inode) != CEPH_SNAPDIR &&
-                    ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
+                    !d_unhashed(dentry) && d_really_is_positive(dentry) &&
+                    ceph_snap(d_inode(dentry)) != CEPH_SNAPDIR &&
+                    ceph_ino(d_inode(dentry)) != CEPH_INO_CEPH &&
                     fpos_cmp(ctx->pos, di->offset) <= 0)
                         break;
                 dout(" skipping %p %pd at %llu (%llu)%s%s\n", dentry,
                      dentry, di->offset,
                      ctx->pos, d_unhashed(dentry) ? " unhashed" : "",
-                     !dentry->d_inode ? " null" : "");
+                     !d_inode(dentry) ? " null" : "");
                 spin_unlock(&dentry->d_lock);
                 p = p->prev;
                 dentry = list_entry(p, struct dentry, d_child);
@@ -189,11 +189,11 @@ more:
         }
 
         dout(" %llu (%llu) dentry %p %pd %p\n", di->offset, ctx->pos,
-             dentry, dentry, dentry->d_inode);
+             dentry, dentry, d_inode(dentry));
         if (!dir_emit(ctx, dentry->d_name.name,
                       dentry->d_name.len,
-                      ceph_translate_ino(dentry->d_sb, dentry->d_inode->i_ino),
-                      dentry->d_inode->i_mode >> 12)) {
+                      ceph_translate_ino(dentry->d_sb, d_inode(dentry)->i_ino),
+                      d_inode(dentry)->i_mode >> 12)) {
                 if (last) {
                         /* remember our position */
                         fi->dentry = last;
@@ -543,7 +543,7 @@ int ceph_handle_snapdir(struct ceph_mds_request *req,
                         struct dentry *dentry, int err)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
-        struct inode *parent = dentry->d_parent->d_inode; /* we hold i_mutex */
+        struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */
 
         /* .snap dir? */
         if (err == -ENOENT &&
@@ -579,8 +579,8 @@ struct dentry *ceph_finish_lookup(struct ceph_mds_request *req,
                 err = 0;
                 if (!req->r_reply_info.head->is_dentry) {
                         dout("ENOENT and no trace, dentry %p inode %p\n",
-                             dentry, dentry->d_inode);
-                        if (dentry->d_inode) {
+                             dentry, d_inode(dentry));
+                        if (d_really_is_positive(dentry)) {
                                 d_drop(dentry);
                                 err = -ENOENT;
                         } else {
@@ -627,7 +627,7 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
                 return ERR_PTR(err);
 
         /* can we conclude ENOENT locally? */
-        if (dentry->d_inode == NULL) {
+        if (d_really_is_negative(dentry)) {
                 struct ceph_inode_info *ci = ceph_inode(dir);
                 struct ceph_dentry_info *di = ceph_dentry(dentry);
 
@@ -734,7 +734,7 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
         ceph_mdsc_put_request(req);
 out:
         if (!err)
-                ceph_init_inode_acls(dentry->d_inode, &acls);
+                ceph_init_inode_acls(d_inode(dentry), &acls);
         else
                 d_drop(dentry);
         ceph_release_acls_info(&acls);
@@ -835,7 +835,7 @@ static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         ceph_mdsc_put_request(req);
 out:
         if (!err)
-                ceph_init_inode_acls(dentry->d_inode, &acls);
+                ceph_init_inode_acls(d_inode(dentry), &acls);
         else
                 d_drop(dentry);
         ceph_release_acls_info(&acls);
@@ -872,8 +872,8 @@ static int ceph_link(struct dentry *old_dentry, struct inode *dir,
         if (err) {
                 d_drop(dentry);
         } else if (!req->r_reply_info.head->is_dentry) {
-                ihold(old_dentry->d_inode);
-                d_instantiate(dentry, old_dentry->d_inode);
+                ihold(d_inode(old_dentry));
+                d_instantiate(dentry, d_inode(old_dentry));
         }
         ceph_mdsc_put_request(req);
         return err;
@@ -906,7 +906,7 @@ static int ceph_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_mds_request *req;
         int err = -EROFS;
         int op;
@@ -975,8 +975,8 @@ static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
         req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
         /* release LINK_RDCACHE on source inode (mds will lock it) */
         req->r_old_inode_drop = CEPH_CAP_LINK_SHARED;
-        if (new_dentry->d_inode)
-                req->r_inode_drop = drop_caps_for_unlink(new_dentry->d_inode);
+        if (d_really_is_positive(new_dentry))
+                req->r_inode_drop = drop_caps_for_unlink(d_inode(new_dentry));
         err = ceph_mdsc_do_request(mdsc, old_dir, req);
         if (!err && !req->r_reply_info.head->is_dentry) {
                 /*
@@ -1042,7 +1042,7 @@ static int dentry_lease_is_valid(struct dentry *dentry)
                         if (di->lease_renew_after &&
                             time_after(jiffies, di->lease_renew_after)) {
                                 /* we should renew */
-                                dir = dentry->d_parent->d_inode;
+                                dir = d_inode(dentry->d_parent);
                                 session = ceph_get_mds_session(s);
                                 seq = di->lease_seq;
                                 di->lease_renew_after = 0;
@@ -1092,22 +1092,22 @@ static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         dout("d_revalidate %p '%pd' inode %p offset %lld\n", dentry,
-             dentry, dentry->d_inode, ceph_dentry(dentry)->offset);
+             dentry, d_inode(dentry), ceph_dentry(dentry)->offset);
 
         dir = ceph_get_dentry_parent_inode(dentry);
 
         /* always trust cached snapped dentries, snapdir dentry */
         if (ceph_snap(dir) != CEPH_NOSNAP) {
                 dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry,
-                     dentry, dentry->d_inode);
+                     dentry, d_inode(dentry));
                 valid = 1;
-        } else if (dentry->d_inode &&
-                   ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) {
+        } else if (d_really_is_positive(dentry) &&
+                   ceph_snap(d_inode(dentry)) == CEPH_SNAPDIR) {
                 valid = 1;
         } else if (dentry_lease_is_valid(dentry) ||
                    dir_lease_is_valid(dir, dentry)) {
-                if (dentry->d_inode)
-                        valid = ceph_is_any_caps(dentry->d_inode);
+                if (d_really_is_positive(dentry))
+                        valid = ceph_is_any_caps(d_inode(dentry));
                 else
                         valid = 1;
         }
@@ -1169,7 +1169,7 @@ static void ceph_d_prune(struct dentry *dentry)
          * we hold d_lock, so d_parent is stable, and d_fsdata is never
          * cleared until d_release
          */
-        ceph_dir_clear_complete(dentry->d_parent->d_inode);
+        ceph_dir_clear_complete(d_inode(dentry->d_parent));
 }
 
 /*
diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index 8d7d782f4382..fe02ae7f056a 100644
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -136,8 +136,8 @@ static struct dentry *__get_parent(struct super_block *sb,
                 return ERR_CAST(req);
 
         if (child) {
-                req->r_inode = child->d_inode;
-                ihold(child->d_inode);
+                req->r_inode = d_inode(child);
+                ihold(d_inode(child));
         } else {
                 req->r_ino1 = (struct ceph_vino) {
                         .ino = ino,
@@ -164,7 +164,7 @@ static struct dentry *__get_parent(struct super_block *sb,
                 return ERR_PTR(err);
         }
         dout("__get_parent ino %llx parent %p ino %llx.%llx\n",
-             child ? ceph_ino(child->d_inode) : ino,
+             child ? ceph_ino(d_inode(child)) : ino,
              dentry, ceph_vinop(inode));
         return dentry;
 }
@@ -172,11 +172,11 @@ static struct dentry *__get_parent(struct super_block *sb,
 static struct dentry *ceph_get_parent(struct dentry *child)
 {
         /* don't re-export snaps */
-        if (ceph_snap(child->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(child)) != CEPH_NOSNAP)
                 return ERR_PTR(-EINVAL);
 
         dout("get_parent %p ino %llx.%llx\n",
-             child, ceph_vinop(child->d_inode));
+             child, ceph_vinop(d_inode(child)));
         return __get_parent(child->d_sb, child, 0);
 }
 
@@ -209,32 +209,32 @@ static int ceph_get_name(struct dentry *parent, char *name,
         struct ceph_mds_request *req;
         int err;
 
-        mdsc = ceph_inode_to_client(child->d_inode)->mdsc;
+        mdsc = ceph_inode_to_client(d_inode(child))->mdsc;
         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME,
                                        USE_ANY_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
 
-        req->r_inode = child->d_inode;
-        ihold(child->d_inode);
-        req->r_ino2 = ceph_vino(parent->d_inode);
-        req->r_locked_dir = parent->d_inode;
+        req->r_inode = d_inode(child);
+        ihold(d_inode(child));
+        req->r_ino2 = ceph_vino(d_inode(parent));
+        req->r_locked_dir = d_inode(parent);
         req->r_num_caps = 2;
         err = ceph_mdsc_do_request(mdsc, NULL, req);
 
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 
         if (!err) {
                 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
                 memcpy(name, rinfo->dname, rinfo->dname_len);
                 name[rinfo->dname_len] = 0;
                 dout("get_name %p ino %llx.%llx name %s\n",
-                     child, ceph_vinop(child->d_inode), name);
+                     child, ceph_vinop(d_inode(child)), name);
         } else {
                 dout("get_name %p ino %llx.%llx err %d\n",
-                     child, ceph_vinop(child->d_inode), err);
+                     child, ceph_vinop(d_inode(child)), err);
         }
 
         ceph_mdsc_put_request(req);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index b9b8eb225f66..3b6b522b4b31 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -291,14 +291,14 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
         }
         if (err)
                 goto out_req;
-        if (dn || dentry->d_inode == NULL || d_is_symlink(dentry)) {
+        if (dn || d_really_is_negative(dentry) || d_is_symlink(dentry)) {
                 /* make vfs retry on splice, ENOENT, or symlink */
                 dout("atomic_open finish_no_open on dn %p\n", dn);
                 err = finish_no_open(file, dn);
         } else {
                 dout("atomic_open finish_open on dn %p\n", dn);
                 if (req->r_op == CEPH_MDS_OP_CREATE && req->r_reply_info.has_create_ino) {
-                        ceph_init_inode_acls(dentry->d_inode, &acls);
+                        ceph_init_inode_acls(d_inode(dentry), &acls);
                         *opened |= FILE_CREATED;
                 }
                 err = finish_open(file, dentry, ceph_open, opened);
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 119c43c80638..e876e1944519 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -940,7 +940,7 @@ static void update_dentry_lease(struct dentry *dentry,
              dentry, duration, ttl);
 
         /* make lease_rdcache_gen match directory */
-        dir = dentry->d_parent->d_inode;
+        dir = d_inode(dentry->d_parent);
         di->lease_shared_gen = ceph_inode(dir)->i_shared_gen;
 
         if (duration == 0)
@@ -980,7 +980,7 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
 {
         struct dentry *realdn;
 
-        BUG_ON(dn->d_inode);
+        BUG_ON(d_inode(dn));
 
         /* dn must be unhashed */
         if (!d_unhashed(dn))
@@ -998,13 +998,13 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
                      "inode %p ino %llx.%llx\n",
                      dn, d_count(dn),
                      realdn, d_count(realdn),
-                     realdn->d_inode, ceph_vinop(realdn->d_inode));
+                     d_inode(realdn), ceph_vinop(d_inode(realdn)));
                 dput(dn);
                 dn = realdn;
         } else {
                 BUG_ON(!ceph_dentry(dn));
                 dout("dn %p attached to %p ino %llx.%llx\n",
-                     dn, dn->d_inode, ceph_vinop(dn->d_inode));
+                     dn, d_inode(dn), ceph_vinop(d_inode(dn)));
         }
         if ((!prehash || *prehash) && d_unhashed(dn))
                 d_rehash(dn);
@@ -1125,11 +1125,11 @@ retry_lookup:
                                         dput(parent);
                                         goto done;
                                 }
-                        } else if (dn->d_inode &&
-                                   (ceph_ino(dn->d_inode) != vino.ino ||
-                                    ceph_snap(dn->d_inode) != vino.snap)) {
+                        } else if (d_really_is_positive(dn) &&
+                                   (ceph_ino(d_inode(dn)) != vino.ino ||
+                                    ceph_snap(d_inode(dn)) != vino.snap)) {
                                 dout(" dn %p points to wrong inode %p\n",
-                                     dn, dn->d_inode);
+                                     dn, d_inode(dn));
                                 d_delete(dn);
                                 dput(dn);
                                 goto retry_lookup;
@@ -1183,7 +1183,7 @@ retry_lookup:
 
                 BUG_ON(!dn);
                 BUG_ON(!dir);
-                BUG_ON(dn->d_parent->d_inode != dir);
+                BUG_ON(d_inode(dn->d_parent) != dir);
                 BUG_ON(ceph_ino(dir) !=
                        le64_to_cpu(rinfo->diri.in->ino));
                 BUG_ON(ceph_snap(dir) !=
@@ -1235,7 +1235,7 @@ retry_lookup:
                 /* null dentry? */
                 if (!rinfo->head->is_target) {
                         dout("fill_trace null dentry\n");
-                        if (dn->d_inode) {
+                        if (d_really_is_positive(dn)) {
                                 ceph_dir_clear_ordered(dir);
                                 dout("d_delete %p\n", dn);
                                 d_delete(dn);
@@ -1252,7 +1252,7 @@ retry_lookup:
                 }
 
                 /* attach proper inode */
-                if (!dn->d_inode) {
+                if (d_really_is_negative(dn)) {
                         ceph_dir_clear_ordered(dir);
                         ihold(in);
                         dn = splice_dentry(dn, in, &have_lease);
@@ -1261,9 +1261,9 @@ retry_lookup:
                                 goto done;
                         }
                         req->r_dentry = dn;  /* may have spliced */
-                } else if (dn->d_inode && dn->d_inode != in) {
+                } else if (d_really_is_positive(dn) && d_inode(dn) != in) {
                         dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
-                             dn, dn->d_inode, ceph_vinop(dn->d_inode),
+                             dn, d_inode(dn), ceph_vinop(d_inode(dn)),
                              ceph_vinop(in));
                         have_lease = false;
                 }
@@ -1363,7 +1363,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                 return readdir_prepopulate_inodes_only(req, session);
 
         if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
-                snapdir = ceph_get_snapdir(parent->d_inode);
+                snapdir = ceph_get_snapdir(d_inode(parent));
                 parent = d_find_alias(snapdir);
                 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n",
                      rinfo->dir_nr, parent);
@@ -1371,7 +1371,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
                 dout("readdir_prepopulate %d items under dn %p\n",
                      rinfo->dir_nr, parent);
                 if (rinfo->dir_dir)
-                        ceph_fill_dirfrag(parent->d_inode, rinfo->dir_dir);
+                        ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
         }
 
         /* FIXME: release caps/leases if error occurs */
@@ -1405,11 +1405,11 @@ retry_lookup:
                                 err = ret;
                                 goto out;
                         }
-                } else if (dn->d_inode &&
-                           (ceph_ino(dn->d_inode) != vino.ino ||
-                            ceph_snap(dn->d_inode) != vino.snap)) {
+                } else if (d_really_is_positive(dn) &&
+                           (ceph_ino(d_inode(dn)) != vino.ino ||
+                            ceph_snap(d_inode(dn)) != vino.snap)) {
                         dout(" dn %p points to wrong inode %p\n",
-                             dn, dn->d_inode);
+                             dn, d_inode(dn));
                         d_delete(dn);
                         dput(dn);
                         goto retry_lookup;
@@ -1423,8 +1423,8 @@ retry_lookup:
                 }
 
                 /* inode */
-                if (dn->d_inode) {
-                        in = dn->d_inode;
+                if (d_really_is_positive(dn)) {
+                        in = d_inode(dn);
                 } else {
                         in = ceph_get_inode(parent->d_sb, vino);
                         if (IS_ERR(in)) {
@@ -1440,13 +1440,13 @@ retry_lookup:
                                req->r_request_started, -1,
                                &req->r_caps_reservation) < 0) {
                         pr_err("fill_inode badness on %p\n", in);
-                        if (!dn->d_inode)
+                        if (d_really_is_negative(dn))
                                 iput(in);
                         d_drop(dn);
                         goto next_item;
                 }
 
-                if (!dn->d_inode) {
+                if (d_really_is_negative(dn)) {
                         struct dentry *realdn = splice_dentry(dn, in, NULL);
                         if (IS_ERR(realdn)) {
                                 err = PTR_ERR(realdn);
@@ -1693,7 +1693,7 @@ retry:
  */
 static void *ceph_sym_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ceph_inode_info *ci = ceph_inode(dentry->d_inode);
+        struct ceph_inode_info *ci = ceph_inode(d_inode(dentry));
         nd_set_link(nd, ci->i_symlink);
         return NULL;
 }
@@ -1714,7 +1714,7 @@ static const struct inode_operations ceph_symlink_iops = {
  */
 int ceph_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         const unsigned int ia_valid = attr->ia_valid;
         struct ceph_mds_request *req;
@@ -1990,7 +1990,7 @@ int ceph_permission(struct inode *inode, int mask)
 int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         int err;
 
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 0a2eb32ffe43..84f37f34f9aa 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -679,7 +679,7 @@ static struct dentry *get_nonsnap_parent(struct dentry *dentry)
          * except to resplice to another snapdir, and either the old or new
          * result is a valid result.
          */
-        while (!IS_ROOT(dentry) && ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        while (!IS_ROOT(dentry) && ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 dentry = dentry->d_parent;
         return dentry;
 }
@@ -716,20 +716,20 @@ static int __choose_mds(struct ceph_mds_client *mdsc,
         } else if (req->r_dentry) {
                 /* ignore race with rename; old or new d_parent is okay */
                 struct dentry *parent = req->r_dentry->d_parent;
-                struct inode *dir = parent->d_inode;
+                struct inode *dir = d_inode(parent);
 
                 if (dir->i_sb != mdsc->fsc->sb) {
                         /* not this fs! */
-                        inode = req->r_dentry->d_inode;
+                        inode = d_inode(req->r_dentry);
                 } else if (ceph_snap(dir) != CEPH_NOSNAP) {
                         /* direct snapped/virtual snapdir requests
                          * based on parent dir inode */
                         struct dentry *dn = get_nonsnap_parent(parent);
-                        inode = dn->d_inode;
+                        inode = d_inode(dn);
                         dout("__choose_mds using nonsnap parent %p\n", inode);
                 } else {
                         /* dentry target */
-                        inode = req->r_dentry->d_inode;
+                        inode = d_inode(req->r_dentry);
                         if (!inode || mode == USE_AUTH_MDS) {
                                 /* dir + name */
                                 inode = dir;
@@ -1732,7 +1732,7 @@ retry:
         seq = read_seqbegin(&rename_lock);
         rcu_read_lock();
         for (temp = dentry; !IS_ROOT(temp);) {
-                struct inode *inode = temp->d_inode;
+                struct inode *inode = d_inode(temp);
                 if (inode && ceph_snap(inode) == CEPH_SNAPDIR)
                         len++;  /* slash only */
                 else if (stop_on_nosnap && inode &&
@@ -1756,7 +1756,7 @@ retry:
                 struct inode *inode;
 
                 spin_lock(&temp->d_lock);
-                inode = temp->d_inode;
+                inode = d_inode(temp);
                 if (inode && ceph_snap(inode) == CEPH_SNAPDIR) {
                         dout("build_path path+%d: %p SNAPDIR\n",
                              pos, temp);
@@ -1790,7 +1790,7 @@ retry:
                 goto retry;
         }
 
-        *base = ceph_ino(temp->d_inode);
+        *base = ceph_ino(d_inode(temp));
         *plen = len;
         dout("build_path on %p %d built %llx '%.*s'\n",
              dentry, d_count(dentry), *base, len, path);
@@ -1803,8 +1803,8 @@ static int build_dentry_path(struct dentry *dentry,
 {
         char *path;
 
-        if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP) {
-                *pino = ceph_ino(dentry->d_parent->d_inode);
+        if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP) {
+                *pino = ceph_ino(d_inode(dentry->d_parent));
                 *ppath = dentry->d_name.name;
                 *ppathlen = dentry->d_name.len;
                 return 0;
@@ -1945,7 +1945,7 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
         releases = 0;
         if (req->r_inode_drop)
                 releases += ceph_encode_inode_release(&p,
-                      req->r_inode ? req->r_inode : req->r_dentry->d_inode,
+                      req->r_inode ? req->r_inode : d_inode(req->r_dentry),
                       mds, req->r_inode_drop, req->r_inode_unless, 0);
         if (req->r_dentry_drop)
                 releases += ceph_encode_dentry_release(&p, req->r_dentry,
@@ -1955,7 +1955,7 @@ static struct ceph_msg *create_request_message(struct ceph_mds_client *mdsc,
                        mds, req->r_old_dentry_drop, req->r_old_dentry_unless);
         if (req->r_old_inode_drop)
                 releases += ceph_encode_inode_release(&p,
-                      req->r_old_dentry->d_inode,
+                      d_inode(req->r_old_dentry),
                       mds, req->r_old_inode_drop, req->r_old_inode_unless, 0);
 
         if (drop_cap_releases) {
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index e463ebd69a9c..4e9905374078 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -44,7 +44,7 @@ static void ceph_put_super(struct super_block *s)
 
 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct ceph_fs_client *fsc = ceph_inode_to_client(dentry->d_inode);
+        struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry));
         struct ceph_monmap *monmap = fsc->client->monc.monmap;
         struct ceph_statfs st;
         u64 fsid;
@@ -972,7 +972,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type,
         if (IS_ERR(res))
                 goto out_splat;
         dout("root %p inode %p ino %llx.%llx\n", res,
-             res->d_inode, ceph_vinop(res->d_inode));
+             d_inode(res), ceph_vinop(d_inode(res)));
         return res;
 
 out_splat:
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index 5c4c9c256931..cd7ffad4041d 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -776,12 +776,12 @@ ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value,
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
                 return generic_getxattr(dentry, name, value, size);
 
-        return __ceph_getxattr(dentry->d_inode, name, value, size);
+        return __ceph_getxattr(d_inode(dentry), name, value, size);
 }
 
 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
         u32 vir_namelen = 0;
@@ -847,7 +847,7 @@ static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
                               const char *value, size_t size, int flags)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_inode_info *ci = ceph_inode(inode);
         struct ceph_mds_request *req;
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -908,7 +908,7 @@ out:
 int __ceph_setxattr(struct dentry *dentry, const char *name,
                         const void *value, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_vxattr *vxattr;
         struct ceph_inode_info *ci = ceph_inode(inode);
         int issued;
@@ -1002,7 +1002,7 @@ out:
 int ceph_setxattr(struct dentry *dentry, const char *name,
                   const void *value, size_t size, int flags)
 {
-        if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 return -EROFS;
 
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
@@ -1018,7 +1018,7 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_mds_request *req;
         int err;
 
@@ -1041,7 +1041,7 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
 
 int __ceph_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ceph_vxattr *vxattr;
         struct ceph_inode_info *ci = ceph_inode(inode);
         int issued;
@@ -1107,7 +1107,7 @@ out:
 
 int ceph_removexattr(struct dentry *dentry, const char *name)
 {
-        if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP)
+        if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP)
                 return -EROFS;
 
         if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
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;
 
diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 46ee6f238985..5bb630a769e0 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -94,8 +94,8 @@ static void coda_flag_children(struct dentry *parent, int flag)
         spin_lock(&parent->d_lock);
         list_for_each_entry(de, &parent->d_subdirs, d_child) {
                 /* don't know what to do with negative dentries */
-                if (de->d_inode ) 
-                        coda_flag_inode(de->d_inode, flag);
+                if (d_inode(de) ) 
+                        coda_flag_inode(d_inode(de), flag);
         }
         spin_unlock(&parent->d_lock);
         return; 
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 60cb88c1dd2b..fda9f4311212 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -201,7 +201,7 @@ err_out:
 static int coda_link(struct dentry *source_de, struct inode *dir_inode, 
           struct dentry *de)
 {
-        struct inode *inode = source_de->d_inode;
+        struct inode *inode = d_inode(source_de);
         const char * name = de->d_name.name;
         int len = de->d_name.len;
         int error;
@@ -266,7 +266,7 @@ static int coda_unlink(struct inode *dir, struct dentry *de)
                 return error;
 
         coda_dir_update_mtime(dir);
-        drop_nlink(de->d_inode);
+        drop_nlink(d_inode(de));
         return 0;
 }
 
@@ -279,8 +279,8 @@ static int coda_rmdir(struct inode *dir, struct dentry *de)
         error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
         if (!error) {
                 /* VFS may delete the child */
-                if (de->d_inode)
-                        clear_nlink(de->d_inode);
+                if (d_really_is_positive(de))
+                        clear_nlink(d_inode(de));
 
                 /* fix the link count of the parent */
                 coda_dir_drop_nlink(dir);
@@ -303,14 +303,14 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
                              coda_i2f(new_dir), old_length, new_length,
                              (const char *) old_name, (const char *)new_name);
         if (!error) {
-                if (new_dentry->d_inode) {
+                if (d_really_is_positive(new_dentry)) {
                         if (d_is_dir(new_dentry)) {
                                 coda_dir_drop_nlink(old_dir);
                                 coda_dir_inc_nlink(new_dir);
                         }
                         coda_dir_update_mtime(old_dir);
                         coda_dir_update_mtime(new_dir);
-                        coda_flag_inode(new_dentry->d_inode, C_VATTR);
+                        coda_flag_inode(d_inode(new_dentry), C_VATTR);
                 } else {
                         coda_flag_inode(old_dir, C_VATTR);
                         coda_flag_inode(new_dir, C_VATTR);
@@ -449,13 +449,13 @@ static int coda_dentry_revalidate(struct dentry *de, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = de->d_inode;
+        inode = d_inode(de);
         if (!inode || is_root_inode(inode))
                 goto out;
         if (is_bad_inode(inode))
                 goto bad;
 
-        cii = ITOC(de->d_inode);
+        cii = ITOC(d_inode(de));
         if (!(cii->c_flags & (C_PURGE | C_FLUSH)))
                 goto out;
 
@@ -487,11 +487,11 @@ static int coda_dentry_delete(const struct dentry * dentry)
 {
         int flags;
 
-        if (!dentry->d_inode) 
+        if (d_really_is_negative(dentry)) 
                 return 0;
 
-        flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE;
-        if (is_bad_inode(dentry->d_inode) || flags) {
+        flags = (ITOC(d_inode(dentry))->c_flags) & C_PURGE;
+        if (is_bad_inode(d_inode(dentry)) || flags) {
                 return 1;
         }
         return 0;
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 82ec68b59208..cac1390b87a3 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -257,15 +257,15 @@ static void coda_evict_inode(struct inode *inode)
 
 int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        int err = coda_revalidate_inode(dentry->d_inode);
+        int err = coda_revalidate_inode(d_inode(dentry));
         if (!err)
-                generic_fillattr(dentry->d_inode, stat);
+                generic_fillattr(d_inode(dentry), stat);
         return err;
 }
 
 int coda_setattr(struct dentry *de, struct iattr *iattr)
 {
-        struct inode *inode = de->d_inode;
+        struct inode *inode = d_inode(de);
         struct coda_vattr vattr;
         int error;
 
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index 4326d172fc27..f36a4040afb8 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -72,7 +72,7 @@ static long coda_pioctl(struct file *filp, unsigned int cmd,
         if (error)
                 return error;
 
-        target_inode = path.dentry->d_inode;
+        target_inode = d_inode(path.dentry);
 
         /* return if it is not a Coda inode */
         if (target_inode->i_sb != inode->i_sb) {
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index 5bb6e27298a4..9b1ffaa0572e 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -820,8 +820,8 @@ int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out)
         case CODA_FLUSH:
                 coda_cache_clear_all(sb);
                 shrink_dcache_sb(sb);
-                if (sb->s_root->d_inode)
-                        coda_flag_inode(sb->s_root->d_inode, C_FLUSH);
+                if (d_really_is_positive(sb->s_root))
+                        coda_flag_inode(d_inode(sb->s_root), C_FLUSH);
                 break;
 
         case CODA_PURGEUSER:
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index acb3d63bc9dc..c81ce7f200a6 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -289,7 +289,7 @@ static int configfs_create_dir(struct config_item *item, struct dentry *dentry)
         configfs_set_dir_dirent_depth(p->d_fsdata, dentry->d_fsdata);
         error = configfs_create(dentry, mode, init_dir);
         if (!error) {
-                inc_nlink(p->d_inode);
+                inc_nlink(d_inode(p));
                 item->ci_dentry = dentry;
         } else {
                 struct configfs_dirent *sd = dentry->d_fsdata;
@@ -375,8 +375,8 @@ static void remove_dir(struct dentry * d)
         list_del_init(&sd->s_sibling);
         spin_unlock(&configfs_dirent_lock);
         configfs_put(sd);
-        if (d->d_inode)
-                simple_rmdir(parent->d_inode,d);
+        if (d_really_is_positive(d))
+                simple_rmdir(d_inode(parent),d);
 
         pr_debug(" o %pd removing done (%d)\n", d, d_count(d));
 
@@ -513,7 +513,7 @@ static int configfs_detach_prep(struct dentry *dentry, struct mutex **wait_mutex
                         /* Abort if racing with mkdir() */
                         if (sd->s_type & CONFIGFS_USET_IN_MKDIR) {
                                 if (wait_mutex)
-                                        *wait_mutex = &sd->s_dentry->d_inode->i_mutex;
+                                        *wait_mutex = &d_inode(sd->s_dentry)->i_mutex;
                                 return -EAGAIN;
                         }
 
@@ -624,13 +624,13 @@ static void detach_groups(struct config_group *group)
 
                 child = sd->s_dentry;
 
-                mutex_lock(&child->d_inode->i_mutex);
+                mutex_lock(&d_inode(child)->i_mutex);
 
                 configfs_detach_group(sd->s_element);
-                child->d_inode->i_flags |= S_DEAD;
+                d_inode(child)->i_flags |= S_DEAD;
                 dont_mount(child);
 
-                mutex_unlock(&child->d_inode->i_mutex);
+                mutex_unlock(&d_inode(child)->i_mutex);
 
                 d_delete(child);
                 dput(child);
@@ -672,7 +672,7 @@ static int create_default_group(struct config_group *parent_group,
                         sd = child->d_fsdata;
                         sd->s_type |= CONFIGFS_USET_DEFAULT;
                 } else {
-                        BUG_ON(child->d_inode);
+                        BUG_ON(d_inode(child));
                         d_drop(child);
                         dput(child);
                 }
@@ -818,11 +818,11 @@ static int configfs_attach_item(struct config_item *parent_item,
                          * the VFS may already have hit and used them. Thus,
                          * we must lock them as rmdir() would.
                          */
-                        mutex_lock(&dentry->d_inode->i_mutex);
+                        mutex_lock(&d_inode(dentry)->i_mutex);
                         configfs_remove_dir(item);
-                        dentry->d_inode->i_flags |= S_DEAD;
+                        d_inode(dentry)->i_flags |= S_DEAD;
                         dont_mount(dentry);
-                        mutex_unlock(&dentry->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(dentry)->i_mutex);
                         d_delete(dentry);
                 }
         }
@@ -858,16 +858,16 @@ static int configfs_attach_group(struct config_item *parent_item,
                  * We must also lock the inode to remove it safely in case of
                  * error, as rmdir() would.
                  */
-                mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+                mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
                 configfs_adjust_dir_dirent_depth_before_populate(sd);
                 ret = populate_groups(to_config_group(item));
                 if (ret) {
                         configfs_detach_item(item);
-                        dentry->d_inode->i_flags |= S_DEAD;
+                        d_inode(dentry)->i_flags |= S_DEAD;
                         dont_mount(dentry);
                 }
                 configfs_adjust_dir_dirent_depth_after_populate(sd);
-                mutex_unlock(&dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dentry)->i_mutex);
                 if (ret)
                         d_delete(dentry);
         }
@@ -1075,7 +1075,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
          * subsystem is really registered, and so we need to lock out
          * configfs_[un]register_subsystem().
          */
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
 
         root_sd = root->d_fsdata;
 
@@ -1111,7 +1111,7 @@ int configfs_depend_item(struct configfs_subsystem *subsys,
 out_unlock_dirent_lock:
         spin_unlock(&configfs_dirent_lock);
 out_unlock_fs:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 
         /*
          * If we succeeded, the fs is pinned via other methods.  If not,
@@ -1453,11 +1453,11 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
         down_write(&configfs_rename_sem);
         parent = item->parent->dentry;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
 
         new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
         if (!IS_ERR(new_dentry)) {
-                if (!new_dentry->d_inode) {
+                if (d_really_is_negative(new_dentry)) {
                         error = config_item_set_name(item, "%s", new_name);
                         if (!error) {
                                 d_add(new_dentry, NULL);
@@ -1469,7 +1469,7 @@ int configfs_rename_dir(struct config_item * item, const char *new_name)
                         error = -EEXIST;
                 dput(new_dentry);
         }
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         up_write(&configfs_rename_sem);
 
         return error;
@@ -1482,7 +1482,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
         struct configfs_dirent * parent_sd = dentry->d_fsdata;
         int err;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         /*
          * Fake invisibility if dir belongs to a group/default groups hierarchy
          * being attached
@@ -1495,7 +1495,7 @@ static int configfs_dir_open(struct inode *inode, struct file *file)
                 else
                         err = 0;
         }
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
 
         return err;
 }
@@ -1505,11 +1505,11 @@ static int configfs_dir_close(struct inode *inode, struct file *file)
         struct dentry * dentry = file->f_path.dentry;
         struct configfs_dirent * cursor = file->private_data;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         spin_lock(&configfs_dirent_lock);
         list_del_init(&cursor->s_sibling);
         spin_unlock(&configfs_dirent_lock);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
 
         release_configfs_dirent(cursor);
 
@@ -1567,7 +1567,7 @@ static int configfs_readdir(struct file *file, struct dir_context *ctx)
                 spin_lock(&configfs_dirent_lock);
                 dentry = next->s_dentry;
                 if (dentry)
-                        inode = dentry->d_inode;
+                        inode = d_inode(dentry);
                 if (inode)
                         ino = inode->i_ino;
                 spin_unlock(&configfs_dirent_lock);
@@ -1590,7 +1590,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry * dentry = file->f_path.dentry;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         switch (whence) {
                 case 1:
                         offset += file->f_pos;
@@ -1598,7 +1598,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&dentry->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(dentry)->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -1624,7 +1624,7 @@ static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence)
                         spin_unlock(&configfs_dirent_lock);
                 }
         }
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
         return offset;
 }
 
@@ -1654,7 +1654,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
         sd = root->d_fsdata;
         link_group(to_config_group(sd->s_element), group);
 
-        mutex_lock_nested(&root->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(root)->i_mutex, I_MUTEX_PARENT);
 
         err = -ENOMEM;
         dentry = d_alloc_name(root, group->cg_item.ci_name);
@@ -1664,7 +1664,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
                 err = configfs_attach_group(sd->s_element, &group->cg_item,
                                             dentry);
                 if (err) {
-                        BUG_ON(dentry->d_inode);
+                        BUG_ON(d_inode(dentry));
                         d_drop(dentry);
                         dput(dentry);
                 } else {
@@ -1674,7 +1674,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
                 }
         }
 
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 
         if (err) {
                 unlink_group(group);
@@ -1695,9 +1695,9 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
                 return;
         }
 
-        mutex_lock_nested(&root->d_inode->i_mutex,
+        mutex_lock_nested(&d_inode(root)->i_mutex,
                           I_MUTEX_PARENT);
-        mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
         mutex_lock(&configfs_symlink_mutex);
         spin_lock(&configfs_dirent_lock);
         if (configfs_detach_prep(dentry, NULL)) {
@@ -1706,13 +1706,13 @@ void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
         spin_unlock(&configfs_dirent_lock);
         mutex_unlock(&configfs_symlink_mutex);
         configfs_detach_group(&group->cg_item);
-        dentry->d_inode->i_flags |= S_DEAD;
+        d_inode(dentry)->i_flags |= S_DEAD;
         dont_mount(dentry);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
 
         d_delete(dentry);
 
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 
         dput(dentry);
 
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index 56d2cdc9ae0a..403269ffcdf3 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -326,10 +326,10 @@ int configfs_create_file(struct config_item * item, const struct configfs_attrib
         umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG;
         int error = 0;
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_NORMAL);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_NORMAL);
         error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode,
                                      CONFIGFS_ITEM_ATTR);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 
         return error;
 }
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 5423a6a6ecc8..8d89f5fd0331 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -56,7 +56,7 @@ static const struct inode_operations configfs_inode_operations ={
 
 int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         struct configfs_dirent * sd = dentry->d_fsdata;
         struct iattr * sd_iattr;
         unsigned int ia_valid = iattr->ia_valid;
@@ -186,7 +186,7 @@ int configfs_create(struct dentry * dentry, umode_t mode, void (*init)(struct in
         if (!dentry)
                 return -ENOENT;
 
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 return -EEXIST;
 
         sd = dentry->d_fsdata;
@@ -194,7 +194,7 @@ int configfs_create(struct dentry * dentry, umode_t mode, void (*init)(struct in
         if (!inode)
                 return -ENOMEM;
 
-        p_inode = dentry->d_parent->d_inode;
+        p_inode = d_inode(dentry->d_parent);
         p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
         configfs_set_inode_lock_class(sd, inode);
 
@@ -236,11 +236,11 @@ void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
 
         if (dentry) {
                 spin_lock(&dentry->d_lock);
-                if (!d_unhashed(dentry) && dentry->d_inode) {
+                if (!d_unhashed(dentry) && d_really_is_positive(dentry)) {
                         dget_dlock(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
-                        simple_unlink(parent->d_inode, dentry);
+                        simple_unlink(d_inode(parent), dentry);
                 } else
                         spin_unlock(&dentry->d_lock);
         }
@@ -251,11 +251,11 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
         struct configfs_dirent * sd;
         struct configfs_dirent * parent_sd = dir->d_fsdata;
 
-        if (dir->d_inode == NULL)
+        if (d_really_is_negative(dir))
                 /* no inode means this hasn't been made visible yet */
                 return;
 
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
         list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
                 if (!sd->s_element)
                         continue;
@@ -268,5 +268,5 @@ void configfs_hash_and_remove(struct dentry * dir, const char * name)
                         break;
                 }
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 }
diff --git a/fs/dax.c b/fs/dax.c
index 0bb0aecb556c..6f65f00e58ec 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -209,7 +209,7 @@ ssize_t dax_do_io(struct kiocb *iocb, struct inode *inode,
         }
 
         /* Protects against truncate */
-        atomic_inc(&inode->i_dio_count);
+        inode_dio_begin(inode);
 
         retval = dax_io(inode, iter, pos, end, get_block, &bh);
 
@@ -219,7 +219,7 @@ ssize_t dax_do_io(struct kiocb *iocb, struct inode *inode,
         if ((retval > 0) && end_io)
                 end_io(iocb, pos, retval, bh.b_private);
 
-        inode_dio_done(inode);
+        inode_dio_end(inode);
  out:
         return retval;
 }
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index 517e64938438..830a7e76f5c6 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -45,7 +45,7 @@ const struct file_operations debugfs_file_operations = {
 
 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        nd_set_link(nd, dentry->d_inode->i_private);
+        nd_set_link(nd, d_inode(dentry)->i_private);
         return NULL;
 }
 
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index c9ee0dfe90b5..c1e7ffb0dab6 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -46,7 +46,7 @@ static struct inode *debugfs_get_inode(struct super_block *sb)
 
 static inline int debugfs_positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 struct debugfs_mount_opts {
@@ -124,7 +124,7 @@ static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
 static int debugfs_apply_options(struct super_block *sb)
 {
         struct debugfs_fs_info *fsi = sb->s_fs_info;
-        struct inode *inode = sb->s_root->d_inode;
+        struct inode *inode = d_inode(sb->s_root);
         struct debugfs_mount_opts *opts = &fsi->mount_opts;
 
         inode->i_mode &= ~S_IALLUGO;
@@ -188,7 +188,7 @@ static struct vfsmount *debugfs_automount(struct path *path)
 {
         struct vfsmount *(*f)(void *);
         f = (struct vfsmount *(*)(void *))path->dentry->d_fsdata;
-        return f(path->dentry->d_inode->i_private);
+        return f(d_inode(path->dentry)->i_private);
 }
 
 static const struct dentry_operations debugfs_dops = {
@@ -270,20 +270,20 @@ static struct dentry *start_creating(const char *name, struct dentry *parent)
         if (!parent)
                 parent = debugfs_mount->mnt_root;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         dentry = lookup_one_len(name, parent, strlen(name));
-        if (!IS_ERR(dentry) && dentry->d_inode) {
+        if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
                 dput(dentry);
                 dentry = ERR_PTR(-EEXIST);
         }
         if (IS_ERR(dentry))
-                mutex_unlock(&parent->d_inode->i_mutex);
+                mutex_unlock(&d_inode(parent)->i_mutex);
         return dentry;
 }
 
 static struct dentry *failed_creating(struct dentry *dentry)
 {
-        mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
         dput(dentry);
         simple_release_fs(&debugfs_mount, &debugfs_mount_count);
         return NULL;
@@ -291,7 +291,7 @@ static struct dentry *failed_creating(struct dentry *dentry)
 
 static struct dentry *end_creating(struct dentry *dentry)
 {
-        mutex_unlock(&dentry->d_parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry->d_parent)->i_mutex);
         return dentry;
 }
 
@@ -344,7 +344,7 @@ struct dentry *debugfs_create_file(const char *name, umode_t mode,
         inode->i_fop = fops ? fops : &debugfs_file_operations;
         inode->i_private = data;
         d_instantiate(dentry, inode);
-        fsnotify_create(dentry->d_parent->d_inode, dentry);
+        fsnotify_create(d_inode(dentry->d_parent), dentry);
         return end_creating(dentry);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_file);
@@ -384,7 +384,7 @@ struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
         struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);
 
         if (de)
-                de->d_inode->i_size = file_size;
+                d_inode(de)->i_size = file_size;
         return de;
 }
 EXPORT_SYMBOL_GPL(debugfs_create_file_size);
@@ -426,8 +426,8 @@ struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
         /* directory inodes start off with i_nlink == 2 (for "." entry) */
         inc_nlink(inode);
         d_instantiate(dentry, inode);
-        inc_nlink(dentry->d_parent->d_inode);
-        fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
+        inc_nlink(d_inode(dentry->d_parent));
+        fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
         return end_creating(dentry);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_dir);
@@ -525,9 +525,9 @@ static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
         if (debugfs_positive(dentry)) {
                 dget(dentry);
                 if (d_is_dir(dentry))
-                        ret = simple_rmdir(parent->d_inode, dentry);
+                        ret = simple_rmdir(d_inode(parent), dentry);
                 else
-                        simple_unlink(parent->d_inode, dentry);
+                        simple_unlink(d_inode(parent), dentry);
                 if (!ret)
                         d_delete(dentry);
                 dput(dentry);
@@ -557,12 +557,12 @@ void debugfs_remove(struct dentry *dentry)
                 return;
 
         parent = dentry->d_parent;
-        if (!parent || !parent->d_inode)
+        if (!parent || d_really_is_negative(parent))
                 return;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         ret = __debugfs_remove(dentry, parent);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         if (!ret)
                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
 }
@@ -588,12 +588,12 @@ void debugfs_remove_recursive(struct dentry *dentry)
                 return;
 
         parent = dentry->d_parent;
-        if (!parent || !parent->d_inode)
+        if (!parent || d_really_is_negative(parent))
                 return;
 
         parent = dentry;
  down:
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
  loop:
         /*
          * The parent->d_subdirs is protected by the d_lock. Outside that
@@ -608,7 +608,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
                 /* perhaps simple_empty(child) makes more sense */
                 if (!list_empty(&child->d_subdirs)) {
                         spin_unlock(&parent->d_lock);
-                        mutex_unlock(&parent->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(parent)->i_mutex);
                         parent = child;
                         goto down;
                 }
@@ -629,10 +629,10 @@ void debugfs_remove_recursive(struct dentry *dentry)
         }
         spin_unlock(&parent->d_lock);
 
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         child = parent;
         parent = parent->d_parent;
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
 
         if (child != dentry)
                 /* go up */
@@ -640,7 +640,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
 
         if (!__debugfs_remove(child, parent))
                 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 }
 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
 
@@ -672,27 +672,27 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
 
         trap = lock_rename(new_dir, old_dir);
         /* Source or destination directories don't exist? */
-        if (!old_dir->d_inode || !new_dir->d_inode)
+        if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
                 goto exit;
         /* Source does not exist, cyclic rename, or mountpoint? */
-        if (!old_dentry->d_inode || old_dentry == trap ||
+        if (d_really_is_negative(old_dentry) || old_dentry == trap ||
             d_mountpoint(old_dentry))
                 goto exit;
         dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
         /* Lookup failed, cyclic rename or target exists? */
-        if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
+        if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
                 goto exit;
 
         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
 
-        error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
+        error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
                 dentry);
         if (error) {
                 fsnotify_oldname_free(old_name);
                 goto exit;
         }
         d_move(old_dentry, dentry);
-        fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
+        fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name,
                 d_is_dir(old_dentry),
                 NULL, old_dentry);
         fsnotify_oldname_free(old_name);
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index cfe8466f7fef..add566303c68 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -253,7 +253,7 @@ static int mknod_ptmx(struct super_block *sb)
         if (!uid_valid(root_uid) || !gid_valid(root_gid))
                 return -EINVAL;
 
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
 
         /* If we have already created ptmx node, return */
         if (fsi->ptmx_dentry) {
@@ -290,7 +290,7 @@ static int mknod_ptmx(struct super_block *sb)
         fsi->ptmx_dentry = dentry;
         rc = 0;
 out:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         return rc;
 }
 
@@ -298,7 +298,7 @@ static void update_ptmx_mode(struct pts_fs_info *fsi)
 {
         struct inode *inode;
         if (fsi->ptmx_dentry) {
-                inode = fsi->ptmx_dentry->d_inode;
+                inode = d_inode(fsi->ptmx_dentry);
                 inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode;
         }
 }
@@ -602,18 +602,18 @@ struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
 
         sprintf(s, "%d", index);
 
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
 
         dentry = d_alloc_name(root, s);
         if (dentry) {
                 d_add(dentry, inode);
-                fsnotify_create(root->d_inode, dentry);
+                fsnotify_create(d_inode(root), dentry);
         } else {
                 iput(inode);
                 inode = ERR_PTR(-ENOMEM);
         }
 
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 
         return inode;
 }
@@ -658,7 +658,7 @@ void devpts_pty_kill(struct inode *inode)
 
         BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR));
 
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
 
         dentry = d_find_alias(inode);
 
@@ -667,7 +667,7 @@ void devpts_pty_kill(struct inode *inode)
         dput(dentry);   /* d_alloc_name() in devpts_pty_new() */
         dput(dentry);           /* d_find_alias above */
 
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 }
 
 static int __init init_devpts_fs(void)
diff --git a/fs/direct-io.c b/fs/direct-io.c
index c3b560b24a46..745d2342651a 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -253,7 +253,9 @@ static ssize_t dio_complete(struct dio *dio, loff_t offset, ssize_t ret,
         if (dio->end_io && dio->result)
                 dio->end_io(dio->iocb, offset, transferred, dio->private);
 
-        inode_dio_done(dio->inode);
+        if (!(dio->flags & DIO_SKIP_DIO_COUNT))
+                inode_dio_end(dio->inode);
+
         if (is_async) {
                 if (dio->rw & WRITE) {
                         int err;
@@ -1195,7 +1197,8 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
         /*
          * Will be decremented at I/O completion time.
          */
-        atomic_inc(&inode->i_dio_count);
+        if (!(dio->flags & DIO_SKIP_DIO_COUNT))
+                inode_dio_begin(inode);
 
         retval = 0;
         sdio.blkbits = blkbits;
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) {
diff --git a/fs/efivarfs/inode.c b/fs/efivarfs/inode.c
index 07ab49745e31..3381b9da9ee6 100644
--- a/fs/efivarfs/inode.c
+++ b/fs/efivarfs/inode.c
@@ -145,12 +145,12 @@ out:
 
 static int efivarfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct efivar_entry *var = dentry->d_inode->i_private;
+        struct efivar_entry *var = d_inode(dentry)->i_private;
 
         if (efivar_entry_delete(var))
                 return -EINVAL;
 
-        drop_nlink(dentry->d_inode);
+        drop_nlink(d_inode(dentry));
         dput(dentry);
         return 0;
 };
diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c
index ddbce42548c9..59fedbcf8798 100644
--- a/fs/efivarfs/super.c
+++ b/fs/efivarfs/super.c
@@ -144,7 +144,7 @@ static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
 
         name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
 
-        inode = efivarfs_get_inode(sb, root->d_inode, S_IFREG | 0644, 0);
+        inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0);
         if (!inode)
                 goto fail_name;
 
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index bbee8f063dfa..40ba9cc41bf7 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -111,9 +111,9 @@ struct dentry *efs_get_parent(struct dentry *child)
         struct dentry *parent = ERR_PTR(-ENOENT);
         efs_ino_t ino;
 
-        ino = efs_find_entry(child->d_inode, "..", 2);
+        ino = efs_find_entry(d_inode(child), "..", 2);
         if (ino)
-                parent = d_obtain_alias(efs_iget(child->d_inode->i_sb, ino));
+                parent = d_obtain_alias(efs_iget(d_inode(child)->i_sb, ino));
 
         return parent;
 }
diff --git a/fs/exofs/dir.c b/fs/exofs/dir.c
index d7defd557601..4deb0b05b011 100644
--- a/fs/exofs/dir.c
+++ b/fs/exofs/dir.c
@@ -379,7 +379,7 @@ ino_t exofs_parent_ino(struct dentry *child)
         struct exofs_dir_entry *de;
         ino_t ino;
 
-        de = exofs_dotdot(child->d_inode, &page);
+        de = exofs_dotdot(d_inode(child), &page);
         if (!de)
                 return 0;
 
@@ -429,7 +429,7 @@ int exofs_set_link(struct inode *dir, struct exofs_dir_entry *de,
 
 int exofs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const unsigned char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         unsigned chunk_size = exofs_chunk_size(dir);
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index 35073aaec6e0..786e4cc8c889 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -1028,7 +1028,7 @@ static int _do_truncate(struct inode *inode, loff_t newsize)
  */
 int exofs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         /* if we are about to modify an object, and it hasn't been
diff --git a/fs/exofs/namei.c b/fs/exofs/namei.c
index 28907460e8fa..5ae25e431191 100644
--- a/fs/exofs/namei.c
+++ b/fs/exofs/namei.c
@@ -141,7 +141,7 @@ out_fail:
 static int exofs_link(struct dentry *old_dentry, struct inode *dir,
                 struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         inode->i_ctime = CURRENT_TIME;
         inode_inc_link_count(inode);
@@ -191,7 +191,7 @@ out_dir:
 
 static int exofs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct exofs_dir_entry *de;
         struct page *page;
         int err = -ENOENT;
@@ -213,7 +213,7 @@ out:
 
 static int exofs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int err = -ENOTEMPTY;
 
         if (exofs_empty_dir(inode)) {
@@ -230,8 +230,8 @@ static int exofs_rmdir(struct inode *dir, struct dentry *dentry)
 static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct page *dir_page = NULL;
         struct exofs_dir_entry *dir_de = NULL;
         struct page *old_page;
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index fcc2e565f540..b795c567b5e1 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -958,7 +958,7 @@ static struct dentry *exofs_get_parent(struct dentry *child)
         if (!ino)
                 return ERR_PTR(-ESTALE);
 
-        return d_obtain_alias(exofs_iget(child->d_inode->i_sb, ino));
+        return d_obtain_alias(exofs_iget(d_inode(child)->i_sb, ino));
 }
 
 static struct inode *exofs_nfs_get_inode(struct super_block *sb,
diff --git a/fs/exofs/symlink.c b/fs/exofs/symlink.c
index 832e2624b80b..6f6f3a4c1365 100644
--- a/fs/exofs/symlink.c
+++ b/fs/exofs/symlink.c
@@ -37,7 +37,7 @@
 
 static void *exofs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct exofs_i_info *oi = exofs_i(dentry->d_inode);
+        struct exofs_i_info *oi = exofs_i(d_inode(dentry));
 
         nd_set_link(nd, (char *)oi->i_data);
         return NULL;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 6e1d4ab09d72..796b491e6978 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -486,7 +486,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
  */
 int ext2_add_link (struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         unsigned chunk_size = ext2_chunk_size(dir);
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 6c14bb8322fa..5c04a0ddea80 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -278,7 +278,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
         avefreeb = free_blocks / ngroups;
         ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
-        if ((parent == sb->s_root->d_inode) ||
+        if ((parent == d_inode(sb->s_root)) ||
             (EXT2_I(parent)->i_flags & EXT2_TOPDIR_FL)) {
                 struct ext2_group_desc *best_desc = NULL;
                 int best_ndir = inodes_per_group;
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 5d9213963fae..f460ae36d5b7 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1544,7 +1544,7 @@ int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
 
 int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, iattr);
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index ce422931f411..3e074a9ccbe6 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -79,10 +79,10 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, uns
 struct dentry *ext2_get_parent(struct dentry *child)
 {
         struct qstr dotdot = QSTR_INIT("..", 2);
-        unsigned long ino = ext2_inode_by_name(child->d_inode, &dotdot);
+        unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(ext2_iget(child->d_inode->i_sb, ino));
+        return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino));
 } 
 
 /*
@@ -208,7 +208,7 @@ out_fail:
 static int ext2_link (struct dentry * old_dentry, struct inode * dir,
         struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int err;
 
         dquot_initialize(dir);
@@ -275,7 +275,7 @@ out_dir:
 
 static int ext2_unlink(struct inode * dir, struct dentry *dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         struct ext2_dir_entry_2 * de;
         struct page * page;
         int err = -ENOENT;
@@ -299,7 +299,7 @@ out:
 
 static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         int err = -ENOTEMPTY;
 
         if (ext2_empty_dir(inode)) {
@@ -316,8 +316,8 @@ static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
 static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
         struct inode * new_dir, struct dentry * new_dentry )
 {
-        struct inode * old_inode = old_dentry->d_inode;
-        struct inode * new_inode = new_dentry->d_inode;
+        struct inode * old_inode = d_inode(old_dentry);
+        struct inode * new_inode = d_inode(new_dentry);
         struct page * dir_page = NULL;
         struct ext2_dir_entry_2 * dir_de = NULL;
         struct page * old_page;
diff --git a/fs/ext2/symlink.c b/fs/ext2/symlink.c
index 565cf817bbf1..20608f17c2e5 100644
--- a/fs/ext2/symlink.c
+++ b/fs/ext2/symlink.c
@@ -23,7 +23,7 @@
 
 static void *ext2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ext2_inode_info *ei = EXT2_I(dentry->d_inode);
+        struct ext2_inode_info *ei = EXT2_I(d_inode(dentry));
         nd_set_link(nd, (char *)ei->i_data);
         return NULL;
 }
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 91426141c33a..0b6bfd3a398b 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -243,7 +243,7 @@ cleanup:
 static int
 ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct buffer_head *bh = NULL;
         struct ext2_xattr_entry *entry;
         char *end;
@@ -319,7 +319,7 @@ cleanup:
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)
diff --git a/fs/ext2/xattr_security.c b/fs/ext2/xattr_security.c
index c0ebc4db8849..702fc6840246 100644
--- a/fs/ext2/xattr_security.c
+++ b/fs/ext2/xattr_security.c
@@ -28,7 +28,7 @@ ext2_xattr_security_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name,
+        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name,
                               buffer, size);
 }
 
@@ -38,7 +38,7 @@ ext2_xattr_security_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name,
+        return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name,
                               value, size, flags);
 }
 
diff --git a/fs/ext2/xattr_trusted.c b/fs/ext2/xattr_trusted.c
index 7e192574c001..42b6e9874bcc 100644
--- a/fs/ext2/xattr_trusted.c
+++ b/fs/ext2/xattr_trusted.c
@@ -32,7 +32,7 @@ ext2_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name,
+        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name,
                               buffer, size);
 }
 
@@ -42,7 +42,7 @@ ext2_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name,
+        return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name,
                               value, size, flags);
 }
 
diff --git a/fs/ext2/xattr_user.c b/fs/ext2/xattr_user.c
index f470e44c4b8d..ecdc4605192c 100644
--- a/fs/ext2/xattr_user.c
+++ b/fs/ext2/xattr_user.c
@@ -36,7 +36,7 @@ ext2_xattr_user_get(struct dentry *dentry, const char *name,
                 return -EINVAL;
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_USER,
+        return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_USER,
                               name, buffer, size);
 }
 
@@ -49,7 +49,7 @@ ext2_xattr_user_set(struct dentry *dentry, const char *name,
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
 
-        return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_USER,
+        return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_USER,
                               name, value, size, flags);
 }
 
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index a1b810230cc5..3ad242e5840e 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -210,7 +210,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
         avefreeb = freeb / ngroups;
         ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
-        if ((parent == sb->s_root->d_inode) ||
+        if ((parent == d_inode(sb->s_root)) ||
             (EXT3_I(parent)->i_flags & EXT3_TOPDIR_FL)) {
                 int best_ndir = inodes_per_group;
                 int best_group = -1;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 13c0868c7160..2ee2dc4351d1 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -3240,7 +3240,7 @@ int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
  */
 int ext3_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error, rc = 0;
         const unsigned int ia_valid = attr->ia_valid;
 
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index f197736dccfa..4264b9bd0002 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1049,19 +1049,19 @@ struct dentry *ext3_get_parent(struct dentry *child)
         struct ext3_dir_entry_2 * de;
         struct buffer_head *bh;
 
-        bh = ext3_find_entry(child->d_inode, &dotdot, &de);
+        bh = ext3_find_entry(d_inode(child), &dotdot, &de);
         if (!bh)
                 return ERR_PTR(-ENOENT);
         ino = le32_to_cpu(de->inode);
         brelse(bh);
 
-        if (!ext3_valid_inum(child->d_inode->i_sb, ino)) {
-                ext3_error(child->d_inode->i_sb, "ext3_get_parent",
+        if (!ext3_valid_inum(d_inode(child)->i_sb, ino)) {
+                ext3_error(d_inode(child)->i_sb, "ext3_get_parent",
                            "bad inode number: %lu", ino);
                 return ERR_PTR(-EIO);
         }
 
-        return d_obtain_alias(ext3_iget(child->d_inode->i_sb, ino));
+        return d_obtain_alias(ext3_iget(d_inode(child)->i_sb, ino));
 }
 
 #define S_SHIFT 12
@@ -1243,7 +1243,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
                              struct inode *inode, struct ext3_dir_entry_2 *de,
                              struct buffer_head * bh)
 {
-        struct inode    *dir = dentry->d_parent->d_inode;
+        struct inode    *dir = d_inode(dentry->d_parent);
         const char      *name = dentry->d_name.name;
         int             namelen = dentry->d_name.len;
         unsigned long   offset = 0;
@@ -1330,7 +1330,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
 static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
                             struct inode *inode, struct buffer_head *bh)
 {
-        struct inode    *dir = dentry->d_parent->d_inode;
+        struct inode    *dir = d_inode(dentry->d_parent);
         const char      *name = dentry->d_name.name;
         int             namelen = dentry->d_name.len;
         struct buffer_head *bh2;
@@ -1435,7 +1435,7 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
 static int ext3_add_entry (handle_t *handle, struct dentry *dentry,
         struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct buffer_head * bh;
         struct ext3_dir_entry_2 *de;
         struct super_block * sb;
@@ -1489,7 +1489,7 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
         struct dx_entry *entries, *at;
         struct dx_hash_info hinfo;
         struct buffer_head * bh;
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct super_block * sb = dir->i_sb;
         struct ext3_dir_entry_2 *de;
         int err;
@@ -2111,7 +2111,7 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
         /* Initialize quotas before so that eventual writes go in
          * separate transaction */
         dquot_initialize(dir);
-        dquot_initialize(dentry->d_inode);
+        dquot_initialize(d_inode(dentry));
 
         handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
         if (IS_ERR(handle))
@@ -2125,7 +2125,7 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
         if (IS_DIRSYNC(dir))
                 handle->h_sync = 1;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         retval = -EIO;
         if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2173,7 +2173,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
         /* Initialize quotas before so that eventual writes go
          * in separate transaction */
         dquot_initialize(dir);
-        dquot_initialize(dentry->d_inode);
+        dquot_initialize(d_inode(dentry));
 
         handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
         if (IS_ERR(handle))
@@ -2187,7 +2187,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
         if (!bh)
                 goto end_unlink;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         retval = -EIO;
         if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -2328,7 +2328,7 @@ static int ext3_link (struct dentry * old_dentry,
                 struct inode * dir, struct dentry *dentry)
 {
         handle_t *handle;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int err, retries = 0;
 
         if (inode->i_nlink >= EXT3_LINK_MAX)
@@ -2391,8 +2391,8 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
 
         /* Initialize quotas before so that eventual writes go
          * in separate transaction */
-        if (new_dentry->d_inode)
-                dquot_initialize(new_dentry->d_inode);
+        if (d_really_is_positive(new_dentry))
+                dquot_initialize(d_inode(new_dentry));
         handle = ext3_journal_start(old_dir, 2 *
                                         EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) +
                                         EXT3_INDEX_EXTRA_TRANS_BLOCKS + 2);
@@ -2409,12 +2409,12 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
          *  and merrily kill the link to whatever was created under the
          *  same name. Goodbye sticky bit ;-<
          */
-        old_inode = old_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
         retval = -ENOENT;
         if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino)
                 goto end_rename;
 
-        new_inode = new_dentry->d_inode;
+        new_inode = d_inode(new_dentry);
         new_bh = ext3_find_entry(new_dir, &new_dentry->d_name, &new_de);
         if (new_bh) {
                 if (!new_inode) {
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index f037b4b27300..a9312f0a54e5 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1170,7 +1170,7 @@ static int parse_options (char *options, struct super_block *sb,
                                 return 0;
                         }
 
-                        journal_inode = path.dentry->d_inode;
+                        journal_inode = d_inode(path.dentry);
                         if (!S_ISBLK(journal_inode->i_mode)) {
                                 ext3_msg(sb, KERN_ERR, "error: journal path %s "
                                         "is not a block device", journal_path);
@@ -2947,7 +2947,7 @@ static int ext3_write_info(struct super_block *sb, int type)
         handle_t *handle;
 
         /* Data block + inode block */
-        handle = ext3_journal_start(sb->s_root->d_inode, 2);
+        handle = ext3_journal_start(d_inode(sb->s_root), 2);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
         ret = dquot_commit_info(sb, type);
@@ -2994,7 +2994,7 @@ static int ext3_quota_on(struct super_block *sb, int type, int format_id,
          * When we journal data on quota file, we have to flush journal to see
          * all updates to the file when we bypass pagecache...
          */
-        if (ext3_should_journal_data(path->dentry->d_inode)) {
+        if (ext3_should_journal_data(d_inode(path->dentry))) {
                 /*
                  * We don't need to lock updates but journal_flush() could
                  * otherwise be livelocked...
diff --git a/fs/ext3/symlink.c b/fs/ext3/symlink.c
index 6b01c3eab1f3..ea96df3c58db 100644
--- a/fs/ext3/symlink.c
+++ b/fs/ext3/symlink.c
@@ -23,7 +23,7 @@
 
 static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ext3_inode_info *ei = EXT3_I(dentry->d_inode);
+        struct ext3_inode_info *ei = EXT3_I(d_inode(dentry));
         nd_set_link(nd, (char*)ei->i_data);
         return NULL;
 }
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index 24215dc09a18..7cf36501ccf4 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -137,7 +137,7 @@ ext3_xattr_handler(int name_index)
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext3_listxattr(struct dentry *dentry, char *buffer, size_t size)
@@ -355,7 +355,7 @@ ext3_xattr_list_entries(struct dentry *dentry, struct ext3_xattr_entry *entry,
 static int
 ext3_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct buffer_head *bh = NULL;
         int error;
 
@@ -391,7 +391,7 @@ cleanup:
 static int
 ext3_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ext3_xattr_ibody_header *header;
         struct ext3_inode *raw_inode;
         struct ext3_iloc iloc;
@@ -432,7 +432,7 @@ ext3_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
         int i_error, b_error;
 
-        down_read(&EXT3_I(dentry->d_inode)->xattr_sem);
+        down_read(&EXT3_I(d_inode(dentry))->xattr_sem);
         i_error = ext3_xattr_ibody_list(dentry, buffer, buffer_size);
         if (i_error < 0) {
                 b_error = 0;
@@ -445,7 +445,7 @@ ext3_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
                 if (b_error < 0)
                         i_error = 0;
         }
-        up_read(&EXT3_I(dentry->d_inode)->xattr_sem);
+        up_read(&EXT3_I(d_inode(dentry))->xattr_sem);
         return i_error + b_error;
 }
 
diff --git a/fs/ext3/xattr_security.c b/fs/ext3/xattr_security.c
index 722c2bf9645d..c9506d5e3b13 100644
--- a/fs/ext3/xattr_security.c
+++ b/fs/ext3/xattr_security.c
@@ -29,7 +29,7 @@ ext3_xattr_security_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY,
+        return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY,
                               name, buffer, size);
 }
 
@@ -39,7 +39,7 @@ ext3_xattr_security_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY,
+        return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY,
                               name, value, size, flags);
 }
 
diff --git a/fs/ext3/xattr_trusted.c b/fs/ext3/xattr_trusted.c
index d75727cc67fa..206cc66dc285 100644
--- a/fs/ext3/xattr_trusted.c
+++ b/fs/ext3/xattr_trusted.c
@@ -32,7 +32,7 @@ ext3_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED,
+        return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED,
                               name, buffer, size);
 }
 
@@ -42,7 +42,7 @@ ext3_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED, name,
+        return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED, name,
                               value, size, flags);
 }
 
diff --git a/fs/ext3/xattr_user.c b/fs/ext3/xattr_user.c
index 5612af3567e0..021508ad1616 100644
--- a/fs/ext3/xattr_user.c
+++ b/fs/ext3/xattr_user.c
@@ -34,7 +34,7 @@ ext3_xattr_user_get(struct dentry *dentry, const char *name, void *buffer,
                 return -EINVAL;
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_USER,
+        return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_USER,
                               name, buffer, size);
 }
 
@@ -46,7 +46,7 @@ ext3_xattr_user_set(struct dentry *dentry, const char *name,
                 return -EINVAL;
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_USER,
+        return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_USER,
                               name, value, size, flags);
 }
 
diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
index e9d632e9aa4b..8850254136ae 100644
--- a/fs/ext4/fsync.c
+++ b/fs/ext4/fsync.c
@@ -55,7 +55,7 @@ static int ext4_sync_parent(struct inode *inode)
                 dentry = d_find_any_alias(inode);
                 if (!dentry)
                         break;
-                next = igrab(dentry->d_parent->d_inode);
+                next = igrab(d_inode(dentry->d_parent));
                 dput(dentry);
                 if (!next)
                         break;
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 2cf18a2d5c72..1eaa6cb96cd0 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -443,7 +443,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent,
         ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
 
         if (S_ISDIR(mode) &&
-            ((parent == sb->s_root->d_inode) ||
+            ((parent == d_inode(sb->s_root)) ||
              (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) {
                 int best_ndir = inodes_per_group;
                 int ret = -1;
diff --git a/fs/ext4/indirect.c b/fs/ext4/indirect.c
index 3580629e42d3..958824019509 100644
--- a/fs/ext4/indirect.c
+++ b/fs/ext4/indirect.c
@@ -682,11 +682,11 @@ retry:
                  * via ext4_inode_block_unlocked_dio(). Check inode's state
                  * while holding extra i_dio_count ref.
                  */
-                atomic_inc(&inode->i_dio_count);
+                inode_dio_begin(inode);
                 smp_mb();
                 if (unlikely(ext4_test_inode_state(inode,
                                                     EXT4_STATE_DIOREAD_LOCK))) {
-                        inode_dio_done(inode);
+                        inode_dio_end(inode);
                         goto locked;
                 }
                 if (IS_DAX(inode))
@@ -697,7 +697,7 @@ retry:
                                                    inode->i_sb->s_bdev, iter,
                                                    offset, ext4_get_block, NULL,
                                                    NULL, 0);
-                inode_dio_done(inode);
+                inode_dio_end(inode);
         } else {
 locked:
                 if (IS_DAX(inode))
diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index feb2cafbeace..095c7a258d97 100644
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -1000,7 +1000,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle,
                                      struct ext4_iloc *iloc,
                                      void *inline_start, int inline_size)
 {
-        struct inode    *dir = dentry->d_parent->d_inode;
+        struct inode    *dir = d_inode(dentry->d_parent);
         const char      *name = dentry->d_name.name;
         int             namelen = dentry->d_name.len;
         int             err;
@@ -1254,7 +1254,7 @@ int ext4_try_add_inline_entry(handle_t *handle, struct dentry *dentry,
         int ret, inline_size;
         void *inline_start;
         struct ext4_iloc iloc;
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
 
         ret = ext4_get_inode_loc(dir, &iloc);
         if (ret)
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 366476e71e10..cbd0654a2675 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -3077,7 +3077,7 @@ static ssize_t ext4_ext_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
          * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
          */
         if (iov_iter_rw(iter) == WRITE)
-                atomic_inc(&inode->i_dio_count);
+                inode_dio_begin(inode);
 
         /* If we do a overwrite dio, i_mutex locking can be released */
         overwrite = *((int *)iocb->private);
@@ -3182,7 +3182,7 @@ static ssize_t ext4_ext_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 retake_lock:
         if (iov_iter_rw(iter) == WRITE)
-                inode_dio_done(inode);
+                inode_dio_end(inode);
         /* take i_mutex locking again if we do a ovewrite dio */
         if (overwrite) {
                 up_read(&EXT4_I(inode)->i_data_sem);
@@ -4637,7 +4637,7 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode)
  */
 int ext4_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error, rc = 0;
         int orphan = 0;
         const unsigned int ia_valid = attr->ia_valid;
@@ -4785,7 +4785,7 @@ int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
         struct inode *inode;
         unsigned long long delalloc_blocks;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         generic_fillattr(inode, stat);
 
         /*
diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
index 3cb267aee802..b52374e42102 100644
--- a/fs/ext4/migrate.c
+++ b/fs/ext4/migrate.c
@@ -475,7 +475,7 @@ int ext4_ext_migrate(struct inode *inode)
                 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
         owner[0] = i_uid_read(inode);
         owner[1] = i_gid_read(inode);
-        tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
+        tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root),
                                    S_IFREG, NULL, goal, owner);
         if (IS_ERR(tmp_inode)) {
                 retval = PTR_ERR(tmp_inode);
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index ef22cd951c0c..7223b0b4bc38 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1664,7 +1664,7 @@ struct dentry *ext4_get_parent(struct dentry *child)
         struct ext4_dir_entry_2 * de;
         struct buffer_head *bh;
 
-        bh = ext4_find_entry(child->d_inode, &dotdot, &de, NULL);
+        bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
         if (IS_ERR(bh))
                 return (struct dentry *) bh;
         if (!bh)
@@ -1672,13 +1672,13 @@ struct dentry *ext4_get_parent(struct dentry *child)
         ino = le32_to_cpu(de->inode);
         brelse(bh);
 
-        if (!ext4_valid_inum(child->d_inode->i_sb, ino)) {
-                EXT4_ERROR_INODE(child->d_inode,
+        if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
+                EXT4_ERROR_INODE(d_inode(child),
                                  "bad parent inode number: %u", ino);
                 return ERR_PTR(-EIO);
         }
 
-        return d_obtain_alias(ext4_iget_normal(child->d_inode->i_sb, ino));
+        return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
 }
 
 /*
@@ -1988,7 +1988,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
                              struct inode *inode, struct ext4_dir_entry_2 *de,
                              struct buffer_head *bh)
 {
-        struct inode    *dir = dentry->d_parent->d_inode;
+        struct inode    *dir = d_inode(dentry->d_parent);
         const char      *name = dentry->d_name.name;
         int             namelen = dentry->d_name.len;
         unsigned int    blocksize = dir->i_sb->s_blocksize;
@@ -2048,7 +2048,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
 static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
                             struct inode *inode, struct buffer_head *bh)
 {
-        struct inode    *dir = dentry->d_parent->d_inode;
+        struct inode    *dir = d_inode(dentry->d_parent);
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
         struct ext4_fname_crypto_ctx *ctx = NULL;
         int res;
@@ -2202,7 +2202,7 @@ out_frames:
 static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
                           struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct buffer_head *bh = NULL;
         struct ext4_dir_entry_2 *de;
         struct ext4_dir_entry_tail *t;
@@ -2287,7 +2287,7 @@ static int ext4_dx_add_entry(handle_t *handle, struct dentry *dentry,
         struct dx_entry *entries, *at;
         struct dx_hash_info hinfo;
         struct buffer_head *bh;
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct super_block *sb = dir->i_sb;
         struct ext4_dir_entry_2 *de;
         int err;
@@ -3063,7 +3063,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
         /* Initialize quotas before so that eventual writes go in
          * separate transaction */
         dquot_initialize(dir);
-        dquot_initialize(dentry->d_inode);
+        dquot_initialize(d_inode(dentry));
 
         retval = -ENOENT;
         bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
@@ -3072,7 +3072,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
         if (!bh)
                 goto end_rmdir;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         retval = -EIO;
         if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -3132,7 +3132,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
         /* Initialize quotas before so that eventual writes go
          * in separate transaction */
         dquot_initialize(dir);
-        dquot_initialize(dentry->d_inode);
+        dquot_initialize(d_inode(dentry));
 
         retval = -ENOENT;
         bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
@@ -3141,7 +3141,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
         if (!bh)
                 goto end_unlink;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         retval = -EIO;
         if (le32_to_cpu(de->inode) != inode->i_ino)
@@ -3339,7 +3339,7 @@ static int ext4_link(struct dentry *old_dentry,
                      struct inode *dir, struct dentry *dentry)
 {
         handle_t *handle;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int err, retries = 0;
 
         if (inode->i_nlink >= EXT4_LINK_MAX)
@@ -3613,12 +3613,12 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct ext4_renament old = {
                 .dir = old_dir,
                 .dentry = old_dentry,
-                .inode = old_dentry->d_inode,
+                .inode = d_inode(old_dentry),
         };
         struct ext4_renament new = {
                 .dir = new_dir,
                 .dentry = new_dentry,
-                .inode = new_dentry->d_inode,
+                .inode = d_inode(new_dentry),
         };
         int force_reread;
         int retval;
@@ -3809,12 +3809,12 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct ext4_renament old = {
                 .dir = old_dir,
                 .dentry = old_dentry,
-                .inode = old_dentry->d_inode,
+                .inode = d_inode(old_dentry),
         };
         struct ext4_renament new = {
                 .dir = new_dir,
                 .dentry = new_dentry,
-                .inode = new_dentry->d_inode,
+                .inode = d_inode(new_dentry),
         };
         u8 new_file_type;
         int retval;
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 821f22dbe825..f06d0589ddba 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1556,7 +1556,7 @@ static int handle_mount_opt(struct super_block *sb, char *opt, int token,
                         return -1;
                 }
 
-                journal_inode = path.dentry->d_inode;
+                journal_inode = d_inode(path.dentry);
                 if (!S_ISBLK(journal_inode->i_mode)) {
                         ext4_msg(sb, KERN_ERR, "error: journal path %s "
                                 "is not a block device", journal_path);
@@ -5217,7 +5217,7 @@ static int ext4_write_info(struct super_block *sb, int type)
         handle_t *handle;
 
         /* Data block + inode block */
-        handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2);
+        handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
         ret = dquot_commit_info(sb, type);
@@ -5265,7 +5265,7 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
          * all updates to the file when we bypass pagecache...
          */
         if (EXT4_SB(sb)->s_journal &&
-            ext4_should_journal_data(path->dentry->d_inode)) {
+            ext4_should_journal_data(d_inode(path->dentry))) {
                 /*
                  * We don't need to lock updates but journal_flush() could
                  * otherwise be livelocked...
diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
index 136ca0e911fd..19f78f20975e 100644
--- a/fs/ext4/symlink.c
+++ b/fs/ext4/symlink.c
@@ -28,7 +28,7 @@ static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
         struct page *cpage = NULL;
         char *caddr, *paddr = NULL;
         struct ext4_str cstr, pstr;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ext4_fname_crypto_ctx *ctx = NULL;
         struct ext4_encrypted_symlink_data *sd;
         loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1);
@@ -43,8 +43,8 @@ static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
                 return ctx;
 
         if (ext4_inode_is_fast_symlink(inode)) {
-                caddr = (char *) EXT4_I(dentry->d_inode)->i_data;
-                max_size = sizeof(EXT4_I(dentry->d_inode)->i_data);
+                caddr = (char *) EXT4_I(inode)->i_data;
+                max_size = sizeof(EXT4_I(inode)->i_data);
         } else {
                 cpage = read_mapping_page(inode->i_mapping, 0, NULL);
                 if (IS_ERR(cpage)) {
@@ -113,7 +113,7 @@ static void ext4_put_link(struct dentry *dentry, struct nameidata *nd,
 
 static void *ext4_follow_fast_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ext4_inode_info *ei = EXT4_I(dentry->d_inode);
+        struct ext4_inode_info *ei = EXT4_I(d_inode(dentry));
         nd_set_link(nd, (char *) ei->i_data);
         return NULL;
 }
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 759842ff8af0..16e28c08d1e8 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -178,7 +178,7 @@ ext4_xattr_handler(int name_index)
 /*
  * Inode operation listxattr()
  *
- * dentry->d_inode->i_mutex: don't care
+ * d_inode(dentry)->i_mutex: don't care
  */
 ssize_t
 ext4_listxattr(struct dentry *dentry, char *buffer, size_t size)
@@ -423,7 +423,7 @@ ext4_xattr_list_entries(struct dentry *dentry, struct ext4_xattr_entry *entry,
 static int
 ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct buffer_head *bh = NULL;
         int error;
         struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
@@ -460,7 +460,7 @@ cleanup:
 static int
 ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ext4_xattr_ibody_header *header;
         struct ext4_inode *raw_inode;
         struct ext4_iloc iloc;
@@ -501,7 +501,7 @@ ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
         int ret, ret2;
 
-        down_read(&EXT4_I(dentry->d_inode)->xattr_sem);
+        down_read(&EXT4_I(d_inode(dentry))->xattr_sem);
         ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size);
         if (ret < 0)
                 goto errout;
@@ -514,7 +514,7 @@ ext4_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
                 goto errout;
         ret += ret2;
 errout:
-        up_read(&EXT4_I(dentry->d_inode)->xattr_sem);
+        up_read(&EXT4_I(d_inode(dentry))->xattr_sem);
         return ret;
 }
 
diff --git a/fs/ext4/xattr_security.c b/fs/ext4/xattr_security.c
index d2a200624af5..95d90e0560f0 100644
--- a/fs/ext4/xattr_security.c
+++ b/fs/ext4/xattr_security.c
@@ -33,7 +33,7 @@ ext4_xattr_security_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY,
+        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY,
                               name, buffer, size);
 }
 
@@ -43,7 +43,7 @@ ext4_xattr_security_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY,
+        return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY,
                               name, value, size, flags);
 }
 
diff --git a/fs/ext4/xattr_trusted.c b/fs/ext4/xattr_trusted.c
index 95f1f4ab59a4..891ee2ddfbd6 100644
--- a/fs/ext4/xattr_trusted.c
+++ b/fs/ext4/xattr_trusted.c
@@ -36,7 +36,7 @@ ext4_xattr_trusted_get(struct dentry *dentry, const char *name, void *buffer,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED,
+        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED,
                               name, buffer, size);
 }
 
@@ -46,7 +46,7 @@ ext4_xattr_trusted_set(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED,
+        return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED,
                               name, value, size, flags);
 }
 
diff --git a/fs/ext4/xattr_user.c b/fs/ext4/xattr_user.c
index 0edb7611ffbe..6ed932b3c043 100644
--- a/fs/ext4/xattr_user.c
+++ b/fs/ext4/xattr_user.c
@@ -37,7 +37,7 @@ ext4_xattr_user_get(struct dentry *dentry, const char *name,
                 return -EINVAL;
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_USER,
+        return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_USER,
                               name, buffer, size);
 }
 
@@ -49,7 +49,7 @@ ext4_xattr_user_set(struct dentry *dentry, const char *name,
                 return -EINVAL;
         if (!test_opt(dentry->d_sb, XATTR_USER))
                 return -EOPNOTSUPP;
-        return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_USER,
+        return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_USER,
                               name, value, size, flags);
 }
 
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index c06a25e5cec3..d8921cf2ba9a 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1482,7 +1482,7 @@ bool f2fs_empty_dir(struct inode *);
 
 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
+        return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
                                 inode, inode->i_ino, inode->i_mode);
 }
 
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index a6f3f6186588..2b52e48d7482 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -574,7 +574,7 @@ void f2fs_truncate(struct inode *inode)
 int f2fs_getattr(struct vfsmount *mnt,
                          struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         generic_fillattr(inode, stat);
         stat->blocks <<= 3;
         return 0;
@@ -613,7 +613,7 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
 
 int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct f2fs_inode_info *fi = F2FS_I(inode);
         int err;
 
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 407dde3d7a92..7e3794edae42 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -151,7 +151,7 @@ out:
 static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
                 struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
         int err;
 
@@ -182,10 +182,10 @@ out:
 struct dentry *f2fs_get_parent(struct dentry *child)
 {
         struct qstr dotdot = QSTR_INIT("..", 2);
-        unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot);
+        unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));
+        return d_obtain_alias(f2fs_iget(d_inode(child)->i_sb, ino));
 }
 
 static int __recover_dot_dentries(struct inode *dir, nid_t pino)
@@ -263,7 +263,7 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
 static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct f2fs_dir_entry *de;
         struct page *page;
         int err = -ENOENT;
@@ -403,7 +403,7 @@ out_fail:
 
 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         if (f2fs_empty_dir(inode))
                 return f2fs_unlink(dir, dentry);
         return -ENOTEMPTY;
@@ -451,8 +451,8 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         struct inode *new_dir, struct dentry *new_dentry)
 {
         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct page *old_dir_page;
         struct page *old_page, *new_page;
         struct f2fs_dir_entry *old_dir_entry = NULL;
@@ -578,8 +578,8 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
                              struct inode *new_dir, struct dentry *new_dentry)
 {
         struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct page *old_dir_page, *new_dir_page;
         struct page *old_page, *new_page;
         struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index b0fd2f2d0716..9757f65a05bc 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -83,7 +83,7 @@ static int f2fs_xattr_generic_get(struct dentry *dentry, const char *name,
         }
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return f2fs_getxattr(dentry->d_inode, type, name, buffer, size, NULL);
+        return f2fs_getxattr(d_inode(dentry), type, name, buffer, size, NULL);
 }
 
 static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
@@ -108,7 +108,7 @@ static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
         if (strcmp(name, "") == 0)
                 return -EINVAL;
 
-        return f2fs_setxattr(dentry->d_inode, type, name,
+        return f2fs_setxattr(d_inode(dentry), type, name,
                                         value, size, NULL, flags);
 }
 
@@ -130,7 +130,7 @@ static size_t f2fs_xattr_advise_list(struct dentry *dentry, char *list,
 static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
                 void *buffer, size_t size, int type)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (strcmp(name, "") != 0)
                 return -EINVAL;
@@ -143,7 +143,7 @@ static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
 static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name,
                 const void *value, size_t size, int flags, int type)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (strcmp(name, "") != 0)
                 return -EINVAL;
@@ -444,7 +444,7 @@ cleanup:
 
 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct f2fs_xattr_entry *entry;
         void *base_addr;
         int error = 0;
diff --git a/fs/fat/file.c b/fs/fat/file.c
index cf50d93565a2..442d50a0e33e 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -305,7 +305,7 @@ void fat_truncate_blocks(struct inode *inode, loff_t offset)
 
 int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         generic_fillattr(inode, stat);
         stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size;
 
@@ -377,7 +377,7 @@ static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
 int fat_setattr(struct dentry *dentry, struct iattr *attr)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         unsigned int ia_valid;
         int error;
 
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index cc6a8541b668..b7e2b33aa793 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -308,7 +308,7 @@ out:
 static int msdos_rmdir(struct inode *dir, struct dentry *dentry)
 {
         struct super_block *sb = dir->i_sb;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct fat_slot_info sinfo;
         int err;
 
@@ -402,7 +402,7 @@ out:
 /***** Unlink a file */
 static int msdos_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = inode->i_sb;
         struct fat_slot_info sinfo;
         int err;
@@ -440,8 +440,8 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
         int err, old_attrs, is_dir, update_dotdot, corrupt = 0;
 
         old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
-        old_inode = old_dentry->d_inode;
-        new_inode = new_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
+        new_inode = d_inode(new_dentry);
 
         err = fat_scan(old_dir, old_name, &old_sinfo);
         if (err) {
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 7e0974eebd8e..7092584f424a 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -33,7 +33,7 @@ static int vfat_revalidate_shortname(struct dentry *dentry)
 {
         int ret = 1;
         spin_lock(&dentry->d_lock);
-        if (dentry->d_time != dentry->d_parent->d_inode->i_version)
+        if (dentry->d_time != d_inode(dentry->d_parent)->i_version)
                 ret = 0;
         spin_unlock(&dentry->d_lock);
         return ret;
@@ -45,7 +45,7 @@ static int vfat_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         /* This is not negative dentry. Always valid. */
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 return 1;
         return vfat_revalidate_shortname(dentry);
 }
@@ -65,7 +65,7 @@ static int vfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
          * positive dentry isn't good idea. So it's unsupported like
          * rename("filename", "FILENAME") for now.
          */
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 return 1;
 
         /*
@@ -801,7 +801,7 @@ out:
 
 static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = dir->i_sb;
         struct fat_slot_info sinfo;
         int err;
@@ -832,7 +832,7 @@ out:
 
 static int vfat_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = dir->i_sb;
         struct fat_slot_info sinfo;
         int err;
@@ -915,8 +915,8 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct super_block *sb = old_dir->i_sb;
 
         old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
-        old_inode = old_dentry->d_inode;
-        new_inode = new_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
+        new_inode = d_inode(new_dentry);
         mutex_lock(&MSDOS_SB(sb)->s_lock);
         err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
         if (err)
diff --git a/fs/fat/nfs.c b/fs/fat/nfs.c
index 93e14933dcb6..eb192656fba2 100644
--- a/fs/fat/nfs.c
+++ b/fs/fat/nfs.c
@@ -266,7 +266,7 @@ struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
  * Find the parent for a directory that is not currently connected to
  * the filesystem root.
  *
- * On entry, the caller holds child_dir->d_inode->i_mutex.
+ * On entry, the caller holds d_inode(child_dir)->i_mutex.
  */
 static struct dentry *fat_get_parent(struct dentry *child_dir)
 {
@@ -276,7 +276,7 @@ static struct dentry *fat_get_parent(struct dentry *child_dir)
         struct inode *parent_inode = NULL;
         struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
-        if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
+        if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) {
                 int parent_logstart = fat_get_start(sbi, de);
                 parent_inode = fat_dget(sb, parent_logstart);
                 if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
diff --git a/fs/freevxfs/vxfs_immed.c b/fs/freevxfs/vxfs_immed.c
index c36aeaf92e41..8b9229e2ca5c 100644
--- a/fs/freevxfs/vxfs_immed.c
+++ b/fs/freevxfs/vxfs_immed.c
@@ -76,7 +76,7 @@ const struct address_space_operations vxfs_immed_aops = {
 static void *
 vxfs_immed_follow_link(struct dentry *dp, struct nameidata *np)
 {
-        struct vxfs_inode_info          *vip = VXFS_INO(dp->d_inode);
+        struct vxfs_inode_info          *vip = VXFS_INO(d_inode(dp));
         nd_set_link(np, vip->vii_immed.vi_immed);
         return NULL;
 }
diff --git a/fs/fuse/control.c b/fs/fuse/control.c
index 205e0d5d5307..f863ac6647ac 100644
--- a/fs/fuse/control.c
+++ b/fs/fuse/control.c
@@ -244,7 +244,7 @@ int fuse_ctl_add_conn(struct fuse_conn *fc)
                 return 0;
 
         parent = fuse_control_sb->s_root;
-        inc_nlink(parent->d_inode);
+        inc_nlink(d_inode(parent));
         sprintf(name, "%u", fc->dev);
         parent = fuse_ctl_add_dentry(parent, fc, name, S_IFDIR | 0500, 2,
                                      &simple_dir_inode_operations,
@@ -283,11 +283,11 @@ void fuse_ctl_remove_conn(struct fuse_conn *fc)
 
         for (i = fc->ctl_ndents - 1; i >= 0; i--) {
                 struct dentry *dentry = fc->ctl_dentry[i];
-                dentry->d_inode->i_private = NULL;
+                d_inode(dentry)->i_private = NULL;
                 d_drop(dentry);
                 dput(dentry);
         }
-        drop_nlink(fuse_control_sb->s_root->d_inode);
+        drop_nlink(d_inode(fuse_control_sb->s_root));
 }
 
 static int fuse_ctl_fill_super(struct super_block *sb, void *data, int silent)
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 1545b711ddcf..0572bca49f15 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -192,7 +192,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
         struct fuse_inode *fi;
         int ret;
 
-        inode = ACCESS_ONCE(entry->d_inode);
+        inode = d_inode_rcu(entry);
         if (inode && is_bad_inode(inode))
                 goto invalid;
         else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
@@ -220,7 +220,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                 attr_version = fuse_get_attr_version(fc);
 
                 parent = dget_parent(entry);
-                fuse_lookup_init(fc, &args, get_node_id(parent->d_inode),
+                fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
                                  &entry->d_name, &outarg);
                 ret = fuse_simple_request(fc, &args);
                 dput(parent);
@@ -254,7 +254,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                                 return -ECHILD;
                 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
                         parent = dget_parent(entry);
-                        fuse_advise_use_readdirplus(parent->d_inode);
+                        fuse_advise_use_readdirplus(d_inode(parent));
                         dput(parent);
                 }
         }
@@ -487,7 +487,7 @@ static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
                         entry = res;
         }
 
-        if (!(flags & O_CREAT) || entry->d_inode)
+        if (!(flags & O_CREAT) || d_really_is_positive(entry))
                 goto no_open;
 
         /* Only creates */
@@ -653,7 +653,7 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
         args.in.args[0].value = entry->d_name.name;
         err = fuse_simple_request(fc, &args);
         if (!err) {
-                struct inode *inode = entry->d_inode;
+                struct inode *inode = d_inode(entry);
                 struct fuse_inode *fi = get_fuse_inode(inode);
 
                 spin_lock(&fc->lock);
@@ -689,7 +689,7 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
         args.in.args[0].value = entry->d_name.name;
         err = fuse_simple_request(fc, &args);
         if (!err) {
-                clear_nlink(entry->d_inode);
+                clear_nlink(d_inode(entry));
                 fuse_invalidate_attr(dir);
                 fuse_invalidate_entry_cache(entry);
         } else if (err == -EINTR)
@@ -721,12 +721,12 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
         err = fuse_simple_request(fc, &args);
         if (!err) {
                 /* ctime changes */
-                fuse_invalidate_attr(oldent->d_inode);
-                fuse_update_ctime(oldent->d_inode);
+                fuse_invalidate_attr(d_inode(oldent));
+                fuse_update_ctime(d_inode(oldent));
 
                 if (flags & RENAME_EXCHANGE) {
-                        fuse_invalidate_attr(newent->d_inode);
-                        fuse_update_ctime(newent->d_inode);
+                        fuse_invalidate_attr(d_inode(newent));
+                        fuse_update_ctime(d_inode(newent));
                 }
 
                 fuse_invalidate_attr(olddir);
@@ -734,10 +734,10 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
                         fuse_invalidate_attr(newdir);
 
                 /* newent will end up negative */
-                if (!(flags & RENAME_EXCHANGE) && newent->d_inode) {
-                        fuse_invalidate_attr(newent->d_inode);
+                if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
+                        fuse_invalidate_attr(d_inode(newent));
                         fuse_invalidate_entry_cache(newent);
-                        fuse_update_ctime(newent->d_inode);
+                        fuse_update_ctime(d_inode(newent));
                 }
         } else if (err == -EINTR) {
                 /* If request was interrupted, DEITY only knows if the
@@ -746,7 +746,7 @@ static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
                    directory), then there can be inconsistency between
                    the dcache and the real filesystem.  Tough luck. */
                 fuse_invalidate_entry(oldent);
-                if (newent->d_inode)
+                if (d_really_is_positive(newent))
                         fuse_invalidate_entry(newent);
         }
 
@@ -788,7 +788,7 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
 {
         int err;
         struct fuse_link_in inarg;
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
 
@@ -961,9 +961,9 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
         fuse_invalidate_attr(parent);
         fuse_invalidate_entry(entry);
 
-        if (child_nodeid != 0 && entry->d_inode) {
-                mutex_lock(&entry->d_inode->i_mutex);
-                if (get_node_id(entry->d_inode) != child_nodeid) {
+        if (child_nodeid != 0 && d_really_is_positive(entry)) {
+                mutex_lock(&d_inode(entry)->i_mutex);
+                if (get_node_id(d_inode(entry)) != child_nodeid) {
                         err = -ENOENT;
                         goto badentry;
                 }
@@ -977,13 +977,13 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
                                 err = -ENOTEMPTY;
                                 goto badentry;
                         }
-                        entry->d_inode->i_flags |= S_DEAD;
+                        d_inode(entry)->i_flags |= S_DEAD;
                 }
                 dont_mount(entry);
-                clear_nlink(entry->d_inode);
+                clear_nlink(d_inode(entry));
                 err = 0;
  badentry:
-                mutex_unlock(&entry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(entry)->i_mutex);
                 if (!err)
                         d_delete(entry);
         } else {
@@ -1169,7 +1169,7 @@ static int fuse_direntplus_link(struct file *file,
         struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
         struct dentry *dentry;
         struct dentry *alias;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct fuse_conn *fc;
         struct inode *inode;
 
@@ -1205,7 +1205,7 @@ static int fuse_direntplus_link(struct file *file,
         name.hash = full_name_hash(name.name, name.len);
         dentry = d_lookup(parent, &name);
         if (dentry) {
-                inode = dentry->d_inode;
+                inode = d_inode(dentry);
                 if (!inode) {
                         d_drop(dentry);
                 } else if (get_node_id(inode) != o->nodeid ||
@@ -1367,7 +1367,7 @@ static int fuse_readdir(struct file *file, struct dir_context *ctx)
 
 static char *read_link(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         char *link;
@@ -1712,7 +1712,7 @@ error:
 
 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
 
         if (!fuse_allow_current_process(get_fuse_conn(inode)))
                 return -EACCES;
@@ -1726,7 +1726,7 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
                         struct kstat *stat)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
 
         if (!fuse_allow_current_process(fc))
@@ -1738,7 +1738,7 @@ static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
 static int fuse_setxattr(struct dentry *entry, const char *name,
                          const void *value, size_t size, int flags)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         struct fuse_setxattr_in inarg;
@@ -1774,7 +1774,7 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
                              void *value, size_t size)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         struct fuse_getxattr_in inarg;
@@ -1815,7 +1815,7 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
 
 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         struct fuse_getxattr_in inarg;
@@ -1857,7 +1857,7 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
 
 static int fuse_removexattr(struct dentry *entry, const char *name)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode = d_inode(entry);
         struct fuse_conn *fc = get_fuse_conn(inode);
         FUSE_ARGS(args);
         int err;
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index e8799c11424b..082ac1c97f39 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -421,7 +421,7 @@ static int fuse_statfs(struct dentry *dentry, struct kstatfs *buf)
         memset(&outarg, 0, sizeof(outarg));
         args.in.numargs = 0;
         args.in.h.opcode = FUSE_STATFS;
-        args.in.h.nodeid = get_node_id(dentry->d_inode);
+        args.in.h.nodeid = get_node_id(d_inode(dentry));
         args.out.numargs = 1;
         args.out.args[0].size = sizeof(outarg);
         args.out.args[0].value = &outarg;
@@ -740,7 +740,7 @@ static struct dentry *fuse_fh_to_parent(struct super_block *sb,
 
 static struct dentry *fuse_get_parent(struct dentry *child)
 {
-        struct inode *child_inode = child->d_inode;
+        struct inode *child_inode = d_inode(child);
         struct fuse_conn *fc = get_fuse_conn(child_inode);
         struct inode *inode;
         struct dentry *parent;
diff --git a/fs/gfs2/dentry.c b/fs/gfs2/dentry.c
index 589f4ea9381c..30822b148f3e 100644
--- a/fs/gfs2/dentry.c
+++ b/fs/gfs2/dentry.c
@@ -48,9 +48,9 @@ static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         parent = dget_parent(dentry);
-        sdp = GFS2_SB(parent->d_inode);
-        dip = GFS2_I(parent->d_inode);
-        inode = dentry->d_inode;
+        sdp = GFS2_SB(d_inode(parent));
+        dip = GFS2_I(d_inode(parent));
+        inode = d_inode(dentry);
 
         if (inode) {
                 if (is_bad_inode(inode))
@@ -68,7 +68,7 @@ static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
                         goto fail;
         } 
 
-        error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
+        error = gfs2_dir_check(d_inode(parent), &dentry->d_name, ip);
         switch (error) {
         case 0:
                 if (!inode)
@@ -113,10 +113,10 @@ static int gfs2_dentry_delete(const struct dentry *dentry)
 {
         struct gfs2_inode *ginode;
 
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 return 0;
 
-        ginode = GFS2_I(dentry->d_inode);
+        ginode = GFS2_I(d_inode(dentry));
         if (!ginode->i_iopen_gh.gh_gl)
                 return 0;
 
diff --git a/fs/gfs2/export.c b/fs/gfs2/export.c
index c41d255b6a7b..5d15e9498b48 100644
--- a/fs/gfs2/export.c
+++ b/fs/gfs2/export.c
@@ -49,7 +49,7 @@ static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len,
         fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
         *len = GFS2_SMALL_FH_SIZE;
 
-        if (!parent || inode == sb->s_root->d_inode)
+        if (!parent || inode == d_inode(sb->s_root))
                 return *len;
 
         ip = GFS2_I(parent);
@@ -88,8 +88,8 @@ static int get_name_filldir(struct dir_context *ctx, const char *name,
 static int gfs2_get_name(struct dentry *parent, char *name,
                          struct dentry *child)
 {
-        struct inode *dir = parent->d_inode;
-        struct inode *inode = child->d_inode;
+        struct inode *dir = d_inode(parent);
+        struct inode *inode = d_inode(child);
         struct gfs2_inode *dip, *ip;
         struct get_name_filldir gnfd = {
                 .ctx.actor = get_name_filldir,
@@ -128,7 +128,7 @@ static int gfs2_get_name(struct dentry *parent, char *name,
 
 static struct dentry *gfs2_get_parent(struct dentry *child)
 {
-        return d_obtain_alias(gfs2_lookupi(child->d_inode, &gfs2_qdotdot, 1));
+        return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1));
 }
 
 static struct dentry *gfs2_get_dentry(struct super_block *sb,
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 08bc84d7e768..1b3ca7a2e3fc 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -295,7 +295,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 
         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
-             dir == sb->s_root->d_inode)) {
+             dir == d_inode(sb->s_root))) {
                 igrab(dir);
                 return dir;
         }
@@ -687,7 +687,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
         }
         gfs2_set_inode_flags(inode);
 
-        if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
+        if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) ||
             (dip->i_diskflags & GFS2_DIF_TOPDIR))
                 aflags |= GFS2_AF_ORLOV;
 
@@ -888,7 +888,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 {
         struct gfs2_inode *dip = GFS2_I(dir);
         struct gfs2_sbd *sdp = GFS2_SB(dir);
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder ghs[2];
         struct buffer_head *dibh;
@@ -1055,7 +1055,7 @@ static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 static int gfs2_unlink_inode(struct gfs2_inode *dip,
                              const struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         int error;
 
@@ -1091,7 +1091,7 @@ static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct gfs2_inode *dip = GFS2_I(dir);
         struct gfs2_sbd *sdp = GFS2_SB(dir);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder ghs[3];
         struct gfs2_rgrpd *rgd;
@@ -1241,7 +1241,7 @@ static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
                 return PTR_ERR(d);
         if (d != NULL)
                 dentry = d;
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 if (!(*opened & FILE_OPENED))
                         return finish_no_open(file, d);
                 dput(d);
@@ -1282,7 +1282,7 @@ static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
                         error = -EINVAL;
                         break;
                 }
-                if (dir == sb->s_root->d_inode) {
+                if (dir == d_inode(sb->s_root)) {
                         error = 0;
                         break;
                 }
@@ -1321,7 +1321,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 {
         struct gfs2_inode *odip = GFS2_I(odir);
         struct gfs2_inode *ndip = GFS2_I(ndir);
-        struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(d_inode(odentry));
         struct gfs2_inode *nip = NULL;
         struct gfs2_sbd *sdp = GFS2_SB(odir);
         struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
@@ -1332,8 +1332,8 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
         unsigned int x;
         int error;
 
-        if (ndentry->d_inode) {
-                nip = GFS2_I(ndentry->d_inode);
+        if (d_really_is_positive(ndentry)) {
+                nip = GFS2_I(d_inode(ndentry));
                 if (ip == nip)
                         return 0;
         }
@@ -1457,7 +1457,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
         /* Check out the dir to be renamed */
 
         if (dir_rename) {
-                error = gfs2_permission(odentry->d_inode, MAY_WRITE);
+                error = gfs2_permission(d_inode(odentry), MAY_WRITE);
                 if (error)
                         goto out_gunlock;
         }
@@ -1550,7 +1550,7 @@ out:
 
 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
         struct gfs2_holder i_gh;
         struct buffer_head *dibh;
         unsigned int size;
@@ -1742,7 +1742,7 @@ out:
 
 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder i_gh;
         int error;
@@ -1798,7 +1798,7 @@ out:
 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
                         struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int error;
@@ -1821,7 +1821,7 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 static int gfs2_setxattr(struct dentry *dentry, const char *name,
                          const void *data, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int ret;
@@ -1841,7 +1841,7 @@ static int gfs2_setxattr(struct dentry *dentry, const char *name,
 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
                              void *data, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int ret;
@@ -1862,7 +1862,7 @@ static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
 
 static int gfs2_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
         int ret;
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index efc8e254787c..35b49f44c72f 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -647,7 +647,7 @@ out_unlock:
 
 static int init_journal(struct gfs2_sbd *sdp, int undo)
 {
-        struct inode *master = sdp->sd_master_dir->d_inode;
+        struct inode *master = d_inode(sdp->sd_master_dir);
         struct gfs2_holder ji_gh;
         struct gfs2_inode *ip;
         int jindex = 1;
@@ -782,7 +782,7 @@ static struct lock_class_key gfs2_quota_imutex_key;
 static int init_inodes(struct gfs2_sbd *sdp, int undo)
 {
         int error = 0;
-        struct inode *master = sdp->sd_master_dir->d_inode;
+        struct inode *master = d_inode(sdp->sd_master_dir);
 
         if (undo)
                 goto fail_qinode;
@@ -848,7 +848,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
         char buf[30];
         int error = 0;
         struct gfs2_inode *ip;
-        struct inode *master = sdp->sd_master_dir->d_inode;
+        struct inode *master = d_inode(sdp->sd_master_dir);
 
         if (sdp->sd_args.ar_spectator)
                 return 0;
@@ -1357,7 +1357,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
                 return ERR_PTR(error);
         }
         s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
-                 path.dentry->d_inode->i_sb->s_bdev);
+                 d_inode(path.dentry)->i_sb->s_bdev);
         path_put(&path);
         if (IS_ERR(s)) {
                 pr_warn("gfs2 mount does not exist\n");
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index 1666382b198d..859c6edbf81a 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -1171,7 +1171,7 @@ static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *s
 
 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-        struct super_block *sb = dentry->d_inode->i_sb;
+        struct super_block *sb = d_inode(dentry)->i_sb;
         struct gfs2_sbd *sdp = sb->s_fs_info;
         struct gfs2_statfs_change_host sc;
         int error;
diff --git a/fs/gfs2/xattr.c b/fs/gfs2/xattr.c
index fd260ce8869a..4c096fa9e2a1 100644
--- a/fs/gfs2/xattr.c
+++ b/fs/gfs2/xattr.c
@@ -420,7 +420,7 @@ static int ea_list_i(struct gfs2_inode *ip, struct buffer_head *bh,
 
 ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-        struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
         struct gfs2_ea_request er;
         struct gfs2_holder i_gh;
         int error;
@@ -586,7 +586,7 @@ out:
 static int gfs2_xattr_get(struct dentry *dentry, const char *name,
                 void *buffer, size_t size, int type)
 {
-        struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
+        struct gfs2_inode *ip = GFS2_I(d_inode(dentry));
         struct gfs2_ea_location el;
         int error;
 
@@ -1230,7 +1230,7 @@ int __gfs2_xattr_set(struct inode *inode, const char *name,
 static int gfs2_xattr_set(struct dentry *dentry, const char *name,
                 const void *value, size_t size, int flags, int type)
 {
-        return __gfs2_xattr_set(dentry->d_inode, name, value,
+        return __gfs2_xattr_set(d_inode(dentry), name, value,
                                 size, flags, type);
 }
 
diff --git a/fs/hfs/attr.c b/fs/hfs/attr.c
index e057ec542a6a..8d931b157bbe 100644
--- a/fs/hfs/attr.c
+++ b/fs/hfs/attr.c
@@ -16,7 +16,7 @@
 int hfs_setxattr(struct dentry *dentry, const char *name,
                  const void *value, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfs_find_data fd;
         hfs_cat_rec rec;
         struct hfs_cat_file *file;
@@ -59,7 +59,7 @@ out:
 ssize_t hfs_getxattr(struct dentry *dentry, const char *name,
                          void *value, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfs_find_data fd;
         hfs_cat_rec rec;
         struct hfs_cat_file *file;
@@ -105,7 +105,7 @@ out:
 
 ssize_t hfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
                 return -EOPNOTSUPP;
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 36d1a6ae7655..70788e03820a 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -253,7 +253,7 @@ static int hfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
  */
 static int hfs_remove(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int res;
 
         if (S_ISDIR(inode->i_mode) && inode->i_size != 2)
@@ -285,18 +285,18 @@ static int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         int res;
 
         /* Unlink destination if it already exists */
-        if (new_dentry->d_inode) {
+        if (d_really_is_positive(new_dentry)) {
                 res = hfs_remove(new_dir, new_dentry);
                 if (res)
                         return res;
         }
 
-        res = hfs_cat_move(old_dentry->d_inode->i_ino,
+        res = hfs_cat_move(d_inode(old_dentry)->i_ino,
                            old_dir, &old_dentry->d_name,
                            new_dir, &new_dentry->d_name);
         if (!res)
                 hfs_cat_build_key(old_dir->i_sb,
-                                  (btree_key *)&HFS_I(old_dentry->d_inode)->cat_key,
+                                  (btree_key *)&HFS_I(d_inode(old_dentry))->cat_key,
                                   new_dir->i_ino, &new_dentry->d_name);
         return res;
 }
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 75fd5d873c19..b99ebddb10cb 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -600,7 +600,7 @@ static int hfs_file_release(struct inode *inode, struct file *file)
 
 int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfs_sb_info *hsb = HFS_SB(inode->i_sb);
         int error;
 
diff --git a/fs/hfs/sysdep.c b/fs/hfs/sysdep.c
index 91b91fd3a901..2875961fdc10 100644
--- a/fs/hfs/sysdep.c
+++ b/fs/hfs/sysdep.c
@@ -21,7 +21,7 @@ static int hfs_revalidate_dentry(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         if(!inode)
                 return 1;
 
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 3074609befc3..d0f39dcbb58e 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -81,7 +81,7 @@ again:
                                         HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->
                                                 create_date ||
                                 entry.file.create_date ==
-                                        HFSPLUS_I(sb->s_root->d_inode)->
+                                        HFSPLUS_I(d_inode(sb->s_root))->
                                                 create_date) &&
                                 HFSPLUS_SB(sb)->hidden_dir) {
                         struct qstr str;
@@ -296,8 +296,8 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
                         struct dentry *dst_dentry)
 {
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);
-        struct inode *inode = src_dentry->d_inode;
-        struct inode *src_dir = src_dentry->d_parent->d_inode;
+        struct inode *inode = d_inode(src_dentry);
+        struct inode *src_dir = d_inode(src_dentry->d_parent);
         struct qstr str;
         char name[32];
         u32 cnid, id;
@@ -353,7 +353,7 @@ out:
 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct qstr str;
         char name[32];
         u32 cnid;
@@ -410,7 +410,7 @@ out:
 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
 {
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int res;
 
         if (inode->i_size != 2)
@@ -529,7 +529,7 @@ static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
         int res;
 
         /* Unlink destination if it already exists */
-        if (new_dentry->d_inode) {
+        if (d_really_is_positive(new_dentry)) {
                 if (d_is_dir(new_dentry))
                         res = hfsplus_rmdir(new_dir, new_dentry);
                 else
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index b0afedbef12b..6dd107d7421e 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -243,7 +243,7 @@ static int hfsplus_file_release(struct inode *inode, struct file *file)
 
 static int hfsplus_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, attr);
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 8e98f5db6ad6..0624ce4e0702 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -26,7 +26,7 @@
 static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
 {
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
         struct hfsplus_vh *vh = sbi->s_vhdr;
         struct hfsplus_vh *bvh = sbi->s_backup_vhdr;
diff --git a/fs/hfsplus/xattr.c b/fs/hfsplus/xattr.c
index 89f262d8fcd8..416b1dbafe51 100644
--- a/fs/hfsplus/xattr.c
+++ b/fs/hfsplus/xattr.c
@@ -440,7 +440,7 @@ int hfsplus_setxattr(struct dentry *dentry, const char *name,
                 return -ENOMEM;
         strcpy(xattr_name, prefix);
         strcpy(xattr_name + prefixlen, name);
-        res = __hfsplus_setxattr(dentry->d_inode, xattr_name, value, size,
+        res = __hfsplus_setxattr(d_inode(dentry), xattr_name, value, size,
                                  flags);
         kfree(xattr_name);
         return res;
@@ -600,7 +600,7 @@ ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
         strcpy(xattr_name, prefix);
         strcpy(xattr_name + prefixlen, name);
 
-        res = __hfsplus_getxattr(dentry->d_inode, xattr_name, value, size);
+        res = __hfsplus_getxattr(d_inode(dentry), xattr_name, value, size);
         kfree(xattr_name);
         return res;
 
@@ -620,7 +620,7 @@ static ssize_t hfsplus_listxattr_finder_info(struct dentry *dentry,
                                                 char *buffer, size_t size)
 {
         ssize_t res = 0;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfs_find_data fd;
         u16 entry_type;
         u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)];
@@ -688,7 +688,7 @@ ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
         ssize_t err;
         ssize_t res = 0;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hfs_find_data fd;
         u16 key_len = 0;
         struct hfsplus_attr_key attr_key;
@@ -868,7 +868,7 @@ static int hfsplus_osx_getxattr(struct dentry *dentry, const char *name,
          * creates), so we pass the name through unmodified (after
          * ensuring it doesn't conflict with another namespace).
          */
-        return __hfsplus_getxattr(dentry->d_inode, name, buffer, size);
+        return __hfsplus_getxattr(d_inode(dentry), name, buffer, size);
 }
 
 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
@@ -890,7 +890,7 @@ static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name,
          * creates), so we pass the name through unmodified (after
          * ensuring it doesn't conflict with another namespace).
          */
-        return __hfsplus_setxattr(dentry->d_inode, name, buffer, size, flags);
+        return __hfsplus_setxattr(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index b83a0343378b..ef263174acd2 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -807,7 +807,7 @@ static int hostfs_permission(struct inode *ino, int desired)
 
 static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hostfs_iattr attrs;
         char *name;
         int err;
diff --git a/fs/hpfs/inode.c b/fs/hpfs/inode.c
index 7ce4b74234a1..933c73780813 100644
--- a/fs/hpfs/inode.c
+++ b/fs/hpfs/inode.c
@@ -257,7 +257,7 @@ void hpfs_write_inode_nolock(struct inode *i)
 
 int hpfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error = -EINVAL;
 
         hpfs_lock(inode->i_sb);
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index bdbc2c3080a4..a0872f239f04 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -359,7 +359,7 @@ static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
         unsigned len = dentry->d_name.len;
         struct quad_buffer_head qbh;
         struct hpfs_dirent *de;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         dnode_secno dno;
         int r;
         int rep = 0;
@@ -433,7 +433,7 @@ static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
         unsigned len = dentry->d_name.len;
         struct quad_buffer_head qbh;
         struct hpfs_dirent *de;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         dnode_secno dno;
         int n_items = 0;
         int err;
@@ -522,8 +522,8 @@ static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         unsigned old_len = old_dentry->d_name.len;
         const unsigned char *new_name = new_dentry->d_name.name;
         unsigned new_len = new_dentry->d_name.len;
-        struct inode *i = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *i = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct quad_buffer_head qbh, qbh1;
         struct hpfs_dirent *dep, *nde;
         struct hpfs_dirent de;
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index 043ac9d77262..fa2bd5366ecf 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -153,9 +153,9 @@ static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
                 return ERR_PTR(-ENOENT);
 
         parent = HPPFS_I(ino)->proc_dentry;
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         proc_dentry = lookup_one_len(name->name, parent, name->len);
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
 
         if (IS_ERR(proc_dentry))
                 return proc_dentry;
@@ -637,25 +637,25 @@ static const struct super_operations hppfs_sbops = {
 static int hppfs_readlink(struct dentry *dentry, char __user *buffer,
                           int buflen)
 {
-        struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
-        return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer,
+        struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
+        return d_inode(proc_dentry)->i_op->readlink(proc_dentry, buffer,
                                                     buflen);
 }
 
 static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
+        struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
-        return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd);
+        return d_inode(proc_dentry)->i_op->follow_link(proc_dentry, nd);
 }
 
 static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd,
                            void *cookie)
 {
-        struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
+        struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry;
 
-        if (proc_dentry->d_inode->i_op->put_link)
-                proc_dentry->d_inode->i_op->put_link(proc_dentry, nd, cookie);
+        if (d_inode(proc_dentry)->i_op->put_link)
+                d_inode(proc_dentry)->i_op->put_link(proc_dentry, nd, cookie);
 }
 
 static const struct inode_operations hppfs_dir_iops = {
@@ -670,7 +670,7 @@ static const struct inode_operations hppfs_link_iops = {
 
 static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
 {
-        struct inode *proc_ino = dentry->d_inode;
+        struct inode *proc_ino = d_inode(dentry);
         struct inode *inode = new_inode(sb);
 
         if (!inode) {
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 2640d88b0e63..87724c1d7be6 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -393,7 +393,7 @@ static int hugetlb_vmtruncate(struct inode *inode, loff_t offset)
 
 static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct hstate *h = hstate_inode(inode);
         int error;
         unsigned int ia_valid = attr->ia_valid;
@@ -587,7 +587,7 @@ static int hugetlbfs_migrate_page(struct address_space *mapping,
 static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb);
-        struct hstate *h = hstate_inode(dentry->d_inode);
+        struct hstate *h = hstate_inode(d_inode(dentry));
 
         buf->f_type = HUGETLBFS_MAGIC;
         buf->f_bsize = huge_page_size(h);
diff --git a/fs/inode.c b/fs/inode.c
index f00b16f45507..ea37cd17b53f 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1587,7 +1587,7 @@ static int update_time(struct inode *inode, struct timespec *time, int flags)
 void touch_atime(const struct path *path)
 {
         struct vfsmount *mnt = path->mnt;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_inode(path->dentry);
         struct timespec now;
 
         if (inode->i_flags & S_NOATIME)
@@ -1639,7 +1639,7 @@ EXPORT_SYMBOL(touch_atime);
  */
 int should_remove_suid(struct dentry *dentry)
 {
-        umode_t mode = dentry->d_inode->i_mode;
+        umode_t mode = d_inode(dentry)->i_mode;
         int kill = 0;
 
         /* suid always must be killed */
@@ -1675,7 +1675,7 @@ static int __remove_suid(struct dentry *dentry, int kill)
 int file_remove_suid(struct file *file)
 {
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int killsuid;
         int killpriv;
         int error = 0;
@@ -1946,20 +1946,6 @@ void inode_dio_wait(struct inode *inode)
 EXPORT_SYMBOL(inode_dio_wait);
 
 /*
- * inode_dio_done - signal finish of a direct I/O requests
- * @inode: inode the direct I/O happens on
- *
- * This is called once we've finished processing a direct I/O request,
- * and is used to wake up callers waiting for direct I/O to be quiesced.
- */
-void inode_dio_done(struct inode *inode)
-{
-        if (atomic_dec_and_test(&inode->i_dio_count))
-                wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
-}
-EXPORT_SYMBOL(inode_dio_done);
-
-/*
  * inode_set_flags - atomically set some inode flags
  *
  * Note: the caller should be holding i_mutex, or else be sure that
diff --git a/fs/isofs/export.c b/fs/isofs/export.c
index 12088d8de3fa..0c5f721b4e91 100644
--- a/fs/isofs/export.c
+++ b/fs/isofs/export.c
@@ -44,7 +44,7 @@ static struct dentry *isofs_export_get_parent(struct dentry *child)
 {
         unsigned long parent_block = 0;
         unsigned long parent_offset = 0;
-        struct inode *child_inode = child->d_inode;
+        struct inode *child_inode = d_inode(child);
         struct iso_inode_info *e_child_inode = ISOFS_I(child_inode);
         struct iso_directory_record *de = NULL;
         struct buffer_head * bh = NULL;
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index f21b6fb5e4c4..1ba5c97943b8 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -224,14 +224,14 @@ static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
 {
         struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
         struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
-        struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode);
+        struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));
         int ret;
         uint32_t now = get_seconds();
 
         ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
                               dentry->d_name.len, dead_f, now);
         if (dead_f->inocache)
-                set_nlink(dentry->d_inode, dead_f->inocache->pino_nlink);
+                set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);
         if (!ret)
                 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
         return ret;
@@ -241,8 +241,8 @@ static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
 
 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
 {
-        struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb);
-        struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
+        struct jffs2_sb_info *c = JFFS2_SB_INFO(d_inode(old_dentry)->i_sb);
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
         struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
         int ret;
         uint8_t type;
@@ -256,7 +256,7 @@ static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct de
                 return -EPERM;
 
         /* XXX: This is ugly */
-        type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
+        type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
         if (!type) type = DT_REG;
 
         now = get_seconds();
@@ -264,11 +264,11 @@ static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct de
 
         if (!ret) {
                 mutex_lock(&f->sem);
-                set_nlink(old_dentry->d_inode, ++f->inocache->pino_nlink);
+                set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);
                 mutex_unlock(&f->sem);
-                d_instantiate(dentry, old_dentry->d_inode);
+                d_instantiate(dentry, d_inode(old_dentry));
                 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
-                ihold(old_dentry->d_inode);
+                ihold(d_inode(old_dentry));
         }
         return ret;
 }
@@ -585,7 +585,7 @@ static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
 {
         struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
         struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
-        struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
         struct jffs2_full_dirent *fd;
         int ret;
         uint32_t now = get_seconds();
@@ -599,7 +599,7 @@ static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
                               dentry->d_name.len, f, now);
         if (!ret) {
                 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
-                clear_nlink(dentry->d_inode);
+                clear_nlink(d_inode(dentry));
                 drop_nlink(dir_i);
         }
         return ret;
@@ -770,8 +770,8 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
          * the VFS can't check whether the victim is empty. The filesystem
          * needs to do that for itself.
          */
-        if (new_dentry->d_inode) {
-                victim_f = JFFS2_INODE_INFO(new_dentry->d_inode);
+        if (d_really_is_positive(new_dentry)) {
+                victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
                 if (d_is_dir(new_dentry)) {
                         struct jffs2_full_dirent *fd;
 
@@ -794,12 +794,12 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
         /* Make a hard link */
 
         /* XXX: This is ugly */
-        type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
+        type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
         if (!type) type = DT_REG;
 
         now = get_seconds();
         ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
-                            old_dentry->d_inode->i_ino, type,
+                            d_inode(old_dentry)->i_ino, type,
                             new_dentry->d_name.name, new_dentry->d_name.len, now);
 
         if (ret)
@@ -808,9 +808,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
         if (victim_f) {
                 /* There was a victim. Kill it off nicely */
                 if (d_is_dir(new_dentry))
-                        clear_nlink(new_dentry->d_inode);
+                        clear_nlink(d_inode(new_dentry));
                 else
-                        drop_nlink(new_dentry->d_inode);
+                        drop_nlink(d_inode(new_dentry));
                 /* Don't oops if the victim was a dirent pointing to an
                    inode which didn't exist. */
                 if (victim_f->inocache) {
@@ -836,9 +836,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
 
         if (ret) {
                 /* Oh shit. We really ought to make a single node which can do both atomically */
-                struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
+                struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
                 mutex_lock(&f->sem);
-                inc_nlink(old_dentry->d_inode);
+                inc_nlink(d_inode(old_dentry));
                 if (f->inocache && !d_is_dir(old_dentry))
                         f->inocache->pino_nlink++;
                 mutex_unlock(&f->sem);
@@ -846,8 +846,8 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
                 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
                           __func__, ret);
                 /* Might as well let the VFS know */
-                d_instantiate(new_dentry, old_dentry->d_inode);
-                ihold(old_dentry->d_inode);
+                d_instantiate(new_dentry, d_inode(old_dentry));
+                ihold(d_inode(old_dentry));
                 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
                 return ret;
         }
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 601afd1afddf..fe5ea080b4ec 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -190,7 +190,7 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
 
 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int rc;
 
         rc = inode_change_ok(inode, iattr);
diff --git a/fs/jffs2/security.c b/fs/jffs2/security.c
index aca97f35b292..d4b43fb7adb1 100644
--- a/fs/jffs2/security.c
+++ b/fs/jffs2/security.c
@@ -54,7 +54,7 @@ static int jffs2_security_getxattr(struct dentry *dentry, const char *name,
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY,
+        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY,
                                  name, buffer, size);
 }
 
@@ -64,7 +64,7 @@ static int jffs2_security_setxattr(struct dentry *dentry, const char *name,
         if (!strcmp(name, ""))
                 return -EINVAL;
 
-        return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY,
+        return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY,
                                  name, buffer, size, flags);
 }
 
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 3d76f28a2ba9..d86c5e3176a1 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -140,14 +140,14 @@ static struct dentry *jffs2_get_parent(struct dentry *child)
 
         BUG_ON(!d_is_dir(child));
 
-        f = JFFS2_INODE_INFO(child->d_inode);
+        f = JFFS2_INODE_INFO(d_inode(child));
 
         pino = f->inocache->pino_nlink;
 
         JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
                     f->inocache->ino, pino);
 
-        return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
+        return d_obtain_alias(jffs2_iget(d_inode(child)->i_sb, pino));
 }
 
 static const struct export_operations jffs2_export_ops = {
diff --git a/fs/jffs2/symlink.c b/fs/jffs2/symlink.c
index c7c77b0dfccd..1fefa25d0fa5 100644
--- a/fs/jffs2/symlink.c
+++ b/fs/jffs2/symlink.c
@@ -31,7 +31,7 @@ const struct inode_operations jffs2_symlink_inode_operations =
 
 static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
+        struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
         char *p = (char *)f->target;
 
         /*
diff --git a/fs/jffs2/xattr.c b/fs/jffs2/xattr.c
index 2eac55379239..f092fee5be50 100644
--- a/fs/jffs2/xattr.c
+++ b/fs/jffs2/xattr.c
@@ -960,7 +960,7 @@ static const struct xattr_handler *xprefix_to_handler(int xprefix) {
 
 ssize_t jffs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
         struct jffs2_inode_cache *ic = f->inocache;
diff --git a/fs/jffs2/xattr_trusted.c b/fs/jffs2/xattr_trusted.c
index 1c868194c504..ceaf9c693225 100644
--- a/fs/jffs2/xattr_trusted.c
+++ b/fs/jffs2/xattr_trusted.c
@@ -21,7 +21,7 @@ static int jffs2_trusted_getxattr(struct dentry *dentry, const char *name,
 {
         if (!strcmp(name, ""))
                 return -EINVAL;
-        return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED,
+        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED,
                                  name, buffer, size);
 }
 
@@ -30,7 +30,7 @@ static int jffs2_trusted_setxattr(struct dentry *dentry, const char *name,
 {
         if (!strcmp(name, ""))
                 return -EINVAL;
-        return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED,
+        return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED,
                                  name, buffer, size, flags);
 }
 
diff --git a/fs/jffs2/xattr_user.c b/fs/jffs2/xattr_user.c
index 916b5c966039..a71391eba514 100644
--- a/fs/jffs2/xattr_user.c
+++ b/fs/jffs2/xattr_user.c
@@ -21,7 +21,7 @@ static int jffs2_user_getxattr(struct dentry *dentry, const char *name,
 {
         if (!strcmp(name, ""))
                 return -EINVAL;
-        return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_USER,
+        return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_USER,
                                  name, buffer, size);
 }
 
@@ -30,7 +30,7 @@ static int jffs2_user_setxattr(struct dentry *dentry, const char *name,
 {
         if (!strcmp(name, ""))
                 return -EINVAL;
-        return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_USER,
+        return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_USER,
                                  name, buffer, size, flags);
 }
 
diff --git a/fs/jfs/file.c b/fs/jfs/file.c
index ae46788b9723..e98d39d75cf4 100644
--- a/fs/jfs/file.c
+++ b/fs/jfs/file.c
@@ -100,7 +100,7 @@ static int jfs_release(struct inode *inode, struct file *file)
 
 int jfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int rc;
 
         rc = inode_change_ok(inode, iattr);
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 38fdc533f4ec..66db7bc0ed10 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -346,7 +346,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
 {
         int rc;
         tid_t tid;              /* transaction id */
-        struct inode *ip = dentry->d_inode;
+        struct inode *ip = d_inode(dentry);
         ino_t ino;
         struct component_name dname;
         struct inode *iplist[2];
@@ -472,7 +472,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
 {
         int rc;
         tid_t tid;              /* transaction id */
-        struct inode *ip = dentry->d_inode;
+        struct inode *ip = d_inode(dentry);
         ino_t ino;
         struct component_name dname;    /* object name */
         struct inode *iplist[2];
@@ -791,7 +791,7 @@ static int jfs_link(struct dentry *old_dentry,
 {
         int rc;
         tid_t tid;
-        struct inode *ip = old_dentry->d_inode;
+        struct inode *ip = d_inode(old_dentry);
         ino_t ino;
         struct component_name dname;
         struct btstack btstack;
@@ -879,7 +879,7 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
         struct component_name dname;
         int ssize;              /* source pathname size */
         struct btstack btstack;
-        struct inode *ip = dentry->d_inode;
+        struct inode *ip = d_inode(dentry);
         unchar *i_fastsymlink;
         s64 xlen = 0;
         int bmask = 0, xsize;
@@ -1086,8 +1086,8 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dquot_initialize(old_dir);
         dquot_initialize(new_dir);
 
-        old_ip = old_dentry->d_inode;
-        new_ip = new_dentry->d_inode;
+        old_ip = d_inode(old_dentry);
+        new_ip = d_inode(new_dentry);
 
         if ((rc = get_UCSname(&old_dname, old_dentry)))
                 goto out1;
@@ -1500,9 +1500,9 @@ struct dentry *jfs_get_parent(struct dentry *dentry)
         unsigned long parent_ino;
 
         parent_ino =
-                le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
+                le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot);
 
-        return d_obtain_alias(jfs_iget(dentry->d_inode->i_sb, parent_ino));
+        return d_obtain_alias(jfs_iget(d_inode(dentry)->i_sb, parent_ino));
 }
 
 const struct inode_operations jfs_dir_inode_operations = {
@@ -1578,7 +1578,7 @@ static int jfs_ci_revalidate(struct dentry *dentry, unsigned int flags)
          * positive dentry isn't good idea. So it's unsupported like
          * rename("filename", "FILENAME") for now.
          */
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 return 1;
 
         /*
diff --git a/fs/jfs/symlink.c b/fs/jfs/symlink.c
index 205b946d8e0d..80f42bcc4ef1 100644
--- a/fs/jfs/symlink.c
+++ b/fs/jfs/symlink.c
@@ -24,7 +24,7 @@
 
 static void *jfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        char *s = JFS_IP(dentry->d_inode)->i_inline;
+        char *s = JFS_IP(d_inode(dentry))->i_inline;
         nd_set_link(nd, s);
         return NULL;
 }
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index 46325d5c34fc..48b15a6e5558 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -849,7 +849,7 @@ int __jfs_setxattr(tid_t tid, struct inode *inode, const char *name,
 int jfs_setxattr(struct dentry *dentry, const char *name, const void *value,
                  size_t value_len, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct jfs_inode_info *ji = JFS_IP(inode);
         int rc;
         tid_t tid;
@@ -872,7 +872,7 @@ int jfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 
         tid = txBegin(inode->i_sb, 0);
         mutex_lock(&ji->commit_mutex);
-        rc = __jfs_setxattr(tid, dentry->d_inode, name, value, value_len,
+        rc = __jfs_setxattr(tid, d_inode(dentry), name, value, value_len,
                             flags);
         if (!rc)
                 rc = txCommit(tid, 1, &inode, 0);
@@ -959,7 +959,7 @@ ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
                         return -EOPNOTSUPP;
         }
 
-        err = __jfs_getxattr(dentry->d_inode, name, data, buf_size);
+        err = __jfs_getxattr(d_inode(dentry), name, data, buf_size);
 
         return err;
 }
@@ -976,7 +976,7 @@ static inline int can_list(struct jfs_ea *ea)
 
 ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         char *buffer;
         ssize_t size = 0;
         int xattr_size;
@@ -1029,7 +1029,7 @@ ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size)
 
 int jfs_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct jfs_inode_info *ji = JFS_IP(inode);
         int rc;
         tid_t tid;
@@ -1047,7 +1047,7 @@ int jfs_removexattr(struct dentry *dentry, const char *name)
 
         tid = txBegin(inode->i_sb, 0);
         mutex_lock(&ji->commit_mutex);
-        rc = __jfs_setxattr(tid, dentry->d_inode, name, NULL, 0, XATTR_REPLACE);
+        rc = __jfs_setxattr(tid, d_inode(dentry), name, NULL, 0, XATTR_REPLACE);
         if (!rc)
                 rc = txCommit(tid, 1, &inode, 0);
         txEnd(tid);
diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index 6acc9648f986..f131fc23ffc4 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -444,7 +444,7 @@ static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         /* Always perform fresh lookup for negatives */
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto out_bad_unlocked;
 
         kn = dentry->d_fsdata;
diff --git a/fs/kernfs/inode.c b/fs/kernfs/inode.c
index 9000874a945b..2da8493a380b 100644
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -111,7 +111,7 @@ int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
 
 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct kernfs_node *kn = dentry->d_fsdata;
         int error;
 
@@ -172,11 +172,11 @@ int kernfs_iop_setxattr(struct dentry *dentry, const char *name,
 
         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) {
                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
-                error = security_inode_setsecurity(dentry->d_inode, suffix,
+                error = security_inode_setsecurity(d_inode(dentry), suffix,
                                                 value, size, flags);
                 if (error)
                         return error;
-                error = security_inode_getsecctx(dentry->d_inode,
+                error = security_inode_getsecctx(d_inode(dentry),
                                                 &secdata, &secdata_len);
                 if (error)
                         return error;
@@ -271,7 +271,7 @@ int kernfs_iop_getattr(struct vfsmount *mnt, struct dentry *dentry,
                    struct kstat *stat)
 {
         struct kernfs_node *kn = dentry->d_fsdata;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         mutex_lock(&kernfs_mutex);
         kernfs_refresh_inode(kn, inode);
diff --git a/fs/libfs.c b/fs/libfs.c
index 0ab65122ee45..cb1fb4b9b637 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -22,13 +22,13 @@
 
 static inline int simple_positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
                    struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         generic_fillattr(inode, stat);
         stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
         return 0;
@@ -94,7 +94,7 @@ EXPORT_SYMBOL(dcache_dir_close);
 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry *dentry = file->f_path.dentry;
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         switch (whence) {
                 case 1:
                         offset += file->f_pos;
@@ -102,7 +102,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&dentry->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(dentry)->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -129,7 +129,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
                         spin_unlock(&dentry->d_lock);
                 }
         }
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
         return offset;
 }
 EXPORT_SYMBOL(dcache_dir_lseek);
@@ -169,7 +169,7 @@ int dcache_readdir(struct file *file, struct dir_context *ctx)
                 spin_unlock(&next->d_lock);
                 spin_unlock(&dentry->d_lock);
                 if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
-                              next->d_inode->i_ino, dt_type(next->d_inode)))
+                              d_inode(next)->i_ino, dt_type(d_inode(next))))
                         return 0;
                 spin_lock(&dentry->d_lock);
                 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
@@ -270,7 +270,7 @@ EXPORT_SYMBOL(simple_open);
 
 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
         inc_nlink(inode);
@@ -304,7 +304,7 @@ EXPORT_SYMBOL(simple_empty);
 
 int simple_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
         drop_nlink(inode);
@@ -318,7 +318,7 @@ int simple_rmdir(struct inode *dir, struct dentry *dentry)
         if (!simple_empty(dentry))
                 return -ENOTEMPTY;
 
-        drop_nlink(dentry->d_inode);
+        drop_nlink(d_inode(dentry));
         simple_unlink(dir, dentry);
         drop_nlink(dir);
         return 0;
@@ -328,16 +328,16 @@ EXPORT_SYMBOL(simple_rmdir);
 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
                 struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int they_are_dirs = d_is_dir(old_dentry);
 
         if (!simple_empty(new_dentry))
                 return -ENOTEMPTY;
 
-        if (new_dentry->d_inode) {
+        if (d_really_is_positive(new_dentry)) {
                 simple_unlink(new_dir, new_dentry);
                 if (they_are_dirs) {
-                        drop_nlink(new_dentry->d_inode);
+                        drop_nlink(d_inode(new_dentry));
                         drop_nlink(old_dir);
                 }
         } else if (they_are_dirs) {
@@ -368,7 +368,7 @@ EXPORT_SYMBOL(simple_rename);
  */
 int simple_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, iattr);
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 6bdc347008f5..4cf38f118549 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -213,7 +213,7 @@ static void abort_transaction(struct inode *inode, struct logfs_transaction *ta)
 static int logfs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct logfs_super *super = logfs_super(dir->i_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct logfs_transaction *ta;
         struct page *page;
         pgoff_t index;
@@ -271,7 +271,7 @@ static inline int logfs_empty_dir(struct inode *dir)
 
 static int logfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (!logfs_empty_dir(inode))
                 return -ENOTEMPTY;
@@ -537,7 +537,7 @@ static int logfs_symlink(struct inode *dir, struct dentry *dentry,
 static int logfs_link(struct dentry *old_dentry, struct inode *dir,
                 struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
         ihold(inode);
@@ -607,7 +607,7 @@ static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry,
         /* 2. write target dd */
         mutex_lock(&super->s_dirop_mutex);
         logfs_add_transaction(new_dir, ta);
-        err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode);
+        err = logfs_write_dir(new_dir, new_dentry, d_inode(old_dentry));
         if (!err)
                 err = write_inode(new_dir);
 
@@ -658,8 +658,8 @@ static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry,
                                struct inode *new_dir, struct dentry *new_dentry)
 {
         struct logfs_super *super = logfs_super(old_dir->i_sb);
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         int isdir = S_ISDIR(old_inode->i_mode);
         struct logfs_disk_dentry dd;
         struct logfs_transaction *ta;
@@ -719,7 +719,7 @@ out:
 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         struct inode *new_dir, struct dentry *new_dentry)
 {
-        if (new_dentry->d_inode)
+        if (d_really_is_positive(new_dentry))
                 return logfs_rename_target(old_dir, old_dentry,
                                            new_dir, new_dentry);
         return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index b2c13f739ffa..1a6f0167b16a 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -241,7 +241,7 @@ int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 
 static int logfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int err = 0;
 
         err = inode_change_ok(inode, attr);
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index dfaf6fa9b7b5..118e4e7bc935 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -156,7 +156,7 @@ minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
 {
         const char * name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
-        struct inode * dir = dentry->d_parent->d_inode;
+        struct inode * dir = d_inode(dentry->d_parent);
         struct super_block * sb = dir->i_sb;
         struct minix_sb_info * sbi = minix_sb(sb);
         unsigned long n;
@@ -203,7 +203,7 @@ found:
 
 int minix_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const char * name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         struct super_block * sb = dir->i_sb;
diff --git a/fs/minix/file.c b/fs/minix/file.c
index 6d63e27ec961..94f0eb9a6e2c 100644
--- a/fs/minix/file.c
+++ b/fs/minix/file.c
@@ -23,7 +23,7 @@ const struct file_operations minix_file_operations = {
 
 static int minix_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, attr);
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 3f57af196a7d..1182d1e26a9c 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -626,8 +626,8 @@ static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
 int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
         struct super_block *sb = dentry->d_sb;
-        generic_fillattr(dentry->d_inode, stat);
-        if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
+        generic_fillattr(d_inode(dentry), stat);
+        if (INODE_VERSION(d_inode(dentry)) == MINIX_V1)
                 stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
         else
                 stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index cd950e2331b6..a795a11e50c7 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -104,7 +104,7 @@ out_fail:
 static int minix_link(struct dentry * old_dentry, struct inode * dir,
         struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         inode->i_ctime = CURRENT_TIME_SEC;
         inode_inc_link_count(inode);
@@ -151,7 +151,7 @@ out_dir:
 static int minix_unlink(struct inode * dir, struct dentry *dentry)
 {
         int err = -ENOENT;
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         struct page * page;
         struct minix_dir_entry * de;
 
@@ -171,7 +171,7 @@ end_unlink:
 
 static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         int err = -ENOTEMPTY;
 
         if (minix_empty_dir(inode)) {
@@ -187,8 +187,8 @@ static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
                            struct inode * new_dir, struct dentry *new_dentry)
 {
-        struct inode * old_inode = old_dentry->d_inode;
-        struct inode * new_inode = new_dentry->d_inode;
+        struct inode * old_inode = d_inode(old_dentry);
+        struct inode * new_inode = d_inode(new_dentry);
         struct page * dir_page = NULL;
         struct minix_dir_entry * dir_de = NULL;
         struct page * old_page;
diff --git a/fs/namei.c b/fs/namei.c
index ffab2e06e147..4a8d998b7274 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1590,7 +1590,8 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
 
         if (should_follow_link(path->dentry, follow)) {
                 if (nd->flags & LOOKUP_RCU) {
-                        if (unlikely(unlazy_walk(nd, path->dentry))) {
+                        if (unlikely(nd->path.mnt != path->mnt ||
+                                     unlazy_walk(nd, path->dentry))) {
                                 err = -ECHILD;
                                 goto out_err;
                         }
@@ -3045,7 +3046,8 @@ finish_lookup:
 
         if (should_follow_link(path->dentry, !symlink_ok)) {
                 if (nd->flags & LOOKUP_RCU) {
-                        if (unlikely(unlazy_walk(nd, path->dentry))) {
+                        if (unlikely(nd->path.mnt != path->mnt ||
+                                     unlazy_walk(nd, path->dentry))) {
                                 error = -ECHILD;
                                 goto out;
                         }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index e7ca827d7694..80021c709af9 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -127,7 +127,7 @@ static inline int ncp_case_sensitive(const struct inode *i)
 static int 
 ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
 {
-        struct inode *inode = ACCESS_ONCE(dentry->d_inode);
+        struct inode *inode = d_inode_rcu(dentry);
 
         if (!inode)
                 return 0;
@@ -162,7 +162,7 @@ ncp_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
         if (len != name->len)
                 return 1;
 
-        pinode = ACCESS_ONCE(parent->d_inode);
+        pinode = d_inode_rcu(parent);
         if (!pinode)
                 return 1;
 
@@ -180,7 +180,7 @@ ncp_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
 static int
 ncp_delete_dentry(const struct dentry * dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (inode) {
                 if (is_bad_inode(inode))
@@ -224,7 +224,7 @@ ncp_force_unlink(struct inode *dir, struct dentry* dentry)
         memset(&info, 0, sizeof(info));
         
         /* remove the Read-Only flag on the NW server */
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         old_nwattr = NCP_FINFO(inode)->nwattr;
         info.attributes = old_nwattr & ~(aRONLY|aDELETEINHIBIT|aRENAMEINHIBIT);
@@ -254,7 +254,7 @@ ncp_force_rename(struct inode *old_dir, struct dentry* old_dentry, char *_old_na
 {
         struct nw_modify_dos_info info;
         int res=0x90,res2;
-        struct inode *old_inode = old_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
         __le32 old_nwattr = NCP_FINFO(old_inode)->nwattr;
         __le32 new_nwattr = 0; /* shut compiler warning */
         int old_nwattr_changed = 0;
@@ -268,8 +268,8 @@ ncp_force_rename(struct inode *old_dir, struct dentry* old_dentry, char *_old_na
         res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode), old_inode, NULL, DM_ATTRIBUTES, &info);
         if (!res2)
                 old_nwattr_changed = 1;
-        if (new_dentry && new_dentry->d_inode) {
-                new_nwattr = NCP_FINFO(new_dentry->d_inode)->nwattr;
+        if (new_dentry && d_really_is_positive(new_dentry)) {
+                new_nwattr = NCP_FINFO(d_inode(new_dentry))->nwattr;
                 info.attributes = new_nwattr & ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
                 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir), new_dir, _new_name, DM_ATTRIBUTES, &info);
                 if (!res2)
@@ -324,9 +324,9 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
                 return -ECHILD;
 
         parent = dget_parent(dentry);
-        dir = parent->d_inode;
+        dir = d_inode(parent);
 
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto finished;
 
         server = NCP_SERVER(dir);
@@ -367,7 +367,7 @@ ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
          * what we remember, it's not valid any more.
          */
         if (!res) {
-                struct inode *inode = dentry->d_inode;
+                struct inode *inode = d_inode(dentry);
 
                 mutex_lock(&inode->i_mutex);
                 if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) {
@@ -388,7 +388,7 @@ finished:
 
 static time_t ncp_obtain_mtime(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ncp_server *server = NCP_SERVER(inode);
         struct nw_info_struct i;
 
@@ -404,7 +404,7 @@ static time_t ncp_obtain_mtime(struct dentry *dentry)
 static inline void
 ncp_invalidate_dircache_entries(struct dentry *parent)
 {
-        struct ncp_server *server = NCP_SERVER(parent->d_inode);
+        struct ncp_server *server = NCP_SERVER(d_inode(parent));
         struct dentry *dentry;
 
         spin_lock(&parent->d_lock);
@@ -418,7 +418,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
 static int ncp_readdir(struct file *file, struct dir_context *ctx)
 {
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct page *page = NULL;
         struct ncp_server *server = NCP_SERVER(inode);
         union  ncp_dir_cache *cache = NULL;
@@ -491,13 +491,13 @@ static int ncp_readdir(struct file *file, struct dir_context *ctx)
                                 goto invalid_cache;
                         }
                         spin_unlock(&dentry->d_lock);
-                        if (!dent->d_inode) {
+                        if (d_really_is_negative(dent)) {
                                 dput(dent);
                                 goto invalid_cache;
                         }
                         over = !dir_emit(ctx, dent->d_name.name,
                                         dent->d_name.len,
-                                        dent->d_inode->i_ino, DT_UNKNOWN);
+                                        d_inode(dent)->i_ino, DT_UNKNOWN);
                         dput(dent);
                         if (over)
                                 goto finished;
@@ -571,7 +571,7 @@ static void ncp_d_prune(struct dentry *dentry)
 {
         if (!dentry->d_fsdata)  /* not referenced from page cache */
                 return;
-        NCP_FINFO(dentry->d_parent->d_inode)->flags &= ~NCPI_DIR_CACHE;
+        NCP_FINFO(d_inode(dentry->d_parent))->flags &= ~NCPI_DIR_CACHE;
 }
 
 static int
@@ -580,7 +580,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                 int inval_childs)
 {
         struct dentry *newdent, *dentry = file->f_path.dentry;
-        struct inode *dir = dentry->d_inode;
+        struct inode *dir = d_inode(dentry);
         struct ncp_cache_control ctl = *ctrl;
         struct qstr qname;
         int valid = 0;
@@ -621,7 +621,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                 dentry_update_name_case(newdent, &qname);
         }
 
-        if (!newdent->d_inode) {
+        if (d_really_is_negative(newdent)) {
                 struct inode *inode;
 
                 entry->opened = 0;
@@ -637,7 +637,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                         spin_unlock(&dentry->d_lock);
                 }
         } else {
-                struct inode *inode = newdent->d_inode;
+                struct inode *inode = d_inode(newdent);
 
                 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
                 ncp_update_inode2(inode, entry);
@@ -659,10 +659,10 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                         ctl.cache = kmap(ctl.page);
         }
         if (ctl.cache) {
-                if (newdent->d_inode) {
+                if (d_really_is_positive(newdent)) {
                         newdent->d_fsdata = newdent;
                         ctl.cache->dentry[ctl.idx] = newdent;
-                        ino = newdent->d_inode->i_ino;
+                        ino = d_inode(newdent)->i_ino;
                         ncp_new_dentry(newdent);
                 }
                 valid = 1;
@@ -807,7 +807,7 @@ int ncp_conn_logged_in(struct super_block *sb)
                 }
                 dent = sb->s_root;
                 if (dent) {
-                        struct inode* ino = dent->d_inode;
+                        struct inode* ino = d_inode(dent);
                         if (ino) {
                                 ncp_update_known_namespace(server, volNumber, NULL);
                                 NCP_FINFO(ino)->volNumber = volNumber;
@@ -815,7 +815,7 @@ int ncp_conn_logged_in(struct super_block *sb)
                                 NCP_FINFO(ino)->DosDirNum = DosDirNum;
                                 result = 0;
                         } else {
-                                ncp_dbg(1, "sb->s_root->d_inode == NULL!\n");
+                                ncp_dbg(1, "d_inode(sb->s_root) == NULL!\n");
                         }
                 } else {
                         ncp_dbg(1, "sb->s_root == NULL!\n");
@@ -1055,7 +1055,7 @@ out:
 
 static int ncp_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ncp_server *server;
         int error;
 
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 01a9e16e9782..9605a2f63549 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -812,7 +812,7 @@ static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
         if (!d) {
                 goto dflt;
         }
-        i = d->d_inode;
+        i = d_inode(d);
         if (!i) {
                 goto dflt;
         }
@@ -865,7 +865,7 @@ dflt:;
 
 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int result = 0;
         __le32 info_mask;
         struct nw_modify_dos_info info;
@@ -878,7 +878,7 @@ int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
                 goto out;
 
         result = -EPERM;
-        if (IS_DEADDIR(dentry->d_inode))
+        if (IS_DEADDIR(d_inode(dentry)))
                 goto out;
 
         /* ageing the dentry to force validation */
diff --git a/fs/ncpfs/ioctl.c b/fs/ncpfs/ioctl.c
index cf7e043a9447..79b113048eac 100644
--- a/fs/ncpfs/ioctl.c
+++ b/fs/ncpfs/ioctl.c
@@ -376,7 +376,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                 struct dentry* dentry = inode->i_sb->s_root;
 
                                 if (dentry) {
-                                        struct inode* s_inode = dentry->d_inode;
+                                        struct inode* s_inode = d_inode(dentry);
 
                                         if (s_inode) {
                                                 sr.volNumber = NCP_FINFO(s_inode)->volNumber;
@@ -384,7 +384,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                                 sr.namespace = server->name_space[sr.volNumber];
                                                 result = 0;
                                         } else
-                                                ncp_dbg(1, "s_root->d_inode==NULL\n");
+                                                ncp_dbg(1, "d_inode(s_root)==NULL\n");
                                 } else
                                         ncp_dbg(1, "s_root==NULL\n");
                         } else {
@@ -431,7 +431,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                 if (result == 0) {
                                         dentry = inode->i_sb->s_root;
                                         if (dentry) {
-                                                struct inode* s_inode = dentry->d_inode;
+                                                struct inode* s_inode = d_inode(dentry);
 
                                                 if (s_inode) {
                                                         NCP_FINFO(s_inode)->volNumber = vnum;
@@ -439,7 +439,7 @@ static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg
                                                         NCP_FINFO(s_inode)->DosDirNum = dosde;
                                                         server->root_setuped = 1;
                                                 } else {
-                                                        ncp_dbg(1, "s_root->d_inode==NULL\n");
+                                                        ncp_dbg(1, "d_inode(s_root)==NULL\n");
                                                         result = -EIO;
                                                 }
                                         } else {
diff --git a/fs/ncpfs/ncplib_kernel.c b/fs/ncpfs/ncplib_kernel.c
index 2b502a0d7941..88dbbc9fcf4d 100644
--- a/fs/ncpfs/ncplib_kernel.c
+++ b/fs/ncpfs/ncplib_kernel.c
@@ -727,7 +727,7 @@ int
 ncp_del_file_or_subdir2(struct ncp_server *server,
                         struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         __u8  volnum;
         __le32 dirent;
 
diff --git a/fs/ncpfs/symlink.c b/fs/ncpfs/symlink.c
index 1a63bfdb4a65..421b6f91e8ec 100644
--- a/fs/ncpfs/symlink.c
+++ b/fs/ncpfs/symlink.c
@@ -156,7 +156,7 @@ int ncp_symlink(struct inode *dir, struct dentry *dentry, const char *symname) {
                 goto failfree;
         }
 
-        inode=dentry->d_inode;
+        inode=d_inode(dentry);
 
         if (ncp_make_open(inode, O_WRONLY))
                 goto failfree;
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index 1e987acf20c9..8664417955a2 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -22,7 +22,7 @@ nfsv3-$(CONFIG_NFS_V3_ACL) += nfs3acl.o
 obj-$(CONFIG_NFS_V4) += nfsv4.o
 CFLAGS_nfs4trace.o += -I$(src)
 nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o \
-          delegation.o idmap.o callback.o callback_xdr.o callback_proc.o \
+          delegation.o nfs4idmap.o callback.o callback_xdr.o callback_proc.o \
           nfs4namespace.o nfs4getroot.o nfs4client.o nfs4session.o \
           dns_resolve.o nfs4trace.o
 nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 1cac3c175d18..d2554fe140a3 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -890,6 +890,7 @@ static struct pnfs_layoutdriver_type blocklayout_type = {
         .free_deviceid_node             = bl_free_deviceid_node,
         .pg_read_ops                    = &bl_pg_read_ops,
         .pg_write_ops                   = &bl_pg_write_ops,
+        .sync                           = pnfs_generic_sync,
 };
 
 static int __init nfs4blocklayout_init(void)
diff --git a/fs/nfs/blocklayout/dev.c b/fs/nfs/blocklayout/dev.c
index 5aed4f98df41..e535599a0719 100644
--- a/fs/nfs/blocklayout/dev.c
+++ b/fs/nfs/blocklayout/dev.c
@@ -33,7 +33,7 @@ bl_free_deviceid_node(struct nfs4_deviceid_node *d)
                 container_of(d, struct pnfs_block_dev, node);
 
         bl_free_device(dev);
-        kfree(dev);
+        kfree_rcu(dev, node.rcu);
 }
 
 static int
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 351be9205bf8..8d129bb7355a 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -128,7 +128,7 @@ nfs41_callback_svc(void *vrqstp)
                 if (try_to_freeze())
                         continue;
 
-                prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_UNINTERRUPTIBLE);
+                prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
                 spin_lock_bh(&serv->sv_cb_lock);
                 if (!list_empty(&serv->sv_cb_list)) {
                         req = list_first_entry(&serv->sv_cb_list,
@@ -142,10 +142,10 @@ nfs41_callback_svc(void *vrqstp)
                                 error);
                 } else {
                         spin_unlock_bh(&serv->sv_cb_lock);
-                        /* schedule_timeout to game the hung task watchdog */
-                        schedule_timeout(60 * HZ);
+                        schedule();
                         finish_wait(&serv->sv_cb_waitq, &wq);
                 }
+                flush_signals(current);
         }
         return 0;
 }
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 19874151e95c..892aefff3630 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -31,7 +31,6 @@
 #include <linux/lockd/bind.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
-#include <linux/nfs_idmap.h>
 #include <linux/vfs.h>
 #include <linux/inet.h>
 #include <linux/in6.h>
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index a6ad68865880..029d688a969f 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -378,7 +378,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
                 if (freeme == NULL)
                         goto out;
         }
-        list_add_rcu(&delegation->super_list, &server->delegations);
+        list_add_tail_rcu(&delegation->super_list, &server->delegations);
         rcu_assign_pointer(nfsi->delegation, delegation);
         delegation = NULL;
 
@@ -514,7 +514,7 @@ void nfs_inode_return_delegation_noreclaim(struct inode *inode)
 
         delegation = nfs_inode_detach_delegation(inode);
         if (delegation != NULL)
-                nfs_do_return_delegation(inode, delegation, 0);
+                nfs_do_return_delegation(inode, delegation, 1);
 }
 
 /**
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index c19e16f0b2d0..b2c8b31b2be7 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -416,15 +416,14 @@ int nfs_same_file(struct dentry *dentry, struct nfs_entry *entry)
 {
         struct nfs_inode *nfsi;
 
-        if (dentry->d_inode == NULL)
-                goto different;
+        if (d_really_is_negative(dentry))
+                return 0;
 
-        nfsi = NFS_I(dentry->d_inode);
+        nfsi = NFS_I(d_inode(dentry));
         if (entry->fattr->fileid == nfsi->fileid)
                 return 1;
         if (nfs_compare_fh(entry->fh, &nfsi->fh) == 0)
                 return 1;
-different:
         return 0;
 }
 
@@ -473,7 +472,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         struct qstr filename = QSTR_INIT(entry->name, entry->len);
         struct dentry *dentry;
         struct dentry *alias;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct inode *inode;
         int status;
 
@@ -497,9 +496,9 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
                         goto out;
                 if (nfs_same_file(dentry, entry)) {
                         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-                        status = nfs_refresh_inode(dentry->d_inode, entry->fattr);
+                        status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
                         if (!status)
-                                nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label);
+                                nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
                         goto out;
                 } else {
                         d_invalidate(dentry);
@@ -544,6 +543,9 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
         if (scratch == NULL)
                 return -ENOMEM;
 
+        if (buflen == 0)
+                goto out_nopages;
+
         xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 
@@ -565,6 +567,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
                         break;
         } while (!entry->eof);
 
+out_nopages:
         if (count == 0 || (status == -EBADCOOKIE && entry->eof != 0)) {
                 array = nfs_readdir_get_array(page);
                 if (!IS_ERR(array)) {
@@ -870,7 +873,7 @@ static bool nfs_dir_mapping_need_revalidate(struct inode *dir)
 static int nfs_readdir(struct file *file, struct dir_context *ctx)
 {
         struct dentry   *dentry = file->f_path.dentry;
-        struct inode    *inode = dentry->d_inode;
+        struct inode    *inode = d_inode(dentry);
         nfs_readdir_descriptor_t my_desc,
                         *desc = &my_desc;
         struct nfs_open_dir_context *dir_ctx = file->private_data;
@@ -1118,15 +1121,15 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 
         if (flags & LOOKUP_RCU) {
                 parent = ACCESS_ONCE(dentry->d_parent);
-                dir = ACCESS_ONCE(parent->d_inode);
+                dir = d_inode_rcu(parent);
                 if (!dir)
                         return -ECHILD;
         } else {
                 parent = dget_parent(dentry);
-                dir = parent->d_inode;
+                dir = d_inode(parent);
         }
         nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         if (!inode) {
                 if (nfs_neg_need_reval(dir, dentry, flags)) {
@@ -1242,7 +1245,7 @@ out_error:
 }
 
 /*
- * A weaker form of d_revalidate for revalidating just the dentry->d_inode
+ * A weaker form of d_revalidate for revalidating just the d_inode(dentry)
  * when we don't really care about the dentry name. This is called when a
  * pathwalk ends on a dentry that was not found via a normal lookup in the
  * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals).
@@ -1253,7 +1256,7 @@ out_error:
 static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags)
 {
         int error;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         /*
          * I believe we can only get a negative dentry here in the case of a
@@ -1287,7 +1290,7 @@ static int nfs_dentry_delete(const struct dentry *dentry)
                 dentry, dentry->d_flags);
 
         /* Unhash any dentry with a stale inode */
-        if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode))
+        if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry)))
                 return 1;
 
         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
@@ -1491,7 +1494,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
         int err;
 
         /* Expect a negative dentry */
-        BUG_ON(dentry->d_inode);
+        BUG_ON(d_inode(dentry));
 
         dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
                         dir->i_sb->s_id, dir->i_ino, dentry);
@@ -1587,7 +1590,7 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1)
                 goto no_open;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         /* We can't create new files in nfs_open_revalidate(), so we
          * optimize away revalidation of negative dentries.
@@ -1598,12 +1601,12 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 
                 if (flags & LOOKUP_RCU) {
                         parent = ACCESS_ONCE(dentry->d_parent);
-                        dir = ACCESS_ONCE(parent->d_inode);
+                        dir = d_inode_rcu(parent);
                         if (!dir)
                                 return -ECHILD;
                 } else {
                         parent = dget_parent(dentry);
-                        dir = parent->d_inode;
+                        dir = d_inode(parent);
                 }
                 if (!nfs_neg_need_reval(dir, dentry, flags))
                         ret = 1;
@@ -1643,14 +1646,14 @@ int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fhandle,
                                 struct nfs4_label *label)
 {
         struct dentry *parent = dget_parent(dentry);
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct inode *inode;
         int error = -EACCES;
 
         d_drop(dentry);
 
         /* We may have been initialized further down */
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 goto out;
         if (fhandle->size == 0) {
                 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL);
@@ -1768,7 +1771,7 @@ EXPORT_SYMBOL_GPL(nfs_mkdir);
 
 static void nfs_dentry_handle_enoent(struct dentry *dentry)
 {
-        if (dentry->d_inode != NULL && !d_unhashed(dentry))
+        if (d_really_is_positive(dentry) && !d_unhashed(dentry))
                 d_delete(dentry);
 }
 
@@ -1780,13 +1783,13 @@ int nfs_rmdir(struct inode *dir, struct dentry *dentry)
                         dir->i_sb->s_id, dir->i_ino, dentry);
 
         trace_nfs_rmdir_enter(dir, dentry);
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 nfs_wait_on_sillyrename(dentry);
                 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name);
                 /* Ensure the VFS deletes this inode */
                 switch (error) {
                 case 0:
-                        clear_nlink(dentry->d_inode);
+                        clear_nlink(d_inode(dentry));
                         break;
                 case -ENOENT:
                         nfs_dentry_handle_enoent(dentry);
@@ -1808,8 +1811,8 @@ EXPORT_SYMBOL_GPL(nfs_rmdir);
  */
 static int nfs_safe_remove(struct dentry *dentry)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
-        struct inode *inode = dentry->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
+        struct inode *inode = d_inode(dentry);
         int error = -EBUSY;
                 
         dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry);
@@ -1853,7 +1856,7 @@ int nfs_unlink(struct inode *dir, struct dentry *dentry)
         if (d_count(dentry) > 1) {
                 spin_unlock(&dentry->d_lock);
                 /* Start asynchronous writeout of the inode */
-                write_inode_now(dentry->d_inode, 0);
+                write_inode_now(d_inode(dentry), 0);
                 error = nfs_sillyrename(dir, dentry);
                 goto out;
         }
@@ -1931,7 +1934,7 @@ int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
          * No big deal if we can't add this page to the page cache here.
          * READLINK will get the missing page from the server if needed.
          */
-        if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0,
+        if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0,
                                                         GFP_KERNEL)) {
                 SetPageUptodate(page);
                 unlock_page(page);
@@ -1950,7 +1953,7 @@ EXPORT_SYMBOL_GPL(nfs_symlink);
 int
 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int error;
 
         dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n",
@@ -1997,8 +2000,8 @@ EXPORT_SYMBOL_GPL(nfs_link);
 int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                       struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct dentry *dentry = NULL, *rehash = NULL;
         struct rpc_task *task;
         int error = -EBUSY;
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 682f65fe09b5..38678d9a5cc4 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -129,22 +129,25 @@ nfs_direct_good_bytes(struct nfs_direct_req *dreq, struct nfs_pgio_header *hdr)
         int i;
         ssize_t count;
 
-        WARN_ON_ONCE(hdr->pgio_mirror_idx >= dreq->mirror_count);
-
-        count = dreq->mirrors[hdr->pgio_mirror_idx].count;
-        if (count + dreq->io_start < hdr->io_start + hdr->good_bytes) {
-                count = hdr->io_start + hdr->good_bytes - dreq->io_start;
-                dreq->mirrors[hdr->pgio_mirror_idx].count = count;
-        }
-
-        /* update the dreq->count by finding the minimum agreed count from all
-         * mirrors */
-        count = dreq->mirrors[0].count;
+        if (dreq->mirror_count == 1) {
+                dreq->mirrors[hdr->pgio_mirror_idx].count += hdr->good_bytes;
+                dreq->count += hdr->good_bytes;
+        } else {
+                /* mirrored writes */
+                count = dreq->mirrors[hdr->pgio_mirror_idx].count;
+                if (count + dreq->io_start < hdr->io_start + hdr->good_bytes) {
+                        count = hdr->io_start + hdr->good_bytes - dreq->io_start;
+                        dreq->mirrors[hdr->pgio_mirror_idx].count = count;
+                }
+                /* update the dreq->count by finding the minimum agreed count from all
+                 * mirrors */
+                count = dreq->mirrors[0].count;
 
-        for (i = 1; i < dreq->mirror_count; i++)
-                count = min(count, dreq->mirrors[i].count);
+                for (i = 1; i < dreq->mirror_count; i++)
+                        count = min(count, dreq->mirrors[i].count);
 
-        dreq->count = count;
+                dreq->count = count;
+        }
 }
 
 /*
@@ -258,18 +261,11 @@ ssize_t nfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t pos)
         if (!IS_SWAPFILE(inode))
                 return 0;
 
-#ifndef CONFIG_NFS_SWAP
-        dprintk("NFS: nfs_direct_IO (%pD) off/no(%Ld/%lu) EINVAL\n",
-                        iocb->ki_filp, (long long) pos, iter->nr_segs);
-
-        return -EINVAL;
-#else
         VM_BUG_ON(iov_iter_count(iter) != PAGE_SIZE);
 
         if (iov_iter_rw(iter) == READ)
                 return nfs_file_direct_read(iocb, iter, pos);
         return nfs_file_direct_write(iocb, iter);
-#endif /* CONFIG_NFS_SWAP */
 }
 
 static void nfs_direct_release_pages(struct page **pages, unsigned int npages)
@@ -386,7 +382,7 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
         if (write)
                 nfs_zap_mapping(inode, inode->i_mapping);
 
-        inode_dio_done(inode);
+        inode_dio_end(inode);
 
         if (dreq->iocb) {
                 long res = (long) dreq->error;
@@ -403,8 +399,8 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
 static void nfs_direct_readpage_release(struct nfs_page *req)
 {
         dprintk("NFS: direct read done (%s/%llu %d@%lld)\n",
-                req->wb_context->dentry->d_inode->i_sb->s_id,
-                (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                d_inode(req->wb_context->dentry)->i_sb->s_id,
+                (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
                 req->wb_bytes,
                 (long long)req_offset(req));
         nfs_release_request(req);
@@ -486,7 +482,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
                              &nfs_direct_read_completion_ops);
         get_dreq(dreq);
         desc.pg_dreq = dreq;
-        atomic_inc(&inode->i_dio_count);
+        inode_dio_begin(inode);
 
         while (iov_iter_count(iter)) {
                 struct page **pagevec;
@@ -538,7 +534,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
          * generic layer handle the completion.
          */
         if (requested_bytes == 0) {
-                inode_dio_done(inode);
+                inode_dio_end(inode);
                 nfs_direct_req_release(dreq);
                 return result < 0 ? result : -EIO;
         }
@@ -872,7 +868,7 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
                               &nfs_direct_write_completion_ops);
         desc.pg_dreq = dreq;
         get_dreq(dreq);
-        atomic_inc(&inode->i_dio_count);
+        inode_dio_begin(inode);
 
         NFS_I(inode)->write_io += iov_iter_count(iter);
         while (iov_iter_count(iter)) {
@@ -928,7 +924,7 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
          * generic layer handle the completion.
          */
         if (requested_bytes == 0) {
-                inode_dio_done(inode);
+                inode_dio_end(inode);
                 nfs_direct_req_release(dreq);
                 return result < 0 ? result : -EIO;
         }
@@ -1030,6 +1026,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
                         if (i_size_read(inode) < iocb->ki_pos)
                                 i_size_write(inode, iocb->ki_pos);
                         spin_unlock(&inode->i_lock);
+                        generic_write_sync(file, pos, result);
                 }
         }
         nfs_direct_req_release(dreq);
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index c40e4363e746..8b8d83a526ce 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -280,6 +280,7 @@ nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 
         trace_nfs_fsync_enter(inode);
 
+        nfs_inode_dio_wait(inode);
         do {
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
                 if (ret != 0)
@@ -782,7 +783,7 @@ do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
          * Flush all pending writes before doing anything
          * with locks..
          */
-        nfs_sync_mapping(filp->f_mapping);
+        vfs_fsync(filp, 0);
 
         l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
         if (!IS_ERR(l_ctx)) {
diff --git a/fs/nfs/filelayout/filelayout.c b/fs/nfs/filelayout/filelayout.c
index 91e88a7ecef0..a46bf6de9ce4 100644
--- a/fs/nfs/filelayout/filelayout.c
+++ b/fs/nfs/filelayout/filelayout.c
@@ -258,7 +258,8 @@ filelayout_set_layoutcommit(struct nfs_pgio_header *hdr)
             hdr->res.verf->committed != NFS_DATA_SYNC)
                 return;
 
-        pnfs_set_layoutcommit(hdr);
+        pnfs_set_layoutcommit(hdr->inode, hdr->lseg,
+                        hdr->mds_offset + hdr->res.count);
         dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
                 (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
 }
@@ -373,7 +374,7 @@ static int filelayout_commit_done_cb(struct rpc_task *task,
         }
 
         if (data->verf.committed == NFS_UNSTABLE)
-                pnfs_commit_set_layoutcommit(data);
+                pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb);
 
         return 0;
 }
@@ -1086,7 +1087,7 @@ filelayout_alloc_deviceid_node(struct nfs_server *server,
 }
 
 static void
-filelayout_free_deveiceid_node(struct nfs4_deviceid_node *d)
+filelayout_free_deviceid_node(struct nfs4_deviceid_node *d)
 {
         nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
 }
@@ -1137,7 +1138,8 @@ static struct pnfs_layoutdriver_type filelayout_type = {
         .read_pagelist          = filelayout_read_pagelist,
         .write_pagelist         = filelayout_write_pagelist,
         .alloc_deviceid_node    = filelayout_alloc_deviceid_node,
-        .free_deviceid_node     = filelayout_free_deveiceid_node,
+        .free_deviceid_node     = filelayout_free_deviceid_node,
+        .sync                   = pnfs_nfs_generic_sync,
 };
 
 static int __init nfs4filelayout_init(void)
diff --git a/fs/nfs/filelayout/filelayoutdev.c b/fs/nfs/filelayout/filelayoutdev.c
index 4f372e224603..4946ef40ba87 100644
--- a/fs/nfs/filelayout/filelayoutdev.c
+++ b/fs/nfs/filelayout/filelayoutdev.c
@@ -55,7 +55,7 @@ nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
                         nfs4_pnfs_ds_put(ds);
         }
         kfree(dsaddr->stripe_indices);
-        kfree(dsaddr);
+        kfree_rcu(dsaddr, id_node.rcu);
 }
 
 /* Decode opaque device data and return the result */
diff --git a/fs/nfs/flexfilelayout/flexfilelayout.c b/fs/nfs/flexfilelayout/flexfilelayout.c
index 315cc68945b9..7d05089e52d6 100644
--- a/fs/nfs/flexfilelayout/flexfilelayout.c
+++ b/fs/nfs/flexfilelayout/flexfilelayout.c
@@ -11,10 +11,10 @@
 #include <linux/module.h>
 
 #include <linux/sunrpc/metrics.h>
-#include <linux/nfs_idmap.h>
 
 #include "flexfilelayout.h"
 #include "../nfs4session.h"
+#include "../nfs4idmap.h"
 #include "../internal.h"
 #include "../delegation.h"
 #include "../nfs4trace.h"
@@ -891,7 +891,8 @@ static int ff_layout_read_done_cb(struct rpc_task *task,
 static void
 ff_layout_set_layoutcommit(struct nfs_pgio_header *hdr)
 {
-        pnfs_set_layoutcommit(hdr);
+        pnfs_set_layoutcommit(hdr->inode, hdr->lseg,
+                        hdr->mds_offset + hdr->res.count);
         dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
                 (unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
 }
@@ -1074,7 +1075,7 @@ static int ff_layout_commit_done_cb(struct rpc_task *task,
         }
 
         if (data->verf.committed == NFS_UNSTABLE)
-                pnfs_commit_set_layoutcommit(data);
+                pnfs_set_layoutcommit(data->inode, data->lseg, data->lwb);
 
         return 0;
 }
@@ -1414,7 +1415,7 @@ ff_layout_get_ds_info(struct inode *inode)
 }
 
 static void
-ff_layout_free_deveiceid_node(struct nfs4_deviceid_node *d)
+ff_layout_free_deviceid_node(struct nfs4_deviceid_node *d)
 {
         nfs4_ff_layout_free_deviceid(container_of(d, struct nfs4_ff_layout_ds,
                                                   id_node));
@@ -1498,7 +1499,7 @@ static struct pnfs_layoutdriver_type flexfilelayout_type = {
         .pg_read_ops            = &ff_layout_pg_read_ops,
         .pg_write_ops           = &ff_layout_pg_write_ops,
         .get_ds_info            = ff_layout_get_ds_info,
-        .free_deviceid_node     = ff_layout_free_deveiceid_node,
+        .free_deviceid_node     = ff_layout_free_deviceid_node,
         .mark_request_commit    = pnfs_layout_mark_request_commit,
         .clear_request_commit   = pnfs_generic_clear_request_commit,
         .scan_commit_lists      = pnfs_generic_scan_commit_lists,
@@ -1508,6 +1509,7 @@ static struct pnfs_layoutdriver_type flexfilelayout_type = {
         .write_pagelist         = ff_layout_write_pagelist,
         .alloc_deviceid_node    = ff_layout_alloc_deviceid_node,
         .encode_layoutreturn    = ff_layout_encode_layoutreturn,
+        .sync                   = pnfs_nfs_generic_sync,
 };
 
 static int __init nfs4flexfilelayout_init(void)
diff --git a/fs/nfs/flexfilelayout/flexfilelayoutdev.c b/fs/nfs/flexfilelayout/flexfilelayoutdev.c
index e2c01f204a95..77a2d026aa12 100644
--- a/fs/nfs/flexfilelayout/flexfilelayoutdev.c
+++ b/fs/nfs/flexfilelayout/flexfilelayoutdev.c
@@ -30,7 +30,7 @@ void nfs4_ff_layout_free_deviceid(struct nfs4_ff_layout_ds *mirror_ds)
 {
         nfs4_print_deviceid(&mirror_ds->id_node.deviceid);
         nfs4_pnfs_ds_put(mirror_ds->ds);
-        kfree(mirror_ds);
+        kfree_rcu(mirror_ds, id_node.rcu);
 }
 
 /* Decode opaque device data and construct new_ds using it */
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 9ac3846cb59e..a608ffd28acc 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -56,11 +56,11 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                  * This again causes shrink_dcache_for_umount_subtree() to
                  * Oops, since the test for IS_ROOT() will fail.
                  */
-                spin_lock(&sb->s_root->d_inode->i_lock);
+                spin_lock(&d_inode(sb->s_root)->i_lock);
                 spin_lock(&sb->s_root->d_lock);
                 hlist_del_init(&sb->s_root->d_u.d_alias);
                 spin_unlock(&sb->s_root->d_lock);
-                spin_unlock(&sb->s_root->d_inode->i_lock);
+                spin_unlock(&d_inode(sb->s_root)->i_lock);
         }
         return 0;
 }
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index d42dff6d5e98..f734562c6d24 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -133,6 +133,13 @@ void nfs_evict_inode(struct inode *inode)
         nfs_clear_inode(inode);
 }
 
+int nfs_sync_inode(struct inode *inode)
+{
+        nfs_inode_dio_wait(inode);
+        return nfs_wb_all(inode);
+}
+EXPORT_SYMBOL_GPL(nfs_sync_inode);
+
 /**
  * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  */
@@ -192,7 +199,6 @@ void nfs_zap_caches(struct inode *inode)
         nfs_zap_caches_locked(inode);
         spin_unlock(&inode->i_lock);
 }
-EXPORT_SYMBOL_GPL(nfs_zap_caches);
 
 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
 {
@@ -495,7 +501,7 @@ EXPORT_SYMBOL_GPL(nfs_fhget);
 int
 nfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct nfs_fattr *fattr;
         int error = -ENOMEM;
 
@@ -525,10 +531,8 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr)
         trace_nfs_setattr_enter(inode);
 
         /* Write all dirty data */
-        if (S_ISREG(inode->i_mode)) {
-                nfs_inode_dio_wait(inode);
-                nfs_wb_all(inode);
-        }
+        if (S_ISREG(inode->i_mode))
+                nfs_sync_inode(inode);
 
         fattr = nfs_alloc_fattr();
         if (fattr == NULL)
@@ -621,7 +625,7 @@ static void nfs_request_parent_use_readdirplus(struct dentry *dentry)
         struct dentry *parent;
 
         parent = dget_parent(dentry);
-        nfs_force_use_readdirplus(parent->d_inode);
+        nfs_force_use_readdirplus(d_inode(parent));
         dput(parent);
 }
 
@@ -637,15 +641,16 @@ static bool nfs_need_revalidate_inode(struct inode *inode)
 
 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
         int err = 0;
 
         trace_nfs_getattr_enter(inode);
         /* Flush out writes to the server in order to update c/mtime.  */
         if (S_ISREG(inode->i_mode)) {
-                nfs_inode_dio_wait(inode);
-                err = filemap_write_and_wait(inode->i_mapping);
+                mutex_lock(&inode->i_mutex);
+                err = nfs_sync_inode(inode);
+                mutex_unlock(&inode->i_mutex);
                 if (err)
                         goto out;
         }
@@ -708,7 +713,7 @@ static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context
 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
 {
         struct nfs_lock_context *res, *new = NULL;
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = d_inode(ctx->dentry);
 
         spin_lock(&inode->i_lock);
         res = __nfs_find_lock_context(ctx);
@@ -736,7 +741,7 @@ EXPORT_SYMBOL_GPL(nfs_get_lock_context);
 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
 {
         struct nfs_open_context *ctx = l_ctx->open_context;
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = d_inode(ctx->dentry);
 
         if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
                 return;
@@ -763,7 +768,7 @@ void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
                 return;
         if (!is_sync)
                 return;
-        inode = ctx->dentry->d_inode;
+        inode = d_inode(ctx->dentry);
         if (!list_empty(&NFS_I(inode)->open_files))
                 return;
         server = NFS_SERVER(inode);
@@ -810,7 +815,7 @@ EXPORT_SYMBOL_GPL(get_nfs_open_context);
 
 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
 {
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = d_inode(ctx->dentry);
         struct super_block *sb = ctx->dentry->d_sb;
 
         if (!list_empty(&ctx->list)) {
@@ -842,7 +847,7 @@ EXPORT_SYMBOL_GPL(put_nfs_open_context);
  */
 void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
 {
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = d_inode(ctx->dentry);
         struct nfs_inode *nfsi = NFS_I(inode);
 
         spin_lock(&inode->i_lock);
@@ -885,7 +890,7 @@ static void nfs_file_clear_open_context(struct file *filp)
         struct nfs_open_context *ctx = nfs_file_open_context(filp);
 
         if (ctx) {
-                struct inode *inode = ctx->dentry->d_inode;
+                struct inode *inode = d_inode(ctx->dentry);
 
                 filp->private_data = NULL;
                 spin_lock(&inode->i_lock);
@@ -1588,6 +1593,19 @@ int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fa
 }
 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
 
+
+static inline bool nfs_fileid_valid(struct nfs_inode *nfsi,
+                                    struct nfs_fattr *fattr)
+{
+        bool ret1 = true, ret2 = true;
+
+        if (fattr->valid & NFS_ATTR_FATTR_FILEID)
+                ret1 = (nfsi->fileid == fattr->fileid);
+        if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
+                ret2 = (nfsi->fileid == fattr->mounted_on_fileid);
+        return ret1 || ret2;
+}
+
 /*
  * Many nfs protocol calls return the new file attributes after
  * an operation.  Here we update the inode to reflect the state
@@ -1614,7 +1632,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                         nfs_display_fhandle_hash(NFS_FH(inode)),
                         atomic_read(&inode->i_count), fattr->valid);
 
-        if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
+        if (!nfs_fileid_valid(nfsi, fattr)) {
                 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
                         "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
                         NFS_SERVER(inode)->nfs_client->cl_hostname,
@@ -1819,7 +1837,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
 struct inode *nfs_alloc_inode(struct super_block *sb)
 {
         struct nfs_inode *nfsi;
-        nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
+        nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
         if (!nfsi)
                 return NULL;
         nfsi->flags = 0UL;
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index b5a0afc3ee10..c8162c660c44 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -139,7 +139,7 @@ EXPORT_SYMBOL_GPL(nfs_path);
 struct vfsmount *nfs_d_automount(struct path *path)
 {
         struct vfsmount *mnt;
-        struct nfs_server *server = NFS_SERVER(path->dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(d_inode(path->dentry));
         struct nfs_fh *fh = NULL;
         struct nfs_fattr *fattr = NULL;
 
@@ -180,16 +180,16 @@ out_nofree:
 static int
 nfs_namespace_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        if (NFS_FH(dentry->d_inode)->size != 0)
+        if (NFS_FH(d_inode(dentry))->size != 0)
                 return nfs_getattr(mnt, dentry, stat);
-        generic_fillattr(dentry->d_inode, stat);
+        generic_fillattr(d_inode(dentry), stat);
         return 0;
 }
 
 static int
 nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        if (NFS_FH(dentry->d_inode)->size != 0)
+        if (NFS_FH(d_inode(dentry))->size != 0)
                 return nfs_setattr(dentry, attr);
         return -EACCES;
 }
@@ -279,7 +279,7 @@ struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,
         struct dentry *parent = dget_parent(dentry);
 
         /* Look it up again to get its attributes */
-        err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr, NULL);
+        err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL);
         dput(parent);
         if (err != 0)
                 return ERR_PTR(err);
diff --git a/fs/nfs/nfs3acl.c b/fs/nfs/nfs3acl.c
index 658e586ca438..1ebe2fc7cda2 100644
--- a/fs/nfs/nfs3acl.c
+++ b/fs/nfs/nfs3acl.c
@@ -279,7 +279,7 @@ nfs3_list_one_acl(struct inode *inode, int type, const char *name, void *data,
 ssize_t
 nfs3_listxattr(struct dentry *dentry, char *data, size_t size)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         ssize_t result = 0;
         int error;
 
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 1f11d2533ee4..cb28cceefebe 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -120,7 +120,7 @@ static int
 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                         struct iattr *sattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct nfs3_sattrargs   arg = {
                 .fh             = NFS_FH(inode),
                 .sattr          = sattr,
@@ -386,13 +386,13 @@ nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                  * not sure this buys us anything (and I'd have
                  * to revamp the NFSv3 XDR code) */
                 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
-                nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
+                nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);
                 dprintk("NFS reply setattr (post-create): %d\n", status);
                 if (status != 0)
                         goto out_release_acls;
         }
 
-        status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+        status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
         posix_acl_release(acl);
@@ -570,7 +570,7 @@ nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
         if (status != 0)
                 goto out_release_acls;
 
-        status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+        status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
         posix_acl_release(acl);
@@ -623,7 +623,7 @@ static int
 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                   u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-        struct inode            *dir = dentry->d_inode;
+        struct inode            *dir = d_inode(dentry);
         __be32                  *verf = NFS_I(dir)->cookieverf;
         struct nfs3_readdirargs arg = {
                 .fh             = NFS_FH(dir),
@@ -715,7 +715,7 @@ nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
         if (status != 0)
                 goto out_release_acls;
 
-        status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
+        status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 
 out_release_acls:
         posix_acl_release(acl);
diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c
index cb170722769c..3a9e75235f30 100644
--- a/fs/nfs/nfs42proc.c
+++ b/fs/nfs/nfs42proc.c
@@ -36,13 +36,16 @@ static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
                                  loff_t offset, loff_t len)
 {
         struct inode *inode = file_inode(filep);
+        struct nfs_server *server = NFS_SERVER(inode);
         struct nfs42_falloc_args args = {
                 .falloc_fh      = NFS_FH(inode),
                 .falloc_offset  = offset,
                 .falloc_length  = len,
+                .falloc_bitmask = server->cache_consistency_bitmask,
+        };
+        struct nfs42_falloc_res res = {
+                .falloc_server  = server,
         };
-        struct nfs42_falloc_res res;
-        struct nfs_server *server = NFS_SERVER(inode);
         int status;
 
         msg->rpc_argp = &args;
@@ -52,8 +55,17 @@ static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
         if (status)
                 return status;
 
-        return nfs4_call_sync(server->client, server, msg,
-                              &args.seq_args, &res.seq_res, 0);
+        res.falloc_fattr = nfs_alloc_fattr();
+        if (!res.falloc_fattr)
+                return -ENOMEM;
+
+        status = nfs4_call_sync(server->client, server, msg,
+                                &args.seq_args, &res.seq_res, 0);
+        if (status == 0)
+                status = nfs_post_op_update_inode(inode, res.falloc_fattr);
+
+        kfree(res.falloc_fattr);
+        return status;
 }
 
 static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
@@ -84,9 +96,13 @@ int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
         if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
                 return -EOPNOTSUPP;
 
+        mutex_lock(&inode->i_mutex);
+
         err = nfs42_proc_fallocate(&msg, filep, offset, len);
         if (err == -EOPNOTSUPP)
                 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
+
+        mutex_unlock(&inode->i_mutex);
         return err;
 }
 
@@ -101,9 +117,16 @@ int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
         if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
                 return -EOPNOTSUPP;
 
+        nfs_wb_all(inode);
+        mutex_lock(&inode->i_mutex);
+
         err = nfs42_proc_fallocate(&msg, filep, offset, len);
+        if (err == 0)
+                truncate_pagecache_range(inode, offset, (offset + len) -1);
         if (err == -EOPNOTSUPP)
                 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
+
+        mutex_unlock(&inode->i_mutex);
         return err;
 }
 
diff --git a/fs/nfs/nfs42xdr.c b/fs/nfs/nfs42xdr.c
index 038a7e1521fa..1a25b27248f2 100644
--- a/fs/nfs/nfs42xdr.c
+++ b/fs/nfs/nfs42xdr.c
@@ -25,16 +25,20 @@
 
 #define NFS4_enc_allocate_sz            (compound_encode_hdr_maxsz + \
                                          encode_putfh_maxsz + \
-                                         encode_allocate_maxsz)
+                                         encode_allocate_maxsz + \
+                                         encode_getattr_maxsz)
 #define NFS4_dec_allocate_sz            (compound_decode_hdr_maxsz + \
                                          decode_putfh_maxsz + \
-                                         decode_allocate_maxsz)
+                                         decode_allocate_maxsz + \
+                                         decode_getattr_maxsz)
 #define NFS4_enc_deallocate_sz          (compound_encode_hdr_maxsz + \
                                          encode_putfh_maxsz + \
-                                         encode_deallocate_maxsz)
+                                         encode_deallocate_maxsz + \
+                                         encode_getattr_maxsz)
 #define NFS4_dec_deallocate_sz          (compound_decode_hdr_maxsz + \
                                          decode_putfh_maxsz + \
-                                         decode_deallocate_maxsz)
+                                         decode_deallocate_maxsz + \
+                                         decode_getattr_maxsz)
 #define NFS4_enc_seek_sz                (compound_encode_hdr_maxsz + \
                                          encode_putfh_maxsz + \
                                          encode_seek_maxsz)
@@ -92,6 +96,7 @@ static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
         encode_sequence(xdr, &args->seq_args, &hdr);
         encode_putfh(xdr, args->falloc_fh, &hdr);
         encode_allocate(xdr, args, &hdr);
+        encode_getfattr(xdr, args->falloc_bitmask, &hdr);
         encode_nops(&hdr);
 }
 
@@ -110,6 +115,7 @@ static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
         encode_sequence(xdr, &args->seq_args, &hdr);
         encode_putfh(xdr, args->falloc_fh, &hdr);
         encode_deallocate(xdr, args, &hdr);
+        encode_getfattr(xdr, args->falloc_bitmask, &hdr);
         encode_nops(&hdr);
 }
 
@@ -183,6 +189,9 @@ static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
         if (status)
                 goto out;
         status = decode_allocate(xdr, res);
+        if (status)
+                goto out;
+        decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
 out:
         return status;
 }
@@ -207,6 +216,9 @@ static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
         if (status)
                 goto out;
         status = decode_deallocate(xdr, res);
+        if (status)
+                goto out;
+        decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
 out:
         return status;
 }
diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c
index 86d6214ea022..e42be52a8c18 100644
--- a/fs/nfs/nfs4client.c
+++ b/fs/nfs/nfs4client.c
@@ -4,7 +4,6 @@
  */
 #include <linux/module.h>
 #include <linux/nfs_fs.h>
-#include <linux/nfs_idmap.h>
 #include <linux/nfs_mount.h>
 #include <linux/sunrpc/addr.h>
 #include <linux/sunrpc/auth.h>
@@ -15,6 +14,7 @@
 #include "callback.h"
 #include "delegation.h"
 #include "nfs4session.h"
+#include "nfs4idmap.h"
 #include "pnfs.h"
 #include "netns.h"
 
@@ -1130,7 +1130,7 @@ error:
  */
 static int nfs_probe_destination(struct nfs_server *server)
 {
-        struct inode *inode = server->super->s_root->d_inode;
+        struct inode *inode = d_inode(server->super->s_root);
         struct nfs_fattr *fattr;
         int error;
 
diff --git a/fs/nfs/nfs4file.c b/fs/nfs/nfs4file.c
index 0181cde1d102..f58c17b3b480 100644
--- a/fs/nfs/nfs4file.c
+++ b/fs/nfs/nfs4file.c
@@ -10,6 +10,8 @@
 #include "fscache.h"
 #include "pnfs.h"
 
+#include "nfstrace.h"
+
 #ifdef CONFIG_NFS_V4_2
 #include "nfs42.h"
 #endif
@@ -46,7 +48,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
         openflags &= ~(O_CREAT|O_EXCL);
 
         parent = dget_parent(dentry);
-        dir = parent->d_inode;
+        dir = d_inode(parent);
 
         ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
         err = PTR_ERR(ctx);
@@ -57,7 +59,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
         if (openflags & O_TRUNC) {
                 attr.ia_valid |= ATTR_SIZE;
                 attr.ia_size = 0;
-                nfs_wb_all(inode);
+                nfs_sync_inode(inode);
         }
 
         inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr, &opened);
@@ -74,7 +76,7 @@ nfs4_file_open(struct inode *inode, struct file *filp)
                         goto out_drop;
                 }
         }
-        if (inode != dentry->d_inode)
+        if (inode != d_inode(dentry))
                 goto out_drop;
 
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
@@ -100,6 +102,9 @@ nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         int ret;
         struct inode *inode = file_inode(file);
 
+        trace_nfs_fsync_enter(inode);
+
+        nfs_inode_dio_wait(inode);
         do {
                 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
                 if (ret != 0)
@@ -107,7 +112,7 @@ nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 mutex_lock(&inode->i_mutex);
                 ret = nfs_file_fsync_commit(file, start, end, datasync);
                 if (!ret)
-                        ret = pnfs_layoutcommit_inode(inode, true);
+                        ret = pnfs_sync_inode(inode, !!datasync);
                 mutex_unlock(&inode->i_mutex);
                 /*
                  * If nfs_file_fsync_commit detected a server reboot, then
@@ -118,6 +123,7 @@ nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
                 end = LLONG_MAX;
         } while (ret == -EAGAIN);
 
+        trace_nfs_fsync_exit(inode, ret);
         return ret;
 }
 
@@ -152,15 +158,9 @@ static long nfs42_fallocate(struct file *filep, int mode, loff_t offset, loff_t
         if (ret < 0)
                 return ret;
 
-        mutex_lock(&inode->i_mutex);
         if (mode & FALLOC_FL_PUNCH_HOLE)
-                ret = nfs42_proc_deallocate(filep, offset, len);
-        else
-                ret = nfs42_proc_allocate(filep, offset, len);
-        mutex_unlock(&inode->i_mutex);
-
-        nfs_zap_caches(inode);
-        return ret;
+                return nfs42_proc_deallocate(filep, offset, len);
+        return nfs42_proc_allocate(filep, offset, len);
 }
 #endif /* CONFIG_NFS_V4_2 */
 
diff --git a/fs/nfs/idmap.c b/fs/nfs/nfs4idmap.c
index 857e2a99acc8..2e1737c40a29 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/nfs4idmap.c
@@ -36,7 +36,6 @@
 #include <linux/types.h>
 #include <linux/parser.h>
 #include <linux/fs.h>
-#include <linux/nfs_idmap.h>
 #include <net/net_namespace.h>
 #include <linux/sunrpc/rpc_pipe_fs.h>
 #include <linux/nfs_fs.h>
@@ -49,6 +48,7 @@
 
 #include "internal.h"
 #include "netns.h"
+#include "nfs4idmap.h"
 #include "nfs4trace.h"
 
 #define NFS_UINT_MAXLEN 11
diff --git a/include/linux/nfs_idmap.h b/fs/nfs/nfs4idmap.h
index 333844e38f66..de44d7330ab3 100644
--- a/include/linux/nfs_idmap.h
+++ b/fs/nfs/nfs4idmap.h
@@ -1,5 +1,5 @@
 /*
- * include/linux/nfs_idmap.h
+ * fs/nfs/nfs4idmap.h
  *
  *  UID and GID to name mapping for clients.
  *
@@ -46,19 +46,8 @@ struct nfs_server;
 struct nfs_fattr;
 struct nfs4_string;
 
-#if IS_ENABLED(CONFIG_NFS_V4)
 int nfs_idmap_init(void);
 void nfs_idmap_quit(void);
-#else
-static inline int nfs_idmap_init(void)
-{
-        return 0;
-}
-
-static inline void nfs_idmap_quit(void)
-{}
-#endif
-
 int nfs_idmap_new(struct nfs_client *);
 void nfs_idmap_delete(struct nfs_client *);
 
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 3d83cb1fdc70..f592672373cb 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -375,7 +375,7 @@ static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *
         dprintk("%s: getting locations for %pd2\n",
                 __func__, dentry);
 
-        err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
+        err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);
         dput(parent);
         if (err != 0 ||
             fs_locations->nlocations <= 0 ||
@@ -396,7 +396,7 @@ struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
 {
         rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
         struct dentry *parent = dget_parent(dentry);
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct qstr *name = &dentry->d_name;
         struct rpc_clnt *client;
         struct vfsmount *mnt;
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 627f37c44456..45b35b9b1e36 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -51,7 +51,6 @@
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/module.h>
-#include <linux/nfs_idmap.h>
 #include <linux/xattr.h>
 #include <linux/utsname.h>
 #include <linux/freezer.h>
@@ -63,6 +62,7 @@
 #include "callback.h"
 #include "pnfs.h"
 #include "netns.h"
+#include "nfs4idmap.h"
 #include "nfs4session.h"
 #include "fscache.h"
 
@@ -185,7 +185,8 @@ const u32 nfs4_fattr_bitmap[3] = {
         | FATTR4_WORD1_SPACE_USED
         | FATTR4_WORD1_TIME_ACCESS
         | FATTR4_WORD1_TIME_METADATA
-        | FATTR4_WORD1_TIME_MODIFY,
+        | FATTR4_WORD1_TIME_MODIFY
+        | FATTR4_WORD1_MOUNTED_ON_FILEID,
 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
         FATTR4_WORD2_SECURITY_LABEL
 #endif
@@ -293,7 +294,7 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent
                 *p++ = xdr_one;                         /* bitmap length */
                 *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
                 *p++ = htonl(8);              /* attribute buffer length */
-                p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
+                p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
         }
         
         *p++ = xdr_one;                                  /* next */
@@ -305,7 +306,7 @@ static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dent
         *p++ = xdr_one;                         /* bitmap length */
         *p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
         *p++ = htonl(8);              /* attribute buffer length */
-        p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
+        p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
 
         readdir->pgbase = (char *)p - (char *)start;
         readdir->count -= readdir->pgbase;
@@ -1004,7 +1005,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
                 gfp_t gfp_mask)
 {
         struct dentry *parent = dget_parent(dentry);
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
         struct nfs4_opendata *p;
@@ -1057,7 +1058,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         case NFS4_OPEN_CLAIM_FH:
         case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
         case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
-                p->o_arg.fh = NFS_FH(dentry->d_inode);
+                p->o_arg.fh = NFS_FH(d_inode(dentry));
         }
         if (attrs != NULL && attrs->ia_valid != 0) {
                 __u32 verf[2];
@@ -1794,7 +1795,7 @@ static const struct rpc_call_ops nfs4_open_confirm_ops = {
  */
 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
 {
-        struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
+        struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
         struct rpc_task *task;
         struct  rpc_message msg = {
                 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
@@ -1951,7 +1952,7 @@ static const struct rpc_call_ops nfs4_open_ops = {
 
 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
 {
-        struct inode *dir = data->dir->d_inode;
+        struct inode *dir = d_inode(data->dir);
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs_openargs *o_arg = &data->o_arg;
         struct nfs_openres *o_res = &data->o_res;
@@ -1998,7 +1999,7 @@ static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
 
 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
 {
-        struct inode *dir = data->dir->d_inode;
+        struct inode *dir = d_inode(data->dir);
         struct nfs_openres *o_res = &data->o_res;
         int status;
 
@@ -2067,7 +2068,7 @@ static int nfs4_opendata_access(struct rpc_cred *cred,
  */
 static int _nfs4_proc_open(struct nfs4_opendata *data)
 {
-        struct inode *dir = data->dir->d_inode;
+        struct inode *dir = d_inode(data->dir);
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs_openargs *o_arg = &data->o_arg;
         struct nfs_openres *o_res = &data->o_res;
@@ -2314,7 +2315,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
 
         dentry = opendata->dentry;
-        if (dentry->d_inode == NULL) {
+        if (d_really_is_negative(dentry)) {
                 /* FIXME: Is this d_drop() ever needed? */
                 d_drop(dentry);
                 dentry = d_add_unique(dentry, igrab(state->inode));
@@ -2325,7 +2326,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                         ctx->dentry = dget(dentry);
                 }
                 nfs_set_verifier(dentry,
-                                nfs_save_change_attribute(opendata->dir->d_inode));
+                                nfs_save_change_attribute(d_inode(opendata->dir)));
         }
 
         ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
@@ -2333,7 +2334,7 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
                 goto out;
 
         ctx->state = state;
-        if (dentry->d_inode == state->inode) {
+        if (d_inode(dentry) == state->inode) {
                 nfs_inode_attach_open_context(ctx);
                 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
                         nfs4_schedule_stateid_recovery(server, state);
@@ -2374,10 +2375,10 @@ static int _nfs4_do_open(struct inode *dir,
         status = nfs4_recover_expired_lease(server);
         if (status != 0)
                 goto err_put_state_owner;
-        if (dentry->d_inode != NULL)
-                nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
+        if (d_really_is_positive(dentry))
+                nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
         status = -ENOMEM;
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 claim = NFS4_OPEN_CLAIM_FH;
         opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
                         label, claim, GFP_KERNEL);
@@ -2400,8 +2401,8 @@ static int _nfs4_do_open(struct inode *dir,
                 }
                 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
         }
-        if (dentry->d_inode != NULL)
-                opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
+        if (d_really_is_positive(dentry))
+                opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
 
         status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
         if (status != 0)
@@ -3095,16 +3096,13 @@ int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
                          struct nfs_fsinfo *info,
                          bool auth_probe)
 {
-        int status;
+        int status = 0;
 
-        switch (auth_probe) {
-        case false:
+        if (!auth_probe)
                 status = nfs4_lookup_root(server, fhandle, info);
-                if (status != -NFS4ERR_WRONGSEC)
-                        break;
-        default:
+
+        if (auth_probe || status == NFS4ERR_WRONGSEC)
                 status = nfs4_do_find_root_sec(server, fhandle, info);
-        }
 
         if (status == 0)
                 status = nfs4_server_capabilities(server, fhandle);
@@ -3254,7 +3252,7 @@ static int
 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                   struct iattr *sattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct rpc_cred *cred = NULL;
         struct nfs4_state *state = NULL;
         struct nfs4_label *label = NULL;
@@ -3871,13 +3869,13 @@ static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                 u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-        struct inode            *dir = dentry->d_inode;
+        struct inode            *dir = d_inode(dentry);
         struct nfs4_readdir_arg args = {
                 .fh = NFS_FH(dir),
                 .pages = pages,
                 .pgbase = 0,
                 .count = count,
-                .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
+                .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
                 .plus = plus,
         };
         struct nfs4_readdir_res res;
@@ -3914,8 +3912,8 @@ static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
         do {
                 err = _nfs4_proc_readdir(dentry, cred, cookie,
                                 pages, count, plus);
-                trace_nfs4_readdir(dentry->d_inode, err);
-                err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err,
+                trace_nfs4_readdir(d_inode(dentry), err);
+                err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
                                 &exception);
         } while (exception.retry);
         return err;
@@ -4830,7 +4828,7 @@ nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
         struct nfs4_label ilabel, *olabel = NULL;
         struct nfs_fattr fattr;
         struct rpc_cred *cred;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int status;
 
         if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
@@ -5670,7 +5668,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
         data->rpc_status = task->tk_status;
         switch (task->tk_status) {
         case 0:
-                renew_lease(NFS_SERVER(data->ctx->dentry->d_inode),
+                renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
                                 data->timestamp);
                 if (data->arg.new_lock) {
                         data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
@@ -6112,7 +6110,7 @@ static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
         if (strcmp(key, "") != 0)
                 return -EINVAL;
 
-        return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
+        return nfs4_proc_set_acl(d_inode(dentry), buf, buflen);
 }
 
 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
@@ -6121,7 +6119,7 @@ static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
         if (strcmp(key, "") != 0)
                 return -EINVAL;
 
-        return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
+        return nfs4_proc_get_acl(d_inode(dentry), buf, buflen);
 }
 
 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
@@ -6130,7 +6128,7 @@ static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
 {
         size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
 
-        if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
+        if (!nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry))))
                 return 0;
 
         if (list && len <= list_len)
@@ -6158,7 +6156,7 @@ static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key,
                                    void *buf, size_t buflen, int type)
 {
         if (security_ismaclabel(key))
-                return nfs4_get_security_label(dentry->d_inode, buf, buflen);
+                return nfs4_get_security_label(d_inode(dentry), buf, buflen);
         return -EOPNOTSUPP;
 }
 
@@ -6168,10 +6166,10 @@ static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list,
 {
         size_t len = 0;
 
-        if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) {
-                len = security_inode_listsecurity(dentry->d_inode, NULL, 0);
+        if (nfs_server_capable(d_inode(dentry), NFS_CAP_SECURITY_LABEL)) {
+                len = security_inode_listsecurity(d_inode(dentry), NULL, 0);
                 if (list && len <= list_len)
-                        security_inode_listsecurity(dentry->d_inode, list, len);
+                        security_inode_listsecurity(d_inode(dentry), list, len);
         }
         return len;
 }
@@ -7944,6 +7942,8 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server,
 {
         struct nfs4_getdeviceinfo_args args = {
                 .pdev = pdev,
+                .notify_types = NOTIFY_DEVICEID4_CHANGE |
+                        NOTIFY_DEVICEID4_DELETE,
         };
         struct nfs4_getdeviceinfo_res res = {
                 .pdev = pdev,
@@ -7958,6 +7958,11 @@ _nfs4_proc_getdeviceinfo(struct nfs_server *server,
 
         dprintk("--> %s\n", __func__);
         status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
+        if (res.notification & ~args.notify_types)
+                dprintk("%s: unsupported notification\n", __func__);
+        if (res.notification != args.notify_types)
+                pdev->nocache = 1;
+
         dprintk("<-- %s status=%d\n", __func__, status);
 
         return status;
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index f95e3b58bbc3..2782cfca2265 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -42,7 +42,6 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/nfs_fs.h>
-#include <linux/nfs_idmap.h>
 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/random.h>
@@ -57,6 +56,7 @@
 #include "callback.h"
 #include "delegation.h"
 #include "internal.h"
+#include "nfs4idmap.h"
 #include "nfs4session.h"
 #include "pnfs.h"
 #include "netns.h"
@@ -1902,7 +1902,7 @@ static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
                 goto out;
         }
 
-        inode = server->super->s_root->d_inode;
+        inode = d_inode(server->super->s_root);
         result = nfs4_proc_get_locations(inode, locations, page, cred);
         if (result) {
                 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
@@ -2021,7 +2021,7 @@ restart:
 
                 rcu_read_unlock();
 
-                inode = server->super->s_root->d_inode;
+                inode = d_inode(server->super->s_root);
                 status = nfs4_proc_fsid_present(inode, cred);
                 if (status != -NFS4ERR_MOVED)
                         goto restart;   /* wasn't this one */
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 75090feeafad..6fb7cb6b3f4b 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -3,12 +3,12 @@
  */
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/nfs_idmap.h>
 #include <linux/nfs4_mount.h>
 #include <linux/nfs_fs.h>
 #include "delegation.h"
 #include "internal.h"
 #include "nfs4_fs.h"
+#include "nfs4idmap.h"
 #include "dns_resolve.h"
 #include "pnfs.h"
 #include "nfs.h"
@@ -91,10 +91,11 @@ static void nfs4_evict_inode(struct inode *inode)
 {
         truncate_inode_pages_final(&inode->i_data);
         clear_inode(inode);
-        pnfs_return_layout(inode);
-        pnfs_destroy_layout(NFS_I(inode));
         /* If we are holding a delegation, return it! */
         nfs_inode_return_delegation_noreclaim(inode);
+        /* Note that above delegreturn would trigger pnfs return-on-close */
+        pnfs_return_layout(inode);
+        pnfs_destroy_layout(NFS_I(inode));
         /* First call standard NFS clear_inode() code */
         nfs_clear_inode(inode);
 }
diff --git a/fs/nfs/nfs4sysctl.c b/fs/nfs/nfs4sysctl.c
index b6ebe7e445f6..0fbd3ab1be22 100644
--- a/fs/nfs/nfs4sysctl.c
+++ b/fs/nfs/nfs4sysctl.c
@@ -6,10 +6,10 @@
  * Copyright (c) 2006 Trond Myklebust <Trond.Myklebust@netapp.com>
  */
 #include <linux/sysctl.h>
-#include <linux/nfs_idmap.h>
 #include <linux/nfs_fs.h>
 
 #include "nfs4_fs.h"
+#include "nfs4idmap.h"
 #include "callback.h"
 
 static const int nfs_set_port_min = 0;
diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h
index 1c32adbe728d..470af1a78bec 100644
--- a/fs/nfs/nfs4trace.h
+++ b/fs/nfs/nfs4trace.h
@@ -418,7 +418,7 @@ DECLARE_EVENT_CLASS(nfs4_open_event,
                                 __entry->fileid = 0;
                                 __entry->fhandle = 0;
                         }
-                        __entry->dir = NFS_FILEID(ctx->dentry->d_parent->d_inode);
+                        __entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
                         __assign_str(name, ctx->dentry->d_name.name);
                 ),
 
@@ -1110,7 +1110,7 @@ TRACE_EVENT(nfs4_layoutget,
                 ),
 
                 TP_fast_assign(
-                        const struct inode *inode = ctx->dentry->d_inode;
+                        const struct inode *inode = d_inode(ctx->dentry);
                         __entry->dev = inode->i_sb->s_dev;
                         __entry->fileid = NFS_FILEID(inode);
                         __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 5c399ec41079..0aea97841d30 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -52,10 +52,10 @@
 #include <linux/nfs.h>
 #include <linux/nfs4.h>
 #include <linux/nfs_fs.h>
-#include <linux/nfs_idmap.h>
 
 #include "nfs4_fs.h"
 #include "internal.h"
+#include "nfs4idmap.h"
 #include "nfs4session.h"
 #include "pnfs.h"
 #include "netns.h"
@@ -1920,7 +1920,7 @@ encode_getdeviceinfo(struct xdr_stream *xdr,
 
         p = reserve_space(xdr, 4 + 4);
         *p++ = cpu_to_be32(1);                  /* bitmap length */
-        *p++ = cpu_to_be32(NOTIFY_DEVICEID4_CHANGE | NOTIFY_DEVICEID4_DELETE);
+        *p++ = cpu_to_be32(args->notify_types);
 }
 
 static void
@@ -5753,8 +5753,9 @@ out_overflow:
 
 #if defined(CONFIG_NFS_V4_1)
 static int decode_getdeviceinfo(struct xdr_stream *xdr,
-                                struct pnfs_device *pdev)
+                                struct nfs4_getdeviceinfo_res *res)
 {
+        struct pnfs_device *pdev = res->pdev;
         __be32 *p;
         uint32_t len, type;
         int status;
@@ -5802,12 +5803,7 @@ static int decode_getdeviceinfo(struct xdr_stream *xdr,
                 if (unlikely(!p))
                         goto out_overflow;
 
-                if (be32_to_cpup(p++) &
-                    ~(NOTIFY_DEVICEID4_CHANGE | NOTIFY_DEVICEID4_DELETE)) {
-                        dprintk("%s: unsupported notification\n",
-                                __func__);
-                }
-
+                res->notification = be32_to_cpup(p++);
                 for (i = 1; i < len; i++) {
                         if (be32_to_cpup(p++)) {
                                 dprintk("%s: unsupported notification\n",
@@ -7061,7 +7057,7 @@ static int nfs4_xdr_dec_getdeviceinfo(struct rpc_rqst *rqstp,
         status = decode_sequence(xdr, &res->seq_res, rqstp);
         if (status != 0)
                 goto out;
-        status = decode_getdeviceinfo(xdr, res->pdev);
+        status = decode_getdeviceinfo(xdr, res);
 out:
         return status;
 }
@@ -7365,6 +7361,11 @@ nfs4_stat_to_errno(int stat)
         .p_name   = #proc,                                      \
 }
 
+#define STUB(proc)              \
+[NFSPROC4_CLNT_##proc] = {      \
+        .p_name = #proc,        \
+}
+
 struct rpc_procinfo     nfs4_procedures[] = {
         PROC(READ,              enc_read,               dec_read),
         PROC(WRITE,             enc_write,              dec_write),
@@ -7417,6 +7418,7 @@ struct rpc_procinfo	nfs4_procedures[] = {
         PROC(SECINFO_NO_NAME,   enc_secinfo_no_name,    dec_secinfo_no_name),
         PROC(TEST_STATEID,      enc_test_stateid,       dec_test_stateid),
         PROC(FREE_STATEID,      enc_free_stateid,       dec_free_stateid),
+        STUB(GETDEVICELIST),
         PROC(BIND_CONN_TO_SESSION,
                         enc_bind_conn_to_session, dec_bind_conn_to_session),
         PROC(DESTROY_CLIENTID,  enc_destroy_clientid,   dec_destroy_clientid),
diff --git a/fs/nfs/nfstrace.c b/fs/nfs/nfstrace.c
index 4eb0aead69b6..c74f7af23d77 100644
--- a/fs/nfs/nfstrace.c
+++ b/fs/nfs/nfstrace.c
@@ -7,3 +7,6 @@
 
 #define CREATE_TRACE_POINTS
 #include "nfstrace.h"
+
+EXPORT_TRACEPOINT_SYMBOL_GPL(nfs_fsync_enter);
+EXPORT_TRACEPOINT_SYMBOL_GPL(nfs_fsync_exit);
diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
index 24e1d7403c0b..5aaed363556a 100644
--- a/fs/nfs/objlayout/objio_osd.c
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -57,7 +57,7 @@ objio_free_deviceid_node(struct nfs4_deviceid_node *d)
 
         dprintk("%s: free od=%p\n", __func__, de->od.od);
         osduld_put_device(de->od.od);
-        kfree(de);
+        kfree_rcu(d, rcu);
 }
 
 struct objio_segment {
@@ -637,6 +637,8 @@ static struct pnfs_layoutdriver_type objlayout_type = {
         .pg_read_ops             = &objio_pg_read_ops,
         .pg_write_ops            = &objio_pg_write_ops,
 
+        .sync                    = pnfs_generic_sync,
+
         .free_deviceid_node      = objio_free_deviceid_node,
 
         .encode_layoutcommit     = objlayout_encode_layoutcommit,
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index d57190a0d533..282b39369510 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -938,7 +938,7 @@ static bool nfs_can_coalesce_requests(struct nfs_page *prev,
         if (prev) {
                 if (!nfs_match_open_context(req->wb_context, prev->wb_context))
                         return false;
-                flctx = req->wb_context->dentry->d_inode->i_flctx;
+                flctx = d_inode(req->wb_context->dentry)->i_flctx;
                 if (flctx != NULL &&
                     !(list_empty_careful(&flctx->flc_posix) &&
                       list_empty_careful(&flctx->flc_flock)) &&
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 4f802b02fbb9..230606243be6 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -1090,6 +1090,7 @@ bool pnfs_roc(struct inode *ino)
         pnfs_get_layout_hdr(lo); /* matched in pnfs_roc_release */
         spin_unlock(&ino->i_lock);
         pnfs_free_lseg_list(&tmp_list);
+        pnfs_layoutcommit_inode(ino, true);
         return true;
 
 out_noroc:
@@ -1104,8 +1105,10 @@ out_noroc:
                 }
         }
         spin_unlock(&ino->i_lock);
-        if (layoutreturn)
+        if (layoutreturn) {
+                pnfs_layoutcommit_inode(ino, true);
                 pnfs_send_layoutreturn(lo, stateid, IOMODE_ANY, true);
+        }
         return false;
 }
 
@@ -1841,7 +1844,8 @@ void pnfs_ld_write_done(struct nfs_pgio_header *hdr)
 {
         trace_nfs4_pnfs_write(hdr, hdr->pnfs_error);
         if (!hdr->pnfs_error) {
-                pnfs_set_layoutcommit(hdr);
+                pnfs_set_layoutcommit(hdr->inode, hdr->lseg,
+                                hdr->mds_offset + hdr->res.count);
                 hdr->mds_ops->rpc_call_done(&hdr->task, hdr);
         } else
                 pnfs_ld_handle_write_error(hdr);
@@ -1902,7 +1906,6 @@ static void pnfs_writehdr_free(struct nfs_pgio_header *hdr)
         pnfs_put_lseg(hdr->lseg);
         nfs_pgio_header_free(hdr);
 }
-EXPORT_SYMBOL_GPL(pnfs_writehdr_free);
 
 int
 pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc)
@@ -2032,7 +2035,6 @@ static void pnfs_readhdr_free(struct nfs_pgio_header *hdr)
         pnfs_put_lseg(hdr->lseg);
         nfs_pgio_header_free(hdr);
 }
-EXPORT_SYMBOL_GPL(pnfs_readhdr_free);
 
 int
 pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc)
@@ -2099,64 +2101,34 @@ void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg)
 EXPORT_SYMBOL_GPL(pnfs_set_lo_fail);
 
 void
-pnfs_set_layoutcommit(struct nfs_pgio_header *hdr)
+pnfs_set_layoutcommit(struct inode *inode, struct pnfs_layout_segment *lseg,
+                loff_t end_pos)
 {
-        struct inode *inode = hdr->inode;
         struct nfs_inode *nfsi = NFS_I(inode);
-        loff_t end_pos = hdr->mds_offset + hdr->res.count;
         bool mark_as_dirty = false;
 
         spin_lock(&inode->i_lock);
         if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
-                mark_as_dirty = true;
-                dprintk("%s: Set layoutcommit for inode %lu ",
-                        __func__, inode->i_ino);
-        }
-        if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &hdr->lseg->pls_flags)) {
-                /* references matched in nfs4_layoutcommit_release */
-                pnfs_get_lseg(hdr->lseg);
-        }
-        if (end_pos > nfsi->layout->plh_lwb)
                 nfsi->layout->plh_lwb = end_pos;
-        spin_unlock(&inode->i_lock);
-        dprintk("%s: lseg %p end_pos %llu\n",
-                __func__, hdr->lseg, nfsi->layout->plh_lwb);
-
-        /* if pnfs_layoutcommit_inode() runs between inode locks, the next one
-         * will be a noop because NFS_INO_LAYOUTCOMMIT will not be set */
-        if (mark_as_dirty)
-                mark_inode_dirty_sync(inode);
-}
-EXPORT_SYMBOL_GPL(pnfs_set_layoutcommit);
-
-void pnfs_commit_set_layoutcommit(struct nfs_commit_data *data)
-{
-        struct inode *inode = data->inode;
-        struct nfs_inode *nfsi = NFS_I(inode);
-        bool mark_as_dirty = false;
-
-        spin_lock(&inode->i_lock);
-        if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
                 mark_as_dirty = true;
                 dprintk("%s: Set layoutcommit for inode %lu ",
                         __func__, inode->i_ino);
-        }
-        if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &data->lseg->pls_flags)) {
+        } else if (end_pos > nfsi->layout->plh_lwb)
+                nfsi->layout->plh_lwb = end_pos;
+        if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags)) {
                 /* references matched in nfs4_layoutcommit_release */
-                pnfs_get_lseg(data->lseg);
+                pnfs_get_lseg(lseg);
         }
-        if (data->lwb > nfsi->layout->plh_lwb)
-                nfsi->layout->plh_lwb = data->lwb;
         spin_unlock(&inode->i_lock);
         dprintk("%s: lseg %p end_pos %llu\n",
-                __func__, data->lseg, nfsi->layout->plh_lwb);
+                __func__, lseg, nfsi->layout->plh_lwb);
 
         /* if pnfs_layoutcommit_inode() runs between inode locks, the next one
          * will be a noop because NFS_INO_LAYOUTCOMMIT will not be set */
         if (mark_as_dirty)
                 mark_inode_dirty_sync(inode);
 }
-EXPORT_SYMBOL_GPL(pnfs_commit_set_layoutcommit);
+EXPORT_SYMBOL_GPL(pnfs_set_layoutcommit);
 
 void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data)
 {
@@ -2216,7 +2188,6 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
         pnfs_list_write_lseg(inode, &data->lseg_list);
 
         end_pos = nfsi->layout->plh_lwb;
-        nfsi->layout->plh_lwb = 0;
 
         nfs4_stateid_copy(&data->args.stateid, &nfsi->layout->plh_stateid);
         spin_unlock(&inode->i_lock);
@@ -2233,11 +2204,11 @@ pnfs_layoutcommit_inode(struct inode *inode, bool sync)
                 status = ld->prepare_layoutcommit(&data->args);
                 if (status) {
                         spin_lock(&inode->i_lock);
-                        if (end_pos < nfsi->layout->plh_lwb)
+                        set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags);
+                        if (end_pos > nfsi->layout->plh_lwb)
                                 nfsi->layout->plh_lwb = end_pos;
                         spin_unlock(&inode->i_lock);
                         put_rpccred(data->cred);
-                        set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags);
                         goto clear_layoutcommitting;
                 }
         }
@@ -2258,6 +2229,13 @@ clear_layoutcommitting:
 }
 EXPORT_SYMBOL_GPL(pnfs_layoutcommit_inode);
 
+int
+pnfs_generic_sync(struct inode *inode, bool datasync)
+{
+        return pnfs_layoutcommit_inode(inode, true);
+}
+EXPORT_SYMBOL_GPL(pnfs_generic_sync);
+
 struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
 {
         struct nfs4_threshold *thp;
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index 635f0865671c..1e6308f82fc3 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -155,6 +155,8 @@ struct pnfs_layoutdriver_type {
                                int how,
                                struct nfs_commit_info *cinfo);
 
+        int (*sync)(struct inode *inode, bool datasync);
+
         /*
          * Return PNFS_ATTEMPTED to indicate the layout code has attempted
          * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
@@ -203,6 +205,7 @@ struct pnfs_device {
         struct page **pages;
         unsigned int  pgbase;
         unsigned int  pglen;    /* reply buffer length */
+        unsigned char nocache : 1;/* May not be cached */
 };
 
 #define NFS4_PNFS_GETDEVLIST_MAXNUM 16
@@ -263,10 +266,11 @@ bool pnfs_roc(struct inode *ino);
 void pnfs_roc_release(struct inode *ino);
 void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
 bool pnfs_roc_drain(struct inode *ino, u32 *barrier, struct rpc_task *task);
-void pnfs_set_layoutcommit(struct nfs_pgio_header *);
-void pnfs_commit_set_layoutcommit(struct nfs_commit_data *data);
+void pnfs_set_layoutcommit(struct inode *, struct pnfs_layout_segment *, loff_t);
 void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data);
 int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
+int pnfs_generic_sync(struct inode *inode, bool datasync);
+int pnfs_nfs_generic_sync(struct inode *inode, bool datasync);
 int _pnfs_return_layout(struct inode *);
 int pnfs_commit_and_return_layout(struct inode *);
 void pnfs_ld_write_done(struct nfs_pgio_header *);
@@ -291,6 +295,7 @@ void pnfs_error_mark_layout_for_return(struct inode *inode,
 enum {
         NFS_DEVICEID_INVALID = 0,       /* set when MDS clientid recalled */
         NFS_DEVICEID_UNAVAILABLE,       /* device temporarily unavailable */
+        NFS_DEVICEID_NOCACHE,           /* device may not be cached */
 };
 
 /* pnfs_dev.c */
@@ -302,6 +307,7 @@ struct nfs4_deviceid_node {
         unsigned long                   flags;
         unsigned long                   timestamp_unavailable;
         struct nfs4_deviceid            deviceid;
+        struct rcu_head                 rcu;
         atomic_t                        ref;
 };
 
@@ -426,7 +432,7 @@ static inline bool
 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
                          struct nfs_commit_info *cinfo, u32 ds_commit_idx)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = d_inode(req->wb_context->dentry);
         struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
         if (lseg == NULL || ld->mark_request_commit == NULL)
@@ -438,7 +444,7 @@ pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
 static inline bool
 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = d_inode(req->wb_context->dentry);
         struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
 
         if (ld == NULL || ld->clear_request_commit == NULL)
@@ -486,6 +492,14 @@ pnfs_ld_read_whole_page(struct inode *inode)
         return NFS_SERVER(inode)->pnfs_curr_ld->flags & PNFS_READ_WHOLE_PAGE;
 }
 
+static inline int
+pnfs_sync_inode(struct inode *inode, bool datasync)
+{
+        if (!pnfs_enabled_sb(NFS_SERVER(inode)))
+                return 0;
+        return NFS_SERVER(inode)->pnfs_curr_ld->sync(inode, datasync);
+}
+
 static inline bool
 pnfs_layoutcommit_outstanding(struct inode *inode)
 {
@@ -568,6 +582,12 @@ pnfs_ld_read_whole_page(struct inode *inode)
         return false;
 }
 
+static inline int
+pnfs_sync_inode(struct inode *inode, bool datasync)
+{
+        return 0;
+}
+
 static inline bool
 pnfs_roc(struct inode *ino)
 {
diff --git a/fs/nfs/pnfs_dev.c b/fs/nfs/pnfs_dev.c
index aa2ec0015183..2961fcd7a2df 100644
--- a/fs/nfs/pnfs_dev.c
+++ b/fs/nfs/pnfs_dev.c
@@ -149,6 +149,8 @@ nfs4_get_device_info(struct nfs_server *server,
          */
         d = server->pnfs_curr_ld->alloc_deviceid_node(server, pdev,
                         gfp_flags);
+        if (d && pdev->nocache)
+                set_bit(NFS_DEVICEID_NOCACHE, &d->flags);
 
 out_free_pages:
         for (i = 0; i < max_pages; i++)
@@ -175,8 +177,8 @@ __nfs4_find_get_deviceid(struct nfs_server *server,
         rcu_read_lock();
         d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
                         hash);
-        if (d != NULL)
-                atomic_inc(&d->ref);
+        if (d != NULL && !atomic_inc_not_zero(&d->ref))
+                d = NULL;
         rcu_read_unlock();
         return d;
 }
@@ -235,12 +237,11 @@ nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
                 return;
         }
         hlist_del_init_rcu(&d->node);
+        clear_bit(NFS_DEVICEID_NOCACHE, &d->flags);
         spin_unlock(&nfs4_deviceid_lock);
-        synchronize_rcu();
 
         /* balance the initial ref set in pnfs_insert_deviceid */
-        if (atomic_dec_and_test(&d->ref))
-                d->ld->free_deviceid_node(d);
+        nfs4_put_deviceid_node(d);
 }
 EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
 
@@ -271,6 +272,11 @@ EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
 bool
 nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
 {
+        if (test_bit(NFS_DEVICEID_NOCACHE, &d->flags)) {
+                if (atomic_add_unless(&d->ref, -1, 2))
+                        return false;
+                nfs4_delete_deviceid(d->ld, d->nfs_client, &d->deviceid);
+        }
         if (!atomic_dec_and_test(&d->ref))
                 return false;
         d->ld->free_deviceid_node(d);
@@ -314,6 +320,7 @@ _deviceid_purge_client(const struct nfs_client *clp, long hash)
                 if (d->nfs_client == clp && atomic_read(&d->ref)) {
                         hlist_del_init_rcu(&d->node);
                         hlist_add_head(&d->tmpnode, &tmp);
+                        clear_bit(NFS_DEVICEID_NOCACHE, &d->flags);
                 }
         rcu_read_unlock();
         spin_unlock(&nfs4_deviceid_lock);
@@ -321,12 +328,10 @@ _deviceid_purge_client(const struct nfs_client *clp, long hash)
         if (hlist_empty(&tmp))
                 return;
 
-        synchronize_rcu();
         while (!hlist_empty(&tmp)) {
                 d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
                 hlist_del(&d->tmpnode);
-                if (atomic_dec_and_test(&d->ref))
-                        d->ld->free_deviceid_node(d);
+                nfs4_put_deviceid_node(d);
         }
 }
 
diff --git a/fs/nfs/pnfs_nfs.c b/fs/nfs/pnfs_nfs.c
index 54e36b38fb5f..f37e25b6311c 100644
--- a/fs/nfs/pnfs_nfs.c
+++ b/fs/nfs/pnfs_nfs.c
@@ -561,7 +561,7 @@ static bool load_v3_ds_connect(void)
         return(get_v3_ds_connect != NULL);
 }
 
-void __exit nfs4_pnfs_v3_ds_connect_unload(void)
+void nfs4_pnfs_v3_ds_connect_unload(void)
 {
         if (get_v3_ds_connect) {
                 symbol_put(nfs3_set_ds_client);
@@ -868,3 +868,13 @@ pnfs_layout_mark_request_commit(struct nfs_page *req,
         nfs_request_add_commit_list(req, list, cinfo);
 }
 EXPORT_SYMBOL_GPL(pnfs_layout_mark_request_commit);
+
+int
+pnfs_nfs_generic_sync(struct inode *inode, bool datasync)
+{
+        if (datasync)
+                return 0;
+        return pnfs_layoutcommit_inode(inode, true);
+}
+EXPORT_SYMBOL_GPL(pnfs_nfs_generic_sync);
+
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index c63189acd052..b417bbcd9704 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -118,7 +118,7 @@ static int
 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                  struct iattr *sattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct nfs_sattrargs    arg = { 
                 .fh     = NFS_FH(inode),
                 .sattr  = sattr
@@ -487,7 +487,7 @@ static int
 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
                  u64 cookie, struct page **pages, unsigned int count, int plus)
 {
-        struct inode            *dir = dentry->d_inode;
+        struct inode            *dir = d_inode(dentry);
         struct nfs_readdirargs  arg = {
                 .fh             = NFS_FH(dir),
                 .cookie         = cookie,
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index b8f5c63f77b2..ae0ff7a11b40 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -117,7 +117,7 @@ int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
 
 static void nfs_readpage_release(struct nfs_page *req)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = d_inode(req->wb_context->dentry);
 
         dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id,
                 (unsigned long long)NFS_FILEID(inode), req->wb_bytes,
@@ -284,7 +284,7 @@ int nfs_readpage(struct file *file, struct page *page)
         dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",
                 page, PAGE_CACHE_SIZE, page_file_index(page));
         nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);
-        nfs_inc_stats(inode, NFSIOS_READPAGES);
+        nfs_add_stats(inode, NFSIOS_READPAGES, 1);
 
         /*
          * Try to flush any pending writes to the file..
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 322b2de02988..f175b833b6ba 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -43,7 +43,6 @@
 #include <linux/seq_file.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
-#include <linux/nfs_idmap.h>
 #include <linux/vfs.h>
 #include <linux/inet.h>
 #include <linux/in6.h>
@@ -433,7 +432,7 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
         struct nfs_server *server = NFS_SB(dentry->d_sb);
         unsigned char blockbits;
         unsigned long blockres;
-        struct nfs_fh *fh = NFS_FH(dentry->d_inode);
+        struct nfs_fh *fh = NFS_FH(d_inode(dentry));
         struct nfs_fsstat res;
         int error = -ENOMEM;
 
@@ -447,7 +446,7 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 
                 pd_dentry = dget_parent(dentry);
                 if (pd_dentry != NULL) {
-                        nfs_zap_caches(pd_dentry->d_inode);
+                        nfs_zap_caches(d_inode(pd_dentry));
                         dput(pd_dentry);
                 }
         }
@@ -2193,7 +2192,7 @@ nfs_compare_remount_data(struct nfs_server *nfss,
             data->version != nfss->nfs_client->rpc_ops->version ||
             data->minorversion != nfss->nfs_client->cl_minorversion ||
             data->retrans != nfss->client->cl_timeout->to_retries ||
-            data->selected_flavor != nfss->client->cl_auth->au_flavor ||
+            !nfs_auth_info_match(&data->auth_info, nfss->client->cl_auth->au_flavor) ||
             data->acregmin != nfss->acregmin / HZ ||
             data->acregmax != nfss->acregmax / HZ ||
             data->acdirmin != nfss->acdirmin / HZ ||
@@ -2241,7 +2240,6 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
         data->wsize = nfss->wsize;
         data->retrans = nfss->client->cl_timeout->to_retries;
         data->selected_flavor = nfss->client->cl_auth->au_flavor;
-        data->auth_info = nfss->auth_info;
         data->acregmin = nfss->acregmin / HZ;
         data->acregmax = nfss->acregmax / HZ;
         data->acdirmin = nfss->acdirmin / HZ;
@@ -2526,7 +2524,7 @@ int nfs_clone_sb_security(struct super_block *s, struct dentry *mntroot,
                           struct nfs_mount_info *mount_info)
 {
         /* clone any lsm security options from the parent to the new sb */
-        if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
+        if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops)
                 return -ESTALE;
         return security_sb_clone_mnt_opts(mount_info->cloned->sb, s);
 }
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index 05c9e02f4153..2d56200655fe 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -45,7 +45,7 @@ error:
 
 static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct page *page;
         void *err;
 
diff --git a/fs/nfs/unlink.c b/fs/nfs/unlink.c
index de54129336c6..fa538b2ba251 100644
--- a/fs/nfs/unlink.c
+++ b/fs/nfs/unlink.c
@@ -143,7 +143,7 @@ static int nfs_do_call_unlink(struct dentry *parent, struct inode *dir, struct n
                 nfs_free_dname(data);
                 ret = nfs_copy_dname(alias, data);
                 spin_lock(&alias->d_lock);
-                if (ret == 0 && alias->d_inode != NULL &&
+                if (ret == 0 && d_really_is_positive(alias) &&
                     !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
                         devname_garbage = alias->d_fsdata;
                         alias->d_fsdata = data;
@@ -190,7 +190,7 @@ static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data)
         parent = dget_parent(dentry);
         if (parent == NULL)
                 goto out_free;
-        dir = parent->d_inode;
+        dir = d_inode(parent);
         /* Non-exclusive lock protects against concurrent lookup() calls */
         spin_lock(&dir->i_lock);
         if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) {
@@ -210,21 +210,21 @@ out_free:
 
 void nfs_wait_on_sillyrename(struct dentry *dentry)
 {
-        struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
+        struct nfs_inode *nfsi = NFS_I(d_inode(dentry));
 
         wait_event(nfsi->waitqueue, atomic_read(&nfsi->silly_count) <= 1);
 }
 
 void nfs_block_sillyrename(struct dentry *dentry)
 {
-        struct nfs_inode *nfsi = NFS_I(dentry->d_inode);
+        struct nfs_inode *nfsi = NFS_I(d_inode(dentry));
 
         wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1);
 }
 
 void nfs_unblock_sillyrename(struct dentry *dentry)
 {
-        struct inode *dir = dentry->d_inode;
+        struct inode *dir = d_inode(dentry);
         struct nfs_inode *nfsi = NFS_I(dir);
         struct nfs_unlinkdata *data;
 
@@ -367,8 +367,8 @@ static void nfs_async_rename_release(void *calldata)
         struct nfs_renamedata   *data = calldata;
         struct super_block *sb = data->old_dir->i_sb;
 
-        if (data->old_dentry->d_inode)
-                nfs_mark_for_revalidate(data->old_dentry->d_inode);
+        if (d_really_is_positive(data->old_dentry))
+                nfs_mark_for_revalidate(d_inode(data->old_dentry));
 
         dput(data->old_dentry);
         dput(data->new_dentry);
@@ -529,10 +529,10 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
                 goto out;
 
-        fileid = NFS_FILEID(dentry->d_inode);
+        fileid = NFS_FILEID(d_inode(dentry));
 
         /* Return delegation in anticipation of the rename */
-        NFS_PROTO(dentry->d_inode)->return_delegation(dentry->d_inode);
+        NFS_PROTO(d_inode(dentry))->return_delegation(d_inode(dentry));
 
         sdentry = NULL;
         do {
@@ -554,7 +554,7 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
                  */
                 if (IS_ERR(sdentry))
                         goto out;
-        } while (sdentry->d_inode != NULL); /* need negative lookup */
+        } while (d_inode(sdentry) != NULL); /* need negative lookup */
 
         /* queue unlink first. Can't do this from rpc_release as it
          * has to allocate memory
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 759931088094..d12a4be613a5 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -580,7 +580,7 @@ static int nfs_do_writepage(struct page *page, struct writeback_control *wbc, st
         int ret;
 
         nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
-        nfs_inc_stats(inode, NFSIOS_WRITEPAGES);
+        nfs_add_stats(inode, NFSIOS_WRITEPAGES, 1);
 
         nfs_pageio_cond_complete(pgio, page_file_index(page));
         ret = nfs_page_async_flush(pgio, page, wbc->sync_mode == WB_SYNC_NONE);
@@ -702,7 +702,7 @@ static void nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
  */
 static void nfs_inode_remove_request(struct nfs_page *req)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = d_inode(req->wb_context->dentry);
         struct nfs_inode *nfsi = NFS_I(inode);
         struct nfs_page *head;
 
@@ -861,7 +861,7 @@ static void
 nfs_clear_request_commit(struct nfs_page *req)
 {
         if (test_bit(PG_CLEAN, &req->wb_flags)) {
-                struct inode *inode = req->wb_context->dentry->d_inode;
+                struct inode *inode = d_inode(req->wb_context->dentry);
                 struct nfs_commit_info cinfo;
 
                 nfs_init_cinfo_from_inode(&cinfo, inode);
@@ -1591,7 +1591,7 @@ void nfs_init_commit(struct nfs_commit_data *data,
                      struct nfs_commit_info *cinfo)
 {
         struct nfs_page *first = nfs_list_entry(head->next);
-        struct inode *inode = first->wb_context->dentry->d_inode;
+        struct inode *inode = d_inode(first->wb_context->dentry);
 
         /* Set up the RPC argument and reply structs
          * NB: take care not to mess about with data->commit et al. */
@@ -1690,7 +1690,7 @@ static void nfs_commit_release_pages(struct nfs_commit_data *data)
 
                 dprintk("NFS:       commit (%s/%llu %d@%lld)",
                         req->wb_context->dentry->d_sb->s_id,
-                        (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                        (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)),
                         req->wb_bytes,
                         (long long)req_offset(req));
                 if (status < 0) {
@@ -1840,17 +1840,16 @@ EXPORT_SYMBOL_GPL(nfs_write_inode);
  */
 int nfs_wb_all(struct inode *inode)
 {
-        struct writeback_control wbc = {
-                .sync_mode = WB_SYNC_ALL,
-                .nr_to_write = LONG_MAX,
-                .range_start = 0,
-                .range_end = LLONG_MAX,
-        };
         int ret;
 
         trace_nfs_writeback_inode_enter(inode);
 
-        ret = sync_inode(inode, &wbc);
+        ret = filemap_write_and_wait(inode->i_mapping);
+        if (!ret) {
+                ret = nfs_commit_inode(inode, FLUSH_SYNC);
+                if (!ret)
+                        pnfs_sync_inode(inode, true);
+        }
 
         trace_nfs_writeback_inode_exit(inode, ret);
         return ret;
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 900c3ae94adc..f79521a59747 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -599,7 +599,7 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                                 goto out4;
                 }
 
-                err = check_export(exp.ex_path.dentry->d_inode, &exp.ex_flags,
+                err = check_export(d_inode(exp.ex_path.dentry), &exp.ex_flags,
                                    exp.ex_uuid);
                 if (err)
                         goto out4;
@@ -890,7 +890,7 @@ exp_rootfh(struct net *net, struct auth_domain *clp, char *name,
                 printk("nfsd: exp_rootfh path not found %s", name);
                 return err;
         }
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
                  name, path.dentry, clp->name,
diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c
index ac54ea60b3f6..d54701f6dc78 100644
--- a/fs/nfsd/nfs2acl.c
+++ b/fs/nfsd/nfs2acl.c
@@ -42,7 +42,7 @@ static __be32 nfsacld_proc_getacl(struct svc_rqst * rqstp,
         if (nfserr)
                 RETURN_STATUS(nfserr);
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
 
         if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
                 RETURN_STATUS(nfserr_inval);
@@ -103,7 +103,7 @@ static __be32 nfsacld_proc_setacl(struct svc_rqst * rqstp,
         if (nfserr)
                 goto out;
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
         if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) {
                 error = -EOPNOTSUPP;
                 goto out_errno;
@@ -266,9 +266,9 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
          * nfsd_dispatch actually ensures the following cannot happen.
          * However, it seems fragile to depend on that.
          */
-        if (dentry == NULL || dentry->d_inode == NULL)
+        if (dentry == NULL || d_really_is_negative(dentry))
                 return 0;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat);
         *p++ = htonl(resp->mask);
diff --git a/fs/nfsd/nfs3acl.c b/fs/nfsd/nfs3acl.c
index 34cbbab6abd7..882b1a14bc3e 100644
--- a/fs/nfsd/nfs3acl.c
+++ b/fs/nfsd/nfs3acl.c
@@ -39,7 +39,7 @@ static __be32 nfsd3_proc_getacl(struct svc_rqst * rqstp,
         if (nfserr)
                 RETURN_STATUS(nfserr);
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
 
         if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
                 RETURN_STATUS(nfserr_inval);
@@ -94,7 +94,7 @@ static __be32 nfsd3_proc_setacl(struct svc_rqst * rqstp,
         if (nfserr)
                 goto out;
 
-        inode = fh->fh_dentry->d_inode;
+        inode = d_inode(fh->fh_dentry);
         if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) {
                 error = -EOPNOTSUPP;
                 goto out_errno;
@@ -174,8 +174,8 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
         struct dentry *dentry = resp->fh.fh_dentry;
 
         p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh);
-        if (resp->status == 0 && dentry && dentry->d_inode) {
-                struct inode *inode = dentry->d_inode;
+        if (resp->status == 0 && dentry && d_really_is_positive(dentry)) {
+                struct inode *inode = d_inode(dentry);
                 struct kvec *head = rqstp->rq_res.head;
                 unsigned int base;
                 int n;
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 12f2aab4f614..7b755b7f785c 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -166,7 +166,7 @@ nfsd3_proc_read(struct svc_rqst *rqstp, struct nfsd3_readargs *argp,
                                   rqstp->rq_vec, argp->vlen,
                                   &resp->count);
         if (nfserr == 0) {
-                struct inode    *inode = resp->fh.fh_dentry->d_inode;
+                struct inode    *inode = d_inode(resp->fh.fh_dentry);
 
                 resp->eof = (argp->offset + resp->count) >= inode->i_size;
         }
@@ -551,7 +551,7 @@ nfsd3_proc_fsinfo(struct svc_rqst * rqstp, struct nfsd_fhandle    *argp,
          * different read/write sizes for file systems known to have
          * problems with large blocks */
         if (nfserr == 0) {
-                struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb;
+                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
 
                 /* Note that we don't care for remote fs's here */
                 if (sb->s_magic == MSDOS_SUPER_MAGIC) {
@@ -587,7 +587,7 @@ nfsd3_proc_pathconf(struct svc_rqst * rqstp, struct nfsd_fhandle      *argp,
         nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP);
 
         if (nfserr == 0) {
-                struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb;
+                struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb;
 
                 /* Note that we don't care for remote fs's here */
                 switch (sb->s_magic) {
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 39c5eb3ad33a..e4b2b4322553 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -146,7 +146,7 @@ static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
         default:
         case FSIDSOURCE_DEV:
                 p = xdr_encode_hyper(p, (u64)huge_encode_dev
-                                     (fhp->fh_dentry->d_inode->i_sb->s_dev));
+                                     (d_inode(fhp->fh_dentry)->i_sb->s_dev));
                 break;
         case FSIDSOURCE_FSID:
                 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
@@ -203,14 +203,14 @@ static __be32 *
 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
         struct dentry *dentry = fhp->fh_dentry;
-        if (dentry && dentry->d_inode) {
+        if (dentry && d_really_is_positive(dentry)) {
                 __be32 err;
                 struct kstat stat;
 
                 err = fh_getattr(fhp, &stat);
                 if (!err) {
                         *p++ = xdr_one;         /* attributes follow */
-                        lease_get_mtime(dentry->d_inode, &stat.mtime);
+                        lease_get_mtime(d_inode(dentry), &stat.mtime);
                         return encode_fattr3(rqstp, p, fhp, &stat);
                 }
         }
@@ -233,7 +233,7 @@ encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
 {
         struct dentry   *dentry = fhp->fh_dentry;
 
-        if (dentry && dentry->d_inode && fhp->fh_post_saved) {
+        if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) {
                 if (fhp->fh_pre_saved) {
                         *p++ = xdr_one;
                         p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
@@ -260,11 +260,11 @@ void fill_post_wcc(struct svc_fh *fhp)
                 printk("nfsd: inode locked twice during operation.\n");
 
         err = fh_getattr(fhp, &fhp->fh_post_attr);
-        fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
+        fhp->fh_post_change = d_inode(fhp->fh_dentry)->i_version;
         if (err) {
                 fhp->fh_post_saved = 0;
                 /* Grab the ctime anyway - set_change_info might use it */
-                fhp->fh_post_attr.ctime = fhp->fh_dentry->d_inode->i_ctime;
+                fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime;
         } else
                 fhp->fh_post_saved = 1;
 }
@@ -628,7 +628,7 @@ nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
                                         struct nfsd3_attrstat *resp)
 {
         if (resp->status == 0) {
-                lease_get_mtime(resp->fh.fh_dentry->d_inode,
+                lease_get_mtime(d_inode(resp->fh.fh_dentry),
                                 &resp->stat.mtime);
                 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
         }
@@ -828,7 +828,7 @@ compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
                 return rv;
         if (d_mountpoint(dchild))
                 goto out;
-        if (!dchild->d_inode)
+        if (d_really_is_negative(dchild))
                 goto out;
         rv = fh_compose(fhp, exp, dchild, &cd->fh);
 out:
diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c
index eaf4605a4b9e..67242bf7c6cc 100644
--- a/fs/nfsd/nfs4acl.c
+++ b/fs/nfsd/nfs4acl.c
@@ -139,7 +139,7 @@ int
 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry,
                 struct nfs4_acl **acl)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error = 0;
         struct posix_acl *pacl = NULL, *dpacl = NULL;
         unsigned int flags = 0;
@@ -780,7 +780,7 @@ nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 return error;
 
         dentry = fhp->fh_dentry;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         if (!inode->i_op->set_acl || !IS_POSIXACL(inode))
                 return nfserr_attrnotsupp;
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 4a8314f08a0e..864e2003e8de 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -52,7 +52,7 @@
 static inline void
 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
 {
-        struct inode *inode = resfh->fh_dentry->d_inode;
+        struct inode *inode = d_inode(resfh->fh_dentry);
         int status;
 
         mutex_lock(&inode->i_mutex);
@@ -110,7 +110,7 @@ check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
          * in current environment or not.
          */
         if (bmval[0] & FATTR4_WORD0_ACL) {
-                if (!IS_POSIXACL(dentry->d_inode))
+                if (!IS_POSIXACL(d_inode(dentry)))
                         return nfserr_attrnotsupp;
         }
 
@@ -209,7 +209,7 @@ do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfs
 
 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
 {
-        umode_t mode = fh->fh_dentry->d_inode->i_mode;
+        umode_t mode = d_inode(fh->fh_dentry)->i_mode;
 
         if (S_ISREG(mode))
                 return nfs_ok;
@@ -881,7 +881,7 @@ nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                                     &exp, &dentry);
         if (err)
                 return err;
-        if (dentry->d_inode == NULL) {
+        if (d_really_is_negative(dentry)) {
                 exp_put(exp);
                 err = nfserr_noent;
         } else
@@ -1312,7 +1312,7 @@ nfsd4_layoutget(struct svc_rqst *rqstp,
         if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
                 goto out_put_stid;
 
-        nfserr = ops->proc_layoutget(current_fh->fh_dentry->d_inode,
+        nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
                                      current_fh, lgp);
         if (nfserr)
                 goto out_put_stid;
@@ -1346,7 +1346,7 @@ nfsd4_layoutcommit(struct svc_rqst *rqstp,
         ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
         if (!ops)
                 goto out;
-        inode = current_fh->fh_dentry->d_inode;
+        inode = d_inode(current_fh->fh_dentry);
 
         nfserr = nfserr_inval;
         if (new_size <= seg->offset) {
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 1c307f02baa8..d88ea7b9a85c 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -192,14 +192,14 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
 
         dir = nn->rec_file->f_path.dentry;
         /* lock the parent */
-        mutex_lock(&dir->d_inode->i_mutex);
+        mutex_lock(&d_inode(dir)->i_mutex);
 
         dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 goto out_unlock;
         }
-        if (dentry->d_inode)
+        if (d_really_is_positive(dentry))
                 /*
                  * In the 4.1 case, where we're called from
                  * reclaim_complete(), records from the previous reboot
@@ -209,11 +209,11 @@ nfsd4_create_clid_dir(struct nfs4_client *clp)
                  * as well be forgiving and just succeed silently.
                  */
                 goto out_put;
-        status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
+        status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU);
 out_put:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         if (status == 0) {
                 if (nn->in_grace) {
                         crp = nfs4_client_to_reclaim(dname, nn);
@@ -285,7 +285,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
         }
 
         status = iterate_dir(nn->rec_file, &ctx.ctx);
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
         while (!list_empty(&ctx.names)) {
                 struct name_list *entry;
                 entry = list_entry(ctx.names.next, struct name_list, list);
@@ -302,7 +302,7 @@ nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
                 list_del(&entry->list);
                 kfree(entry);
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         nfs4_reset_creds(original_cred);
         return status;
 }
@@ -316,20 +316,20 @@ nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 
         dir = nn->rec_file->f_path.dentry;
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
         dentry = lookup_one_len(name, dir, namlen);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 goto out_unlock;
         }
         status = -ENOENT;
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto out;
-        status = vfs_rmdir(dir->d_inode, dentry);
+        status = vfs_rmdir(d_inode(dir), dentry);
 out:
         dput(dentry);
 out_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
         return status;
 }
 
@@ -385,7 +385,7 @@ purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
         if (nfs4_has_reclaimed_state(child->d_name.name, nn))
                 return 0;
 
-        status = vfs_rmdir(parent->d_inode, child);
+        status = vfs_rmdir(d_inode(parent), child);
         if (status)
                 printk("failed to remove client recovery directory %pd\n",
                                 child);
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index d42786ee39af..38f2d7abe3a7 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -4472,7 +4472,7 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
         struct nfs4_ol_stateid *stp = NULL;
         struct nfs4_delegation *dp = NULL;
         struct svc_fh *current_fh = &cstate->current_fh;
-        struct inode *ino = current_fh->fh_dentry->d_inode;
+        struct inode *ino = d_inode(current_fh->fh_dentry);
         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
         struct file *file = NULL;
         __be32 status;
@@ -5170,7 +5170,7 @@ lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
         struct nfs4_file *fi = ost->st_stid.sc_file;
         struct nfs4_openowner *oo = openowner(ost->st_stateowner);
         struct nfs4_client *cl = oo->oo_owner.so_client;
-        struct inode *inode = cstate->current_fh.fh_dentry->d_inode;
+        struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
         struct nfs4_lockowner *lo;
         unsigned int strhashval;
 
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index a45032ce7b80..158badf945df 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2292,7 +2292,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
         if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) ||
                         bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
-                err = security_inode_getsecctx(dentry->d_inode,
+                err = security_inode_getsecctx(d_inode(dentry),
                                                 &context, &contextlen);
                 contextsupport = (err == 0);
                 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
@@ -2384,7 +2384,7 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
                 p = xdr_reserve_space(xdr, 8);
                 if (!p)
                         goto out_resource;
-                p = encode_change(p, &stat, dentry->d_inode);
+                p = encode_change(p, &stat, d_inode(dentry));
         }
         if (bmval0 & FATTR4_WORD0_SIZE) {
                 p = xdr_reserve_space(xdr, 8);
@@ -2807,7 +2807,7 @@ nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
         dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);
         if (IS_ERR(dentry))
                 return nfserrno(PTR_ERR(dentry));
-        if (!dentry->d_inode) {
+        if (d_really_is_negative(dentry)) {
                 /*
                  * nfsd_buffered_readdir drops the i_mutex between
                  * readdir and calling this callback, leaving a window
@@ -3324,7 +3324,7 @@ static __be32 nfsd4_encode_splice_read(
         }
 
         eof = (read->rd_offset + maxcount >=
-               read->rd_fhp->fh_dentry->d_inode->i_size);
+               d_inode(read->rd_fhp->fh_dentry)->i_size);
 
         *(p++) = htonl(eof);
         *(p++) = htonl(maxcount);
@@ -3401,7 +3401,7 @@ static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
         xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
 
         eof = (read->rd_offset + maxcount >=
-               read->rd_fhp->fh_dentry->d_inode->i_size);
+               d_inode(read->rd_fhp->fh_dentry)->i_size);
 
         tmp = htonl(eof);
         write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index e9fa966fc37f..350041a40fe5 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -38,7 +38,7 @@ static int nfsd_acceptable(void *expv, struct dentry *dentry)
                 /* make sure parents give x permission to user */
                 int err;
                 parent = dget_parent(tdentry);
-                err = inode_permission(parent->d_inode, MAY_EXEC);
+                err = inode_permission(d_inode(parent), MAY_EXEC);
                 if (err < 0) {
                         dput(parent);
                         break;
@@ -340,7 +340,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, int access)
         if (error)
                 goto out;
 
-        error = nfsd_mode_check(rqstp, dentry->d_inode->i_mode, type);
+        error = nfsd_mode_check(rqstp, d_inode(dentry)->i_mode, type);
         if (error)
                 goto out;
 
@@ -412,8 +412,8 @@ static inline void _fh_update_old(struct dentry *dentry,
                                   struct svc_export *exp,
                                   struct knfsd_fh *fh)
 {
-        fh->ofh_ino = ino_t_to_u32(dentry->d_inode->i_ino);
-        fh->ofh_generation = dentry->d_inode->i_generation;
+        fh->ofh_ino = ino_t_to_u32(d_inode(dentry)->i_ino);
+        fh->ofh_generation = d_inode(dentry)->i_generation;
         if (d_is_dir(dentry) ||
             (exp->ex_flags & NFSEXP_NOSUBTREECHECK))
                 fh->ofh_dirino = 0;
@@ -426,7 +426,7 @@ static bool is_root_export(struct svc_export *exp)
 
 static struct super_block *exp_sb(struct svc_export *exp)
 {
-        return exp->ex_path.dentry->d_inode->i_sb;
+        return d_inode(exp->ex_path.dentry)->i_sb;
 }
 
 static bool fsid_type_ok_for_exp(u8 fsid_type, struct svc_export *exp)
@@ -520,12 +520,12 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
          *
          */
 
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         dev_t ex_dev = exp_sb(exp)->s_dev;
 
         dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
                 MAJOR(ex_dev), MINOR(ex_dev),
-                (long) exp->ex_path.dentry->d_inode->i_ino,
+                (long) d_inode(exp->ex_path.dentry)->i_ino,
                 dentry,
                 (inode ? inode->i_ino : 0));
 
@@ -558,7 +558,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
                 fhp->fh_handle.ofh_dev =  old_encode_dev(ex_dev);
                 fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev;
                 fhp->fh_handle.ofh_xino =
-                        ino_t_to_u32(exp->ex_path.dentry->d_inode->i_ino);
+                        ino_t_to_u32(d_inode(exp->ex_path.dentry)->i_ino);
                 fhp->fh_handle.ofh_dirino = ino_t_to_u32(parent_ino(dentry));
                 if (inode)
                         _fh_update_old(dentry, exp, &fhp->fh_handle);
@@ -570,7 +570,7 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
                 mk_fsid(fhp->fh_handle.fh_fsid_type,
                         fhp->fh_handle.fh_fsid,
                         ex_dev,
-                        exp->ex_path.dentry->d_inode->i_ino,
+                        d_inode(exp->ex_path.dentry)->i_ino,
                         exp->ex_fsid, exp->ex_uuid);
 
                 if (inode)
@@ -597,7 +597,7 @@ fh_update(struct svc_fh *fhp)
                 goto out_bad;
 
         dentry = fhp->fh_dentry;
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 goto out_negative;
         if (fhp->fh_handle.fh_version != 1) {
                 _fh_update_old(dentry, fhp->fh_export, &fhp->fh_handle);
diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index f22920442172..1e90dad4926b 100644
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -225,7 +225,7 @@ fill_pre_wcc(struct svc_fh *fhp)
 {
         struct inode    *inode;
 
-        inode = fhp->fh_dentry->d_inode;
+        inode = d_inode(fhp->fh_dentry);
         if (!fhp->fh_pre_saved) {
                 fhp->fh_pre_mtime = inode->i_mtime;
                 fhp->fh_pre_ctime = inode->i_ctime;
@@ -264,7 +264,7 @@ fh_lock_nested(struct svc_fh *fhp, unsigned int subclass)
                 return;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         mutex_lock_nested(&inode->i_mutex, subclass);
         fill_pre_wcc(fhp);
         fhp->fh_locked = 1;
@@ -284,7 +284,7 @@ fh_unlock(struct svc_fh *fhp)
 {
         if (fhp->fh_locked) {
                 fill_post_wcc(fhp);
-                mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(fhp->fh_dentry)->i_mutex);
                 fhp->fh_locked = 0;
         }
 }
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index b8680738f588..aecbcd34d336 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -223,7 +223,7 @@ nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
         }
         fh_init(newfhp, NFS_FHSIZE);
         nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp);
-        if (!nfserr && !dchild->d_inode)
+        if (!nfserr && d_really_is_negative(dchild))
                 nfserr = nfserr_noent;
         dput(dchild);
         if (nfserr) {
@@ -241,7 +241,7 @@ nfsd_proc_create(struct svc_rqst *rqstp, struct nfsd_createargs *argp,
                 }
         }
 
-        inode = newfhp->fh_dentry->d_inode;
+        inode = d_inode(newfhp->fh_dentry);
 
         /* Unfudge the mode bits */
         if (attr->ia_valid & ATTR_MODE) {
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 412d7061f9e5..79d964aa8079 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -187,7 +187,7 @@ encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
         *p++ = htonl((u32) stat->ino);
         *p++ = htonl((u32) stat->atime.tv_sec);
         *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0);
-        lease_get_mtime(dentry->d_inode, &time); 
+        lease_get_mtime(d_inode(dentry), &time); 
         *p++ = htonl((u32) time.tv_sec);
         *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); 
         *p++ = htonl((u32) stat->ctime.tv_sec);
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 368526582429..84d770be056e 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -174,7 +174,7 @@ int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
                 return 1;
         if (!(exp->ex_flags & NFSEXP_V4ROOT))
                 return 0;
-        return dentry->d_inode != NULL;
+        return d_inode(dentry) != NULL;
 }
 
 __be32
@@ -270,7 +270,7 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
          * dentry may be negative, it may need to be updated.
          */
         err = fh_compose(resfh, exp, dentry, fhp);
-        if (!err && !dentry->d_inode)
+        if (!err && d_really_is_negative(dentry))
                 err = nfserr_noent;
 out:
         dput(dentry);
@@ -284,7 +284,7 @@ out:
 static int
 commit_metadata(struct svc_fh *fhp)
 {
-        struct inode *inode = fhp->fh_dentry->d_inode;
+        struct inode *inode = d_inode(fhp->fh_dentry);
         const struct export_operations *export_ops = inode->i_sb->s_export_op;
 
         if (!EX_ISSYNC(fhp->fh_export))
@@ -364,7 +364,7 @@ static __be32
 nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 struct iattr *iap)
 {
-        struct inode *inode = fhp->fh_dentry->d_inode;
+        struct inode *inode = d_inode(fhp->fh_dentry);
         int host_err;
 
         if (iap->ia_size < inode->i_size) {
@@ -426,7 +426,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
         }
 
         dentry = fhp->fh_dentry;
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         /* Ignore any mode updates on symlinks */
         if (S_ISLNK(inode->i_mode))
@@ -495,7 +495,7 @@ out:
  */
 int nfsd4_is_junction(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (inode == NULL)
                 return 0;
@@ -521,9 +521,9 @@ __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
 
         dentry = fhp->fh_dentry;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
+        mutex_lock(&d_inode(dentry)->i_mutex);
         host_error = security_inode_setsecctx(dentry, label->data, label->len);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
         return nfserrno(host_error);
 }
 #else
@@ -706,7 +706,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
 
         path.mnt = fhp->fh_export->ex_path.mnt;
         path.dentry = fhp->fh_dentry;
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         /* Disallow write access to files with the append-only bit set
          * or any access when mandatory locking enabled
@@ -1211,7 +1211,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
 
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         err = nfserr_notdir;
         if (!dirp->i_op->lookup)
@@ -1250,7 +1250,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
          * Make sure the child dentry is still negative ...
          */
         err = nfserr_exist;
-        if (dchild->d_inode) {
+        if (d_really_is_positive(dchild)) {
                 dprintk("nfsd_create: dentry %pd/%pd not negative!\n",
                         dentry, dchild);
                 goto out; 
@@ -1353,7 +1353,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out;
 
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         /* Get all the sanity checks out of the way before
          * we lock the parent. */
@@ -1376,7 +1376,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 goto out_nfserr;
 
         /* If file doesn't exist, check for permissions to create one */
-        if (!dchild->d_inode) {
+        if (d_really_is_negative(dchild)) {
                 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
                 if (err)
                         goto out;
@@ -1397,7 +1397,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 v_atime = verifier[1]&0x7fffffff;
         }
         
-        if (dchild->d_inode) {
+        if (d_really_is_positive(dchild)) {
                 err = 0;
 
                 switch (createmode) {
@@ -1420,17 +1420,17 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                         }
                         break;
                 case NFS3_CREATE_EXCLUSIVE:
-                        if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
-                            && dchild->d_inode->i_atime.tv_sec == v_atime
-                            && dchild->d_inode->i_size  == 0 ) {
+                        if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
+                            && d_inode(dchild)->i_atime.tv_sec == v_atime
+                            && d_inode(dchild)->i_size  == 0 ) {
                                 if (created)
                                         *created = 1;
                                 break;
                         }
                 case NFS4_CREATE_EXCLUSIVE4_1:
-                        if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
-                            && dchild->d_inode->i_atime.tv_sec == v_atime
-                            && dchild->d_inode->i_size  == 0 ) {
+                        if (   d_inode(dchild)->i_mtime.tv_sec == v_mtime
+                            && d_inode(dchild)->i_atime.tv_sec == v_atime
+                            && d_inode(dchild)->i_size  == 0 ) {
                                 if (created)
                                         *created = 1;
                                 goto set_attr;
@@ -1513,7 +1513,7 @@ nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
 
         path.mnt = fhp->fh_export->ex_path.mnt;
         path.dentry = fhp->fh_dentry;
-        inode = path.dentry->d_inode;
+        inode = d_inode(path.dentry);
 
         err = nfserr_inval;
         if (!inode->i_op->readlink)
@@ -1576,7 +1576,7 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (IS_ERR(dnew))
                 goto out_nfserr;
 
-        host_err = vfs_symlink(dentry->d_inode, dnew, path);
+        host_err = vfs_symlink(d_inode(dentry), dnew, path);
         err = nfserrno(host_err);
         if (!err)
                 err = nfserrno(commit_metadata(fhp));
@@ -1632,7 +1632,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
 
         fh_lock_nested(ffhp, I_MUTEX_PARENT);
         ddir = ffhp->fh_dentry;
-        dirp = ddir->d_inode;
+        dirp = d_inode(ddir);
 
         dnew = lookup_one_len(name, ddir, len);
         host_err = PTR_ERR(dnew);
@@ -1642,7 +1642,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
         dold = tfhp->fh_dentry;
 
         err = nfserr_noent;
-        if (!dold->d_inode)
+        if (d_really_is_negative(dold))
                 goto out_dput;
         host_err = vfs_link(dold, dirp, dnew, NULL);
         if (!host_err) {
@@ -1689,10 +1689,10 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out;
 
         fdentry = ffhp->fh_dentry;
-        fdir = fdentry->d_inode;
+        fdir = d_inode(fdentry);
 
         tdentry = tfhp->fh_dentry;
-        tdir = tdentry->d_inode;
+        tdir = d_inode(tdentry);
 
         err = nfserr_perm;
         if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
@@ -1717,7 +1717,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out_nfserr;
 
         host_err = -ENOENT;
-        if (!odentry->d_inode)
+        if (d_really_is_negative(odentry))
                 goto out_dput_old;
         host_err = -EINVAL;
         if (odentry == trap)
@@ -1790,21 +1790,21 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
 
         fh_lock_nested(fhp, I_MUTEX_PARENT);
         dentry = fhp->fh_dentry;
-        dirp = dentry->d_inode;
+        dirp = d_inode(dentry);
 
         rdentry = lookup_one_len(fname, dentry, flen);
         host_err = PTR_ERR(rdentry);
         if (IS_ERR(rdentry))
                 goto out_nfserr;
 
-        if (!rdentry->d_inode) {
+        if (d_really_is_negative(rdentry)) {
                 dput(rdentry);
                 err = nfserr_noent;
                 goto out;
         }
 
         if (!type)
-                type = rdentry->d_inode->i_mode & S_IFMT;
+                type = d_inode(rdentry)->i_mode & S_IFMT;
 
         if (type != S_IFDIR)
                 host_err = vfs_unlink(dirp, rdentry, NULL);
@@ -2015,7 +2015,7 @@ __be32
 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
                                         struct dentry *dentry, int acc)
 {
-        struct inode    *inode = dentry->d_inode;
+        struct inode    *inode = d_inode(dentry);
         int             err;
 
         if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
index 556ce2e47555..f982ae84f0cd 100644
--- a/fs/nfsd/xdr4.h
+++ b/fs/nfsd/xdr4.h
@@ -631,7 +631,7 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
 {
         BUG_ON(!fhp->fh_pre_saved);
         cinfo->atomic = fhp->fh_post_saved;
-        cinfo->change_supported = IS_I_VERSION(fhp->fh_dentry->d_inode);
+        cinfo->change_supported = IS_I_VERSION(d_inode(fhp->fh_dentry));
 
         cinfo->before_change = fhp->fh_pre_change;
         cinfo->after_change = fhp->fh_post_change;
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 197a63e9d102..0ee0bed3649b 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -435,7 +435,7 @@ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
  */
 int nilfs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const unsigned char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         unsigned chunk_size = nilfs_chunk_size(dir);
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index be936df4ba73..258d9fe2521a 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -835,7 +835,7 @@ void nilfs_evict_inode(struct inode *inode)
 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
         struct nilfs_transaction_info ti;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = inode->i_sb;
         int err;
 
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index 0f84b257932c..22180836ec22 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -192,7 +192,7 @@ out_fail:
 static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
                       struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct nilfs_transaction_info ti;
         int err;
 
@@ -283,7 +283,7 @@ static int nilfs_do_unlink(struct inode *dir, struct dentry *dentry)
         if (!de)
                 goto out;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         err = -EIO;
         if (le64_to_cpu(de->inode) != inode->i_ino)
                 goto out;
@@ -318,7 +318,7 @@ static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
 
         if (!err) {
                 nilfs_mark_inode_dirty(dir);
-                nilfs_mark_inode_dirty(dentry->d_inode);
+                nilfs_mark_inode_dirty(d_inode(dentry));
                 err = nilfs_transaction_commit(dir->i_sb);
         } else
                 nilfs_transaction_abort(dir->i_sb);
@@ -328,7 +328,7 @@ static int nilfs_unlink(struct inode *dir, struct dentry *dentry)
 
 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct nilfs_transaction_info ti;
         int err;
 
@@ -358,8 +358,8 @@ static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         struct inode *new_dir,  struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct page *dir_page = NULL;
         struct nilfs_dir_entry *dir_de = NULL;
         struct page *old_page;
@@ -453,13 +453,13 @@ static struct dentry *nilfs_get_parent(struct dentry *child)
         struct qstr dotdot = QSTR_INIT("..", 2);
         struct nilfs_root *root;
 
-        ino = nilfs_inode_by_name(child->d_inode, &dotdot);
+        ino = nilfs_inode_by_name(d_inode(child), &dotdot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
 
-        root = NILFS_I(child->d_inode)->i_root;
+        root = NILFS_I(d_inode(child))->i_root;
 
-        inode = nilfs_iget(child->d_inode->i_sb, root, ino);
+        inode = nilfs_iget(d_inode(child)->i_sb, root, ino);
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index c1725f20a9d1..f47585bfeb01 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -610,7 +610,7 @@ static int nilfs_unfreeze(struct super_block *sb)
 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct super_block *sb = dentry->d_sb;
-        struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root;
+        struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
         struct the_nilfs *nilfs = root->nilfs;
         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
         unsigned long long blocks;
@@ -681,7 +681,7 @@ static int nilfs_show_options(struct seq_file *seq, struct dentry *dentry)
 {
         struct super_block *sb = dentry->d_sb;
         struct the_nilfs *nilfs = sb->s_fs_info;
-        struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root;
+        struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root;
 
         if (!nilfs_test_opt(nilfs, BARRIER))
                 seq_puts(seq, ",nobarrier");
@@ -1190,7 +1190,7 @@ static int nilfs_remount(struct super_block *sb, int *flags, char *data)
 
                 sb->s_flags &= ~MS_RDONLY;
 
-                root = NILFS_I(sb->s_root->d_inode)->i_root;
+                root = NILFS_I(d_inode(sb->s_root))->i_root;
                 err = nilfs_attach_log_writer(sb, root);
                 if (err)
                         goto restore_opts;
diff --git a/fs/nsfs.c b/fs/nsfs.c
index af1b24fa899d..99521e7c492b 100644
--- a/fs/nsfs.c
+++ b/fs/nsfs.c
@@ -13,7 +13,7 @@ static const struct file_operations ns_file_operations = {
 
 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         const struct proc_ns_operations *ns_ops = dentry->d_fsdata;
 
         return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]",
@@ -22,7 +22,7 @@ static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 
 static void ns_prune_dentry(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         if (inode) {
                 struct ns_common *ns = inode->i_private;
                 atomic_long_set(&ns->stashed, 0);
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 1d0c21df0d80..d284f07eda77 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -2889,7 +2889,7 @@ void ntfs_truncate_vfs(struct inode *vi) {
  */
 int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *vi = dentry->d_inode;
+        struct inode *vi = d_inode(dentry);
         int err;
         unsigned int ia_valid = attr->ia_valid;
 
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index b3973c2fd190..0f35b80d17fe 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -292,14 +292,14 @@ const struct inode_operations ntfs_dir_inode_ops = {
  * The code is based on the ext3 ->get_parent() implementation found in
  * fs/ext3/namei.c::ext3_get_parent().
  *
- * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_mutex down.
+ * Note: ntfs_get_parent() is called with @d_inode(child_dent)->i_mutex down.
  *
  * Return the dentry of the parent directory on success or the error code on
  * error (IS_ERR() is true).
  */
 static struct dentry *ntfs_get_parent(struct dentry *child_dent)
 {
-        struct inode *vi = child_dent->d_inode;
+        struct inode *vi = d_inode(child_dent);
         ntfs_inode *ni = NTFS_I(vi);
         MFT_RECORD *mrec;
         ntfs_attr_search_ctx *ctx;
diff --git a/fs/ocfs2/dcache.c b/fs/ocfs2/dcache.c
index 4fda7a5f3088..290373024d9d 100644
--- a/fs/ocfs2/dcache.c
+++ b/fs/ocfs2/dcache.c
@@ -42,8 +42,8 @@
 void ocfs2_dentry_attach_gen(struct dentry *dentry)
 {
         unsigned long gen =
-                OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
-        BUG_ON(dentry->d_inode);
+                OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
+        BUG_ON(d_inode(dentry));
         dentry->d_fsdata = (void *)gen;
 }
 
@@ -57,7 +57,7 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         osb = OCFS2_SB(dentry->d_sb);
 
         trace_ocfs2_dentry_revalidate(dentry, dentry->d_name.len,
@@ -71,7 +71,7 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
                 unsigned long gen = (unsigned long) dentry->d_fsdata;
                 unsigned long pgen;
                 spin_lock(&dentry->d_lock);
-                pgen = OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen;
+                pgen = OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen;
                 spin_unlock(&dentry->d_lock);
                 trace_ocfs2_dentry_revalidate_negative(dentry->d_name.len,
                                                        dentry->d_name.name,
@@ -146,7 +146,7 @@ static int ocfs2_match_dentry(struct dentry *dentry,
         if (skip_unhashed && d_unhashed(dentry))
                 return 0;
 
-        parent = dentry->d_parent->d_inode;
+        parent = d_inode(dentry->d_parent);
         /* Negative parent dentry? */
         if (!parent)
                 return 0;
@@ -243,7 +243,7 @@ int ocfs2_dentry_attach_lock(struct dentry *dentry,
         if (!inode)
                 return 0;
 
-        if (!dentry->d_inode && dentry->d_fsdata) {
+        if (d_really_is_negative(dentry) && dentry->d_fsdata) {
                 /* Converting a negative dentry to positive
                    Clear dentry->d_fsdata */
                 dentry->d_fsdata = dl = NULL;
@@ -446,7 +446,7 @@ void ocfs2_dentry_move(struct dentry *dentry, struct dentry *target,
 {
         int ret;
         struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb);
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         /*
          * Move within the same directory, so the actual lock info won't
diff --git a/fs/ocfs2/dir.h b/fs/ocfs2/dir.h
index f0344b75b14d..3d8639f38973 100644
--- a/fs/ocfs2/dir.h
+++ b/fs/ocfs2/dir.h
@@ -72,7 +72,7 @@ static inline int ocfs2_add_entry(handle_t *handle,
                                   struct buffer_head *parent_fe_bh,
                                   struct ocfs2_dir_lookup_result *lookup)
 {
-        return __ocfs2_add_entry(handle, dentry->d_parent->d_inode,
+        return __ocfs2_add_entry(handle, d_inode(dentry->d_parent),
                                  dentry->d_name.name, dentry->d_name.len,
                                  inode, blkno, parent_fe_bh, lookup);
 }
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index 061ba6a91bf2..b5cf27dcb18a 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -208,7 +208,7 @@ static int dlmfs_file_release(struct inode *inode,
 static int dlmfs_file_setattr(struct dentry *dentry, struct iattr *attr)
 {
         int error;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         attr->ia_valid &= ~ATTR_SIZE;
         error = inode_change_ok(inode, attr);
@@ -549,7 +549,7 @@ static int dlmfs_unlink(struct inode *dir,
                         struct dentry *dentry)
 {
         int status;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         mlog(0, "unlink inode %lu\n", inode->i_ino);
 
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index 540dc4bdd042..827fc9809bc2 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -147,7 +147,7 @@ static struct dentry *ocfs2_get_parent(struct dentry *child)
         int status;
         u64 blkno;
         struct dentry *parent;
-        struct inode *dir = child->d_inode;
+        struct inode *dir = d_inode(child);
 
         trace_ocfs2_get_parent(child, child->d_name.len, child->d_name.name,
                                (unsigned long long)OCFS2_I(dir)->ip_blkno);
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 913fc250d85a..d8b670cbd909 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1126,7 +1126,7 @@ out:
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
         int status = 0, size_change;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct super_block *sb = inode->i_sb;
         struct ocfs2_super *osb = OCFS2_SB(sb);
         struct buffer_head *bh = NULL;
@@ -1275,8 +1275,8 @@ int ocfs2_getattr(struct vfsmount *mnt,
                   struct dentry *dentry,
                   struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
-        struct super_block *sb = dentry->d_inode->i_sb;
+        struct inode *inode = d_inode(dentry);
+        struct super_block *sb = d_inode(dentry)->i_sb;
         struct ocfs2_super *osb = sb->s_fs_info;
         int err;
 
@@ -2114,7 +2114,7 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
 {
         int ret = 0, meta_level = 0;
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         loff_t end;
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
         int full_coherency = !(osb->s_mount_opt &
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index be71ca0937f7..b254416dc8d9 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -1209,7 +1209,7 @@ int ocfs2_drop_inode(struct inode *inode)
  */
 int ocfs2_inode_revalidate(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int status = 0;
 
         trace_ocfs2_inode_revalidate(inode,
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 09f90cbf0e24..176fe6afd94e 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -689,8 +689,8 @@ static int ocfs2_link(struct dentry *old_dentry,
                       struct dentry *dentry)
 {
         handle_t *handle;
-        struct inode *inode = old_dentry->d_inode;
-        struct inode *old_dir = old_dentry->d_parent->d_inode;
+        struct inode *inode = d_inode(old_dentry);
+        struct inode *old_dir = d_inode(old_dentry->d_parent);
         int err;
         struct buffer_head *fe_bh = NULL;
         struct buffer_head *old_dir_bh = NULL;
@@ -879,7 +879,7 @@ static int ocfs2_unlink(struct inode *dir,
         int status;
         int child_locked = 0;
         bool is_unlinkable = false;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct inode *orphan_dir = NULL;
         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
         u64 blkno;
@@ -898,7 +898,7 @@ static int ocfs2_unlink(struct inode *dir,
 
         dquot_initialize(dir);
 
-        BUG_ON(dentry->d_parent->d_inode != dir);
+        BUG_ON(d_inode(dentry->d_parent) != dir);
 
         if (inode == osb->root_inode)
                 return -EPERM;
@@ -1209,8 +1209,8 @@ static int ocfs2_rename(struct inode *old_dir,
 {
         int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
         int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct inode *orphan_dir = NULL;
         struct ocfs2_dinode *newfe = NULL;
         char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
@@ -1454,7 +1454,7 @@ static int ocfs2_rename(struct inode *old_dir,
                         should_add_orphan = true;
                 }
         } else {
-                BUG_ON(new_dentry->d_parent->d_inode != new_dir);
+                BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
 
                 status = ocfs2_check_dir_for_entry(new_dir,
                                                    new_dentry->d_name.name,
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index df3a500789c7..d8c6af101f3f 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -4194,7 +4194,7 @@ static int __ocfs2_reflink(struct dentry *old_dentry,
                            bool preserve)
 {
         int ret;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct buffer_head *new_bh = NULL;
 
         if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) {
@@ -4263,7 +4263,7 @@ static int ocfs2_reflink(struct dentry *old_dentry, struct inode *dir,
                          struct dentry *new_dentry, bool preserve)
 {
         int error;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct buffer_head *old_bh = NULL;
         struct inode *new_orphan_inode = NULL;
         struct posix_acl *default_acl, *acl;
@@ -4357,7 +4357,7 @@ out:
 /* copied from may_create in VFS. */
 static inline int ocfs2_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;
@@ -4375,7 +4375,7 @@ static inline int ocfs2_may_create(struct inode *dir, struct dentry *child)
 static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir,
                              struct dentry *new_dentry, bool preserve)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int error;
 
         if (!inode)
@@ -4463,7 +4463,7 @@ int ocfs2_reflink_ioctl(struct inode *inode,
         }
 
         error = ocfs2_vfs_reflink(old_path.dentry,
-                                  new_path.dentry->d_inode,
+                                  d_inode(new_path.dentry),
                                   new_dentry, preserve);
 out_dput:
         done_path_create(&new_path, new_dentry);
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 4ca7533be479..d03bfbf3d27d 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -1020,7 +1020,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
         int ret = 0, i_ret = 0, b_ret = 0;
         struct buffer_head *di_bh = NULL;
         struct ocfs2_dinode *di = NULL;
-        struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode);
+        struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry));
 
         if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb)))
                 return -EOPNOTSUPP;
@@ -1028,7 +1028,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
         if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL))
                 return ret;
 
-        ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0);
+        ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0);
         if (ret < 0) {
                 mlog_errno(ret);
                 return ret;
@@ -1037,7 +1037,7 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
         di = (struct ocfs2_dinode *)di_bh->b_data;
 
         down_read(&oi->ip_xattr_sem);
-        i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size);
+        i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size);
         if (i_ret < 0)
                 b_ret = 0;
         else {
@@ -1045,13 +1045,13 @@ ssize_t ocfs2_listxattr(struct dentry *dentry,
                         buffer += i_ret;
                         size -= i_ret;
                 }
-                b_ret = ocfs2_xattr_block_list(dentry->d_inode, di,
+                b_ret = ocfs2_xattr_block_list(d_inode(dentry), di,
                                                buffer, size);
                 if (b_ret < 0)
                         i_ret = 0;
         }
         up_read(&oi->ip_xattr_sem);
-        ocfs2_inode_unlock(dentry->d_inode, 0);
+        ocfs2_inode_unlock(d_inode(dentry), 0);
 
         brelse(di_bh);
 
@@ -7257,7 +7257,7 @@ static int ocfs2_xattr_security_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
                                name, buffer, size);
 }
 
@@ -7267,7 +7267,7 @@ static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name,
         if (strcmp(name, "") == 0)
                 return -EINVAL;
 
-        return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY,
+        return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY,
                                name, value, size, flags);
 }
 
@@ -7347,7 +7347,7 @@ static int ocfs2_xattr_trusted_get(struct dentry *dentry, const char *name,
 {
         if (strcmp(name, "") == 0)
                 return -EINVAL;
-        return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
                                name, buffer, size);
 }
 
@@ -7357,7 +7357,7 @@ static int ocfs2_xattr_trusted_set(struct dentry *dentry, const char *name,
         if (strcmp(name, "") == 0)
                 return -EINVAL;
 
-        return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED,
+        return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED,
                                name, value, size, flags);
 }
 
@@ -7399,7 +7399,7 @@ static int ocfs2_xattr_user_get(struct dentry *dentry, const char *name,
                 return -EINVAL;
         if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                 return -EOPNOTSUPP;
-        return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name,
+        return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_USER, name,
                                buffer, size);
 }
 
@@ -7413,7 +7413,7 @@ static int ocfs2_xattr_user_set(struct dentry *dentry, const char *name,
         if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR)
                 return -EOPNOTSUPP;
 
-        return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER,
+        return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_USER,
                                name, value, size, flags);
 }
 
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index 1b8e9e8405b2..f833bf8d5792 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -110,7 +110,7 @@ int omfs_make_empty(struct inode *inode, struct super_block *sb)
 
 static int omfs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         struct omfs_inode *oi;
@@ -155,7 +155,7 @@ out:
 
 static int omfs_delete_entry(struct dentry *dentry)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct inode *dirty;
         const char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
@@ -237,7 +237,7 @@ static int omfs_dir_is_empty(struct inode *inode)
 
 static int omfs_remove(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int ret;
 
 
@@ -373,8 +373,8 @@ static bool omfs_fill_chain(struct inode *dir, struct dir_context *ctx,
 static int omfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 struct inode *new_dir, struct dentry *new_dentry)
 {
-        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);
         int err;
 
         if (new_inode) {
diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index f993be7f2156..d9e26cfbb793 100644
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -346,7 +346,7 @@ const struct file_operations omfs_file_operations = {
 
 static int omfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, attr);
diff --git a/fs/pipe.c b/fs/pipe.c
index 822da5b7cff0..8865f7963700 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -627,7 +627,7 @@ static struct vfsmount *pipe_mnt __read_mostly;
 static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
 {
         return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
-                                dentry->d_inode->i_ino);
+                                d_inode(dentry)->i_ino);
 }
 
 static const struct dentry_operations pipefs_dentry_operations = {
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
index 3a48bb789c9f..84bb65b83570 100644
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -774,12 +774,12 @@ posix_acl_xattr_get(struct dentry *dentry, const char *name,
         struct posix_acl *acl;
         int error;
 
-        if (!IS_POSIXACL(dentry->d_inode))
+        if (!IS_POSIXACL(d_backing_inode(dentry)))
                 return -EOPNOTSUPP;
         if (d_is_symlink(dentry))
                 return -EOPNOTSUPP;
 
-        acl = get_acl(dentry->d_inode, type);
+        acl = get_acl(d_backing_inode(dentry), type);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl == NULL)
@@ -795,7 +795,7 @@ static int
 posix_acl_xattr_set(struct dentry *dentry, const char *name,
                 const void *value, size_t size, int flags, int type)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct posix_acl *acl = NULL;
         int ret;
 
@@ -834,7 +834,7 @@ posix_acl_xattr_list(struct dentry *dentry, char *list, size_t list_size,
         const char *xname;
         size_t size;
 
-        if (!IS_POSIXACL(dentry->d_inode))
+        if (!IS_POSIXACL(d_backing_inode(dentry)))
                 return -EOPNOTSUPP;
         if (d_is_symlink(dentry))
                 return -EOPNOTSUPP;
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 7a3b82f986dd..093ca14f5701 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -169,7 +169,7 @@ static int get_task_root(struct task_struct *task, struct path *root)
 
 static int proc_cwd_link(struct dentry *dentry, struct path *path)
 {
-        struct task_struct *task = get_proc_task(dentry->d_inode);
+        struct task_struct *task = get_proc_task(d_inode(dentry));
         int result = -ENOENT;
 
         if (task) {
@@ -186,7 +186,7 @@ static int proc_cwd_link(struct dentry *dentry, struct path *path)
 
 static int proc_root_link(struct dentry *dentry, struct path *path)
 {
-        struct task_struct *task = get_proc_task(dentry->d_inode);
+        struct task_struct *task = get_proc_task(d_inode(dentry));
         int result = -ENOENT;
 
         if (task) {
@@ -514,7 +514,7 @@ static int proc_fd_access_allowed(struct inode *inode)
 int proc_setattr(struct dentry *dentry, struct iattr *attr)
 {
         int error;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (attr->ia_valid & ATTR_MODE)
                 return -EPERM;
@@ -1362,7 +1362,7 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
         struct mm_struct *mm;
         struct file *exe_file;
 
-        task = get_proc_task(dentry->d_inode);
+        task = get_proc_task(d_inode(dentry));
         if (!task)
                 return -ENOENT;
         mm = get_task_mm(task);
@@ -1382,7 +1382,7 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
 
 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct path path;
         int error = -EACCES;
 
@@ -1427,7 +1427,7 @@ static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
 {
         int error = -EACCES;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct path path;
 
         /* Are we allowed to snoop on the tasks file descriptors? */
@@ -1497,7 +1497,7 @@ out_unlock:
 
 int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct task_struct *task;
         const struct cred *cred;
         struct pid_namespace *pid = dentry->d_sb->s_fs_info;
@@ -1554,7 +1554,7 @@ int pid_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         task = get_proc_task(inode);
 
         if (task) {
@@ -1588,7 +1588,7 @@ int pid_delete_dentry(const struct dentry *dentry)
          * If so, then don't put the dentry on the lru list,
          * kill it immediately.
          */
-        return proc_inode_is_dead(dentry->d_inode);
+        return proc_inode_is_dead(d_inode(dentry));
 }
 
 const struct dentry_operations pid_dentry_operations =
@@ -1626,12 +1626,12 @@ bool proc_fill_cache(struct file *file, struct dir_context *ctx,
                 child = d_alloc(dir, &qname);
                 if (!child)
                         goto end_instantiate;
-                if (instantiate(dir->d_inode, child, task, ptr) < 0) {
+                if (instantiate(d_inode(dir), child, task, ptr) < 0) {
                         dput(child);
                         goto end_instantiate;
                 }
         }
-        inode = child->d_inode;
+        inode = d_inode(child);
         ino = inode->i_ino;
         type = inode->i_mode >> 12;
         dput(child);
@@ -1674,7 +1674,7 @@ static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
                 goto out_notask;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         task = get_proc_task(inode);
         if (!task)
                 goto out_notask;
@@ -1727,7 +1727,7 @@ static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
         int rc;
 
         rc = -ENOENT;
-        task = get_proc_task(dentry->d_inode);
+        task = get_proc_task(d_inode(dentry));
         if (!task)
                 goto out;
 
@@ -2863,13 +2863,13 @@ int proc_pid_readdir(struct file *file, struct dir_context *ctx)
                 return 0;
 
         if (pos == TGID_OFFSET - 2) {
-                struct inode *inode = ns->proc_self->d_inode;
+                struct inode *inode = d_inode(ns->proc_self);
                 if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
                         return 0;
                 ctx->pos = pos = pos + 1;
         }
         if (pos == TGID_OFFSET - 1) {
-                struct inode *inode = ns->proc_thread_self->d_inode;
+                struct inode *inode = d_inode(ns->proc_thread_self);
                 if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))
                         return 0;
                 ctx->pos = pos = pos + 1;
@@ -3188,7 +3188,7 @@ static int proc_task_readdir(struct file *file, struct dir_context *ctx)
 
 static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct task_struct *p = get_proc_task(inode);
         generic_fillattr(inode, stat);
 
diff --git a/fs/proc/fd.c b/fs/proc/fd.c
index af84ad04df77..6e5fcd00733e 100644
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -91,7 +91,7 @@ static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         task = get_proc_task(inode);
         fd = proc_fd(inode);
 
@@ -151,14 +151,14 @@ static int proc_fd_link(struct dentry *dentry, struct path *path)
         struct task_struct *task;
         int ret = -ENOENT;
 
-        task = get_proc_task(dentry->d_inode);
+        task = get_proc_task(d_inode(dentry));
         if (task) {
                 files = get_files_struct(task);
                 put_task_struct(task);
         }
 
         if (files) {
-                int fd = proc_fd(dentry->d_inode);
+                int fd = proc_fd(d_inode(dentry));
                 struct file *fd_file;
 
                 spin_lock(&files->file_lock);
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index be65b2082135..df6327a2b865 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -101,7 +101,7 @@ static bool pde_subdir_insert(struct proc_dir_entry *dir,
 
 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct proc_dir_entry *de = PDE(inode);
         int error;
 
@@ -120,7 +120,7 @@ static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry,
                         struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct proc_dir_entry *de = PDE(inode);
         if (de && de->nlink)
                 set_nlink(inode, de->nlink);
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 7697b6621cfd..8272aaba1bb0 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -396,7 +396,7 @@ static const struct file_operations proc_reg_file_ops_no_compat = {
 
 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct proc_dir_entry *pde = PDE(dentry->d_inode);
+        struct proc_dir_entry *pde = PDE(d_inode(dentry));
         if (unlikely(!use_pde(pde)))
                 return ERR_PTR(-EINVAL);
         nd_set_link(nd, pde->data);
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index c9eac4563fa8..e512642dbbdc 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -32,7 +32,7 @@ static const struct proc_ns_operations *ns_entries[] = {
 
 static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
         struct task_struct *task;
         struct path ns_path;
@@ -53,7 +53,7 @@ static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd)
 
 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops;
         struct task_struct *task;
         char name[50];
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 1bde894bc624..350984a19c83 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -142,7 +142,7 @@ static struct dentry *proc_tgid_net_lookup(struct inode *dir,
 static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry,
                 struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct net *net;
 
         net = get_proc_task_net(inode);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index f92d5dd578a4..fea2561d773b 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -604,7 +604,7 @@ static bool proc_sys_fill_cache(struct file *file,
                         return false;
                 }
         }
-        inode = child->d_inode;
+        inode = d_inode(child);
         ino  = inode->i_ino;
         type = inode->i_mode >> 12;
         dput(child);
@@ -710,7 +710,7 @@ static int proc_sys_permission(struct inode *inode, int mask)
 
 static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
@@ -727,7 +727,7 @@ static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 
 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ctl_table_header *head = grab_header(inode);
         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 
@@ -773,12 +773,12 @@ static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
 {
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
-        return !PROC_I(dentry->d_inode)->sysctl->unregistering;
+        return !PROC_I(d_inode(dentry))->sysctl->unregistering;
 }
 
 static int proc_sys_delete(const struct dentry *dentry)
 {
-        return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
+        return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
 }
 
 static int sysctl_is_seen(struct ctl_table_header *p)
@@ -805,7 +805,7 @@ static int proc_sys_compare(const struct dentry *parent, const struct dentry *de
         /* Although proc doesn't have negative dentries, rcu-walk means
          * that inode here can be NULL */
         /* AV: can it, indeed? */
-        inode = ACCESS_ONCE(dentry->d_inode);
+        inode = d_inode_rcu(dentry);
         if (!inode)
                 return 1;
         if (name->len != len)
diff --git a/fs/proc/root.c b/fs/proc/root.c
index e74ac9f1a2c0..b7fa4bfe896a 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -195,7 +195,7 @@ void __init proc_root_init(void)
 static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat
 )
 {
-        generic_fillattr(dentry->d_inode, stat);
+        generic_fillattr(d_inode(dentry), stat);
         stat->nlink = proc_root.nlink + nr_processes();
         return 0;
 }
diff --git a/fs/proc/self.c b/fs/proc/self.c
index 4348bb8907c2..6195b4a7c3b1 100644
--- a/fs/proc/self.c
+++ b/fs/proc/self.c
@@ -46,7 +46,7 @@ static unsigned self_inum;
 
 int proc_setup_self(struct super_block *s)
 {
-        struct inode *root_inode = s->s_root->d_inode;
+        struct inode *root_inode = d_inode(s->s_root);
         struct pid_namespace *ns = s->s_fs_info;
         struct dentry *self;
         
diff --git a/fs/proc/thread_self.c b/fs/proc/thread_self.c
index 59075b509df3..a8371993b4fb 100644
--- a/fs/proc/thread_self.c
+++ b/fs/proc/thread_self.c
@@ -47,7 +47,7 @@ static unsigned thread_self_inum;
 
 int proc_setup_thread_self(struct super_block *s)
 {
-        struct inode *root_inode = s->s_root->d_inode;
+        struct inode *root_inode = d_inode(s->s_root);
         struct pid_namespace *ns = s->s_fs_info;
         struct dentry *thread_self;
 
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index 56e1ffda4d89..dc43b5f29305 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -190,7 +190,7 @@ static const struct file_operations pstore_file_operations = {
  */
 static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct pstore_private *p = dentry->d_inode->i_private;
+        struct pstore_private *p = d_inode(dentry)->i_private;
         int err;
 
         err = pstore_check_syslog_permissions(p);
@@ -199,7 +199,7 @@ static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 
         if (p->psi->erase)
                 p->psi->erase(p->type, p->id, p->count,
-                              dentry->d_inode->i_ctime, p->psi);
+                              d_inode(dentry)->i_ctime, p->psi);
         else
                 return -EPERM;
 
@@ -376,7 +376,7 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
                 break;
         }
 
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
 
         dentry = d_alloc_name(root, name);
         if (!dentry)
@@ -396,12 +396,12 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
         list_add(&private->list, &allpstore);
         spin_unlock_irqrestore(&allpstore_lock, flags);
 
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
 
         return 0;
 
 fail_lockedalloc:
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         kfree(private);
 fail_alloc:
         iput(inode);
diff --git a/fs/qnx6/inode.c b/fs/qnx6/inode.c
index 44e73923670d..32d2e1a9774c 100644
--- a/fs/qnx6/inode.c
+++ b/fs/qnx6/inode.c
@@ -182,7 +182,7 @@ static const char *qnx6_checkroot(struct super_block *s)
         static char match_root[2][3] = {".\0\0", "..\0"};
         int i, error = 0;
         struct qnx6_dir_entry *dir_entry;
-        struct inode *root = s->s_root->d_inode;
+        struct inode *root = d_inode(s->s_root);
         struct address_space *mapping = root->i_mapping;
         struct page *page = read_mapping_page(mapping, 0, NULL);
         if (IS_ERR(page))
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index ecc25cf0ee6e..20d1f74561cf 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -2328,7 +2328,7 @@ int dquot_quota_on(struct super_block *sb, int type, int format_id,
         if (path->dentry->d_sb != sb)
                 error = -EXDEV;
         else
-                error = vfs_load_quota_inode(path->dentry->d_inode, type,
+                error = vfs_load_quota_inode(d_inode(path->dentry), type,
                                              format_id, DQUOT_USAGE_ENABLED |
                                              DQUOT_LIMITS_ENABLED);
         return error;
@@ -2392,20 +2392,20 @@ int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
         struct dentry *dentry;
         int error;
 
-        mutex_lock(&sb->s_root->d_inode->i_mutex);
+        mutex_lock(&d_inode(sb->s_root)->i_mutex);
         dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
-        mutex_unlock(&sb->s_root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(sb->s_root)->i_mutex);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        if (!dentry->d_inode) {
+        if (d_really_is_negative(dentry)) {
                 error = -ENOENT;
                 goto out;
         }
 
         error = security_quota_on(dentry);
         if (!error)
-                error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
+                error = vfs_load_quota_inode(d_inode(dentry), type, format_id,
                                 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
 
 out:
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index 0b38befa69f3..ba1323a94924 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -163,7 +163,7 @@ static int ramfs_nommu_resize(struct inode *inode, loff_t newsize, loff_t size)
  */
 static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         unsigned int old_ia_valid = ia->ia_valid;
         int ret = 0;
 
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 0a7dc941aaf4..4a024e2ceb9f 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -53,8 +53,8 @@ static int reiserfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
 static inline bool is_privroot_deh(struct inode *dir, struct reiserfs_de_head *deh)
 {
         struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root;
-        return (privroot->d_inode &&
-                deh->deh_objectid == INODE_PKEY(privroot->d_inode)->k_objectid);
+        return (d_really_is_positive(privroot) &&
+                deh->deh_objectid == INODE_PKEY(d_inode(privroot))->k_objectid);
 }
 
 int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 742242b60972..f6f2fbad9777 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -3308,7 +3308,7 @@ static ssize_t reiserfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
 
 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         unsigned int ia_valid;
         int error;
 
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index cd11358b10c7..b55a074653d7 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -400,7 +400,7 @@ struct dentry *reiserfs_get_parent(struct dentry *child)
         struct inode *inode = NULL;
         struct reiserfs_dir_entry de;
         INITIALIZE_PATH(path_to_entry);
-        struct inode *dir = child->d_inode;
+        struct inode *dir = d_inode(child);
 
         if (dir->i_nlink == 0) {
                 return ERR_PTR(-ENOENT);
@@ -917,7 +917,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
                 goto end_rmdir;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         reiserfs_update_inode_transaction(inode);
         reiserfs_update_inode_transaction(dir);
@@ -987,7 +987,7 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
 
         dquot_initialize(dir);
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         /*
          * in this transaction we can be doing at max two balancings and
@@ -1174,7 +1174,7 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
                          struct dentry *dentry)
 {
         int retval;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct reiserfs_transaction_handle th;
         /*
          * We need blocks for transaction + update of quotas for
@@ -1311,8 +1311,8 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dquot_initialize(old_dir);
         dquot_initialize(new_dir);
 
-        old_inode = old_dentry->d_inode;
-        new_dentry_inode = new_dentry->d_inode;
+        old_inode = d_inode(old_dentry);
+        new_dentry_inode = d_inode(new_dentry);
 
         /*
          * make sure that oldname still exists and points to an object we
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 68b5f182984e..0111ad0466ed 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -1687,7 +1687,7 @@ static __u32 find_hash_out(struct super_block *s)
         __u32 hash = DEFAULT_HASH;
         __u32 deh_hashval, teahash, r5hash, yurahash;
 
-        inode = s->s_root->d_inode;
+        inode = d_inode(s->s_root);
 
         make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
         retval = search_by_entry_key(s, &key, &path, &de);
@@ -2347,7 +2347,7 @@ static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
                 err = -EXDEV;
                 goto out;
         }
-        inode = path->dentry->d_inode;
+        inode = d_inode(path->dentry);
         /*
          * We must not pack tails for quota files on reiserfs for quota
          * IO to work
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 4e781e697c90..e87f9b52bf06 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -87,9 +87,9 @@ static int xattr_unlink(struct inode *dir, struct dentry *dentry)
 
         BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-        mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
         error = dir->i_op->unlink(dir, dentry);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dentry)->i_mutex);
 
         if (!error)
                 d_delete(dentry);
@@ -102,11 +102,11 @@ static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
 
         BUG_ON(!mutex_is_locked(&dir->i_mutex));
 
-        mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD);
+        mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD);
         error = dir->i_op->rmdir(dir, dentry);
         if (!error)
-                dentry->d_inode->i_flags |= S_DEAD;
-        mutex_unlock(&dentry->d_inode->i_mutex);
+                d_inode(dentry)->i_flags |= S_DEAD;
+        mutex_unlock(&d_inode(dentry)->i_mutex);
         if (!error)
                 d_delete(dentry);
 
@@ -120,26 +120,26 @@ static struct dentry *open_xa_root(struct super_block *sb, int flags)
         struct dentry *privroot = REISERFS_SB(sb)->priv_root;
         struct dentry *xaroot;
 
-        if (!privroot->d_inode)
+        if (d_really_is_negative(privroot))
                 return ERR_PTR(-ENODATA);
 
-        mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
+        mutex_lock_nested(&d_inode(privroot)->i_mutex, I_MUTEX_XATTR);
 
         xaroot = dget(REISERFS_SB(sb)->xattr_root);
         if (!xaroot)
                 xaroot = ERR_PTR(-ENODATA);
-        else if (!xaroot->d_inode) {
+        else if (d_really_is_negative(xaroot)) {
                 int err = -ENODATA;
 
                 if (xattr_may_create(flags))
-                        err = xattr_mkdir(privroot->d_inode, xaroot, 0700);
+                        err = xattr_mkdir(d_inode(privroot), xaroot, 0700);
                 if (err) {
                         dput(xaroot);
                         xaroot = ERR_PTR(err);
                 }
         }
 
-        mutex_unlock(&privroot->d_inode->i_mutex);
+        mutex_unlock(&d_inode(privroot)->i_mutex);
         return xaroot;
 }
 
@@ -156,21 +156,21 @@ static struct dentry *open_xa_dir(const struct inode *inode, int flags)
                  le32_to_cpu(INODE_PKEY(inode)->k_objectid),
                  inode->i_generation);
 
-        mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
+        mutex_lock_nested(&d_inode(xaroot)->i_mutex, I_MUTEX_XATTR);
 
         xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
-        if (!IS_ERR(xadir) && !xadir->d_inode) {
+        if (!IS_ERR(xadir) && d_really_is_negative(xadir)) {
                 int err = -ENODATA;
 
                 if (xattr_may_create(flags))
-                        err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
+                        err = xattr_mkdir(d_inode(xaroot), xadir, 0700);
                 if (err) {
                         dput(xadir);
                         xadir = ERR_PTR(err);
                 }
         }
 
-        mutex_unlock(&xaroot->d_inode->i_mutex);
+        mutex_unlock(&d_inode(xaroot)->i_mutex);
         dput(xaroot);
         return xadir;
 }
@@ -195,7 +195,7 @@ fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
                 container_of(ctx, struct reiserfs_dentry_buf, ctx);
         struct dentry *dentry;
 
-        WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
+        WARN_ON_ONCE(!mutex_is_locked(&d_inode(dbuf->xadir)->i_mutex));
 
         if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
                 return -ENOSPC;
@@ -207,7 +207,7 @@ fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
         dentry = lookup_one_len(name, dbuf->xadir, namelen);
         if (IS_ERR(dentry)) {
                 return PTR_ERR(dentry);
-        } else if (!dentry->d_inode) {
+        } else if (d_really_is_negative(dentry)) {
                 /* A directory entry exists, but no file? */
                 reiserfs_error(dentry->d_sb, "xattr-20003",
                                "Corrupted directory: xattr %pd listed but "
@@ -249,16 +249,16 @@ static int reiserfs_for_each_xattr(struct inode *inode,
         if (IS_ERR(dir)) {
                 err = PTR_ERR(dir);
                 goto out;
-        } else if (!dir->d_inode) {
+        } else if (d_really_is_negative(dir)) {
                 err = 0;
                 goto out_dir;
         }
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
 
         buf.xadir = dir;
         while (1) {
-                err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
+                err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
                 if (err)
                         break;
                 if (!buf.count)
@@ -276,7 +276,7 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                         break;
                 buf.count = 0;
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 
         cleanup_dentry_buf(&buf);
 
@@ -298,13 +298,13 @@ static int reiserfs_for_each_xattr(struct inode *inode,
                 if (!err) {
                         int jerror;
 
-                        mutex_lock_nested(&dir->d_parent->d_inode->i_mutex,
+                        mutex_lock_nested(&d_inode(dir->d_parent)->i_mutex,
                                           I_MUTEX_XATTR);
                         err = action(dir, data);
                         reiserfs_write_lock(inode->i_sb);
                         jerror = journal_end(&th);
                         reiserfs_write_unlock(inode->i_sb);
-                        mutex_unlock(&dir->d_parent->d_inode->i_mutex);
+                        mutex_unlock(&d_inode(dir->d_parent)->i_mutex);
                         err = jerror ?: err;
                 }
         }
@@ -319,7 +319,7 @@ out:
 
 static int delete_one_xattr(struct dentry *dentry, void *data)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
 
         /* This is the xattr dir, handle specially. */
         if (d_is_dir(dentry))
@@ -384,27 +384,27 @@ static struct dentry *xattr_lookup(struct inode *inode, const char *name,
         if (IS_ERR(xadir))
                 return ERR_CAST(xadir);
 
-        mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
+        mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
         xafile = lookup_one_len(name, xadir, strlen(name));
         if (IS_ERR(xafile)) {
                 err = PTR_ERR(xafile);
                 goto out;
         }
 
-        if (xafile->d_inode && (flags & XATTR_CREATE))
+        if (d_really_is_positive(xafile) && (flags & XATTR_CREATE))
                 err = -EEXIST;
 
-        if (!xafile->d_inode) {
+        if (d_really_is_negative(xafile)) {
                 err = -ENODATA;
                 if (xattr_may_create(flags))
-                        err = xattr_create(xadir->d_inode, xafile,
+                        err = xattr_create(d_inode(xadir), xafile,
                                               0700|S_IFREG);
         }
 
         if (err)
                 dput(xafile);
 out:
-        mutex_unlock(&xadir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(xadir)->i_mutex);
         dput(xadir);
         if (err)
                 return ERR_PTR(err);
@@ -469,21 +469,21 @@ static int lookup_and_delete_xattr(struct inode *inode, const char *name)
         if (IS_ERR(xadir))
                 return PTR_ERR(xadir);
 
-        mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
+        mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR);
         dentry = lookup_one_len(name, xadir, strlen(name));
         if (IS_ERR(dentry)) {
                 err = PTR_ERR(dentry);
                 goto out_dput;
         }
 
-        if (dentry->d_inode) {
-                err = xattr_unlink(xadir->d_inode, dentry);
+        if (d_really_is_positive(dentry)) {
+                err = xattr_unlink(d_inode(xadir), dentry);
                 update_ctime(inode);
         }
 
         dput(dentry);
 out_dput:
-        mutex_unlock(&xadir->d_inode->i_mutex);
+        mutex_unlock(&d_inode(xadir)->i_mutex);
         dput(xadir);
         return err;
 }
@@ -533,7 +533,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
                 else
                         chunk = buffer_size - buffer_pos;
 
-                page = reiserfs_get_page(dentry->d_inode, file_pos);
+                page = reiserfs_get_page(d_inode(dentry), file_pos);
                 if (IS_ERR(page)) {
                         err = PTR_ERR(page);
                         goto out_unlock;
@@ -573,18 +573,18 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
         }
 
         new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
-        if (!err && new_size < i_size_read(dentry->d_inode)) {
+        if (!err && new_size < i_size_read(d_inode(dentry))) {
                 struct iattr newattrs = {
                         .ia_ctime = current_fs_time(inode->i_sb),
                         .ia_size = new_size,
                         .ia_valid = ATTR_SIZE | ATTR_CTIME,
                 };
 
-                mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
-                inode_dio_wait(dentry->d_inode);
+                mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_XATTR);
+                inode_dio_wait(d_inode(dentry));
 
                 err = reiserfs_setattr(dentry, &newattrs);
-                mutex_unlock(&dentry->d_inode->i_mutex);
+                mutex_unlock(&d_inode(dentry)->i_mutex);
         } else
                 update_ctime(inode);
 out_unlock:
@@ -657,7 +657,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
 
         down_read(&REISERFS_I(inode)->i_xattr_sem);
 
-        isize = i_size_read(dentry->d_inode);
+        isize = i_size_read(d_inode(dentry));
 
         /* Just return the size needed */
         if (buffer == NULL) {
@@ -680,7 +680,7 @@ reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
                 else
                         chunk = isize - file_pos;
 
-                page = reiserfs_get_page(dentry->d_inode, file_pos);
+                page = reiserfs_get_page(d_inode(dentry), file_pos);
                 if (IS_ERR(page)) {
                         err = PTR_ERR(page);
                         goto out_unlock;
@@ -775,7 +775,7 @@ reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
 
         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-        if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                 return -EOPNOTSUPP;
 
         return handler->get(dentry, name, buffer, size, handler->flags);
@@ -784,7 +784,7 @@ reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
 /*
  * Inode operation setxattr()
  *
- * dentry->d_inode->i_mutex down
+ * d_inode(dentry)->i_mutex down
  */
 int
 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
@@ -794,7 +794,7 @@ reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 
         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-        if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                 return -EOPNOTSUPP;
 
         return handler->set(dentry, name, value, size, flags, handler->flags);
@@ -803,7 +803,7 @@ reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
 /*
  * Inode operation removexattr()
  *
- * dentry->d_inode->i_mutex down
+ * d_inode(dentry)->i_mutex down
  */
 int reiserfs_removexattr(struct dentry *dentry, const char *name)
 {
@@ -811,7 +811,7 @@ int reiserfs_removexattr(struct dentry *dentry, const char *name)
 
         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
 
-        if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+        if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                 return -EOPNOTSUPP;
 
         return handler->set(dentry, name, NULL, 0, XATTR_REPLACE, handler->flags);
@@ -875,14 +875,14 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                 .size = buffer ? size : 0,
         };
 
-        if (!dentry->d_inode)
+        if (d_really_is_negative(dentry))
                 return -EINVAL;
 
         if (!dentry->d_sb->s_xattr ||
-            get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
+            get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
                 return -EOPNOTSUPP;
 
-        dir = open_xa_dir(dentry->d_inode, XATTR_REPLACE);
+        dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE);
         if (IS_ERR(dir)) {
                 err = PTR_ERR(dir);
                 if (err == -ENODATA)
@@ -890,9 +890,9 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                 goto out;
         }
 
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
-        err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR);
+        err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
+        mutex_unlock(&d_inode(dir)->i_mutex);
 
         if (!err)
                 err = buf.pos;
@@ -905,12 +905,12 @@ out:
 static int create_privroot(struct dentry *dentry)
 {
         int err;
-        struct inode *inode = dentry->d_parent->d_inode;
+        struct inode *inode = d_inode(dentry->d_parent);
 
         WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
 
         err = xattr_mkdir(inode, dentry, 0700);
-        if (err || !dentry->d_inode) {
+        if (err || d_really_is_negative(dentry)) {
                 reiserfs_warning(dentry->d_sb, "jdm-20006",
                                  "xattrs/ACLs enabled and couldn't "
                                  "find/create .reiserfs_priv. "
@@ -918,7 +918,7 @@ static int create_privroot(struct dentry *dentry)
                 return -EOPNOTSUPP;
         }
 
-        dentry->d_inode->i_flags |= S_PRIVATE;
+        d_inode(dentry)->i_flags |= S_PRIVATE;
         reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
                       "storage.\n", PRIVROOT_NAME);
 
@@ -997,17 +997,17 @@ int reiserfs_lookup_privroot(struct super_block *s)
         int err = 0;
 
         /* If we don't have the privroot located yet - go find it */
-        mutex_lock(&s->s_root->d_inode->i_mutex);
+        mutex_lock(&d_inode(s->s_root)->i_mutex);
         dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
                                 strlen(PRIVROOT_NAME));
         if (!IS_ERR(dentry)) {
                 REISERFS_SB(s)->priv_root = dentry;
                 d_set_d_op(dentry, &xattr_lookup_poison_ops);
-                if (dentry->d_inode)
-                        dentry->d_inode->i_flags |= S_PRIVATE;
+                if (d_really_is_positive(dentry))
+                        d_inode(dentry)->i_flags |= S_PRIVATE;
         } else
                 err = PTR_ERR(dentry);
-        mutex_unlock(&s->s_root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(s->s_root)->i_mutex);
 
         return err;
 }
@@ -1026,15 +1026,15 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
         if (err)
                 goto error;
 
-        if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
-                mutex_lock(&s->s_root->d_inode->i_mutex);
+        if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) {
+                mutex_lock(&d_inode(s->s_root)->i_mutex);
                 err = create_privroot(REISERFS_SB(s)->priv_root);
-                mutex_unlock(&s->s_root->d_inode->i_mutex);
+                mutex_unlock(&d_inode(s->s_root)->i_mutex);
         }
 
-        if (privroot->d_inode) {
+        if (d_really_is_positive(privroot)) {
                 s->s_xattr = reiserfs_xattr_handlers;
-                mutex_lock(&privroot->d_inode->i_mutex);
+                mutex_lock(&d_inode(privroot)->i_mutex);
                 if (!REISERFS_SB(s)->xattr_root) {
                         struct dentry *dentry;
 
@@ -1045,7 +1045,7 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
                         else
                                 err = PTR_ERR(dentry);
                 }
-                mutex_unlock(&privroot->d_inode->i_mutex);
+                mutex_unlock(&d_inode(privroot)->i_mutex);
         }
 
 error:
diff --git a/fs/reiserfs/xattr.h b/fs/reiserfs/xattr.h
index f620e9678dd5..15dde6262c00 100644
--- a/fs/reiserfs/xattr.h
+++ b/fs/reiserfs/xattr.h
@@ -78,7 +78,7 @@ static inline size_t reiserfs_xattr_jcreate_nblocks(struct inode *inode)
 
         if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) {
                 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-                if (!REISERFS_SB(inode->i_sb)->xattr_root->d_inode)
+                if (d_really_is_negative(REISERFS_SB(inode->i_sb)->xattr_root))
                         nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
         }
 
diff --git a/fs/reiserfs/xattr_security.c b/fs/reiserfs/xattr_security.c
index e7f8939a4cb5..9a3b0616f283 100644
--- a/fs/reiserfs/xattr_security.c
+++ b/fs/reiserfs/xattr_security.c
@@ -15,10 +15,10 @@ security_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
         if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
                 return -EINVAL;
 
-        if (IS_PRIVATE(dentry->d_inode))
+        if (IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -28,10 +28,10 @@ security_set(struct dentry *dentry, const char *name, const void *buffer,
         if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX))
                 return -EINVAL;
 
-        if (IS_PRIVATE(dentry->d_inode))
+        if (IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t security_list(struct dentry *dentry, char *list, size_t list_len,
@@ -39,7 +39,7 @@ static size_t security_list(struct dentry *dentry, char *list, size_t list_len,
 {
         const size_t len = namelen + 1;
 
-        if (IS_PRIVATE(dentry->d_inode))
+        if (IS_PRIVATE(d_inode(dentry)))
                 return 0;
 
         if (list && len <= list_len) {
diff --git a/fs/reiserfs/xattr_trusted.c b/fs/reiserfs/xattr_trusted.c
index 5eeb0c48ba46..e4f1343714e0 100644
--- a/fs/reiserfs/xattr_trusted.c
+++ b/fs/reiserfs/xattr_trusted.c
@@ -14,10 +14,10 @@ trusted_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
         if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
                 return -EINVAL;
 
-        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -27,10 +27,10 @@ trusted_set(struct dentry *dentry, const char *name, const void *buffer,
         if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX))
                 return -EINVAL;
 
-        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                 return -EPERM;
 
-        return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t trusted_list(struct dentry *dentry, char *list, size_t list_size,
@@ -38,7 +38,7 @@ static size_t trusted_list(struct dentry *dentry, char *list, size_t list_size,
 {
         const size_t len = name_len + 1;
 
-        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode))
+        if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry)))
                 return 0;
 
         if (list && len <= list_size) {
diff --git a/fs/reiserfs/xattr_user.c b/fs/reiserfs/xattr_user.c
index e50eab046471..d0b08d3e5689 100644
--- a/fs/reiserfs/xattr_user.c
+++ b/fs/reiserfs/xattr_user.c
@@ -15,7 +15,7 @@ user_get(struct dentry *dentry, const char *name, void *buffer, size_t size,
                 return -EINVAL;
         if (!reiserfs_xattrs_user(dentry->d_sb))
                 return -EOPNOTSUPP;
-        return reiserfs_xattr_get(dentry->d_inode, name, buffer, size);
+        return reiserfs_xattr_get(d_inode(dentry), name, buffer, size);
 }
 
 static int
@@ -27,7 +27,7 @@ user_set(struct dentry *dentry, const char *name, const void *buffer,
 
         if (!reiserfs_xattrs_user(dentry->d_sb))
                 return -EOPNOTSUPP;
-        return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags);
+        return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags);
 }
 
 static size_t user_list(struct dentry *dentry, char *list, size_t list_size,
diff --git a/fs/squashfs/export.c b/fs/squashfs/export.c
index 5e1101ff276f..8073b6532cf0 100644
--- a/fs/squashfs/export.c
+++ b/fs/squashfs/export.c
@@ -110,7 +110,7 @@ static struct dentry *squashfs_fh_to_parent(struct super_block *sb,
 
 static struct dentry *squashfs_get_parent(struct dentry *child)
 {
-        struct inode *inode = child->d_inode;
+        struct inode *inode = d_inode(child);
         unsigned int parent_ino = squashfs_i(inode)->parent;
 
         return squashfs_export_iget(inode->i_sb, parent_ino);
diff --git a/fs/squashfs/xattr.c b/fs/squashfs/xattr.c
index 92fcde7b4d61..e5e0ddf5b143 100644
--- a/fs/squashfs/xattr.c
+++ b/fs/squashfs/xattr.c
@@ -39,7 +39,7 @@ static const struct xattr_handler *squashfs_xattr_handler(int);
 ssize_t squashfs_listxattr(struct dentry *d, char *buffer,
         size_t buffer_size)
 {
-        struct inode *inode = d->d_inode;
+        struct inode *inode = d_inode(d);
         struct super_block *sb = inode->i_sb;
         struct squashfs_sb_info *msblk = sb->s_fs_info;
         u64 start = SQUASHFS_XATTR_BLK(squashfs_i(inode)->xattr)
@@ -229,7 +229,7 @@ static int squashfs_user_get(struct dentry *d, const char *name, void *buffer,
         if (name[0] == '\0')
                 return  -EINVAL;
 
-        return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_USER, name,
+        return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_USER, name,
                 buffer, size);
 }
 
@@ -259,7 +259,7 @@ static int squashfs_trusted_get(struct dentry *d, const char *name,
         if (name[0] == '\0')
                 return  -EINVAL;
 
-        return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_TRUSTED, name,
+        return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_TRUSTED, name,
                 buffer, size);
 }
 
@@ -286,7 +286,7 @@ static int squashfs_security_get(struct dentry *d, const char *name,
         if (name[0] == '\0')
                 return  -EINVAL;
 
-        return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_SECURITY, name,
+        return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_SECURITY, name,
                 buffer, size);
 }
 
diff --git a/fs/stat.c b/fs/stat.c
index 19636af5e75c..cccc1aab9a8b 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -51,7 +51,7 @@ EXPORT_SYMBOL(generic_fillattr);
  */
 int vfs_getattr_nosec(struct path *path, struct kstat *stat)
 {
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_backing_inode(path->dentry);
 
         if (inode->i_op->getattr)
                 return inode->i_op->getattr(path->mnt, path->dentry, stat);
@@ -326,7 +326,7 @@ SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
 retry:
         error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty);
         if (!error) {
-                struct inode *inode = path.dentry->d_inode;
+                struct inode *inode = d_backing_inode(path.dentry);
 
                 error = empty ? -ENOENT : -EINVAL;
                 if (inode->i_op->readlink) {
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index d42291d08215..8f3555f00c54 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -132,7 +132,7 @@ struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_
 {
         const char * name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
-        struct inode * dir = dentry->d_parent->d_inode;
+        struct inode * dir = d_inode(dentry->d_parent);
         unsigned long start, n;
         unsigned long npages = dir_pages(dir);
         struct page *page = NULL;
@@ -176,7 +176,7 @@ found:
 
 int sysv_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const char * name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         struct page *page = NULL;
diff --git a/fs/sysv/file.c b/fs/sysv/file.c
index a48e30410ad1..82ddc09061e2 100644
--- a/fs/sysv/file.c
+++ b/fs/sysv/file.c
@@ -30,7 +30,7 @@ const struct file_operations sysv_file_operations = {
 
 static int sysv_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, attr);
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 66bc316927e8..2fde40acf024 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -443,7 +443,7 @@ static unsigned sysv_nblocks(struct super_block *s, loff_t size)
 int sysv_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
         struct super_block *s = dentry->d_sb;
-        generic_fillattr(dentry->d_inode, stat);
+        generic_fillattr(d_inode(dentry), stat);
         stat->blocks = (s->s_blocksize / 512) * sysv_nblocks(s, stat->size);
         stat->blksize = s->s_blocksize;
         return 0;
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 731b2bbcaab3..11e83ed0b4bf 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -118,7 +118,7 @@ out_fail:
 static int sysv_link(struct dentry * old_dentry, struct inode * dir, 
         struct dentry * dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
 
         inode->i_ctime = CURRENT_TIME_SEC;
         inode_inc_link_count(inode);
@@ -166,7 +166,7 @@ out_dir:
 
 static int sysv_unlink(struct inode * dir, struct dentry * dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         struct page * page;
         struct sysv_dir_entry * de;
         int err = -ENOENT;
@@ -187,7 +187,7 @@ out:
 
 static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int err = -ENOTEMPTY;
 
         if (sysv_empty_dir(inode)) {
@@ -208,8 +208,8 @@ static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
                   struct inode * new_dir, struct dentry * new_dentry)
 {
-        struct inode * old_inode = old_dentry->d_inode;
-        struct inode * new_inode = new_dentry->d_inode;
+        struct inode * old_inode = d_inode(old_dentry);
+        struct inode * new_inode = d_inode(new_dentry);
         struct page * dir_page = NULL;
         struct sysv_dir_entry * dir_de = NULL;
         struct page * old_page;
diff --git a/fs/sysv/symlink.c b/fs/sysv/symlink.c
index 00d2f8a43e4e..d3fa0d703314 100644
--- a/fs/sysv/symlink.c
+++ b/fs/sysv/symlink.c
@@ -10,7 +10,7 @@
 
 static void *sysv_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        nd_set_link(nd, (char *)SYSV_I(dentry->d_inode)->i_data);
+        nd_set_link(nd, (char *)SYSV_I(d_inode(dentry))->i_data);
         return NULL;
 }
 
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 02d1ee778df0..27060fc855d4 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -499,7 +499,7 @@ static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
                       struct dentry *dentry)
 {
         struct ubifs_info *c = dir->i_sb->s_fs_info;
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct ubifs_inode *ui = ubifs_inode(inode);
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
@@ -554,7 +554,7 @@ out_cancel:
 static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct ubifs_info *c = dir->i_sb->s_fs_info;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
         int err, budgeted = 1;
@@ -646,7 +646,7 @@ static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
 {
         struct ubifs_info *c = dir->i_sb->s_fs_info;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
         int err, budgeted = 1;
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
@@ -662,7 +662,7 @@ static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
                 inode->i_ino, dir->i_ino);
         ubifs_assert(mutex_is_locked(&dir->i_mutex));
         ubifs_assert(mutex_is_locked(&inode->i_mutex));
-        err = check_dir_empty(c, dentry->d_inode);
+        err = check_dir_empty(c, d_inode(dentry));
         if (err)
                 return err;
 
@@ -970,8 +970,8 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         struct inode *new_dir, struct dentry *new_dentry)
 {
         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
         int err, release, sync = 0, move = (new_dir != old_dir);
         int is_dir = S_ISDIR(old_inode->i_mode);
@@ -1136,7 +1136,7 @@ int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
                   struct kstat *stat)
 {
         loff_t size;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ubifs_inode *ui = ubifs_inode(inode);
 
         mutex_lock(&ui->ui_mutex);
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 3ba3fef64e9e..35efc103c39c 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -1257,7 +1257,7 @@ static int do_setattr(struct ubifs_info *c, struct inode *inode,
 int ubifs_setattr(struct dentry *dentry, struct iattr *attr)
 {
         int err;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct ubifs_info *c = inode->i_sb->s_fs_info;
 
         dbg_gen("ino %lu, mode %#x, ia_valid %#x",
@@ -1302,7 +1302,7 @@ static void ubifs_invalidatepage(struct page *page, unsigned int offset,
 
 static void *ubifs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ubifs_inode *ui = ubifs_inode(dentry->d_inode);
+        struct ubifs_inode *ui = ubifs_inode(d_inode(dentry));
 
         nd_set_link(nd, ui->data);
         return NULL;
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index 90ae1a8439d9..0b9da5b6e0f9 100644
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -930,8 +930,8 @@ int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
         union ubifs_key key;
         struct ubifs_dent_node *dent, *dent2;
         int err, dlen1, dlen2, ilen, lnum, offs, len;
-        const struct inode *old_inode = old_dentry->d_inode;
-        const struct inode *new_inode = new_dentry->d_inode;
+        const struct inode *old_inode = d_inode(old_dentry);
+        const struct inode *new_inode = d_inode(new_dentry);
         int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
         int last_reference = !!(new_inode && new_inode->i_nlink == 0);
         int move = (old_dir != new_dir);
diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c
index 3659b1934500..96f3448b6eb4 100644
--- a/fs/ubifs/xattr.c
+++ b/fs/ubifs/xattr.c
@@ -364,15 +364,15 @@ int ubifs_setxattr(struct dentry *dentry, const char *name,
                    const void *value, size_t size, int flags)
 {
         dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
-                name, dentry->d_inode->i_ino, dentry, size);
+                name, d_inode(dentry)->i_ino, dentry, size);
 
-        return setxattr(dentry->d_inode, name, value, size, flags);
+        return setxattr(d_inode(dentry), name, value, size, flags);
 }
 
 ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
                        size_t size)
 {
-        struct inode *inode, *host = dentry->d_inode;
+        struct inode *inode, *host = d_inode(dentry);
         struct ubifs_info *c = host->i_sb->s_fs_info;
         struct qstr nm = QSTR_INIT(name, strlen(name));
         struct ubifs_inode *ui;
@@ -432,7 +432,7 @@ out_unlock:
 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
         union ubifs_key key;
-        struct inode *host = dentry->d_inode;
+        struct inode *host = d_inode(dentry);
         struct ubifs_info *c = host->i_sb->s_fs_info;
         struct ubifs_inode *host_ui = ubifs_inode(host);
         struct ubifs_dent_node *xent, *pxent = NULL;
@@ -535,7 +535,7 @@ out_cancel:
 
 int ubifs_removexattr(struct dentry *dentry, const char *name)
 {
-        struct inode *inode, *host = dentry->d_inode;
+        struct inode *inode, *host = d_inode(dentry);
         struct ubifs_info *c = host->i_sb->s_fs_info;
         struct qstr nm = QSTR_INIT(name, strlen(name));
         struct ubifs_dent_node *xent;
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 5dadad9960b9..7a95b8fed302 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -249,7 +249,7 @@ const struct file_operations udf_file_operations = {
 
 static int udf_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         int error;
 
         error = inode_change_ok(inode, attr);
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 39661977c89c..5c03f0dfb98b 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -551,7 +551,7 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
 static int udf_add_nondir(struct dentry *dentry, struct inode *inode)
 {
         struct udf_inode_info *iinfo = UDF_I(inode);
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         struct udf_fileident_bh fibh;
         struct fileIdentDesc cfi, *fi;
         int err;
@@ -767,7 +767,7 @@ static int empty_dir(struct inode *dir)
 static int udf_rmdir(struct inode *dir, struct dentry *dentry)
 {
         int retval;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct udf_fileident_bh fibh;
         struct fileIdentDesc *fi, cfi;
         struct kernel_lb_addr tloc;
@@ -809,7 +809,7 @@ out:
 static int udf_unlink(struct inode *dir, struct dentry *dentry)
 {
         int retval;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct udf_fileident_bh fibh;
         struct fileIdentDesc *fi;
         struct fileIdentDesc cfi;
@@ -999,7 +999,7 @@ out_no_entry:
 static int udf_link(struct dentry *old_dentry, struct inode *dir,
                     struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         struct udf_fileident_bh fibh;
         struct fileIdentDesc cfi, *fi;
         int err;
@@ -1038,8 +1038,8 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                       struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct udf_fileident_bh ofibh, nfibh;
         struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
         struct fileIdentDesc ocfi, ncfi;
@@ -1179,7 +1179,7 @@ static struct dentry *udf_get_parent(struct dentry *child)
         struct fileIdentDesc cfi;
         struct udf_fileident_bh fibh;
 
-        if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi))
+        if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi))
                 return ERR_PTR(-EACCES);
 
         if (fibh.sbh != fibh.ebh)
@@ -1187,7 +1187,7 @@ static struct dentry *udf_get_parent(struct dentry *child)
         brelse(fibh.sbh);
 
         tloc = lelb_to_cpu(cfi.icb.extLocation);
-        inode = udf_iget(child->d_inode->i_sb, &tloc);
+        inode = udf_iget(d_inode(child)->i_sb, &tloc);
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 0ecc2cebed8f..1bfe8cabff0f 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -311,7 +311,7 @@ found:
  */
 int ufs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_inode(dentry->d_parent);
         const unsigned char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
         struct super_block *sb = dir->i_sb;
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index fd65deb4b5f0..e491a93a7e9a 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -165,7 +165,7 @@ out_fail:
 static int ufs_link (struct dentry * old_dentry, struct inode * dir,
         struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int error;
 
         lock_ufs(dir->i_sb);
@@ -222,7 +222,7 @@ out_fail:
 
 static int ufs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         struct ufs_dir_entry *de;
         struct page *page;
         int err = -ENOENT;
@@ -244,7 +244,7 @@ out:
 
 static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
 {
-        struct inode * inode = dentry->d_inode;
+        struct inode * inode = d_inode(dentry);
         int err= -ENOTEMPTY;
 
         lock_ufs(dir->i_sb);
@@ -263,8 +263,8 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
                       struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct inode *new_inode = new_dentry->d_inode;
+        struct inode *old_inode = d_inode(old_dentry);
+        struct inode *new_inode = d_inode(new_dentry);
         struct page *dir_page = NULL;
         struct ufs_dir_entry * dir_de = NULL;
         struct page *old_page;
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 8092d3759a5e..b3bc3e7ae79d 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -144,10 +144,10 @@ static struct dentry *ufs_get_parent(struct dentry *child)
         struct qstr dot_dot = QSTR_INIT("..", 2);
         ino_t ino;
 
-        ino = ufs_inode_by_name(child->d_inode, &dot_dot);
+        ino = ufs_inode_by_name(d_inode(child), &dot_dot);
         if (!ino)
                 return ERR_PTR(-ENOENT);
-        return d_obtain_alias(ufs_iget(child->d_inode->i_sb, ino));
+        return d_obtain_alias(ufs_iget(d_inode(child)->i_sb, ino));
 }
 
 static const struct export_operations ufs_export_ops = {
diff --git a/fs/ufs/symlink.c b/fs/ufs/symlink.c
index d283628b4778..5b537e2fdda3 100644
--- a/fs/ufs/symlink.c
+++ b/fs/ufs/symlink.c
@@ -34,7 +34,7 @@
 
 static void *ufs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct ufs_inode_info *p = UFS_I(dentry->d_inode);
+        struct ufs_inode_info *p = UFS_I(d_inode(dentry));
         nd_set_link(nd, (char*)p->i_u1.i_symlink);
         return NULL;
 }
diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index f04f89fbd4d9..21154704c168 100644
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -492,7 +492,7 @@ out:
 
 int ufs_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         unsigned int ia_valid = attr->ia_valid;
         int error;
 
diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
index b97359ba2648..652cd3c5b58c 100644
--- a/fs/xfs/xfs_export.c
+++ b/fs/xfs/xfs_export.c
@@ -215,7 +215,7 @@ xfs_fs_get_parent(
         int                     error;
         struct xfs_inode        *cip;
 
-        error = xfs_lookup(XFS_I(child->d_inode), &xfs_name_dotdot, &cip, NULL);
+        error = xfs_lookup(XFS_I(d_inode(child)), &xfs_name_dotdot, &cip, NULL);
         if (unlikely(error))
                 return ERR_PTR(error);
 
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 8f9f854376c6..da82f1cb4b9b 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -294,7 +294,7 @@ xfs_filestream_get_parent(
         if (!parent)
                 goto out_dput;
 
-        dir = igrab(parent->d_inode);
+        dir = igrab(d_inode(parent));
         dput(parent);
 
 out_dput:
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 5f4a396f5186..87f67c6b654c 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -82,7 +82,7 @@ xfs_find_handle(
                 error = user_lpath((const char __user *)hreq->path, &path);
                 if (error)
                         return error;
-                inode = path.dentry->d_inode;
+                inode = d_inode(path.dentry);
         }
         ip = XFS_I(inode);
 
@@ -210,7 +210,7 @@ xfs_open_by_handle(
         dentry = xfs_handlereq_to_dentry(parfilp, hreq);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
 
         /* Restrict xfs_open_by_handle to directories & regular files. */
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
@@ -303,7 +303,7 @@ xfs_readlink_by_handle(
                 goto out_dput;
         }
 
-        error = xfs_readlink(XFS_I(dentry->d_inode), link);
+        error = xfs_readlink(XFS_I(d_inode(dentry)), link);
         if (error)
                 goto out_kfree;
         error = readlink_copy(hreq->ohandle, olen, link);
@@ -376,7 +376,7 @@ xfs_fssetdm_by_handle(
                 return PTR_ERR(dentry);
         }
 
-        if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
+        if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
                 error = -EPERM;
                 goto out;
         }
@@ -386,7 +386,7 @@ xfs_fssetdm_by_handle(
                 goto out;
         }
 
-        error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+        error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
                                  fsd.fsd_dmstate);
 
  out:
@@ -429,7 +429,7 @@ xfs_attrlist_by_handle(
                 goto out_dput;
 
         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-        error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+        error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
                                         al_hreq.flags, cursor);
         if (error)
                 goto out_kfree;
@@ -559,7 +559,7 @@ xfs_attrmulti_by_handle(
                 switch (ops[i].am_opcode) {
                 case ATTR_OP_GET:
                         ops[i].am_error = xfs_attrmulti_attr_get(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         ops[i].am_attrvalue, &ops[i].am_length,
                                         ops[i].am_flags);
                         break;
@@ -568,7 +568,7 @@ xfs_attrmulti_by_handle(
                         if (ops[i].am_error)
                                 break;
                         ops[i].am_error = xfs_attrmulti_attr_set(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         ops[i].am_attrvalue, ops[i].am_length,
                                         ops[i].am_flags);
                         mnt_drop_write_file(parfilp);
@@ -578,7 +578,7 @@ xfs_attrmulti_by_handle(
                         if (ops[i].am_error)
                                 break;
                         ops[i].am_error = xfs_attrmulti_attr_remove(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         ops[i].am_flags);
                         mnt_drop_write_file(parfilp);
                         break;
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index bfc7c7c8a0c8..b88bdc85dd3d 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -375,7 +375,7 @@ xfs_compat_attrlist_by_handle(
                 goto out_dput;
 
         cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-        error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
+        error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
                                         al_hreq.flags, cursor);
         if (error)
                 goto out_kfree;
@@ -445,7 +445,7 @@ xfs_compat_attrmulti_by_handle(
                 switch (ops[i].am_opcode) {
                 case ATTR_OP_GET:
                         ops[i].am_error = xfs_attrmulti_attr_get(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         compat_ptr(ops[i].am_attrvalue),
                                         &ops[i].am_length, ops[i].am_flags);
                         break;
@@ -454,7 +454,7 @@ xfs_compat_attrmulti_by_handle(
                         if (ops[i].am_error)
                                 break;
                         ops[i].am_error = xfs_attrmulti_attr_set(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         compat_ptr(ops[i].am_attrvalue),
                                         ops[i].am_length, ops[i].am_flags);
                         mnt_drop_write_file(parfilp);
@@ -464,7 +464,7 @@ xfs_compat_attrmulti_by_handle(
                         if (ops[i].am_error)
                                 break;
                         ops[i].am_error = xfs_attrmulti_attr_remove(
-                                        dentry->d_inode, attr_name,
+                                        d_inode(dentry), attr_name,
                                         ops[i].am_flags);
                         mnt_drop_write_file(parfilp);
                         break;
@@ -504,7 +504,7 @@ xfs_compat_fssetdm_by_handle(
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
-        if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
+        if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
                 error = -EPERM;
                 goto out;
         }
@@ -514,7 +514,7 @@ xfs_compat_fssetdm_by_handle(
                 goto out;
         }
 
-        error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
+        error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
                                  fsd.fsd_dmstate);
 
 out:
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 2f1839e4dd1b..f4cd7204e236 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -304,7 +304,7 @@ xfs_vn_link(
         struct inode    *dir,
         struct dentry   *dentry)
 {
-        struct inode    *inode = old_dentry->d_inode;
+        struct inode    *inode = d_inode(old_dentry);
         struct xfs_name name;
         int             error;
 
@@ -329,7 +329,7 @@ xfs_vn_unlink(
 
         xfs_dentry_to_name(&name, dentry, 0);
 
-        error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
+        error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));
         if (error)
                 return error;
 
@@ -389,7 +389,7 @@ xfs_vn_rename(
         struct dentry   *ndentry,
         unsigned int    flags)
 {
-        struct inode    *new_inode = ndentry->d_inode;
+        struct inode    *new_inode = d_inode(ndentry);
         int             omode = 0;
         struct xfs_name oname;
         struct xfs_name nname;
@@ -399,12 +399,12 @@ xfs_vn_rename(
 
         /* if we are exchanging files, we need to set i_mode of both files */
         if (flags & RENAME_EXCHANGE)
-                omode = ndentry->d_inode->i_mode;
+                omode = d_inode(ndentry)->i_mode;
 
         xfs_dentry_to_name(&oname, odentry, omode);
-        xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
+        xfs_dentry_to_name(&nname, ndentry, d_inode(odentry)->i_mode);
 
-        return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
+        return xfs_rename(XFS_I(odir), &oname, XFS_I(d_inode(odentry)),
                           XFS_I(ndir), &nname,
                           new_inode ? XFS_I(new_inode) : NULL, flags);
 }
@@ -426,7 +426,7 @@ xfs_vn_follow_link(
         if (!link)
                 goto out_err;
 
-        error = xfs_readlink(XFS_I(dentry->d_inode), link);
+        error = xfs_readlink(XFS_I(d_inode(dentry)), link);
         if (unlikely(error))
                 goto out_kfree;
 
@@ -446,7 +446,7 @@ xfs_vn_getattr(
         struct dentry           *dentry,
         struct kstat            *stat)
 {
-        struct inode            *inode = dentry->d_inode;
+        struct inode            *inode = d_inode(dentry);
         struct xfs_inode        *ip = XFS_I(inode);
         struct xfs_mount        *mp = ip->i_mount;
 
@@ -946,14 +946,14 @@ xfs_vn_setattr(
         struct dentry           *dentry,
         struct iattr            *iattr)
 {
-        struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+        struct xfs_inode        *ip = XFS_I(d_inode(dentry));
         int                     error;
 
         if (iattr->ia_valid & ATTR_SIZE) {
                 uint            iolock = XFS_IOLOCK_EXCL;
 
                 xfs_ilock(ip, iolock);
-                error = xfs_break_layouts(dentry->d_inode, &iolock, true);
+                error = xfs_break_layouts(d_inode(dentry), &iolock, true);
                 if (!error) {
                         xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
                         iolock |= XFS_MMAPLOCK_EXCL;
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 5f357ca97e76..858e1e62bbaa 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -1048,7 +1048,7 @@ xfs_fs_statfs(
 {
         struct xfs_mount        *mp = XFS_M(dentry->d_sb);
         xfs_sb_t                *sbp = &mp->m_sb;
-        struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+        struct xfs_inode        *ip = XFS_I(d_inode(dentry));
         __uint64_t              fakeinos, id;
         __uint64_t              icount;
         __uint64_t              ifree;
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 69f6e475de97..c036815183cb 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -35,7 +35,7 @@ static int
 xfs_xattr_get(struct dentry *dentry, const char *name,
                 void *value, size_t size, int xflags)
 {
-        struct xfs_inode *ip = XFS_I(dentry->d_inode);
+        struct xfs_inode *ip = XFS_I(d_inode(dentry));
         int error, asize = size;
 
         if (strcmp(name, "") == 0)
@@ -57,7 +57,7 @@ static int
 xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
                 size_t size, int flags, int xflags)
 {
-        struct xfs_inode *ip = XFS_I(dentry->d_inode);
+        struct xfs_inode *ip = XFS_I(d_inode(dentry));
 
         if (strcmp(name, "") == 0)
                 return -EINVAL;
@@ -197,7 +197,7 @@ xfs_vn_listxattr(struct dentry *dentry, char *data, size_t size)
 {
         struct xfs_attr_list_context context;
         struct attrlist_cursor_kern cursor = { 0 };
-        struct inode            *inode = dentry->d_inode;
+        struct inode            *inode = d_inode(dentry);
         int                     error;
 
         /*
diff --git a/include/linux/fs.h b/include/linux/fs.h
index c7496f263860..35ec87e490b1 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1820,7 +1820,7 @@ struct super_operations {
 #define I_SYNC                  (1 << __I_SYNC)
 #define I_REFERENCED            (1 << 8)
 #define __I_DIO_WAKEUP          9
-#define I_DIO_WAKEUP            (1 << I_DIO_WAKEUP)
+#define I_DIO_WAKEUP            (1 << __I_DIO_WAKEUP)
 #define I_LINKABLE              (1 << 10)
 #define I_DIRTY_TIME            (1 << 11)
 #define __I_DIRTY_TIME_EXPIRED  12
@@ -2644,6 +2644,9 @@ enum {
 
         /* filesystem can handle aio writes beyond i_size */
         DIO_ASYNC_EXTEND = 0x04,
+
+        /* inode/fs/bdev does not need truncate protection */
+        DIO_SKIP_DIO_COUNT = 0x08,
 };
 
 void dio_end_io(struct bio *bio, int error);
@@ -2666,7 +2669,31 @@ static inline ssize_t blockdev_direct_IO(struct kiocb *iocb,
 #endif
 
 void inode_dio_wait(struct inode *inode);
-void inode_dio_done(struct inode *inode);
+
+/*
+ * inode_dio_begin - signal start of a direct I/O requests
+ * @inode: inode the direct I/O happens on
+ *
+ * This is called once we've finished processing a direct I/O request,
+ * and is used to wake up callers waiting for direct I/O to be quiesced.
+ */
+static inline void inode_dio_begin(struct inode *inode)
+{
+        atomic_inc(&inode->i_dio_count);
+}
+
+/*
+ * inode_dio_end - signal finish of a direct I/O requests
+ * @inode: inode the direct I/O happens on
+ *
+ * This is called once we've finished processing a direct I/O request,
+ * and is used to wake up callers waiting for direct I/O to be quiesced.
+ */
+static inline void inode_dio_end(struct inode *inode)
+{
+        if (atomic_dec_and_test(&inode->i_dio_count))
+                wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
+}
 
 extern void inode_set_flags(struct inode *inode, unsigned int flags,
                             unsigned int mask);
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index a65208a8fe18..796ef9645827 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -115,10 +115,19 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
  * Extended Capability Register
  */
 
-#define ecap_niotlb_iunits(e)   ((((e) >> 24) & 0xff) + 1)
+#define ecap_pss(e)             ((e >> 35) & 0x1f)
+#define ecap_eafs(e)            ((e >> 34) & 0x1)
+#define ecap_nwfs(e)            ((e >> 33) & 0x1)
+#define ecap_srs(e)             ((e >> 31) & 0x1)
+#define ecap_ers(e)             ((e >> 30) & 0x1)
+#define ecap_prs(e)             ((e >> 29) & 0x1)
+#define ecap_pasid(e)           ((e >> 28) & 0x1)
+#define ecap_dis(e)             ((e >> 27) & 0x1)
+#define ecap_nest(e)            ((e >> 26) & 0x1)
+#define ecap_mts(e)             ((e >> 25) & 0x1)
+#define ecap_ecs(e)             ((e >> 24) & 0x1)
 #define ecap_iotlb_offset(e)    ((((e) >> 8) & 0x3ff) * 16)
-#define ecap_max_iotlb_offset(e) \
-        (ecap_iotlb_offset(e) + ecap_niotlb_iunits(e) * 16)
+#define ecap_max_iotlb_offset(e) (ecap_iotlb_offset(e) + 16)
 #define ecap_coherent(e)        ((e) & 0x1)
 #define ecap_qis(e)             ((e) & 0x2)
 #define ecap_pass_through(e)    ((e >> 6) & 0x1)
@@ -180,6 +189,9 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 #define DMA_GSTS_IRES (((u32)1) << 25)
 #define DMA_GSTS_CFIS (((u32)1) << 23)
 
+/* DMA_RTADDR_REG */
+#define DMA_RTADDR_RTT (((u64)1) << 11)
+
 /* CCMD_REG */
 #define DMA_CCMD_ICC (((u64)1) << 63)
 #define DMA_CCMD_GLOBAL_INVL (((u64)1) << 61)
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 410abd172feb..b95f914ce083 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -511,6 +511,7 @@ extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned
  * Try to write back everything synchronously (but check the
  * return value!)
  */
+extern int nfs_sync_inode(struct inode *inode);
 extern int nfs_wb_all(struct inode *inode);
 extern int nfs_wb_page(struct inode *inode, struct page* page);
 extern int nfs_wb_page_cancel(struct inode *inode, struct page* page);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 4cb3eaa89cf7..93ab6071bbe9 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -255,11 +255,13 @@ struct nfs4_layoutget {
 struct nfs4_getdeviceinfo_args {
         struct nfs4_sequence_args seq_args;
         struct pnfs_device *pdev;
+        __u32 notify_types;
 };
 
 struct nfs4_getdeviceinfo_res {
         struct nfs4_sequence_res seq_res;
         struct pnfs_device *pdev;
+        __u32 notification;
 };
 
 struct nfs4_layoutcommit_args {
@@ -1271,11 +1273,15 @@ struct nfs42_falloc_args {
         nfs4_stateid                     falloc_stateid;
         u64                              falloc_offset;
         u64                              falloc_length;
+        const u32                       *falloc_bitmask;
 };
 
 struct nfs42_falloc_res {
         struct nfs4_sequence_res        seq_res;
         unsigned int                    status;
+
+        struct nfs_fattr                *falloc_fattr;
+        const struct nfs_server         *falloc_server;
 };
 
 struct nfs42_seek_args {
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index aadc6a04e1ac..807371357160 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -142,12 +142,18 @@ typedef __be32	rpc_fraghdr;
         (RPC_REPHDRSIZE + (2 + RPC_MAX_AUTH_SIZE/4))
 
 /*
- * RFC1833/RFC3530 rpcbind (v3+) well-known netid's.
+ * Well-known netids. See:
+ *
+ *   http://www.iana.org/assignments/rpc-netids/rpc-netids.xhtml
  */
 #define RPCBIND_NETID_UDP       "udp"
 #define RPCBIND_NETID_TCP       "tcp"
+#define RPCBIND_NETID_RDMA      "rdma"
+#define RPCBIND_NETID_SCTP      "sctp"
 #define RPCBIND_NETID_UDP6      "udp6"
 #define RPCBIND_NETID_TCP6      "tcp6"
+#define RPCBIND_NETID_RDMA6     "rdma6"
+#define RPCBIND_NETID_SCTP6     "sctp6"
 #define RPCBIND_NETID_LOCAL     "local"
 
 /*
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h
index 64a0a0a97b23..c984c85981ea 100644
--- a/include/linux/sunrpc/xprtrdma.h
+++ b/include/linux/sunrpc/xprtrdma.h
@@ -41,11 +41,6 @@
 #define _LINUX_SUNRPC_XPRTRDMA_H
 
 /*
- * rpcbind (v3+) RDMA netid.
- */
-#define RPCBIND_NETID_RDMA      "rdma"
-
-/*
  * Constants. Max RPC/NFS header is big enough to account for
  * additional marshaling buffers passed down by Linux client.
  *
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 572e6503394a..7f79cf459591 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -407,10 +407,10 @@ TRACE_EVENT(btrfs_sync_file,
 
         TP_fast_assign(
                 struct dentry *dentry = file->f_path.dentry;
-                struct inode *inode = dentry->d_inode;
+                struct inode *inode = d_inode(dentry);
 
                 __entry->ino            = inode->i_ino;
-                __entry->parent         = dentry->d_parent->d_inode->i_ino;
+                __entry->parent         = d_inode(dentry->d_parent)->i_ino;
                 __entry->datasync       = datasync;
                 __entry->root_objectid  =
                                  BTRFS_I(inode)->root->root_key.objectid;
diff --git a/include/trace/events/ext3.h b/include/trace/events/ext3.h
index 7f20707849bb..fc733d28117a 100644
--- a/include/trace/events/ext3.h
+++ b/include/trace/events/ext3.h
@@ -439,10 +439,10 @@ TRACE_EVENT(ext3_sync_file_enter,
         TP_fast_assign(
                 struct dentry *dentry = file->f_path.dentry;
 
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
-                __entry->ino            = dentry->d_inode->i_ino;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
                 __entry->datasync       = datasync;
-                __entry->parent         = dentry->d_parent->d_inode->i_ino;
+                __entry->parent         = d_inode(dentry->d_parent)->i_ino;
         ),
 
         TP_printk("dev %d,%d ino %lu parent %ld datasync %d ",
@@ -710,9 +710,9 @@ TRACE_EVENT(ext3_unlink_enter,
 
         TP_fast_assign(
                 __entry->parent         = parent->i_ino;
-                __entry->ino            = dentry->d_inode->i_ino;
-                __entry->size           = dentry->d_inode->i_size;
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
+                __entry->size           = d_inode(dentry)->i_size;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
         ),
 
         TP_printk("dev %d,%d ino %lu size %lld parent %ld",
@@ -734,8 +734,8 @@ TRACE_EVENT(ext3_unlink_exit,
         ),
 
         TP_fast_assign(
-                __entry->ino            = dentry->d_inode->i_ino;
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
                 __entry->ret            = ret;
         ),
 
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 47fca36ee426..08ec3dd27630 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -872,10 +872,10 @@ TRACE_EVENT(ext4_sync_file_enter,
         TP_fast_assign(
                 struct dentry *dentry = file->f_path.dentry;
 
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
-                __entry->ino            = dentry->d_inode->i_ino;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
                 __entry->datasync       = datasync;
-                __entry->parent         = dentry->d_parent->d_inode->i_ino;
+                __entry->parent         = d_inode(dentry->d_parent)->i_ino;
         ),
 
         TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
@@ -1453,10 +1453,10 @@ TRACE_EVENT(ext4_unlink_enter,
         ),
 
         TP_fast_assign(
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
-                __entry->ino            = dentry->d_inode->i_ino;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
                 __entry->parent         = parent->i_ino;
-                __entry->size           = dentry->d_inode->i_size;
+                __entry->size           = d_inode(dentry)->i_size;
         ),
 
         TP_printk("dev %d,%d ino %lu size %lld parent %lu",
@@ -1477,8 +1477,8 @@ TRACE_EVENT(ext4_unlink_exit,
         ),
 
         TP_fast_assign(
-                __entry->dev            = dentry->d_inode->i_sb->s_dev;
-                __entry->ino            = dentry->d_inode->i_ino;
+                __entry->dev            = d_inode(dentry)->i_sb->s_dev;
+                __entry->ino            = d_inode(dentry)->i_ino;
                 __entry->ret            = ret;
         ),
 
diff --git a/include/uapi/linux/nfs_idmap.h b/include/uapi/linux/nfs_idmap.h
index 8d4b1c7b24d4..038e36c96669 100644
--- a/include/uapi/linux/nfs_idmap.h
+++ b/include/uapi/linux/nfs_idmap.h
@@ -1,5 +1,5 @@
 /*
- * include/linux/nfs_idmap.h
+ * include/uapi/linux/nfs_idmap.h
  *
  *  UID and GID to name mapping for clients.
  *
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 7635a1cf99f3..3aaea7ffd077 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -466,7 +466,7 @@ out_unlock:
 
 static int mqueue_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         dir->i_ctime = dir->i_mtime = dir->i_atime = CURRENT_TIME;
         dir->i_size -= DIRENT_SIZE;
@@ -770,7 +770,7 @@ static struct file *do_open(struct path *path, int oflag)
         if ((oflag & O_ACCMODE) == (O_RDWR | O_WRONLY))
                 return ERR_PTR(-EINVAL);
         acc = oflag2acc[oflag & O_ACCMODE];
-        if (inode_permission(path->dentry->d_inode, acc))
+        if (inode_permission(d_inode(path->dentry), acc))
                 return ERR_PTR(-EACCES);
         return dentry_open(path, oflag, current_cred());
 }
@@ -802,7 +802,7 @@ SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,
 
         ro = mnt_want_write(mnt);       /* we'll drop it in any case */
         error = 0;
-        mutex_lock(&root->d_inode->i_mutex);
+        mutex_lock(&d_inode(root)->i_mutex);
         path.dentry = lookup_one_len(name->name, root, strlen(name->name));
         if (IS_ERR(path.dentry)) {
                 error = PTR_ERR(path.dentry);
@@ -811,7 +811,7 @@ SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,
         path.mnt = mntget(mnt);
 
         if (oflag & O_CREAT) {
-                if (path.dentry->d_inode) {     /* entry already exists */
+                if (d_really_is_positive(path.dentry)) {        /* entry already exists */
                         audit_inode(name, path.dentry, 0);
                         if (oflag & O_EXCL) {
                                 error = -EEXIST;
@@ -824,12 +824,12 @@ SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,
                                 goto out;
                         }
                         audit_inode_parent_hidden(name, root);
-                        filp = do_create(ipc_ns, root->d_inode,
+                        filp = do_create(ipc_ns, d_inode(root),
                                                 &path, oflag, mode,
                                                 u_attr ? &attr : NULL);
                 }
         } else {
-                if (!path.dentry->d_inode) {
+                if (d_really_is_negative(path.dentry)) {
                         error = -ENOENT;
                         goto out;
                 }
@@ -848,7 +848,7 @@ out_putfd:
                 put_unused_fd(fd);
                 fd = error;
         }
-        mutex_unlock(&root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(root)->i_mutex);
         if (!ro)
                 mnt_drop_write(mnt);
 out_putname:
@@ -873,7 +873,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
         err = mnt_want_write(mnt);
         if (err)
                 goto out_name;
-        mutex_lock_nested(&mnt->mnt_root->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&d_inode(mnt->mnt_root)->i_mutex, I_MUTEX_PARENT);
         dentry = lookup_one_len(name->name, mnt->mnt_root,
                                 strlen(name->name));
         if (IS_ERR(dentry)) {
@@ -881,17 +881,17 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
                 goto out_unlock;
         }
 
-        inode = dentry->d_inode;
+        inode = d_inode(dentry);
         if (!inode) {
                 err = -ENOENT;
         } else {
                 ihold(inode);
-                err = vfs_unlink(dentry->d_parent->d_inode, dentry, NULL);
+                err = vfs_unlink(d_inode(dentry->d_parent), dentry, NULL);
         }
         dput(dentry);
 
 out_unlock:
-        mutex_unlock(&mnt->mnt_root->d_inode->i_mutex);
+        mutex_unlock(&d_inode(mnt->mnt_root)->i_mutex);
         if (inode)
                 iput(inode);
         mnt_drop_write(mnt);
diff --git a/ipc/shm.c b/ipc/shm.c
index d280a74af2ef..6d767071c367 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -1132,7 +1132,7 @@ long do_shmat(int shmid, char __user *shmaddr, int shmflg, ulong *raddr,
         path = shp->shm_file->f_path;
         path_get(&path);
         shp->shm_nattch++;
-        size = i_size_read(path.dentry->d_inode);
+        size = i_size_read(d_inode(path.dentry));
         ipc_unlock_object(&shp->shm_perm);
         rcu_read_unlock();
 
diff --git a/kernel/audit.c b/kernel/audit.c
index ab5745ddf962..1c13e4267de6 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -1928,7 +1928,7 @@ void audit_log_link_denied(const char *operation, struct path *link)
 
         /* Generate AUDIT_PATH record with object. */
         name->type = AUDIT_TYPE_NORMAL;
-        audit_copy_inode(name, link->dentry, link->dentry->d_inode);
+        audit_copy_inode(name, link->dentry, d_backing_inode(link->dentry));
         audit_log_name(current->audit_context, name, link, 0, NULL);
 out:
         kfree(name);
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 71fd1f289885..b0f9877273fc 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -577,7 +577,7 @@ int audit_remove_tree_rule(struct audit_krule *rule)
 
 static int compare_root(struct vfsmount *mnt, void *arg)
 {
-        return mnt->mnt_root->d_inode == arg;
+        return d_backing_inode(mnt->mnt_root) == arg;
 }
 
 void audit_trim_trees(void)
@@ -649,7 +649,7 @@ void audit_put_tree(struct audit_tree *tree)
 
 static int tag_mount(struct vfsmount *mnt, void *arg)
 {
-        return tag_chunk(mnt->mnt_root->d_inode, arg);
+        return tag_chunk(d_backing_inode(mnt->mnt_root), arg);
 }
 
 /*
diff --git a/kernel/audit_watch.c b/kernel/audit_watch.c
index ad9c1682f616..6e30024d9aac 100644
--- a/kernel/audit_watch.c
+++ b/kernel/audit_watch.c
@@ -146,7 +146,7 @@ int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
 /* Initialize a parent watch entry. */
 static struct audit_parent *audit_init_parent(struct path *path)
 {
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_backing_inode(path->dentry);
         struct audit_parent *parent;
         int ret;
 
@@ -361,11 +361,11 @@ static int audit_get_nd(struct audit_watch *watch, struct path *parent)
         struct dentry *d = kern_path_locked(watch->path, parent);
         if (IS_ERR(d))
                 return PTR_ERR(d);
-        mutex_unlock(&parent->dentry->d_inode->i_mutex);
-        if (d->d_inode) {
+        mutex_unlock(&d_backing_inode(parent->dentry)->i_mutex);
+        if (d_is_positive(d)) {
                 /* update watch filter fields */
-                watch->dev = d->d_inode->i_sb->s_dev;
-                watch->ino = d->d_inode->i_ino;
+                watch->dev = d_backing_inode(d)->i_sb->s_dev;
+                watch->ino = d_backing_inode(d)->i_ino;
         }
         dput(d);
         return 0;
@@ -426,7 +426,7 @@ int audit_add_watch(struct audit_krule *krule, struct list_head **list)
                 return ret;
 
         /* either find an old parent or attach a new one */
-        parent = audit_find_parent(parent_path.dentry->d_inode);
+        parent = audit_find_parent(d_backing_inode(parent_path.dentry));
         if (!parent) {
                 parent = audit_init_parent(&parent_path);
                 if (IS_ERR(parent)) {
@@ -482,7 +482,7 @@ static int audit_watch_handle_event(struct fsnotify_group *group,
 
         switch (data_type) {
         case (FSNOTIFY_EVENT_PATH):
-                inode = ((struct path *)data)->dentry->d_inode;
+                inode = d_backing_inode(((struct path *)data)->dentry);
                 break;
         case (FSNOTIFY_EVENT_INODE):
                 inode = (struct inode *)data;
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 84c74d08c62b..9fb9d1cb83ce 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1629,7 +1629,7 @@ retry:
         rcu_read_lock();
         seq = read_seqbegin(&rename_lock);
         for(;;) {
-                struct inode *inode = d->d_inode;
+                struct inode *inode = d_backing_inode(d);
                 if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
                         struct audit_chunk *chunk;
                         chunk = audit_tree_lookup(inode);
@@ -1754,7 +1754,7 @@ void __audit_inode(struct filename *name, const struct dentry *dentry,
                    unsigned int flags)
 {
         struct audit_context *context = current->audit_context;
-        const struct inode *inode = dentry->d_inode;
+        const struct inode *inode = d_backing_inode(dentry);
         struct audit_names *n;
         bool parent = flags & AUDIT_INODE_PARENT;
 
@@ -1853,7 +1853,7 @@ void __audit_inode_child(const struct inode *parent,
                          const unsigned char type)
 {
         struct audit_context *context = current->audit_context;
-        const struct inode *inode = dentry->d_inode;
+        const struct inode *inode = d_backing_inode(dentry);
         const char *dname = dentry->d_name.name;
         struct audit_names *n, *found_parent = NULL, *found_child = NULL;
 
diff --git a/kernel/relay.c b/kernel/relay.c
index 5a56d3c8dc03..e9dbaeb8fd65 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -407,7 +407,7 @@ static inline void relay_set_buf_dentry(struct rchan_buf *buf,
                                         struct dentry *dentry)
 {
         buf->dentry = dentry;
-        buf->dentry->d_inode->i_size = buf->early_bytes;
+        d_inode(buf->dentry)->i_size = buf->early_bytes;
 }
 
 static struct dentry *relay_create_buf_file(struct rchan *chan,
@@ -733,7 +733,7 @@ size_t relay_switch_subbuf(struct rchan_buf *buf, size_t length)
                 buf->padding[old_subbuf] = buf->prev_padding;
                 buf->subbufs_produced++;
                 if (buf->dentry)
-                        buf->dentry->d_inode->i_size +=
+                        d_inode(buf->dentry)->i_size +=
                                 buf->chan->subbuf_size -
                                 buf->padding[old_subbuf];
                 else
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 91eecaaa43e0..05330494a0df 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -6079,7 +6079,7 @@ trace_create_cpu_file(const char *name, umode_t mode, struct dentry *parent,
         struct dentry *ret = trace_create_file(name, mode, parent, data, fops);
 
         if (ret) /* See tracing_get_cpu() */
-                ret->d_inode->i_cdev = (void *)(cpu + 1);
+                d_inode(ret)->i_cdev = (void *)(cpu + 1);
         return ret;
 }
 
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 3ab69fb72b85..c4de47fc5cca 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -494,8 +494,8 @@ static void remove_event_file_dir(struct ftrace_event_file *file)
         if (dir) {
                 spin_lock(&dir->d_lock);        /* probably unneeded */
                 list_for_each_entry(child, &dir->d_subdirs, d_child) {
-                        if (child->d_inode)     /* probably unneeded */
-                                child->d_inode->i_private = NULL;
+                        if (d_really_is_positive(child))        /* probably unneeded */
+                                d_inode(child)->i_private = NULL;
                 }
                 spin_unlock(&dir->d_lock);
 
diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index d60fe62ec4fa..6dd022c7b5bc 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -443,7 +443,7 @@ static int create_trace_uprobe(int argc, char **argv)
         if (ret)
                 goto fail_address_parse;
 
-        inode = igrab(path.dentry->d_inode);
+        inode = igrab(d_inode(path.dentry));
         path_put(&path);
 
         if (!inode || !S_ISREG(inode->i_mode)) {
diff --git a/mm/shmem.c b/mm/shmem.c
index 1ea2400b5245..de981370fbc5 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -544,7 +544,7 @@ EXPORT_SYMBOL_GPL(shmem_truncate_range);
 
 static int shmem_setattr(struct dentry *dentry, struct iattr *attr)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
         struct shmem_inode_info *info = SHMEM_I(inode);
         int error;
 
@@ -2274,7 +2274,7 @@ static int shmem_create(struct inode *dir, struct dentry *dentry, umode_t mode,
  */
 static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int ret;
 
         /*
@@ -2298,7 +2298,7 @@ out:
 
 static int shmem_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         if (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode))
                 shmem_free_inode(inode->i_sb);
@@ -2315,7 +2315,7 @@ static int shmem_rmdir(struct inode *dir, struct dentry *dentry)
         if (!simple_empty(dentry))
                 return -ENOTEMPTY;
 
-        drop_nlink(dentry->d_inode);
+        drop_nlink(d_inode(dentry));
         drop_nlink(dir);
         return shmem_unlink(dir, dentry);
 }
@@ -2336,8 +2336,8 @@ static int shmem_exchange(struct inode *old_dir, struct dentry *old_dentry, stru
         }
         old_dir->i_ctime = old_dir->i_mtime =
         new_dir->i_ctime = new_dir->i_mtime =
-        old_dentry->d_inode->i_ctime =
-        new_dentry->d_inode->i_ctime = CURRENT_TIME;
+        d_inode(old_dentry)->i_ctime =
+        d_inode(new_dentry)->i_ctime = CURRENT_TIME;
 
         return 0;
 }
@@ -2376,7 +2376,7 @@ static int shmem_whiteout(struct inode *old_dir, struct dentry *old_dentry)
  */
 static int shmem_rename2(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry, unsigned int flags)
 {
-        struct inode *inode = old_dentry->d_inode;
+        struct inode *inode = d_inode(old_dentry);
         int they_are_dirs = S_ISDIR(inode->i_mode);
 
         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
@@ -2396,10 +2396,10 @@ static int shmem_rename2(struct inode *old_dir, struct dentry *old_dentry, struc
                         return error;
         }
 
-        if (new_dentry->d_inode) {
+        if (d_really_is_positive(new_dentry)) {
                 (void) shmem_unlink(new_dir, new_dentry);
                 if (they_are_dirs) {
-                        drop_nlink(new_dentry->d_inode);
+                        drop_nlink(d_inode(new_dentry));
                         drop_nlink(old_dir);
                 }
         } else if (they_are_dirs) {
@@ -2476,14 +2476,14 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
 
 static void *shmem_follow_short_symlink(struct dentry *dentry, struct nameidata *nd)
 {
-        nd_set_link(nd, SHMEM_I(dentry->d_inode)->symlink);
+        nd_set_link(nd, SHMEM_I(d_inode(dentry))->symlink);
         return NULL;
 }
 
 static void *shmem_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
         struct page *page = NULL;
-        int error = shmem_getpage(dentry->d_inode, 0, &page, SGP_READ, NULL);
+        int error = shmem_getpage(d_inode(dentry), 0, &page, SGP_READ, NULL);
         nd_set_link(nd, error ? ERR_PTR(error) : kmap(page));
         if (page)
                 unlock_page(page);
@@ -2574,7 +2574,7 @@ static int shmem_xattr_validate(const char *name)
 static ssize_t shmem_getxattr(struct dentry *dentry, const char *name,
                               void *buffer, size_t size)
 {
-        struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);
+        struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
         int err;
 
         /*
@@ -2595,7 +2595,7 @@ static ssize_t shmem_getxattr(struct dentry *dentry, const char *name,
 static int shmem_setxattr(struct dentry *dentry, const char *name,
                           const void *value, size_t size, int flags)
 {
-        struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);
+        struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
         int err;
 
         /*
@@ -2615,7 +2615,7 @@ static int shmem_setxattr(struct dentry *dentry, const char *name,
 
 static int shmem_removexattr(struct dentry *dentry, const char *name)
 {
-        struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);
+        struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
         int err;
 
         /*
@@ -2635,7 +2635,7 @@ static int shmem_removexattr(struct dentry *dentry, const char *name)
 
 static ssize_t shmem_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
-        struct shmem_inode_info *info = SHMEM_I(dentry->d_inode);
+        struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
         return simple_xattr_list(&info->xattrs, buffer, size);
 }
 #endif /* CONFIG_TMPFS_XATTR */
diff --git a/net/socket.c b/net/socket.c
index 3e33959f3ce5..884e32997698 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -312,7 +312,7 @@ static const struct super_operations sockfs_ops = {
 static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
 {
         return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
-                                dentry->d_inode->i_ino);
+                                d_inode(dentry)->i_ino);
 }
 
 static const struct dentry_operations sockfs_dentry_operations = {
@@ -375,7 +375,7 @@ struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
                   &socket_file_ops);
         if (unlikely(IS_ERR(file))) {
                 /* drop dentry, keep inode */
-                ihold(path.dentry->d_inode);
+                ihold(d_inode(path.dentry));
                 path_put(&path);
                 return file;
         }
@@ -497,7 +497,7 @@ static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
         ssize_t len;
         ssize_t used = 0;
 
-        len = security_inode_listsecurity(dentry->d_inode, buffer, size);
+        len = security_inode_listsecurity(d_inode(dentry), buffer, size);
         if (len < 0)
                 return len;
         used += len;
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 2d12b76b5a64..d81186d34558 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -94,7 +94,7 @@ rpc_timeout_upcall_queue(struct work_struct *work)
         }
         dentry = dget(pipe->dentry);
         spin_unlock(&pipe->lock);
-        rpc_purge_list(dentry ? &RPC_I(dentry->d_inode)->waitq : NULL,
+        rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL,
                         &free_list, destroy_msg, -ETIMEDOUT);
         dput(dentry);
 }
@@ -152,7 +152,7 @@ rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
         dentry = dget(pipe->dentry);
         spin_unlock(&pipe->lock);
         if (dentry) {
-                wake_up(&RPC_I(dentry->d_inode)->waitq);
+                wake_up(&RPC_I(d_inode(dentry))->waitq);
                 dput(dentry);
         }
         return res;
@@ -591,7 +591,7 @@ static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
         err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
         if (err)
                 return err;
-        rpci = RPC_I(dentry->d_inode);
+        rpci = RPC_I(d_inode(dentry));
         rpci->private = private;
         rpci->pipe = pipe;
         fsnotify_create(dir, dentry);
@@ -616,7 +616,7 @@ int rpc_rmdir(struct dentry *dentry)
         int error;
 
         parent = dget_parent(dentry);
-        dir = parent->d_inode;
+        dir = d_inode(parent);
         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
         error = __rpc_rmdir(dir, dentry);
         mutex_unlock(&dir->i_mutex);
@@ -638,7 +638,7 @@ static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
 
 static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_inode(dentry);
 
         rpc_close_pipes(inode);
         return __rpc_unlink(dir, dentry);
@@ -654,7 +654,7 @@ static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
                 if (!dentry)
                         return ERR_PTR(-ENOMEM);
         }
-        if (dentry->d_inode == NULL)
+        if (d_really_is_negative(dentry))
                 return dentry;
         dput(dentry);
         return ERR_PTR(-EEXIST);
@@ -667,7 +667,7 @@ static void __rpc_depopulate(struct dentry *parent,
                              const struct rpc_filelist *files,
                              int start, int eof)
 {
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct dentry *dentry;
         struct qstr name;
         int i;
@@ -679,9 +679,9 @@ static void __rpc_depopulate(struct dentry *parent,
 
                 if (dentry == NULL)
                         continue;
-                if (dentry->d_inode == NULL)
+                if (d_really_is_negative(dentry))
                         goto next;
-                switch (dentry->d_inode->i_mode & S_IFMT) {
+                switch (d_inode(dentry)->i_mode & S_IFMT) {
                         default:
                                 BUG();
                         case S_IFREG:
@@ -699,7 +699,7 @@ static void rpc_depopulate(struct dentry *parent,
                            const struct rpc_filelist *files,
                            int start, int eof)
 {
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
 
         mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
         __rpc_depopulate(parent, files, start, eof);
@@ -711,7 +711,7 @@ static int rpc_populate(struct dentry *parent,
                         int start, int eof,
                         void *private)
 {
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         struct dentry *dentry;
         int i, err;
 
@@ -754,7 +754,7 @@ static struct dentry *rpc_mkdir_populate(struct dentry *parent,
                 int (*populate)(struct dentry *, void *), void *args_populate)
 {
         struct dentry *dentry;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         int error;
 
         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
@@ -787,7 +787,7 @@ static int rpc_rmdir_depopulate(struct dentry *dentry,
         int error;
 
         parent = dget_parent(dentry);
-        dir = parent->d_inode;
+        dir = d_inode(parent);
         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
         if (depopulate != NULL)
                 depopulate(dentry);
@@ -819,7 +819,7 @@ struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
                                  void *private, struct rpc_pipe *pipe)
 {
         struct dentry *dentry;
-        struct inode *dir = parent->d_inode;
+        struct inode *dir = d_inode(parent);
         umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
         int err;
 
@@ -864,7 +864,7 @@ rpc_unlink(struct dentry *dentry)
         int error = 0;
 
         parent = dget_parent(dentry);
-        dir = parent->d_inode;
+        dir = d_inode(parent);
         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
         error = __rpc_rmpipe(dir, dentry);
         mutex_unlock(&dir->i_mutex);
@@ -1375,7 +1375,7 @@ rpc_gssd_dummy_depopulate(struct dentry *pipe_dentry)
         struct dentry *clnt_dir = pipe_dentry->d_parent;
         struct dentry *gssd_dir = clnt_dir->d_parent;
 
-        __rpc_rmpipe(clnt_dir->d_inode, pipe_dentry);
+        __rpc_rmpipe(d_inode(clnt_dir), pipe_dentry);
         __rpc_depopulate(clnt_dir, gssd_dummy_info_file, 0, 1);
         __rpc_depopulate(gssd_dir, gssd_dummy_clnt_dir, 0, 1);
         dput(pipe_dentry);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index b91fd9c597b4..337ca851a350 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -89,8 +89,8 @@ __rpc_add_timer(struct rpc_wait_queue *queue, struct rpc_task *task)
         if (!task->tk_timeout)
                 return;
 
-        dprintk("RPC: %5u setting alarm for %lu ms\n",
-                        task->tk_pid, task->tk_timeout * 1000 / HZ);
+        dprintk("RPC: %5u setting alarm for %u ms\n",
+                task->tk_pid, jiffies_to_msecs(task->tk_timeout));
 
         task->u.tk_wait.expires = jiffies + task->tk_timeout;
         if (list_empty(&queue->timer_list.list) || time_before(task->u.tk_wait.expires, queue->timer_list.expires))
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 9949722d99ce..1d4fe24af06a 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -326,6 +326,15 @@ out_unlock:
         xprt_clear_locked(xprt);
 }
 
+static void xprt_task_clear_bytes_sent(struct rpc_task *task)
+{
+        if (task != NULL) {
+                struct rpc_rqst *req = task->tk_rqstp;
+                if (req != NULL)
+                        req->rq_bytes_sent = 0;
+        }
+}
+
 /**
  * xprt_release_xprt - allow other requests to use a transport
  * @xprt: transport with other tasks potentially waiting
@@ -336,11 +345,7 @@ out_unlock:
 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
 {
         if (xprt->snd_task == task) {
-                if (task != NULL) {
-                        struct rpc_rqst *req = task->tk_rqstp;
-                        if (req != NULL)
-                                req->rq_bytes_sent = 0;
-                }
+                xprt_task_clear_bytes_sent(task);
                 xprt_clear_locked(xprt);
                 __xprt_lock_write_next(xprt);
         }
@@ -358,11 +363,7 @@ EXPORT_SYMBOL_GPL(xprt_release_xprt);
 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
 {
         if (xprt->snd_task == task) {
-                if (task != NULL) {
-                        struct rpc_rqst *req = task->tk_rqstp;
-                        if (req != NULL)
-                                req->rq_bytes_sent = 0;
-                }
+                xprt_task_clear_bytes_sent(task);
                 xprt_clear_locked(xprt);
                 __xprt_lock_write_next_cong(xprt);
         }
@@ -700,6 +701,7 @@ bool xprt_lock_connect(struct rpc_xprt *xprt,
                 goto out;
         if (xprt->snd_task != task)
                 goto out;
+        xprt_task_clear_bytes_sent(task);
         xprt->snd_task = cookie;
         ret = true;
 out:
diff --git a/net/sunrpc/xprtrdma/Makefile b/net/sunrpc/xprtrdma/Makefile
index da5136fd5694..579f72bbcf4b 100644
--- a/net/sunrpc/xprtrdma/Makefile
+++ b/net/sunrpc/xprtrdma/Makefile
@@ -1,6 +1,7 @@
 obj-$(CONFIG_SUNRPC_XPRT_RDMA_CLIENT) += xprtrdma.o
 
-xprtrdma-y := transport.o rpc_rdma.o verbs.o
+xprtrdma-y := transport.o rpc_rdma.o verbs.o \
+        fmr_ops.o frwr_ops.o physical_ops.o
 
 obj-$(CONFIG_SUNRPC_XPRT_RDMA_SERVER) += svcrdma.o
 
diff --git a/net/sunrpc/xprtrdma/fmr_ops.c b/net/sunrpc/xprtrdma/fmr_ops.c
new file mode 100644
index 000000000000..302d4ebf6fbf
--- /dev/null
+++ b/net/sunrpc/xprtrdma/fmr_ops.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2015 Oracle.  All rights reserved.
+ * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
+ */
+
+/* Lightweight memory registration using Fast Memory Regions (FMR).
+ * Referred to sometimes as MTHCAFMR mode.
+ *
+ * FMR uses synchronous memory registration and deregistration.
+ * FMR registration is known to be fast, but FMR deregistration
+ * can take tens of usecs to complete.
+ */
+
+#include "xprt_rdma.h"
+
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+# define RPCDBG_FACILITY        RPCDBG_TRANS
+#endif
+
+/* Maximum scatter/gather per FMR */
+#define RPCRDMA_MAX_FMR_SGES    (64)
+
+static int
+fmr_op_open(struct rpcrdma_ia *ia, struct rpcrdma_ep *ep,
+            struct rpcrdma_create_data_internal *cdata)
+{
+        return 0;
+}
+
+/* FMR mode conveys up to 64 pages of payload per chunk segment.
+ */
+static size_t
+fmr_op_maxpages(struct rpcrdma_xprt *r_xprt)
+{
+        return min_t(unsigned int, RPCRDMA_MAX_DATA_SEGS,
+                     rpcrdma_max_segments(r_xprt) * RPCRDMA_MAX_FMR_SGES);
+}
+
+static int
+fmr_op_init(struct rpcrdma_xprt *r_xprt)
+{
+        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
+        int mr_access_flags = IB_ACCESS_REMOTE_WRITE | IB_ACCESS_REMOTE_READ;
+        struct ib_fmr_attr fmr_attr = {
+                .max_pages      = RPCRDMA_MAX_FMR_SGES,
+                .max_maps       = 1,
+                .page_shift     = PAGE_SHIFT
+        };
+        struct ib_pd *pd = r_xprt->rx_ia.ri_pd;
+        struct rpcrdma_mw *r;
+        int i, rc;
+
+        INIT_LIST_HEAD(&buf->rb_mws);
+        INIT_LIST_HEAD(&buf->rb_all);
+
+        i = (buf->rb_max_requests + 1) * RPCRDMA_MAX_SEGS;
+        dprintk("RPC:       %s: initializing %d FMRs\n", __func__, i);
+
+        while (i--) {
+                r = kzalloc(sizeof(*r), GFP_KERNEL);
+                if (!r)
+                        return -ENOMEM;
+
+                r->r.fmr = ib_alloc_fmr(pd, mr_access_flags, &fmr_attr);
+                if (IS_ERR(r->r.fmr))
+                        goto out_fmr_err;
+
+                list_add(&r->mw_list, &buf->rb_mws);
+                list_add(&r->mw_all, &buf->rb_all);
+        }
+        return 0;
+
+out_fmr_err:
+        rc = PTR_ERR(r->r.fmr);
+        dprintk("RPC:       %s: ib_alloc_fmr status %i\n", __func__, rc);
+        kfree(r);
+        return rc;
+}
+
+/* Use the ib_map_phys_fmr() verb to register a memory region
+ * for remote access via RDMA READ or RDMA WRITE.
+ */
+static int
+fmr_op_map(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg,
+           int nsegs, bool writing)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+        struct ib_device *device = ia->ri_id->device;
+        enum dma_data_direction direction = rpcrdma_data_dir(writing);
+        struct rpcrdma_mr_seg *seg1 = seg;
+        struct rpcrdma_mw *mw = seg1->rl_mw;
+        u64 physaddrs[RPCRDMA_MAX_DATA_SEGS];
+        int len, pageoff, i, rc;
+
+        pageoff = offset_in_page(seg1->mr_offset);
+        seg1->mr_offset -= pageoff;     /* start of page */
+        seg1->mr_len += pageoff;
+        len = -pageoff;
+        if (nsegs > RPCRDMA_MAX_FMR_SGES)
+                nsegs = RPCRDMA_MAX_FMR_SGES;
+        for (i = 0; i < nsegs;) {
+                rpcrdma_map_one(device, seg, direction);
+                physaddrs[i] = seg->mr_dma;
+                len += seg->mr_len;
+                ++seg;
+                ++i;
+                /* Check for holes */
+                if ((i < nsegs && offset_in_page(seg->mr_offset)) ||
+                    offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
+                        break;
+        }
+
+        rc = ib_map_phys_fmr(mw->r.fmr, physaddrs, i, seg1->mr_dma);
+        if (rc)
+                goto out_maperr;
+
+        seg1->mr_rkey = mw->r.fmr->rkey;
+        seg1->mr_base = seg1->mr_dma + pageoff;
+        seg1->mr_nsegs = i;
+        seg1->mr_len = len;
+        return i;
+
+out_maperr:
+        dprintk("RPC:       %s: ib_map_phys_fmr %u@0x%llx+%i (%d) status %i\n",
+                __func__, len, (unsigned long long)seg1->mr_dma,
+                pageoff, i, rc);
+        while (i--)
+                rpcrdma_unmap_one(device, --seg);
+        return rc;
+}
+
+/* Use the ib_unmap_fmr() verb to prevent further remote
+ * access via RDMA READ or RDMA WRITE.
+ */
+static int
+fmr_op_unmap(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+        struct rpcrdma_mr_seg *seg1 = seg;
+        struct ib_device *device;
+        int rc, nsegs = seg->mr_nsegs;
+        LIST_HEAD(l);
+
+        list_add(&seg1->rl_mw->r.fmr->list, &l);
+        rc = ib_unmap_fmr(&l);
+        read_lock(&ia->ri_qplock);
+        device = ia->ri_id->device;
+        while (seg1->mr_nsegs--)
+                rpcrdma_unmap_one(device, seg++);
+        read_unlock(&ia->ri_qplock);
+        if (rc)
+                goto out_err;
+        return nsegs;
+
+out_err:
+        dprintk("RPC:       %s: ib_unmap_fmr status %i\n", __func__, rc);
+        return nsegs;
+}
+
+/* After a disconnect, unmap all FMRs.
+ *
+ * This is invoked only in the transport connect worker in order
+ * to serialize with rpcrdma_register_fmr_external().
+ */
+static void
+fmr_op_reset(struct rpcrdma_xprt *r_xprt)
+{
+        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
+        struct rpcrdma_mw *r;
+        LIST_HEAD(list);
+        int rc;
+
+        list_for_each_entry(r, &buf->rb_all, mw_all)
+                list_add(&r->r.fmr->list, &list);
+
+        rc = ib_unmap_fmr(&list);
+        if (rc)
+                dprintk("RPC:       %s: ib_unmap_fmr failed %i\n",
+                        __func__, rc);
+}
+
+static void
+fmr_op_destroy(struct rpcrdma_buffer *buf)
+{
+        struct rpcrdma_mw *r;
+        int rc;
+
+        while (!list_empty(&buf->rb_all)) {
+                r = list_entry(buf->rb_all.next, struct rpcrdma_mw, mw_all);
+                list_del(&r->mw_all);
+                rc = ib_dealloc_fmr(r->r.fmr);
+                if (rc)
+                        dprintk("RPC:       %s: ib_dealloc_fmr failed %i\n",
+                                __func__, rc);
+                kfree(r);
+        }
+}
+
+const struct rpcrdma_memreg_ops rpcrdma_fmr_memreg_ops = {
+        .ro_map                         = fmr_op_map,
+        .ro_unmap                       = fmr_op_unmap,
+        .ro_open                        = fmr_op_open,
+        .ro_maxpages                    = fmr_op_maxpages,
+        .ro_init                        = fmr_op_init,
+        .ro_reset                       = fmr_op_reset,
+        .ro_destroy                     = fmr_op_destroy,
+        .ro_displayname                 = "fmr",
+};
diff --git a/net/sunrpc/xprtrdma/frwr_ops.c b/net/sunrpc/xprtrdma/frwr_ops.c
new file mode 100644
index 000000000000..dff0481dbcf8
--- /dev/null
+++ b/net/sunrpc/xprtrdma/frwr_ops.c
@@ -0,0 +1,353 @@
+/*
+ * Copyright (c) 2015 Oracle.  All rights reserved.
+ * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
+ */
+
+/* Lightweight memory registration using Fast Registration Work
+ * Requests (FRWR). Also referred to sometimes as FRMR mode.
+ *
+ * FRWR features ordered asynchronous registration and deregistration
+ * of arbitrarily sized memory regions. This is the fastest and safest
+ * but most complex memory registration mode.
+ */
+
+#include "xprt_rdma.h"
+
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+# define RPCDBG_FACILITY        RPCDBG_TRANS
+#endif
+
+static int
+__frwr_init(struct rpcrdma_mw *r, struct ib_pd *pd, struct ib_device *device,
+            unsigned int depth)
+{
+        struct rpcrdma_frmr *f = &r->r.frmr;
+        int rc;
+
+        f->fr_mr = ib_alloc_fast_reg_mr(pd, depth);
+        if (IS_ERR(f->fr_mr))
+                goto out_mr_err;
+        f->fr_pgl = ib_alloc_fast_reg_page_list(device, depth);
+        if (IS_ERR(f->fr_pgl))
+                goto out_list_err;
+        return 0;
+
+out_mr_err:
+        rc = PTR_ERR(f->fr_mr);
+        dprintk("RPC:       %s: ib_alloc_fast_reg_mr status %i\n",
+                __func__, rc);
+        return rc;
+
+out_list_err:
+        rc = PTR_ERR(f->fr_pgl);
+        dprintk("RPC:       %s: ib_alloc_fast_reg_page_list status %i\n",
+                __func__, rc);
+        ib_dereg_mr(f->fr_mr);
+        return rc;
+}
+
+static void
+__frwr_release(struct rpcrdma_mw *r)
+{
+        int rc;
+
+        rc = ib_dereg_mr(r->r.frmr.fr_mr);
+        if (rc)
+                dprintk("RPC:       %s: ib_dereg_mr status %i\n",
+                        __func__, rc);
+        ib_free_fast_reg_page_list(r->r.frmr.fr_pgl);
+}
+
+static int
+frwr_op_open(struct rpcrdma_ia *ia, struct rpcrdma_ep *ep,
+             struct rpcrdma_create_data_internal *cdata)
+{
+        struct ib_device_attr *devattr = &ia->ri_devattr;
+        int depth, delta;
+
+        ia->ri_max_frmr_depth =
+                        min_t(unsigned int, RPCRDMA_MAX_DATA_SEGS,
+                              devattr->max_fast_reg_page_list_len);
+        dprintk("RPC:       %s: device's max FR page list len = %u\n",
+                __func__, ia->ri_max_frmr_depth);
+
+        /* Add room for frmr register and invalidate WRs.
+         * 1. FRMR reg WR for head
+         * 2. FRMR invalidate WR for head
+         * 3. N FRMR reg WRs for pagelist
+         * 4. N FRMR invalidate WRs for pagelist
+         * 5. FRMR reg WR for tail
+         * 6. FRMR invalidate WR for tail
+         * 7. The RDMA_SEND WR
+         */
+        depth = 7;
+
+        /* Calculate N if the device max FRMR depth is smaller than
+         * RPCRDMA_MAX_DATA_SEGS.
+         */
+        if (ia->ri_max_frmr_depth < RPCRDMA_MAX_DATA_SEGS) {
+                delta = RPCRDMA_MAX_DATA_SEGS - ia->ri_max_frmr_depth;
+                do {
+                        depth += 2; /* FRMR reg + invalidate */
+                        delta -= ia->ri_max_frmr_depth;
+                } while (delta > 0);
+        }
+
+        ep->rep_attr.cap.max_send_wr *= depth;
+        if (ep->rep_attr.cap.max_send_wr > devattr->max_qp_wr) {
+                cdata->max_requests = devattr->max_qp_wr / depth;
+                if (!cdata->max_requests)
+                        return -EINVAL;
+                ep->rep_attr.cap.max_send_wr = cdata->max_requests *
+                                               depth;
+        }
+
+        return 0;
+}
+
+/* FRWR mode conveys a list of pages per chunk segment. The
+ * maximum length of that list is the FRWR page list depth.
+ */
+static size_t
+frwr_op_maxpages(struct rpcrdma_xprt *r_xprt)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+
+        return min_t(unsigned int, RPCRDMA_MAX_DATA_SEGS,
+                     rpcrdma_max_segments(r_xprt) * ia->ri_max_frmr_depth);
+}
+
+/* If FAST_REG or LOCAL_INV failed, indicate the frmr needs to be reset. */
+static void
+frwr_sendcompletion(struct ib_wc *wc)
+{
+        struct rpcrdma_mw *r;
+
+        if (likely(wc->status == IB_WC_SUCCESS))
+                return;
+
+        /* WARNING: Only wr_id and status are reliable at this point */
+        r = (struct rpcrdma_mw *)(unsigned long)wc->wr_id;
+        dprintk("RPC:       %s: frmr %p (stale), status %d\n",
+                __func__, r, wc->status);
+        r->r.frmr.fr_state = FRMR_IS_STALE;
+}
+
+static int
+frwr_op_init(struct rpcrdma_xprt *r_xprt)
+{
+        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
+        struct ib_device *device = r_xprt->rx_ia.ri_id->device;
+        unsigned int depth = r_xprt->rx_ia.ri_max_frmr_depth;
+        struct ib_pd *pd = r_xprt->rx_ia.ri_pd;
+        int i;
+
+        INIT_LIST_HEAD(&buf->rb_mws);
+        INIT_LIST_HEAD(&buf->rb_all);
+
+        i = (buf->rb_max_requests + 1) * RPCRDMA_MAX_SEGS;
+        dprintk("RPC:       %s: initializing %d FRMRs\n", __func__, i);
+
+        while (i--) {
+                struct rpcrdma_mw *r;
+                int rc;
+
+                r = kzalloc(sizeof(*r), GFP_KERNEL);
+                if (!r)
+                        return -ENOMEM;
+
+                rc = __frwr_init(r, pd, device, depth);
+                if (rc) {
+                        kfree(r);
+                        return rc;
+                }
+
+                list_add(&r->mw_list, &buf->rb_mws);
+                list_add(&r->mw_all, &buf->rb_all);
+                r->mw_sendcompletion = frwr_sendcompletion;
+        }
+
+        return 0;
+}
+
+/* Post a FAST_REG Work Request to register a memory region
+ * for remote access via RDMA READ or RDMA WRITE.
+ */
+static int
+frwr_op_map(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg,
+            int nsegs, bool writing)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+        struct ib_device *device = ia->ri_id->device;
+        enum dma_data_direction direction = rpcrdma_data_dir(writing);
+        struct rpcrdma_mr_seg *seg1 = seg;
+        struct rpcrdma_mw *mw = seg1->rl_mw;
+        struct rpcrdma_frmr *frmr = &mw->r.frmr;
+        struct ib_mr *mr = frmr->fr_mr;
+        struct ib_send_wr fastreg_wr, *bad_wr;
+        u8 key;
+        int len, pageoff;
+        int i, rc;
+        int seg_len;
+        u64 pa;
+        int page_no;
+
+        pageoff = offset_in_page(seg1->mr_offset);
+        seg1->mr_offset -= pageoff;     /* start of page */
+        seg1->mr_len += pageoff;
+        len = -pageoff;
+        if (nsegs > ia->ri_max_frmr_depth)
+                nsegs = ia->ri_max_frmr_depth;
+        for (page_no = i = 0; i < nsegs;) {
+                rpcrdma_map_one(device, seg, direction);
+                pa = seg->mr_dma;
+                for (seg_len = seg->mr_len; seg_len > 0; seg_len -= PAGE_SIZE) {
+                        frmr->fr_pgl->page_list[page_no++] = pa;
+                        pa += PAGE_SIZE;
+                }
+                len += seg->mr_len;
+                ++seg;
+                ++i;
+                /* Check for holes */
+                if ((i < nsegs && offset_in_page(seg->mr_offset)) ||
+                    offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
+                        break;
+        }
+        dprintk("RPC:       %s: Using frmr %p to map %d segments (%d bytes)\n",
+                __func__, mw, i, len);
+
+        frmr->fr_state = FRMR_IS_VALID;
+
+        memset(&fastreg_wr, 0, sizeof(fastreg_wr));
+        fastreg_wr.wr_id = (unsigned long)(void *)mw;
+        fastreg_wr.opcode = IB_WR_FAST_REG_MR;
+        fastreg_wr.wr.fast_reg.iova_start = seg1->mr_dma + pageoff;
+        fastreg_wr.wr.fast_reg.page_list = frmr->fr_pgl;
+        fastreg_wr.wr.fast_reg.page_shift = PAGE_SHIFT;
+        fastreg_wr.wr.fast_reg.page_list_len = page_no;
+        fastreg_wr.wr.fast_reg.length = len;
+        fastreg_wr.wr.fast_reg.access_flags = writing ?
+                                IB_ACCESS_REMOTE_WRITE | IB_ACCESS_LOCAL_WRITE :
+                                IB_ACCESS_REMOTE_READ;
+        key = (u8)(mr->rkey & 0x000000FF);
+        ib_update_fast_reg_key(mr, ++key);
+        fastreg_wr.wr.fast_reg.rkey = mr->rkey;
+
+        DECR_CQCOUNT(&r_xprt->rx_ep);
+        rc = ib_post_send(ia->ri_id->qp, &fastreg_wr, &bad_wr);
+        if (rc)
+                goto out_senderr;
+
+        seg1->mr_rkey = mr->rkey;
+        seg1->mr_base = seg1->mr_dma + pageoff;
+        seg1->mr_nsegs = i;
+        seg1->mr_len = len;
+        return i;
+
+out_senderr:
+        dprintk("RPC:       %s: ib_post_send status %i\n", __func__, rc);
+        ib_update_fast_reg_key(mr, --key);
+        frmr->fr_state = FRMR_IS_INVALID;
+        while (i--)
+                rpcrdma_unmap_one(device, --seg);
+        return rc;
+}
+
+/* Post a LOCAL_INV Work Request to prevent further remote access
+ * via RDMA READ or RDMA WRITE.
+ */
+static int
+frwr_op_unmap(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg)
+{
+        struct rpcrdma_mr_seg *seg1 = seg;
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+        struct ib_send_wr invalidate_wr, *bad_wr;
+        int rc, nsegs = seg->mr_nsegs;
+        struct ib_device *device;
+
+        seg1->rl_mw->r.frmr.fr_state = FRMR_IS_INVALID;
+
+        memset(&invalidate_wr, 0, sizeof(invalidate_wr));
+        invalidate_wr.wr_id = (unsigned long)(void *)seg1->rl_mw;
+        invalidate_wr.opcode = IB_WR_LOCAL_INV;
+        invalidate_wr.ex.invalidate_rkey = seg1->rl_mw->r.frmr.fr_mr->rkey;
+        DECR_CQCOUNT(&r_xprt->rx_ep);
+
+        read_lock(&ia->ri_qplock);
+        device = ia->ri_id->device;
+        while (seg1->mr_nsegs--)
+                rpcrdma_unmap_one(device, seg++);
+        rc = ib_post_send(ia->ri_id->qp, &invalidate_wr, &bad_wr);
+        read_unlock(&ia->ri_qplock);
+        if (rc)
+                goto out_err;
+        return nsegs;
+
+out_err:
+        /* Force rpcrdma_buffer_get() to retry */
+        seg1->rl_mw->r.frmr.fr_state = FRMR_IS_STALE;
+        dprintk("RPC:       %s: ib_post_send status %i\n", __func__, rc);
+        return nsegs;
+}
+
+/* After a disconnect, a flushed FAST_REG_MR can leave an FRMR in
+ * an unusable state. Find FRMRs in this state and dereg / reg
+ * each.  FRMRs that are VALID and attached to an rpcrdma_req are
+ * also torn down.
+ *
+ * This gives all in-use FRMRs a fresh rkey and leaves them INVALID.
+ *
+ * This is invoked only in the transport connect worker in order
+ * to serialize with rpcrdma_register_frmr_external().
+ */
+static void
+frwr_op_reset(struct rpcrdma_xprt *r_xprt)
+{
+        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
+        struct ib_device *device = r_xprt->rx_ia.ri_id->device;
+        unsigned int depth = r_xprt->rx_ia.ri_max_frmr_depth;
+        struct ib_pd *pd = r_xprt->rx_ia.ri_pd;
+        struct rpcrdma_mw *r;
+        int rc;
+
+        list_for_each_entry(r, &buf->rb_all, mw_all) {
+                if (r->r.frmr.fr_state == FRMR_IS_INVALID)
+                        continue;
+
+                __frwr_release(r);
+                rc = __frwr_init(r, pd, device, depth);
+                if (rc) {
+                        dprintk("RPC:       %s: mw %p left %s\n",
+                                __func__, r,
+                                (r->r.frmr.fr_state == FRMR_IS_STALE ?
+                                        "stale" : "valid"));
+                        continue;
+                }
+
+                r->r.frmr.fr_state = FRMR_IS_INVALID;
+        }
+}
+
+static void
+frwr_op_destroy(struct rpcrdma_buffer *buf)
+{
+        struct rpcrdma_mw *r;
+
+        while (!list_empty(&buf->rb_all)) {
+                r = list_entry(buf->rb_all.next, struct rpcrdma_mw, mw_all);
+                list_del(&r->mw_all);
+                __frwr_release(r);
+                kfree(r);
+        }
+}
+
+const struct rpcrdma_memreg_ops rpcrdma_frwr_memreg_ops = {
+        .ro_map                         = frwr_op_map,
+        .ro_unmap                       = frwr_op_unmap,
+        .ro_open                        = frwr_op_open,
+        .ro_maxpages                    = frwr_op_maxpages,
+        .ro_init                        = frwr_op_init,
+        .ro_reset                       = frwr_op_reset,
+        .ro_destroy                     = frwr_op_destroy,
+        .ro_displayname                 = "frwr",
+};
diff --git a/net/sunrpc/xprtrdma/physical_ops.c b/net/sunrpc/xprtrdma/physical_ops.c
new file mode 100644
index 000000000000..ba518af16787
--- /dev/null
+++ b/net/sunrpc/xprtrdma/physical_ops.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2015 Oracle.  All rights reserved.
+ * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
+ */
+
+/* No-op chunk preparation. All client memory is pre-registered.
+ * Sometimes referred to as ALLPHYSICAL mode.
+ *
+ * Physical registration is simple because all client memory is
+ * pre-registered and never deregistered. This mode is good for
+ * adapter bring up, but is considered not safe: the server is
+ * trusted not to abuse its access to client memory not involved
+ * in RDMA I/O.
+ */
+
+#include "xprt_rdma.h"
+
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+# define RPCDBG_FACILITY        RPCDBG_TRANS
+#endif
+
+static int
+physical_op_open(struct rpcrdma_ia *ia, struct rpcrdma_ep *ep,
+                 struct rpcrdma_create_data_internal *cdata)
+{
+        return 0;
+}
+
+/* PHYSICAL memory registration conveys one page per chunk segment.
+ */
+static size_t
+physical_op_maxpages(struct rpcrdma_xprt *r_xprt)
+{
+        return min_t(unsigned int, RPCRDMA_MAX_DATA_SEGS,
+                     rpcrdma_max_segments(r_xprt));
+}
+
+static int
+physical_op_init(struct rpcrdma_xprt *r_xprt)
+{
+        return 0;
+}
+
+/* The client's physical memory is already exposed for
+ * remote access via RDMA READ or RDMA WRITE.
+ */
+static int
+physical_op_map(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg,
+                int nsegs, bool writing)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+
+        rpcrdma_map_one(ia->ri_id->device, seg,
+                        rpcrdma_data_dir(writing));
+        seg->mr_rkey = ia->ri_bind_mem->rkey;
+        seg->mr_base = seg->mr_dma;
+        seg->mr_nsegs = 1;
+        return 1;
+}
+
+/* Unmap a memory region, but leave it registered.
+ */
+static int
+physical_op_unmap(struct rpcrdma_xprt *r_xprt, struct rpcrdma_mr_seg *seg)
+{
+        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
+
+        read_lock(&ia->ri_qplock);
+        rpcrdma_unmap_one(ia->ri_id->device, seg);
+        read_unlock(&ia->ri_qplock);
+
+        return 1;
+}
+
+static void
+physical_op_reset(struct rpcrdma_xprt *r_xprt)
+{
+}
+
+static void
+physical_op_destroy(struct rpcrdma_buffer *buf)
+{
+}
+
+const struct rpcrdma_memreg_ops rpcrdma_physical_memreg_ops = {
+        .ro_map                         = physical_op_map,
+        .ro_unmap                       = physical_op_unmap,
+        .ro_open                        = physical_op_open,
+        .ro_maxpages                    = physical_op_maxpages,
+        .ro_init                        = physical_op_init,
+        .ro_reset                       = physical_op_reset,
+        .ro_destroy                     = physical_op_destroy,
+        .ro_displayname                 = "physical",
+};
diff --git a/net/sunrpc/xprtrdma/rpc_rdma.c b/net/sunrpc/xprtrdma/rpc_rdma.c
index 91ffde82fa0c..2c53ea9e1b83 100644
--- a/net/sunrpc/xprtrdma/rpc_rdma.c
+++ b/net/sunrpc/xprtrdma/rpc_rdma.c
@@ -53,6 +53,14 @@
 # define RPCDBG_FACILITY        RPCDBG_TRANS
 #endif
 
+enum rpcrdma_chunktype {
+        rpcrdma_noch = 0,
+        rpcrdma_readch,
+        rpcrdma_areadch,
+        rpcrdma_writech,
+        rpcrdma_replych
+};
+
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 static const char transfertypes[][12] = {
         "pure inline",  /* no chunks */
@@ -179,6 +187,7 @@ rpcrdma_create_chunks(struct rpc_rqst *rqst, struct xdr_buf *target,
         struct rpcrdma_write_array *warray = NULL;
         struct rpcrdma_write_chunk *cur_wchunk = NULL;
         __be32 *iptr = headerp->rm_body.rm_chunks;
+        int (*map)(struct rpcrdma_xprt *, struct rpcrdma_mr_seg *, int, bool);
 
         if (type == rpcrdma_readch || type == rpcrdma_areadch) {
                 /* a read chunk - server will RDMA Read our memory */
@@ -201,9 +210,9 @@ rpcrdma_create_chunks(struct rpc_rqst *rqst, struct xdr_buf *target,
         if (nsegs < 0)
                 return nsegs;
 
+        map = r_xprt->rx_ia.ri_ops->ro_map;
         do {
-                n = rpcrdma_register_external(seg, nsegs,
-                                                cur_wchunk != NULL, r_xprt);
+                n = map(r_xprt, seg, nsegs, cur_wchunk != NULL);
                 if (n <= 0)
                         goto out;
                 if (cur_rchunk) {       /* read */
@@ -275,34 +284,13 @@ rpcrdma_create_chunks(struct rpc_rqst *rqst, struct xdr_buf *target,
         return (unsigned char *)iptr - (unsigned char *)headerp;
 
 out:
-        if (r_xprt->rx_ia.ri_memreg_strategy != RPCRDMA_FRMR) {
-                for (pos = 0; nchunks--;)
-                        pos += rpcrdma_deregister_external(
-                                        &req->rl_segments[pos], r_xprt);
-        }
-        return n;
-}
+        if (r_xprt->rx_ia.ri_memreg_strategy == RPCRDMA_FRMR)
+                return n;
 
-/*
- * Marshal chunks. This routine returns the header length
- * consumed by marshaling.
- *
- * Returns positive RPC/RDMA header size, or negative errno.
- */
-
-ssize_t
-rpcrdma_marshal_chunks(struct rpc_rqst *rqst, ssize_t result)
-{
-        struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
-        struct rpcrdma_msg *headerp = rdmab_to_msg(req->rl_rdmabuf);
-
-        if (req->rl_rtype != rpcrdma_noch)
-                result = rpcrdma_create_chunks(rqst, &rqst->rq_snd_buf,
-                                               headerp, req->rl_rtype);
-        else if (req->rl_wtype != rpcrdma_noch)
-                result = rpcrdma_create_chunks(rqst, &rqst->rq_rcv_buf,
-                                               headerp, req->rl_wtype);
-        return result;
+        for (pos = 0; nchunks--;)
+                pos += r_xprt->rx_ia.ri_ops->ro_unmap(r_xprt,
+                                                      &req->rl_segments[pos]);
+        return n;
 }
 
 /*
@@ -397,6 +385,7 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
         char *base;
         size_t rpclen, padlen;
         ssize_t hdrlen;
+        enum rpcrdma_chunktype rtype, wtype;
         struct rpcrdma_msg *headerp;
 
         /*
@@ -433,13 +422,13 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
          * into pages; otherwise use reply chunks.
          */
         if (rqst->rq_rcv_buf.buflen <= RPCRDMA_INLINE_READ_THRESHOLD(rqst))
-                req->rl_wtype = rpcrdma_noch;
+                wtype = rpcrdma_noch;
         else if (rqst->rq_rcv_buf.page_len == 0)
-                req->rl_wtype = rpcrdma_replych;
+                wtype = rpcrdma_replych;
         else if (rqst->rq_rcv_buf.flags & XDRBUF_READ)
-                req->rl_wtype = rpcrdma_writech;
+                wtype = rpcrdma_writech;
         else
-                req->rl_wtype = rpcrdma_replych;
+                wtype = rpcrdma_replych;
 
         /*
          * Chunks needed for arguments?
@@ -456,16 +445,16 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
          * TBD check NFSv4 setacl
          */
         if (rqst->rq_snd_buf.len <= RPCRDMA_INLINE_WRITE_THRESHOLD(rqst))
-                req->rl_rtype = rpcrdma_noch;
+                rtype = rpcrdma_noch;
         else if (rqst->rq_snd_buf.page_len == 0)
-                req->rl_rtype = rpcrdma_areadch;
+                rtype = rpcrdma_areadch;
         else
-                req->rl_rtype = rpcrdma_readch;
+                rtype = rpcrdma_readch;
 
         /* The following simplification is not true forever */
-        if (req->rl_rtype != rpcrdma_noch && req->rl_wtype == rpcrdma_replych)
-                req->rl_wtype = rpcrdma_noch;
-        if (req->rl_rtype != rpcrdma_noch && req->rl_wtype != rpcrdma_noch) {
+        if (rtype != rpcrdma_noch && wtype == rpcrdma_replych)
+                wtype = rpcrdma_noch;
+        if (rtype != rpcrdma_noch && wtype != rpcrdma_noch) {
                 dprintk("RPC:       %s: cannot marshal multiple chunk lists\n",
                         __func__);
                 return -EIO;
@@ -479,7 +468,7 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
          * When padding is in use and applies to the transfer, insert
          * it and change the message type.
          */
-        if (req->rl_rtype == rpcrdma_noch) {
+        if (rtype == rpcrdma_noch) {
 
                 padlen = rpcrdma_inline_pullup(rqst,
                                                 RPCRDMA_INLINE_PAD_VALUE(rqst));
@@ -494,7 +483,7 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
                         headerp->rm_body.rm_padded.rm_pempty[1] = xdr_zero;
                         headerp->rm_body.rm_padded.rm_pempty[2] = xdr_zero;
                         hdrlen += 2 * sizeof(u32); /* extra words in padhdr */
-                        if (req->rl_wtype != rpcrdma_noch) {
+                        if (wtype != rpcrdma_noch) {
                                 dprintk("RPC:       %s: invalid chunk list\n",
                                         __func__);
                                 return -EIO;
@@ -515,18 +504,26 @@ rpcrdma_marshal_req(struct rpc_rqst *rqst)
                          * on receive. Therefore, we request a reply chunk
                          * for non-writes wherever feasible and efficient.
                          */
-                        if (req->rl_wtype == rpcrdma_noch)
-                                req->rl_wtype = rpcrdma_replych;
+                        if (wtype == rpcrdma_noch)
+                                wtype = rpcrdma_replych;
                 }
         }
 
-        hdrlen = rpcrdma_marshal_chunks(rqst, hdrlen);
+        if (rtype != rpcrdma_noch) {
+                hdrlen = rpcrdma_create_chunks(rqst, &rqst->rq_snd_buf,
+                                               headerp, rtype);
+                wtype = rtype;  /* simplify dprintk */
+
+        } else if (wtype != rpcrdma_noch) {
+                hdrlen = rpcrdma_create_chunks(rqst, &rqst->rq_rcv_buf,
+                                               headerp, wtype);
+        }
         if (hdrlen < 0)
                 return hdrlen;
 
         dprintk("RPC:       %s: %s: hdrlen %zd rpclen %zd padlen %zd"
                 " headerp 0x%p base 0x%p lkey 0x%x\n",
-                __func__, transfertypes[req->rl_wtype], hdrlen, rpclen, padlen,
+                __func__, transfertypes[wtype], hdrlen, rpclen, padlen,
                 headerp, base, rdmab_lkey(req->rl_rdmabuf));
 
         /*
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index 2e192baa59f3..54f23b1be986 100644
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -157,12 +157,47 @@ static struct ctl_table sunrpc_table[] = {
 static struct rpc_xprt_ops xprt_rdma_procs;     /* forward reference */
 
 static void
+xprt_rdma_format_addresses4(struct rpc_xprt *xprt, struct sockaddr *sap)
+{
+        struct sockaddr_in *sin = (struct sockaddr_in *)sap;
+        char buf[20];
+
+        snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
+        xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
+
+        xprt->address_strings[RPC_DISPLAY_NETID] = RPCBIND_NETID_RDMA;
+}
+
+static void
+xprt_rdma_format_addresses6(struct rpc_xprt *xprt, struct sockaddr *sap)
+{
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
+        char buf[40];
+
+        snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
+        xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
+
+        xprt->address_strings[RPC_DISPLAY_NETID] = RPCBIND_NETID_RDMA6;
+}
+
+static void
 xprt_rdma_format_addresses(struct rpc_xprt *xprt)
 {
         struct sockaddr *sap = (struct sockaddr *)
                                         &rpcx_to_rdmad(xprt).addr;
-        struct sockaddr_in *sin = (struct sockaddr_in *)sap;
-        char buf[64];
+        char buf[128];
+
+        switch (sap->sa_family) {
+        case AF_INET:
+                xprt_rdma_format_addresses4(xprt, sap);
+                break;
+        case AF_INET6:
+                xprt_rdma_format_addresses6(xprt, sap);
+                break;
+        default:
+                pr_err("rpcrdma: Unrecognized address family\n");
+                return;
+        }
 
         (void)rpc_ntop(sap, buf, sizeof(buf));
         xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
@@ -170,16 +205,10 @@ xprt_rdma_format_addresses(struct rpc_xprt *xprt)
         snprintf(buf, sizeof(buf), "%u", rpc_get_port(sap));
         xprt->address_strings[RPC_DISPLAY_PORT] = kstrdup(buf, GFP_KERNEL);
 
-        xprt->address_strings[RPC_DISPLAY_PROTO] = "rdma";
-
-        snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
-        xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
-
         snprintf(buf, sizeof(buf), "%4hx", rpc_get_port(sap));
         xprt->address_strings[RPC_DISPLAY_HEX_PORT] = kstrdup(buf, GFP_KERNEL);
 
-        /* netid */
-        xprt->address_strings[RPC_DISPLAY_NETID] = "rdma";
+        xprt->address_strings[RPC_DISPLAY_PROTO] = "rdma";
 }
 
 static void
@@ -377,7 +406,10 @@ xprt_setup_rdma(struct xprt_create *args)
                           xprt_rdma_connect_worker);
 
         xprt_rdma_format_addresses(xprt);
-        xprt->max_payload = rpcrdma_max_payload(new_xprt);
+        xprt->max_payload = new_xprt->rx_ia.ri_ops->ro_maxpages(new_xprt);
+        if (xprt->max_payload == 0)
+                goto out4;
+        xprt->max_payload <<= PAGE_SHIFT;
         dprintk("RPC:       %s: transport data payload maximum: %zu bytes\n",
                 __func__, xprt->max_payload);
 
@@ -552,8 +584,8 @@ xprt_rdma_free(void *buffer)
 
         for (i = 0; req->rl_nchunks;) {
                 --req->rl_nchunks;
-                i += rpcrdma_deregister_external(
-                        &req->rl_segments[i], r_xprt);
+                i += r_xprt->rx_ia.ri_ops->ro_unmap(r_xprt,
+                                                    &req->rl_segments[i]);
         }
 
         rpcrdma_buffer_put(req);
@@ -579,10 +611,7 @@ xprt_rdma_send_request(struct rpc_task *task)
         struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(xprt);
         int rc = 0;
 
-        if (req->rl_niovs == 0)
-                rc = rpcrdma_marshal_req(rqst);
-        else if (r_xprt->rx_ia.ri_memreg_strategy != RPCRDMA_ALLPHYSICAL)
-                rc = rpcrdma_marshal_chunks(rqst, 0);
+        rc = rpcrdma_marshal_req(rqst);
         if (rc < 0)
                 goto failed_marshal;
 
diff --git a/net/sunrpc/xprtrdma/verbs.c b/net/sunrpc/xprtrdma/verbs.c
index e28909fddd30..4870d272e006 100644
--- a/net/sunrpc/xprtrdma/verbs.c
+++ b/net/sunrpc/xprtrdma/verbs.c
@@ -50,6 +50,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/prefetch.h>
+#include <linux/sunrpc/addr.h>
 #include <asm/bitops.h>
 
 #include "xprt_rdma.h"
@@ -62,9 +63,6 @@
 # define RPCDBG_FACILITY        RPCDBG_TRANS
 #endif
 
-static void rpcrdma_reset_frmrs(struct rpcrdma_ia *);
-static void rpcrdma_reset_fmrs(struct rpcrdma_ia *);
-
 /*
  * internal functions
  */
@@ -188,7 +186,7 @@ static const char * const wc_status[] = {
         "remote access error",
         "remote operation error",
         "transport retry counter exceeded",
-        "RNR retrycounter exceeded",
+        "RNR retry counter exceeded",
         "local RDD violation error",
         "remove invalid RD request",
         "operation aborted",
@@ -206,21 +204,17 @@ static const char * const wc_status[] = {
 static void
 rpcrdma_sendcq_process_wc(struct ib_wc *wc)
 {
-        if (likely(wc->status == IB_WC_SUCCESS))
-                return;
-
         /* WARNING: Only wr_id and status are reliable at this point */
-        if (wc->wr_id == 0ULL) {
-                if (wc->status != IB_WC_WR_FLUSH_ERR)
+        if (wc->wr_id == RPCRDMA_IGNORE_COMPLETION) {
+                if (wc->status != IB_WC_SUCCESS &&
+                    wc->status != IB_WC_WR_FLUSH_ERR)
                         pr_err("RPC:       %s: SEND: %s\n",
                                __func__, COMPLETION_MSG(wc->status));
         } else {
                 struct rpcrdma_mw *r;
 
                 r = (struct rpcrdma_mw *)(unsigned long)wc->wr_id;
-                r->r.frmr.fr_state = FRMR_IS_STALE;
-                pr_err("RPC:       %s: frmr %p (stale): %s\n",
-                       __func__, r, COMPLETION_MSG(wc->status));
+                r->mw_sendcompletion(wc);
         }
 }
 
@@ -424,7 +418,7 @@ rpcrdma_conn_upcall(struct rdma_cm_id *id, struct rdma_cm_event *event)
         struct rpcrdma_ia *ia = &xprt->rx_ia;
         struct rpcrdma_ep *ep = &xprt->rx_ep;
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
-        struct sockaddr_in *addr = (struct sockaddr_in *) &ep->rep_remote_addr;
+        struct sockaddr *sap = (struct sockaddr *)&ep->rep_remote_addr;
 #endif
         struct ib_qp_attr *attr = &ia->ri_qp_attr;
         struct ib_qp_init_attr *iattr = &ia->ri_qp_init_attr;
@@ -480,9 +474,8 @@ connected:
                 wake_up_all(&ep->rep_connect_wait);
                 /*FALLTHROUGH*/
         default:
-                dprintk("RPC:       %s: %pI4:%u (ep 0x%p): %s\n",
-                        __func__, &addr->sin_addr.s_addr,
-                        ntohs(addr->sin_port), ep,
+                dprintk("RPC:       %s: %pIS:%u (ep 0x%p): %s\n",
+                        __func__, sap, rpc_get_port(sap), ep,
                         CONNECTION_MSG(event->event));
                 break;
         }
@@ -491,19 +484,16 @@ connected:
         if (connstate == 1) {
                 int ird = attr->max_dest_rd_atomic;
                 int tird = ep->rep_remote_cma.responder_resources;
-                printk(KERN_INFO "rpcrdma: connection to %pI4:%u "
-                        "on %s, memreg %d slots %d ird %d%s\n",
-                        &addr->sin_addr.s_addr,
-                        ntohs(addr->sin_port),
+
+                pr_info("rpcrdma: connection to %pIS:%u on %s, memreg '%s', %d credits, %d responders%s\n",
+                        sap, rpc_get_port(sap),
                         ia->ri_id->device->name,
-                        ia->ri_memreg_strategy,
+                        ia->ri_ops->ro_displayname,
                         xprt->rx_buf.rb_max_requests,
                         ird, ird < 4 && ird < tird / 2 ? " (low!)" : "");
         } else if (connstate < 0) {
-                printk(KERN_INFO "rpcrdma: connection to %pI4:%u closed (%d)\n",
-                        &addr->sin_addr.s_addr,
-                        ntohs(addr->sin_port),
-                        connstate);
+                pr_info("rpcrdma: connection to %pIS:%u closed (%d)\n",
+                        sap, rpc_get_port(sap), connstate);
         }
 #endif
 
@@ -621,17 +611,13 @@ rpcrdma_ia_open(struct rpcrdma_xprt *xprt, struct sockaddr *addr, int memreg)
 
         if (memreg == RPCRDMA_FRMR) {
                 /* Requires both frmr reg and local dma lkey */
-                if ((devattr->device_cap_flags &
+                if (((devattr->device_cap_flags &
                      (IB_DEVICE_MEM_MGT_EXTENSIONS|IB_DEVICE_LOCAL_DMA_LKEY)) !=
-                    (IB_DEVICE_MEM_MGT_EXTENSIONS|IB_DEVICE_LOCAL_DMA_LKEY)) {
+                    (IB_DEVICE_MEM_MGT_EXTENSIONS|IB_DEVICE_LOCAL_DMA_LKEY)) ||
+                      (devattr->max_fast_reg_page_list_len == 0)) {
                         dprintk("RPC:       %s: FRMR registration "
                                 "not supported by HCA\n", __func__);
                         memreg = RPCRDMA_MTHCAFMR;
-                } else {
-                        /* Mind the ia limit on FRMR page list depth */
-                        ia->ri_max_frmr_depth = min_t(unsigned int,
-                                RPCRDMA_MAX_DATA_SEGS,
-                                devattr->max_fast_reg_page_list_len);
                 }
         }
         if (memreg == RPCRDMA_MTHCAFMR) {
@@ -652,13 +638,16 @@ rpcrdma_ia_open(struct rpcrdma_xprt *xprt, struct sockaddr *addr, int memreg)
          */
         switch (memreg) {
         case RPCRDMA_FRMR:
+                ia->ri_ops = &rpcrdma_frwr_memreg_ops;
                 break;
         case RPCRDMA_ALLPHYSICAL:
+                ia->ri_ops = &rpcrdma_physical_memreg_ops;
                 mem_priv = IB_ACCESS_LOCAL_WRITE |
                                 IB_ACCESS_REMOTE_WRITE |
                                 IB_ACCESS_REMOTE_READ;
                 goto register_setup;
         case RPCRDMA_MTHCAFMR:
+                ia->ri_ops = &rpcrdma_fmr_memreg_ops;
                 if (ia->ri_have_dma_lkey)
                         break;
                 mem_priv = IB_ACCESS_LOCAL_WRITE;
@@ -678,8 +667,8 @@ rpcrdma_ia_open(struct rpcrdma_xprt *xprt, struct sockaddr *addr, int memreg)
                 rc = -ENOMEM;
                 goto out3;
         }
-        dprintk("RPC:       %s: memory registration strategy is %d\n",
-                __func__, memreg);
+        dprintk("RPC:       %s: memory registration strategy is '%s'\n",
+                __func__, ia->ri_ops->ro_displayname);
 
         /* Else will do memory reg/dereg for each chunk */
         ia->ri_memreg_strategy = memreg;
@@ -743,49 +732,11 @@ rpcrdma_ep_create(struct rpcrdma_ep *ep, struct rpcrdma_ia *ia,
 
         ep->rep_attr.event_handler = rpcrdma_qp_async_error_upcall;
         ep->rep_attr.qp_context = ep;
-        /* send_cq and recv_cq initialized below */
         ep->rep_attr.srq = NULL;
         ep->rep_attr.cap.max_send_wr = cdata->max_requests;
-        switch (ia->ri_memreg_strategy) {
-        case RPCRDMA_FRMR: {
-                int depth = 7;
-
-                /* Add room for frmr register and invalidate WRs.
-                 * 1. FRMR reg WR for head
-                 * 2. FRMR invalidate WR for head
-                 * 3. N FRMR reg WRs for pagelist
-                 * 4. N FRMR invalidate WRs for pagelist
-                 * 5. FRMR reg WR for tail
-                 * 6. FRMR invalidate WR for tail
-                 * 7. The RDMA_SEND WR
-                 */
-
-                /* Calculate N if the device max FRMR depth is smaller than
-                 * RPCRDMA_MAX_DATA_SEGS.
-                 */
-                if (ia->ri_max_frmr_depth < RPCRDMA_MAX_DATA_SEGS) {
-                        int delta = RPCRDMA_MAX_DATA_SEGS -
-                                    ia->ri_max_frmr_depth;
-
-                        do {
-                                depth += 2; /* FRMR reg + invalidate */
-                                delta -= ia->ri_max_frmr_depth;
-                        } while (delta > 0);
-
-                }
-                ep->rep_attr.cap.max_send_wr *= depth;
-                if (ep->rep_attr.cap.max_send_wr > devattr->max_qp_wr) {
-                        cdata->max_requests = devattr->max_qp_wr / depth;
-                        if (!cdata->max_requests)
-                                return -EINVAL;
-                        ep->rep_attr.cap.max_send_wr = cdata->max_requests *
-                                                       depth;
-                }
-                break;
-        }
-        default:
-                break;
-        }
+        rc = ia->ri_ops->ro_open(ia, ep, cdata);
+        if (rc)
+                return rc;
         ep->rep_attr.cap.max_recv_wr = cdata->max_requests;
         ep->rep_attr.cap.max_send_sge = (cdata->padding ? 4 : 2);
         ep->rep_attr.cap.max_recv_sge = 1;
@@ -944,21 +895,9 @@ retry:
                 rpcrdma_ep_disconnect(ep, ia);
                 rpcrdma_flush_cqs(ep);
 
-                switch (ia->ri_memreg_strategy) {
-                case RPCRDMA_FRMR:
-                        rpcrdma_reset_frmrs(ia);
-                        break;
-                case RPCRDMA_MTHCAFMR:
-                        rpcrdma_reset_fmrs(ia);
-                        break;
-                case RPCRDMA_ALLPHYSICAL:
-                        break;
-                default:
-                        rc = -EIO;
-                        goto out;
-                }
-
                 xprt = container_of(ia, struct rpcrdma_xprt, rx_ia);
+                ia->ri_ops->ro_reset(xprt);
+
                 id = rpcrdma_create_id(xprt, ia,
                                 (struct sockaddr *)&xprt->rx_data.addr);
                 if (IS_ERR(id)) {
@@ -1123,91 +1062,6 @@ out:
         return ERR_PTR(rc);
 }
 
-static int
-rpcrdma_init_fmrs(struct rpcrdma_ia *ia, struct rpcrdma_buffer *buf)
-{
-        int mr_access_flags = IB_ACCESS_REMOTE_WRITE | IB_ACCESS_REMOTE_READ;
-        struct ib_fmr_attr fmr_attr = {
-                .max_pages      = RPCRDMA_MAX_DATA_SEGS,
-                .max_maps       = 1,
-                .page_shift     = PAGE_SHIFT
-        };
-        struct rpcrdma_mw *r;
-        int i, rc;
-
-        i = (buf->rb_max_requests + 1) * RPCRDMA_MAX_SEGS;
-        dprintk("RPC:       %s: initializing %d FMRs\n", __func__, i);
-
-        while (i--) {
-                r = kzalloc(sizeof(*r), GFP_KERNEL);
-                if (r == NULL)
-                        return -ENOMEM;
-
-                r->r.fmr = ib_alloc_fmr(ia->ri_pd, mr_access_flags, &fmr_attr);
-                if (IS_ERR(r->r.fmr)) {
-                        rc = PTR_ERR(r->r.fmr);
-                        dprintk("RPC:       %s: ib_alloc_fmr failed %i\n",
-                                __func__, rc);
-                        goto out_free;
-                }
-
-                list_add(&r->mw_list, &buf->rb_mws);
-                list_add(&r->mw_all, &buf->rb_all);
-        }
-        return 0;
-
-out_free:
-        kfree(r);
-        return rc;
-}
-
-static int
-rpcrdma_init_frmrs(struct rpcrdma_ia *ia, struct rpcrdma_buffer *buf)
-{
-        struct rpcrdma_frmr *f;
-        struct rpcrdma_mw *r;
-        int i, rc;
-
-        i = (buf->rb_max_requests + 1) * RPCRDMA_MAX_SEGS;
-        dprintk("RPC:       %s: initializing %d FRMRs\n", __func__, i);
-
-        while (i--) {
-                r = kzalloc(sizeof(*r), GFP_KERNEL);
-                if (r == NULL)
-                        return -ENOMEM;
-                f = &r->r.frmr;
-
-                f->fr_mr = ib_alloc_fast_reg_mr(ia->ri_pd,
-                                                ia->ri_max_frmr_depth);
-                if (IS_ERR(f->fr_mr)) {
-                        rc = PTR_ERR(f->fr_mr);
-                        dprintk("RPC:       %s: ib_alloc_fast_reg_mr "
-                                "failed %i\n", __func__, rc);
-                        goto out_free;
-                }
-
-                f->fr_pgl = ib_alloc_fast_reg_page_list(ia->ri_id->device,
-                                                        ia->ri_max_frmr_depth);
-                if (IS_ERR(f->fr_pgl)) {
-                        rc = PTR_ERR(f->fr_pgl);
-                        dprintk("RPC:       %s: ib_alloc_fast_reg_page_list "
-                                "failed %i\n", __func__, rc);
-
-                        ib_dereg_mr(f->fr_mr);
-                        goto out_free;
-                }
-
-                list_add(&r->mw_list, &buf->rb_mws);
-                list_add(&r->mw_all, &buf->rb_all);
-        }
-
-        return 0;
-
-out_free:
-        kfree(r);
-        return rc;
-}
-
 int
 rpcrdma_buffer_create(struct rpcrdma_xprt *r_xprt)
 {
@@ -1244,22 +1098,9 @@ rpcrdma_buffer_create(struct rpcrdma_xprt *r_xprt)
         buf->rb_recv_bufs = (struct rpcrdma_rep **) p;
         p = (char *) &buf->rb_recv_bufs[buf->rb_max_requests];
 
-        INIT_LIST_HEAD(&buf->rb_mws);
-        INIT_LIST_HEAD(&buf->rb_all);
-        switch (ia->ri_memreg_strategy) {
-        case RPCRDMA_FRMR:
-                rc = rpcrdma_init_frmrs(ia, buf);
-                if (rc)
-                        goto out;
-                break;
-        case RPCRDMA_MTHCAFMR:
-                rc = rpcrdma_init_fmrs(ia, buf);
-                if (rc)
-                        goto out;
-                break;
-        default:
-                break;
-        }
+        rc = ia->ri_ops->ro_init(r_xprt);
+        if (rc)
+                goto out;
 
         for (i = 0; i < buf->rb_max_requests; i++) {
                 struct rpcrdma_req *req;
@@ -1311,47 +1152,6 @@ rpcrdma_destroy_req(struct rpcrdma_ia *ia, struct rpcrdma_req *req)
         kfree(req);
 }
 
-static void
-rpcrdma_destroy_fmrs(struct rpcrdma_buffer *buf)
-{
-        struct rpcrdma_mw *r;
-        int rc;
-
-        while (!list_empty(&buf->rb_all)) {
-                r = list_entry(buf->rb_all.next, struct rpcrdma_mw, mw_all);
-                list_del(&r->mw_all);
-                list_del(&r->mw_list);
-
-                rc = ib_dealloc_fmr(r->r.fmr);
-                if (rc)
-                        dprintk("RPC:       %s: ib_dealloc_fmr failed %i\n",
-                                __func__, rc);
-
-                kfree(r);
-        }
-}
-
-static void
-rpcrdma_destroy_frmrs(struct rpcrdma_buffer *buf)
-{
-        struct rpcrdma_mw *r;
-        int rc;
-
-        while (!list_empty(&buf->rb_all)) {
-                r = list_entry(buf->rb_all.next, struct rpcrdma_mw, mw_all);
-                list_del(&r->mw_all);
-                list_del(&r->mw_list);
-
-                rc = ib_dereg_mr(r->r.frmr.fr_mr);
-                if (rc)
-                        dprintk("RPC:       %s: ib_dereg_mr failed %i\n",
-                                __func__, rc);
-                ib_free_fast_reg_page_list(r->r.frmr.fr_pgl);
-
-                kfree(r);
-        }
-}
-
 void
 rpcrdma_buffer_destroy(struct rpcrdma_buffer *buf)
 {
@@ -1372,104 +1172,11 @@ rpcrdma_buffer_destroy(struct rpcrdma_buffer *buf)
                         rpcrdma_destroy_req(ia, buf->rb_send_bufs[i]);
         }
 
-        switch (ia->ri_memreg_strategy) {
-        case RPCRDMA_FRMR:
-                rpcrdma_destroy_frmrs(buf);
-                break;
-        case RPCRDMA_MTHCAFMR:
-                rpcrdma_destroy_fmrs(buf);
-                break;
-        default:
-                break;
-        }
+        ia->ri_ops->ro_destroy(buf);
 
         kfree(buf->rb_pool);
 }
 
-/* After a disconnect, unmap all FMRs.
- *
- * This is invoked only in the transport connect worker in order
- * to serialize with rpcrdma_register_fmr_external().
- */
-static void
-rpcrdma_reset_fmrs(struct rpcrdma_ia *ia)
-{
-        struct rpcrdma_xprt *r_xprt =
-                                container_of(ia, struct rpcrdma_xprt, rx_ia);
-        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
-        struct list_head *pos;
-        struct rpcrdma_mw *r;
-        LIST_HEAD(l);
-        int rc;
-
-        list_for_each(pos, &buf->rb_all) {
-                r = list_entry(pos, struct rpcrdma_mw, mw_all);
-
-                INIT_LIST_HEAD(&l);
-                list_add(&r->r.fmr->list, &l);
-                rc = ib_unmap_fmr(&l);
-                if (rc)
-                        dprintk("RPC:       %s: ib_unmap_fmr failed %i\n",
-                                __func__, rc);
-        }
-}
-
-/* After a disconnect, a flushed FAST_REG_MR can leave an FRMR in
- * an unusable state. Find FRMRs in this state and dereg / reg
- * each.  FRMRs that are VALID and attached to an rpcrdma_req are
- * also torn down.
- *
- * This gives all in-use FRMRs a fresh rkey and leaves them INVALID.
- *
- * This is invoked only in the transport connect worker in order
- * to serialize with rpcrdma_register_frmr_external().
- */
-static void
-rpcrdma_reset_frmrs(struct rpcrdma_ia *ia)
-{
-        struct rpcrdma_xprt *r_xprt =
-                                container_of(ia, struct rpcrdma_xprt, rx_ia);
-        struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
-        struct list_head *pos;
-        struct rpcrdma_mw *r;
-        int rc;
-
-        list_for_each(pos, &buf->rb_all) {
-                r = list_entry(pos, struct rpcrdma_mw, mw_all);
-
-                if (r->r.frmr.fr_state == FRMR_IS_INVALID)
-                        continue;
-
-                rc = ib_dereg_mr(r->r.frmr.fr_mr);
-                if (rc)
-                        dprintk("RPC:       %s: ib_dereg_mr failed %i\n",
-                                __func__, rc);
-                ib_free_fast_reg_page_list(r->r.frmr.fr_pgl);
-
-                r->r.frmr.fr_mr = ib_alloc_fast_reg_mr(ia->ri_pd,
-                                        ia->ri_max_frmr_depth);
-                if (IS_ERR(r->r.frmr.fr_mr)) {
-                        rc = PTR_ERR(r->r.frmr.fr_mr);
-                        dprintk("RPC:       %s: ib_alloc_fast_reg_mr"
-                                " failed %i\n", __func__, rc);
-                        continue;
-                }
-                r->r.frmr.fr_pgl = ib_alloc_fast_reg_page_list(
-                                        ia->ri_id->device,
-                                        ia->ri_max_frmr_depth);
-                if (IS_ERR(r->r.frmr.fr_pgl)) {
-                        rc = PTR_ERR(r->r.frmr.fr_pgl);
-                        dprintk("RPC:       %s: "
-                                "ib_alloc_fast_reg_page_list "
-                                "failed %i\n", __func__, rc);
-
-                        ib_dereg_mr(r->r.frmr.fr_mr);
-                        continue;
-                }
-                r->r.frmr.fr_state = FRMR_IS_INVALID;
-        }
-}
-
 /* "*mw" can be NULL when rpcrdma_buffer_get_mrs() fails, leaving
  * some req segments uninitialized.
  */
@@ -1509,7 +1216,7 @@ rpcrdma_buffer_put_sendbuf(struct rpcrdma_req *req, struct rpcrdma_buffer *buf)
         }
 }
 
-/* rpcrdma_unmap_one() was already done by rpcrdma_deregister_frmr_external().
+/* rpcrdma_unmap_one() was already done during deregistration.
  * Redo only the ib_post_send().
  */
 static void
@@ -1729,6 +1436,14 @@ rpcrdma_recv_buffer_put(struct rpcrdma_rep *rep)
  * Wrappers for internal-use kmalloc memory registration, used by buffer code.
  */
 
+void
+rpcrdma_mapping_error(struct rpcrdma_mr_seg *seg)
+{
+        dprintk("RPC:       map_one: offset %p iova %llx len %zu\n",
+                seg->mr_offset,
+                (unsigned long long)seg->mr_dma, seg->mr_dmalen);
+}
+
 static int
 rpcrdma_register_internal(struct rpcrdma_ia *ia, void *va, int len,
                                 struct ib_mr **mrp, struct ib_sge *iov)
@@ -1854,287 +1569,6 @@ rpcrdma_free_regbuf(struct rpcrdma_ia *ia, struct rpcrdma_regbuf *rb)
 }
 
 /*
- * Wrappers for chunk registration, shared by read/write chunk code.
- */
-
-static void
-rpcrdma_map_one(struct rpcrdma_ia *ia, struct rpcrdma_mr_seg *seg, int writing)
-{
-        seg->mr_dir = writing ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-        seg->mr_dmalen = seg->mr_len;
-        if (seg->mr_page)
-                seg->mr_dma = ib_dma_map_page(ia->ri_id->device,
-                                seg->mr_page, offset_in_page(seg->mr_offset),
-                                seg->mr_dmalen, seg->mr_dir);
-        else
-                seg->mr_dma = ib_dma_map_single(ia->ri_id->device,
-                                seg->mr_offset,
-                                seg->mr_dmalen, seg->mr_dir);
-        if (ib_dma_mapping_error(ia->ri_id->device, seg->mr_dma)) {
-                dprintk("RPC:       %s: mr_dma %llx mr_offset %p mr_dma_len %zu\n",
-                        __func__,
-                        (unsigned long long)seg->mr_dma,
-                        seg->mr_offset, seg->mr_dmalen);
-        }
-}
-
-static void
-rpcrdma_unmap_one(struct rpcrdma_ia *ia, struct rpcrdma_mr_seg *seg)
-{
-        if (seg->mr_page)
-                ib_dma_unmap_page(ia->ri_id->device,
-                                seg->mr_dma, seg->mr_dmalen, seg->mr_dir);
-        else
-                ib_dma_unmap_single(ia->ri_id->device,
-                                seg->mr_dma, seg->mr_dmalen, seg->mr_dir);
-}
-
-static int
-rpcrdma_register_frmr_external(struct rpcrdma_mr_seg *seg,
-                        int *nsegs, int writing, struct rpcrdma_ia *ia,
-                        struct rpcrdma_xprt *r_xprt)
-{
-        struct rpcrdma_mr_seg *seg1 = seg;
-        struct rpcrdma_mw *mw = seg1->rl_mw;
-        struct rpcrdma_frmr *frmr = &mw->r.frmr;
-        struct ib_mr *mr = frmr->fr_mr;
-        struct ib_send_wr fastreg_wr, *bad_wr;
-        u8 key;
-        int len, pageoff;
-        int i, rc;
-        int seg_len;
-        u64 pa;
-        int page_no;
-
-        pageoff = offset_in_page(seg1->mr_offset);
-        seg1->mr_offset -= pageoff;     /* start of page */
-        seg1->mr_len += pageoff;
-        len = -pageoff;
-        if (*nsegs > ia->ri_max_frmr_depth)
-                *nsegs = ia->ri_max_frmr_depth;
-        for (page_no = i = 0; i < *nsegs;) {
-                rpcrdma_map_one(ia, seg, writing);
-                pa = seg->mr_dma;
-                for (seg_len = seg->mr_len; seg_len > 0; seg_len -= PAGE_SIZE) {
-                        frmr->fr_pgl->page_list[page_no++] = pa;
-                        pa += PAGE_SIZE;
-                }
-                len += seg->mr_len;
-                ++seg;
-                ++i;
-                /* Check for holes */
-                if ((i < *nsegs && offset_in_page(seg->mr_offset)) ||
-                    offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
-                        break;
-        }
-        dprintk("RPC:       %s: Using frmr %p to map %d segments\n",
-                __func__, mw, i);
-
-        frmr->fr_state = FRMR_IS_VALID;
-
-        memset(&fastreg_wr, 0, sizeof(fastreg_wr));
-        fastreg_wr.wr_id = (unsigned long)(void *)mw;
-        fastreg_wr.opcode = IB_WR_FAST_REG_MR;
-        fastreg_wr.wr.fast_reg.iova_start = seg1->mr_dma;
-        fastreg_wr.wr.fast_reg.page_list = frmr->fr_pgl;
-        fastreg_wr.wr.fast_reg.page_list_len = page_no;
-        fastreg_wr.wr.fast_reg.page_shift = PAGE_SHIFT;
-        fastreg_wr.wr.fast_reg.length = page_no << PAGE_SHIFT;
-        if (fastreg_wr.wr.fast_reg.length < len) {
-                rc = -EIO;
-                goto out_err;
-        }
-
-        /* Bump the key */
-        key = (u8)(mr->rkey & 0x000000FF);
-        ib_update_fast_reg_key(mr, ++key);
-
-        fastreg_wr.wr.fast_reg.access_flags = (writing ?
-                                IB_ACCESS_REMOTE_WRITE | IB_ACCESS_LOCAL_WRITE :
-                                IB_ACCESS_REMOTE_READ);
-        fastreg_wr.wr.fast_reg.rkey = mr->rkey;
-        DECR_CQCOUNT(&r_xprt->rx_ep);
-
-        rc = ib_post_send(ia->ri_id->qp, &fastreg_wr, &bad_wr);
-        if (rc) {
-                dprintk("RPC:       %s: failed ib_post_send for register,"
-                        " status %i\n", __func__, rc);
-                ib_update_fast_reg_key(mr, --key);
-                goto out_err;
-        } else {
-                seg1->mr_rkey = mr->rkey;
-                seg1->mr_base = seg1->mr_dma + pageoff;
-                seg1->mr_nsegs = i;
-                seg1->mr_len = len;
-        }
-        *nsegs = i;
-        return 0;
-out_err:
-        frmr->fr_state = FRMR_IS_INVALID;
-        while (i--)
-                rpcrdma_unmap_one(ia, --seg);
-        return rc;
-}
-
-static int
-rpcrdma_deregister_frmr_external(struct rpcrdma_mr_seg *seg,
-                        struct rpcrdma_ia *ia, struct rpcrdma_xprt *r_xprt)
-{
-        struct rpcrdma_mr_seg *seg1 = seg;
-        struct ib_send_wr invalidate_wr, *bad_wr;
-        int rc;
-
-        seg1->rl_mw->r.frmr.fr_state = FRMR_IS_INVALID;
-
-        memset(&invalidate_wr, 0, sizeof invalidate_wr);
-        invalidate_wr.wr_id = (unsigned long)(void *)seg1->rl_mw;
-        invalidate_wr.opcode = IB_WR_LOCAL_INV;
-        invalidate_wr.ex.invalidate_rkey = seg1->rl_mw->r.frmr.fr_mr->rkey;
-        DECR_CQCOUNT(&r_xprt->rx_ep);
-
-        read_lock(&ia->ri_qplock);
-        while (seg1->mr_nsegs--)
-                rpcrdma_unmap_one(ia, seg++);
-        rc = ib_post_send(ia->ri_id->qp, &invalidate_wr, &bad_wr);
-        read_unlock(&ia->ri_qplock);
-        if (rc) {
-                /* Force rpcrdma_buffer_get() to retry */
-                seg1->rl_mw->r.frmr.fr_state = FRMR_IS_STALE;
-                dprintk("RPC:       %s: failed ib_post_send for invalidate,"
-                        " status %i\n", __func__, rc);
-        }
-        return rc;
-}
-
-static int
-rpcrdma_register_fmr_external(struct rpcrdma_mr_seg *seg,
-                        int *nsegs, int writing, struct rpcrdma_ia *ia)
-{
-        struct rpcrdma_mr_seg *seg1 = seg;
-        u64 physaddrs[RPCRDMA_MAX_DATA_SEGS];
-        int len, pageoff, i, rc;
-
-        pageoff = offset_in_page(seg1->mr_offset);
-        seg1->mr_offset -= pageoff;     /* start of page */
-        seg1->mr_len += pageoff;
-        len = -pageoff;
-        if (*nsegs > RPCRDMA_MAX_DATA_SEGS)
-                *nsegs = RPCRDMA_MAX_DATA_SEGS;
-        for (i = 0; i < *nsegs;) {
-                rpcrdma_map_one(ia, seg, writing);
-                physaddrs[i] = seg->mr_dma;
-                len += seg->mr_len;
-                ++seg;
-                ++i;
-                /* Check for holes */
-                if ((i < *nsegs && offset_in_page(seg->mr_offset)) ||
-                    offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
-                        break;
-        }
-        rc = ib_map_phys_fmr(seg1->rl_mw->r.fmr, physaddrs, i, seg1->mr_dma);
-        if (rc) {
-                dprintk("RPC:       %s: failed ib_map_phys_fmr "
-                        "%u@0x%llx+%i (%d)... status %i\n", __func__,
-                        len, (unsigned long long)seg1->mr_dma,
-                        pageoff, i, rc);
-                while (i--)
-                        rpcrdma_unmap_one(ia, --seg);
-        } else {
-                seg1->mr_rkey = seg1->rl_mw->r.fmr->rkey;
-                seg1->mr_base = seg1->mr_dma + pageoff;
-                seg1->mr_nsegs = i;
-                seg1->mr_len = len;
-        }
-        *nsegs = i;
-        return rc;
-}
-
-static int
-rpcrdma_deregister_fmr_external(struct rpcrdma_mr_seg *seg,
-                        struct rpcrdma_ia *ia)
-{
-        struct rpcrdma_mr_seg *seg1 = seg;
-        LIST_HEAD(l);
-        int rc;
-
-        list_add(&seg1->rl_mw->r.fmr->list, &l);
-        rc = ib_unmap_fmr(&l);
-        read_lock(&ia->ri_qplock);
-        while (seg1->mr_nsegs--)
-                rpcrdma_unmap_one(ia, seg++);
-        read_unlock(&ia->ri_qplock);
-        if (rc)
-                dprintk("RPC:       %s: failed ib_unmap_fmr,"
-                        " status %i\n", __func__, rc);
-        return rc;
-}
-
-int
-rpcrdma_register_external(struct rpcrdma_mr_seg *seg,
-                        int nsegs, int writing, struct rpcrdma_xprt *r_xprt)
-{
-        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
-        int rc = 0;
-
-        switch (ia->ri_memreg_strategy) {
-
-        case RPCRDMA_ALLPHYSICAL:
-                rpcrdma_map_one(ia, seg, writing);
-                seg->mr_rkey = ia->ri_bind_mem->rkey;
-                seg->mr_base = seg->mr_dma;
-                seg->mr_nsegs = 1;
-                nsegs = 1;
-                break;
-
-        /* Registration using frmr registration */
-        case RPCRDMA_FRMR:
-                rc = rpcrdma_register_frmr_external(seg, &nsegs, writing, ia, r_xprt);
-                break;
-
-        /* Registration using fmr memory registration */
-        case RPCRDMA_MTHCAFMR:
-                rc = rpcrdma_register_fmr_external(seg, &nsegs, writing, ia);
-                break;
-
-        default:
-                return -EIO;
-        }
-        if (rc)
-                return rc;
-
-        return nsegs;
-}
-
-int
-rpcrdma_deregister_external(struct rpcrdma_mr_seg *seg,
-                struct rpcrdma_xprt *r_xprt)
-{
-        struct rpcrdma_ia *ia = &r_xprt->rx_ia;
-        int nsegs = seg->mr_nsegs, rc;
-
-        switch (ia->ri_memreg_strategy) {
-
-        case RPCRDMA_ALLPHYSICAL:
-                read_lock(&ia->ri_qplock);
-                rpcrdma_unmap_one(ia, seg);
-                read_unlock(&ia->ri_qplock);
-                break;
-
-        case RPCRDMA_FRMR:
-                rc = rpcrdma_deregister_frmr_external(seg, ia, r_xprt);
-                break;
-
-        case RPCRDMA_MTHCAFMR:
-                rc = rpcrdma_deregister_fmr_external(seg, ia);
-                break;
-
-        default:
-                break;
-        }
-        return nsegs;
-}
-
-/*
  * Prepost any receive buffer, then post send.
  *
  * Receive buffer is donated to hardware, reclaimed upon recv completion.
@@ -2156,7 +1590,7 @@ rpcrdma_ep_post(struct rpcrdma_ia *ia,
         }
 
         send_wr.next = NULL;
-        send_wr.wr_id = 0ULL;   /* no send cookie */
+        send_wr.wr_id = RPCRDMA_IGNORE_COMPLETION;
         send_wr.sg_list = req->rl_send_iov;
         send_wr.num_sge = req->rl_niovs;
         send_wr.opcode = IB_WR_SEND;
@@ -2215,43 +1649,24 @@ rpcrdma_ep_post_recv(struct rpcrdma_ia *ia,
         return rc;
 }
 
-/* Physical mapping means one Read/Write list entry per-page.
- * All list entries must fit within an inline buffer
- *
- * NB: The server must return a Write list for NFS READ,
- *     which has the same constraint. Factor in the inline
- *     rsize as well.
+/* How many chunk list items fit within our inline buffers?
  */
-static size_t
-rpcrdma_physical_max_payload(struct rpcrdma_xprt *r_xprt)
+unsigned int
+rpcrdma_max_segments(struct rpcrdma_xprt *r_xprt)
 {
         struct rpcrdma_create_data_internal *cdata = &r_xprt->rx_data;
-        unsigned int inline_size, pages;
+        int bytes, segments;
 
-        inline_size = min_t(unsigned int,
-                            cdata->inline_wsize, cdata->inline_rsize);
-        inline_size -= RPCRDMA_HDRLEN_MIN;
-        pages = inline_size / sizeof(struct rpcrdma_segment);
-        return pages << PAGE_SHIFT;
-}
-
-static size_t
-rpcrdma_mr_max_payload(struct rpcrdma_xprt *r_xprt)
-{
-        return RPCRDMA_MAX_DATA_SEGS << PAGE_SHIFT;
-}
-
-size_t
-rpcrdma_max_payload(struct rpcrdma_xprt *r_xprt)
-{
-        size_t result;
-
-        switch (r_xprt->rx_ia.ri_memreg_strategy) {
-        case RPCRDMA_ALLPHYSICAL:
-                result = rpcrdma_physical_max_payload(r_xprt);
-                break;
-        default:
-                result = rpcrdma_mr_max_payload(r_xprt);
+        bytes = min_t(unsigned int, cdata->inline_wsize, cdata->inline_rsize);
+        bytes -= RPCRDMA_HDRLEN_MIN;
+        if (bytes < sizeof(struct rpcrdma_segment) * 2) {
+                pr_warn("RPC:       %s: inline threshold too small\n",
+                        __func__);
+                return 0;
         }
-        return result;
+
+        segments = 1 << (fls(bytes / sizeof(struct rpcrdma_segment)) - 1);
+        dprintk("RPC:       %s: max chunk list size = %d segments\n",
+                __func__, segments);
+        return segments;
 }
diff --git a/net/sunrpc/xprtrdma/xprt_rdma.h b/net/sunrpc/xprtrdma/xprt_rdma.h
index 0a16fb6f0885..78e0b8beaa36 100644
--- a/net/sunrpc/xprtrdma/xprt_rdma.h
+++ b/net/sunrpc/xprtrdma/xprt_rdma.h
@@ -60,6 +60,7 @@
  * Interface Adapter -- one per transport instance
  */
 struct rpcrdma_ia {
+        const struct rpcrdma_memreg_ops *ri_ops;
         rwlock_t                ri_qplock;
         struct rdma_cm_id       *ri_id;
         struct ib_pd            *ri_pd;
@@ -105,6 +106,10 @@ struct rpcrdma_ep {
 #define INIT_CQCOUNT(ep) atomic_set(&(ep)->rep_cqcount, (ep)->rep_cqinit)
 #define DECR_CQCOUNT(ep) atomic_sub_return(1, &(ep)->rep_cqcount)
 
+/* Force completion handler to ignore the signal
+ */
+#define RPCRDMA_IGNORE_COMPLETION       (0ULL)
+
 /* Registered buffer -- registered kmalloc'd memory for RDMA SEND/RECV
  *
  * The below structure appears at the front of a large region of kmalloc'd
@@ -143,14 +148,6 @@ rdmab_to_msg(struct rpcrdma_regbuf *rb)
         return (struct rpcrdma_msg *)rb->rg_base;
 }
 
-enum rpcrdma_chunktype {
-        rpcrdma_noch = 0,
-        rpcrdma_readch,
-        rpcrdma_areadch,
-        rpcrdma_writech,
-        rpcrdma_replych
-};
-
 /*
  * struct rpcrdma_rep -- this structure encapsulates state required to recv
  * and complete a reply, asychronously. It needs several pieces of
@@ -213,6 +210,7 @@ struct rpcrdma_mw {
                 struct ib_fmr           *fmr;
                 struct rpcrdma_frmr     frmr;
         } r;
+        void                    (*mw_sendcompletion)(struct ib_wc *);
         struct list_head        mw_list;
         struct list_head        mw_all;
 };
@@ -258,7 +256,6 @@ struct rpcrdma_req {
         unsigned int    rl_niovs;       /* 0, 2 or 4 */
         unsigned int    rl_nchunks;     /* non-zero if chunks */
         unsigned int    rl_connect_cookie;      /* retry detection */
-        enum rpcrdma_chunktype  rl_rtype, rl_wtype;
         struct rpcrdma_buffer *rl_buffer; /* home base for this structure */
         struct rpcrdma_rep      *rl_reply;/* holder for reply buffer */
         struct ib_sge   rl_send_iov[4]; /* for active requests */
@@ -340,6 +337,29 @@ struct rpcrdma_stats {
 };
 
 /*
+ * Per-registration mode operations
+ */
+struct rpcrdma_xprt;
+struct rpcrdma_memreg_ops {
+        int             (*ro_map)(struct rpcrdma_xprt *,
+                                  struct rpcrdma_mr_seg *, int, bool);
+        int             (*ro_unmap)(struct rpcrdma_xprt *,
+                                    struct rpcrdma_mr_seg *);
+        int             (*ro_open)(struct rpcrdma_ia *,
+                                   struct rpcrdma_ep *,
+                                   struct rpcrdma_create_data_internal *);
+        size_t          (*ro_maxpages)(struct rpcrdma_xprt *);
+        int             (*ro_init)(struct rpcrdma_xprt *);
+        void            (*ro_reset)(struct rpcrdma_xprt *);
+        void            (*ro_destroy)(struct rpcrdma_buffer *);
+        const char      *ro_displayname;
+};
+
+extern const struct rpcrdma_memreg_ops rpcrdma_fmr_memreg_ops;
+extern const struct rpcrdma_memreg_ops rpcrdma_frwr_memreg_ops;
+extern const struct rpcrdma_memreg_ops rpcrdma_physical_memreg_ops;
+
+/*
  * RPCRDMA transport -- encapsulates the structures above for
  * integration with RPC.
  *
@@ -398,16 +418,56 @@ void rpcrdma_buffer_put(struct rpcrdma_req *);
 void rpcrdma_recv_buffer_get(struct rpcrdma_req *);
 void rpcrdma_recv_buffer_put(struct rpcrdma_rep *);
 
-int rpcrdma_register_external(struct rpcrdma_mr_seg *,
-                                int, int, struct rpcrdma_xprt *);
-int rpcrdma_deregister_external(struct rpcrdma_mr_seg *,
-                                struct rpcrdma_xprt *);
-
 struct rpcrdma_regbuf *rpcrdma_alloc_regbuf(struct rpcrdma_ia *,
                                             size_t, gfp_t);
 void rpcrdma_free_regbuf(struct rpcrdma_ia *,
                          struct rpcrdma_regbuf *);
 
+unsigned int rpcrdma_max_segments(struct rpcrdma_xprt *);
+
+/*
+ * Wrappers for chunk registration, shared by read/write chunk code.
+ */
+
+void rpcrdma_mapping_error(struct rpcrdma_mr_seg *);
+
+static inline enum dma_data_direction
+rpcrdma_data_dir(bool writing)
+{
+        return writing ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+}
+
+static inline void
+rpcrdma_map_one(struct ib_device *device, struct rpcrdma_mr_seg *seg,
+                enum dma_data_direction direction)
+{
+        seg->mr_dir = direction;
+        seg->mr_dmalen = seg->mr_len;
+
+        if (seg->mr_page)
+                seg->mr_dma = ib_dma_map_page(device,
+                                seg->mr_page, offset_in_page(seg->mr_offset),
+                                seg->mr_dmalen, seg->mr_dir);
+        else
+                seg->mr_dma = ib_dma_map_single(device,
+                                seg->mr_offset,
+                                seg->mr_dmalen, seg->mr_dir);
+
+        if (ib_dma_mapping_error(device, seg->mr_dma))
+                rpcrdma_mapping_error(seg);
+}
+
+static inline void
+rpcrdma_unmap_one(struct ib_device *device, struct rpcrdma_mr_seg *seg)
+{
+        if (seg->mr_page)
+                ib_dma_unmap_page(device,
+                                  seg->mr_dma, seg->mr_dmalen, seg->mr_dir);
+        else
+                ib_dma_unmap_single(device,
+                                    seg->mr_dma, seg->mr_dmalen, seg->mr_dir);
+}
+
 /*
  * RPC/RDMA connection management calls - xprtrdma/rpc_rdma.c
  */
@@ -418,9 +478,7 @@ void rpcrdma_reply_handler(struct rpcrdma_rep *);
 /*
  * RPC/RDMA protocol calls - xprtrdma/rpc_rdma.c
  */
-ssize_t rpcrdma_marshal_chunks(struct rpc_rqst *, ssize_t);
 int rpcrdma_marshal_req(struct rpc_rqst *);
-size_t rpcrdma_max_payload(struct rpcrdma_xprt *);
 
 /* Temporary NFS request map cache. Created in svc_rdma.c  */
 extern struct kmem_cache *svc_rdma_map_cachep;
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 433f287ee548..5266ea7b922b 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -305,7 +305,7 @@ static struct sock *unix_find_socket_byinode(struct inode *i)
                     &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) {
                 struct dentry *dentry = unix_sk(s)->path.dentry;
 
-                if (dentry && dentry->d_inode == i) {
+                if (dentry && d_backing_inode(dentry) == i) {
                         sock_hold(s);
                         goto found;
                 }
@@ -778,7 +778,7 @@ static struct sock *unix_find_other(struct net *net,
                 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
                 if (err)
                         goto fail;
-                inode = path.dentry->d_inode;
+                inode = d_backing_inode(path.dentry);
                 err = inode_permission(inode, MAY_WRITE);
                 if (err)
                         goto put_fail;
@@ -839,7 +839,7 @@ static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
          */
         err = security_path_mknod(&path, dentry, mode, 0);
         if (!err) {
-                err = vfs_mknod(path.dentry->d_inode, dentry, mode, 0);
+                err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
                 if (!err) {
                         res->mnt = mntget(path.mnt);
                         res->dentry = dget(dentry);
@@ -905,7 +905,7 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                         goto out_up;
                 }
                 addr->hash = UNIX_HASH_SIZE;
-                hash = path.dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1);
+                hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE-1);
                 spin_lock(&unix_table_lock);
                 u->path = path;
                 list = &unix_socket_table[hash];
diff --git a/net/unix/diag.c b/net/unix/diag.c
index ef542fbca9fe..c512f64d5287 100644
--- a/net/unix/diag.c
+++ b/net/unix/diag.c
@@ -25,7 +25,7 @@ static int sk_diag_dump_vfs(struct sock *sk, struct sk_buff *nlskb)
 
         if (dentry) {
                 struct unix_diag_vfs uv = {
-                        .udiag_vfs_ino = dentry->d_inode->i_ino,
+                        .udiag_vfs_ino = d_backing_inode(dentry)->i_ino,
                         .udiag_vfs_dev = dentry->d_sb->s_dev,
                 };
 
diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c
index 7db9954f1af2..ad4fa49ad1db 100644
--- a/security/apparmor/apparmorfs.c
+++ b/security/apparmor/apparmorfs.c
@@ -365,7 +365,7 @@ void __aa_fs_profile_rmdir(struct aa_profile *profile)
                 if (!profile->dents[i])
                         continue;
 
-                r = profile->dents[i]->d_inode->i_private;
+                r = d_inode(profile->dents[i])->i_private;
                 securityfs_remove(profile->dents[i]);
                 aa_put_replacedby(r);
                 profile->dents[i] = NULL;
diff --git a/security/apparmor/file.c b/security/apparmor/file.c
index fdaa50cb1876..913f377a038a 100644
--- a/security/apparmor/file.c
+++ b/security/apparmor/file.c
@@ -259,7 +259,7 @@ unsigned int aa_str_perms(struct aa_dfa *dfa, unsigned int start,
  */
 static inline bool is_deleted(struct dentry *dentry)
 {
-        if (d_unlinked(dentry) && dentry->d_inode->i_nlink == 0)
+        if (d_unlinked(dentry) && d_backing_inode(dentry)->i_nlink == 0)
                 return 1;
         return 0;
 }
@@ -351,8 +351,8 @@ int aa_path_link(struct aa_profile *profile, struct dentry *old_dentry,
         struct path link = { new_dir->mnt, new_dentry };
         struct path target = { new_dir->mnt, old_dentry };
         struct path_cond cond = {
-                old_dentry->d_inode->i_uid,
-                old_dentry->d_inode->i_mode
+                d_backing_inode(old_dentry)->i_uid,
+                d_backing_inode(old_dentry)->i_mode
         };
         char *buffer = NULL, *buffer2 = NULL;
         const char *lname, *tname = NULL, *info = NULL;
diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
index dd56bffd6500..e5f1561439db 100644
--- a/security/apparmor/lsm.c
+++ b/security/apparmor/lsm.c
@@ -204,8 +204,8 @@ static int common_perm_mnt_dentry(int op, struct vfsmount *mnt,
                                   struct dentry *dentry, u32 mask)
 {
         struct path path = { mnt, dentry };
-        struct path_cond cond = { dentry->d_inode->i_uid,
-                                  dentry->d_inode->i_mode
+        struct path_cond cond = { d_backing_inode(dentry)->i_uid,
+                                  d_backing_inode(dentry)->i_mode
         };
 
         return common_perm(op, &path, mask, &cond);
@@ -223,7 +223,7 @@ static int common_perm_mnt_dentry(int op, struct vfsmount *mnt,
 static int common_perm_rm(int op, struct path *dir,
                           struct dentry *dentry, u32 mask)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct path_cond cond = { };
 
         if (!inode || !dir->mnt || !mediated_filesystem(dentry))
@@ -281,8 +281,8 @@ static int apparmor_path_mknod(struct path *dir, struct dentry *dentry,
 
 static int apparmor_path_truncate(struct path *path)
 {
-        struct path_cond cond = { path->dentry->d_inode->i_uid,
-                                  path->dentry->d_inode->i_mode
+        struct path_cond cond = { d_backing_inode(path->dentry)->i_uid,
+                                  d_backing_inode(path->dentry)->i_mode
         };
 
         if (!path->mnt || !mediated_filesystem(path->dentry))
@@ -327,8 +327,8 @@ static int apparmor_path_rename(struct path *old_dir, struct dentry *old_dentry,
         if (!unconfined(profile)) {
                 struct path old_path = { old_dir->mnt, old_dentry };
                 struct path new_path = { new_dir->mnt, new_dentry };
-                struct path_cond cond = { old_dentry->d_inode->i_uid,
-                                          old_dentry->d_inode->i_mode
+                struct path_cond cond = { d_backing_inode(old_dentry)->i_uid,
+                                          d_backing_inode(old_dentry)->i_mode
                 };
 
                 error = aa_path_perm(OP_RENAME_SRC, profile, &old_path, 0,
@@ -354,8 +354,8 @@ static int apparmor_path_chmod(struct path *path, umode_t mode)
 
 static int apparmor_path_chown(struct path *path, kuid_t uid, kgid_t gid)
 {
-        struct path_cond cond =  { path->dentry->d_inode->i_uid,
-                                   path->dentry->d_inode->i_mode
+        struct path_cond cond =  { d_backing_inode(path->dentry)->i_uid,
+                                   d_backing_inode(path->dentry)->i_mode
         };
 
         if (!mediated_filesystem(path->dentry))
diff --git a/security/commoncap.c b/security/commoncap.c
index f66713bd7450..f2875cd9f677 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -297,7 +297,7 @@ static inline void bprm_clear_caps(struct linux_binprm *bprm)
  */
 int cap_inode_need_killpriv(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         int error;
 
         if (!inode->i_op->getxattr)
@@ -319,7 +319,7 @@ int cap_inode_need_killpriv(struct dentry *dentry)
  */
 int cap_inode_killpriv(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
 
         if (!inode->i_op->removexattr)
                return 0;
@@ -375,7 +375,7 @@ static inline int bprm_caps_from_vfs_caps(struct cpu_vfs_cap_data *caps,
  */
 int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         __u32 magic_etc;
         unsigned tocopy, i;
         int size;
diff --git a/security/inode.c b/security/inode.c
index 131a3c49f766..91503b79c5f8 100644
--- a/security/inode.c
+++ b/security/inode.c
@@ -27,7 +27,7 @@ static int mount_count;
 
 static inline int positive(struct dentry *dentry)
 {
-        return dentry->d_inode && !d_unhashed(dentry);
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
 }
 
 static int fill_super(struct super_block *sb, void *data, int silent)
@@ -102,14 +102,14 @@ struct dentry *securityfs_create_file(const char *name, umode_t mode,
         if (!parent)
                 parent = mount->mnt_root;
 
-        dir = parent->d_inode;
+        dir = d_inode(parent);
 
         mutex_lock(&dir->i_mutex);
         dentry = lookup_one_len(name, parent, strlen(name));
         if (IS_ERR(dentry))
                 goto out;
 
-        if (dentry->d_inode) {
+        if (d_really_is_positive(dentry)) {
                 error = -EEXIST;
                 goto out1;
         }
@@ -197,20 +197,20 @@ void securityfs_remove(struct dentry *dentry)
                 return;
 
         parent = dentry->d_parent;
-        if (!parent || !parent->d_inode)
+        if (!parent || d_really_is_negative(parent))
                 return;
 
-        mutex_lock(&parent->d_inode->i_mutex);
+        mutex_lock(&d_inode(parent)->i_mutex);
         if (positive(dentry)) {
-                if (dentry->d_inode) {
+                if (d_really_is_positive(dentry)) {
                         if (d_is_dir(dentry))
-                                simple_rmdir(parent->d_inode, dentry);
+                                simple_rmdir(d_inode(parent), dentry);
                         else
-                                simple_unlink(parent->d_inode, dentry);
+                                simple_unlink(d_inode(parent), dentry);
                         dput(dentry);
                 }
         }
-        mutex_unlock(&parent->d_inode->i_mutex);
+        mutex_unlock(&d_inode(parent)->i_mutex);
         simple_release_fs(&mount, &mount_count);
 }
 EXPORT_SYMBOL_GPL(securityfs_remove);
diff --git a/security/integrity/evm/evm_crypto.c b/security/integrity/evm/evm_crypto.c
index 5e9687f02e1b..159ef3ea4130 100644
--- a/security/integrity/evm/evm_crypto.c
+++ b/security/integrity/evm/evm_crypto.c
@@ -131,7 +131,7 @@ static int evm_calc_hmac_or_hash(struct dentry *dentry,
                                 size_t req_xattr_value_len,
                                 char type, char *digest)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct shash_desc *desc;
         char **xattrname;
         size_t xattr_size = 0;
@@ -199,7 +199,7 @@ int evm_calc_hash(struct dentry *dentry, const char *req_xattr_name,
 int evm_update_evmxattr(struct dentry *dentry, const char *xattr_name,
                         const char *xattr_value, size_t xattr_value_len)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct evm_ima_xattr_data xattr_data;
         int rc = 0;
 
diff --git a/security/integrity/evm/evm_main.c b/security/integrity/evm/evm_main.c
index f589c9a05da2..10f994307a04 100644
--- a/security/integrity/evm/evm_main.c
+++ b/security/integrity/evm/evm_main.c
@@ -72,7 +72,7 @@ static void __init evm_init_config(void)
 
 static int evm_find_protected_xattrs(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         char **xattr;
         int error;
         int count = 0;
@@ -165,8 +165,8 @@ static enum integrity_status evm_verify_hmac(struct dentry *dentry,
                         /* Replace RSA with HMAC if not mounted readonly and
                          * not immutable
                          */
-                        if (!IS_RDONLY(dentry->d_inode) &&
-                            !IS_IMMUTABLE(dentry->d_inode))
+                        if (!IS_RDONLY(d_backing_inode(dentry)) &&
+                            !IS_IMMUTABLE(d_backing_inode(dentry)))
                                 evm_update_evmxattr(dentry, xattr_name,
                                                     xattr_value,
                                                     xattr_value_len);
@@ -235,7 +235,7 @@ enum integrity_status evm_verifyxattr(struct dentry *dentry,
                 return INTEGRITY_UNKNOWN;
 
         if (!iint) {
-                iint = integrity_iint_find(dentry->d_inode);
+                iint = integrity_iint_find(d_backing_inode(dentry));
                 if (!iint)
                         return INTEGRITY_UNKNOWN;
         }
@@ -253,7 +253,7 @@ EXPORT_SYMBOL_GPL(evm_verifyxattr);
  */
 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
 
         if (!evm_initialized || !S_ISREG(inode->i_mode) || evm_fixmode)
                 return 0;
@@ -293,13 +293,13 @@ static int evm_protect_xattr(struct dentry *dentry, const char *xattr_name,
         if (evm_status == INTEGRITY_NOXATTRS) {
                 struct integrity_iint_cache *iint;
 
-                iint = integrity_iint_find(dentry->d_inode);
+                iint = integrity_iint_find(d_backing_inode(dentry));
                 if (iint && (iint->flags & IMA_NEW_FILE))
                         return 0;
         }
 out:
         if (evm_status != INTEGRITY_PASS)
-                integrity_audit_msg(AUDIT_INTEGRITY_METADATA, dentry->d_inode,
+                integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry),
                                     dentry->d_name.name, "appraise_metadata",
                                     integrity_status_msg[evm_status],
                                     -EPERM, 0);
@@ -379,7 +379,7 @@ void evm_inode_post_setxattr(struct dentry *dentry, const char *xattr_name,
  */
 void evm_inode_post_removexattr(struct dentry *dentry, const char *xattr_name)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
 
         if (!evm_initialized || !evm_protected_xattr(xattr_name))
                 return;
@@ -404,7 +404,7 @@ int evm_inode_setattr(struct dentry *dentry, struct iattr *attr)
         if ((evm_status == INTEGRITY_PASS) ||
             (evm_status == INTEGRITY_NOXATTRS))
                 return 0;
-        integrity_audit_msg(AUDIT_INTEGRITY_METADATA, dentry->d_inode,
+        integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry),
                             dentry->d_name.name, "appraise_metadata",
                             integrity_status_msg[evm_status], -EPERM, 0);
         return -EPERM;
diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
index fffcdb0b31f0..4df493e4b3c9 100644
--- a/security/integrity/ima/ima_appraise.c
+++ b/security/integrity/ima/ima_appraise.c
@@ -165,7 +165,7 @@ void ima_get_hash_algo(struct evm_ima_xattr_data *xattr_value, int xattr_len,
 int ima_read_xattr(struct dentry *dentry,
                    struct evm_ima_xattr_data **xattr_value)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
 
         if (!inode->i_op->getxattr)
                 return 0;
@@ -190,7 +190,7 @@ int ima_appraise_measurement(int func, struct integrity_iint_cache *iint,
         static const char op[] = "appraise_data";
         char *cause = "unknown";
         struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         enum integrity_status status = INTEGRITY_UNKNOWN;
         int rc = xattr_len, hash_start = 0;
 
@@ -314,7 +314,7 @@ void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file)
  */
 void ima_inode_post_setattr(struct dentry *dentry)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct integrity_iint_cache *iint;
         int must_appraise, rc;
 
@@ -380,7 +380,7 @@ int ima_inode_setxattr(struct dentry *dentry, const char *xattr_name,
         if (result == 1) {
                 if (!xattr_value_len || (xvalue->type >= IMA_XATTR_LAST))
                         return -EINVAL;
-                ima_reset_appraise_flags(dentry->d_inode,
+                ima_reset_appraise_flags(d_backing_inode(dentry),
                          (xvalue->type == EVM_IMA_XATTR_DIGSIG) ? 1 : 0);
                 result = 0;
         }
@@ -393,7 +393,7 @@ int ima_inode_removexattr(struct dentry *dentry, const char *xattr_name)
 
         result = ima_protect_xattr(dentry, xattr_name, NULL, 0);
         if (result == 1) {
-                ima_reset_appraise_flags(dentry->d_inode, 0);
+                ima_reset_appraise_flags(d_backing_inode(dentry), 0);
                 result = 0;
         }
         return result;
diff --git a/security/lsm_audit.c b/security/lsm_audit.c
index b526ddc3add5..1d34277dc402 100644
--- a/security/lsm_audit.c
+++ b/security/lsm_audit.c
@@ -237,7 +237,7 @@ static void dump_common_audit_data(struct audit_buffer *ab,
 
                 audit_log_d_path(ab, " path=", &a->u.path);
 
-                inode = a->u.path.dentry->d_inode;
+                inode = d_backing_inode(a->u.path.dentry);
                 if (inode) {
                         audit_log_format(ab, " dev=");
                         audit_log_untrustedstring(ab, inode->i_sb->s_id);
@@ -251,7 +251,7 @@ static void dump_common_audit_data(struct audit_buffer *ab,
                 audit_log_format(ab, " name=");
                 audit_log_untrustedstring(ab, a->u.dentry->d_name.name);
 
-                inode = a->u.dentry->d_inode;
+                inode = d_backing_inode(a->u.dentry);
                 if (inode) {
                         audit_log_format(ab, " dev=");
                         audit_log_untrustedstring(ab, inode->i_sb->s_id);
diff --git a/security/security.c b/security/security.c
index 730ac65a5737..8e9b1f4b9b45 100644
--- a/security/security.c
+++ b/security/security.c
@@ -410,7 +410,7 @@ EXPORT_SYMBOL(security_old_inode_init_security);
 int security_path_mknod(struct path *dir, struct dentry *dentry, umode_t mode,
                         unsigned int dev)
 {
-        if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
                 return 0;
         return security_ops->path_mknod(dir, dentry, mode, dev);
 }
@@ -418,7 +418,7 @@ EXPORT_SYMBOL(security_path_mknod);
 
 int security_path_mkdir(struct path *dir, struct dentry *dentry, umode_t mode)
 {
-        if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
                 return 0;
         return security_ops->path_mkdir(dir, dentry, mode);
 }
@@ -426,14 +426,14 @@ EXPORT_SYMBOL(security_path_mkdir);
 
 int security_path_rmdir(struct path *dir, struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
                 return 0;
         return security_ops->path_rmdir(dir, dentry);
 }
 
 int security_path_unlink(struct path *dir, struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
                 return 0;
         return security_ops->path_unlink(dir, dentry);
 }
@@ -442,7 +442,7 @@ EXPORT_SYMBOL(security_path_unlink);
 int security_path_symlink(struct path *dir, struct dentry *dentry,
                           const char *old_name)
 {
-        if (unlikely(IS_PRIVATE(dir->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
                 return 0;
         return security_ops->path_symlink(dir, dentry, old_name);
 }
@@ -450,7 +450,7 @@ int security_path_symlink(struct path *dir, struct dentry *dentry,
 int security_path_link(struct dentry *old_dentry, struct path *new_dir,
                        struct dentry *new_dentry)
 {
-        if (unlikely(IS_PRIVATE(old_dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
                 return 0;
         return security_ops->path_link(old_dentry, new_dir, new_dentry);
 }
@@ -459,8 +459,8 @@ int security_path_rename(struct path *old_dir, struct dentry *old_dentry,
                          struct path *new_dir, struct dentry *new_dentry,
                          unsigned int flags)
 {
-        if (unlikely(IS_PRIVATE(old_dentry->d_inode) ||
-                     (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode))))
+        if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
+                     (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
                 return 0;
 
         if (flags & RENAME_EXCHANGE) {
@@ -477,21 +477,21 @@ EXPORT_SYMBOL(security_path_rename);
 
 int security_path_truncate(struct path *path)
 {
-        if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
                 return 0;
         return security_ops->path_truncate(path);
 }
 
 int security_path_chmod(struct path *path, umode_t mode)
 {
-        if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
                 return 0;
         return security_ops->path_chmod(path, mode);
 }
 
 int security_path_chown(struct path *path, kuid_t uid, kgid_t gid)
 {
-        if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
                 return 0;
         return security_ops->path_chown(path, uid, gid);
 }
@@ -513,14 +513,14 @@ EXPORT_SYMBOL_GPL(security_inode_create);
 int security_inode_link(struct dentry *old_dentry, struct inode *dir,
                          struct dentry *new_dentry)
 {
-        if (unlikely(IS_PRIVATE(old_dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
                 return 0;
         return security_ops->inode_link(old_dentry, dir, new_dentry);
 }
 
 int security_inode_unlink(struct inode *dir, struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_unlink(dir, dentry);
 }
@@ -543,7 +543,7 @@ EXPORT_SYMBOL_GPL(security_inode_mkdir);
 
 int security_inode_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_rmdir(dir, dentry);
 }
@@ -559,8 +559,8 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
                            struct inode *new_dir, struct dentry *new_dentry,
                            unsigned int flags)
 {
-        if (unlikely(IS_PRIVATE(old_dentry->d_inode) ||
-            (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode))))
+        if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
+            (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
                 return 0;
 
         if (flags & RENAME_EXCHANGE) {
@@ -576,14 +576,14 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
 
 int security_inode_readlink(struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_readlink(dentry);
 }
 
 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_follow_link(dentry, nd);
 }
@@ -599,7 +599,7 @@ int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
 {
         int ret;
 
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         ret = security_ops->inode_setattr(dentry, attr);
         if (ret)
@@ -610,7 +610,7 @@ EXPORT_SYMBOL_GPL(security_inode_setattr);
 
 int security_inode_getattr(const struct path *path)
 {
-        if (unlikely(IS_PRIVATE(path->dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
                 return 0;
         return security_ops->inode_getattr(path);
 }
@@ -620,7 +620,7 @@ int security_inode_setxattr(struct dentry *dentry, const char *name,
 {
         int ret;
 
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         ret = security_ops->inode_setxattr(dentry, name, value, size, flags);
         if (ret)
@@ -634,7 +634,7 @@ int security_inode_setxattr(struct dentry *dentry, const char *name,
 void security_inode_post_setxattr(struct dentry *dentry, const char *name,
                                   const void *value, size_t size, int flags)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return;
         security_ops->inode_post_setxattr(dentry, name, value, size, flags);
         evm_inode_post_setxattr(dentry, name, value, size);
@@ -642,14 +642,14 @@ void security_inode_post_setxattr(struct dentry *dentry, const char *name,
 
 int security_inode_getxattr(struct dentry *dentry, const char *name)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_getxattr(dentry, name);
 }
 
 int security_inode_listxattr(struct dentry *dentry)
 {
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         return security_ops->inode_listxattr(dentry);
 }
@@ -658,7 +658,7 @@ int security_inode_removexattr(struct dentry *dentry, const char *name)
 {
         int ret;
 
-        if (unlikely(IS_PRIVATE(dentry->d_inode)))
+        if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
                 return 0;
         ret = security_ops->inode_removexattr(dentry, name);
         if (ret)
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index c318b304ee2f..7dade28affba 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -414,7 +414,7 @@ static int sb_finish_set_opts(struct super_block *sb)
 {
         struct superblock_security_struct *sbsec = sb->s_security;
         struct dentry *root = sb->s_root;
-        struct inode *root_inode = root->d_inode;
+        struct inode *root_inode = d_backing_inode(root);
         int rc = 0;
 
         if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
@@ -552,7 +552,7 @@ static int selinux_get_mnt_opts(const struct super_block *sb,
                 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT;
         }
         if (sbsec->flags & ROOTCONTEXT_MNT) {
-                struct inode *root = sbsec->sb->s_root->d_inode;
+                struct inode *root = d_backing_inode(sbsec->sb->s_root);
                 struct inode_security_struct *isec = root->i_security;
 
                 rc = security_sid_to_context(isec->sid, &context, &len);
@@ -608,7 +608,7 @@ static int selinux_set_mnt_opts(struct super_block *sb,
         int rc = 0, i;
         struct superblock_security_struct *sbsec = sb->s_security;
         const char *name = sb->s_type->name;
-        struct inode *inode = sbsec->sb->s_root->d_inode;
+        struct inode *inode = d_backing_inode(sbsec->sb->s_root);
         struct inode_security_struct *root_isec = inode->i_security;
         u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
         u32 defcontext_sid = 0;
@@ -835,8 +835,8 @@ static int selinux_cmp_sb_context(const struct super_block *oldsb,
         if ((oldflags & DEFCONTEXT_MNT) && old->def_sid != new->def_sid)
                 goto mismatch;
         if (oldflags & ROOTCONTEXT_MNT) {
-                struct inode_security_struct *oldroot = oldsb->s_root->d_inode->i_security;
-                struct inode_security_struct *newroot = newsb->s_root->d_inode->i_security;
+                struct inode_security_struct *oldroot = d_backing_inode(oldsb->s_root)->i_security;
+                struct inode_security_struct *newroot = d_backing_inode(newsb->s_root)->i_security;
                 if (oldroot->sid != newroot->sid)
                         goto mismatch;
         }
@@ -886,16 +886,16 @@ static int selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
                 if (!set_fscontext)
                         newsbsec->sid = sid;
                 if (!set_rootcontext) {
-                        struct inode *newinode = newsb->s_root->d_inode;
+                        struct inode *newinode = d_backing_inode(newsb->s_root);
                         struct inode_security_struct *newisec = newinode->i_security;
                         newisec->sid = sid;
                 }
                 newsbsec->mntpoint_sid = sid;
         }
         if (set_rootcontext) {
-                const struct inode *oldinode = oldsb->s_root->d_inode;
+                const struct inode *oldinode = d_backing_inode(oldsb->s_root);
                 const struct inode_security_struct *oldisec = oldinode->i_security;
-                struct inode *newinode = newsb->s_root->d_inode;
+                struct inode *newinode = d_backing_inode(newsb->s_root);
                 struct inode_security_struct *newisec = newinode->i_security;
 
                 newisec->sid = oldisec->sid;
@@ -1610,7 +1610,7 @@ static inline int dentry_has_perm(const struct cred *cred,
                                   struct dentry *dentry,
                                   u32 av)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct common_audit_data ad;
 
         ad.type = LSM_AUDIT_DATA_DENTRY;
@@ -1625,7 +1625,7 @@ static inline int path_has_perm(const struct cred *cred,
                                 const struct path *path,
                                 u32 av)
 {
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_backing_inode(path->dentry);
         struct common_audit_data ad;
 
         ad.type = LSM_AUDIT_DATA_PATH;
@@ -1753,7 +1753,7 @@ static int may_link(struct inode *dir,
         int rc;
 
         dsec = dir->i_security;
-        isec = dentry->d_inode->i_security;
+        isec = d_backing_inode(dentry)->i_security;
 
         ad.type = LSM_AUDIT_DATA_DENTRY;
         ad.u.dentry = dentry;
@@ -1797,7 +1797,7 @@ static inline int may_rename(struct inode *old_dir,
         int rc;
 
         old_dsec = old_dir->i_security;
-        old_isec = old_dentry->d_inode->i_security;
+        old_isec = d_backing_inode(old_dentry)->i_security;
         old_is_dir = d_is_dir(old_dentry);
         new_dsec = new_dir->i_security;
 
@@ -1827,7 +1827,7 @@ static inline int may_rename(struct inode *old_dir,
         if (rc)
                 return rc;
         if (d_is_positive(new_dentry)) {
-                new_isec = new_dentry->d_inode->i_security;
+                new_isec = d_backing_inode(new_dentry)->i_security;
                 new_is_dir = d_is_dir(new_dentry);
                 rc = avc_has_perm(sid, new_isec->sid,
                                   new_isec->sclass,
@@ -1963,7 +1963,7 @@ static int selinux_binder_transfer_file(struct task_struct *from,
 {
         u32 sid = task_sid(to);
         struct file_security_struct *fsec = file->f_security;
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = d_backing_inode(file->f_path.dentry);
         struct inode_security_struct *isec = inode->i_security;
         struct common_audit_data ad;
         int rc;
@@ -2627,7 +2627,7 @@ static int selinux_sb_remount(struct super_block *sb, void *data)
                         break;
                 case ROOTCONTEXT_MNT: {
                         struct inode_security_struct *root_isec;
-                        root_isec = sb->s_root->d_inode->i_security;
+                        root_isec = d_backing_inode(sb->s_root)->i_security;
 
                         if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid))
                                 goto out_bad_option;
@@ -2727,7 +2727,7 @@ static int selinux_dentry_init_security(struct dentry *dentry, int mode,
         struct task_security_struct *tsec;
         struct inode_security_struct *dsec;
         struct superblock_security_struct *sbsec;
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir = d_backing_inode(dentry->d_parent);
         u32 newsid;
         int rc;
 
@@ -2982,7 +2982,7 @@ static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
 static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
                                   const void *value, size_t size, int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct inode_security_struct *isec = inode->i_security;
         struct superblock_security_struct *sbsec;
         struct common_audit_data ad;
@@ -3059,7 +3059,7 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
                                         const void *value, size_t size,
                                         int flags)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = d_backing_inode(dentry);
         struct inode_security_struct *isec = inode->i_security;
         u32 newsid;
         int rc;
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 5fde34326dcf..d2787cca1fcb 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -1737,7 +1737,7 @@ static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
         inc_nlink(inode);
         d_add(dentry, inode);
         /* bump link count on parent directory, too */
-        inc_nlink(dir->d_inode);
+        inc_nlink(d_inode(dir));
 
         return dentry;
 }
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 69fdc384af30..b644757886bc 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -593,7 +593,7 @@ static int smack_sb_copy_data(char *orig, char *smackopts)
 static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
 {
         struct dentry *root = sb->s_root;
-        struct inode *inode = root->d_inode;
+        struct inode *inode = d_backing_inode(root);
         struct superblock_smack *sp = sb->s_security;
         struct inode_smack *isp;
         struct smack_known *skp;
@@ -889,15 +889,15 @@ static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 
-        isp = smk_of_inode(old_dentry->d_inode);
+        isp = smk_of_inode(d_backing_inode(old_dentry));
         rc = smk_curacc(isp, MAY_WRITE, &ad);
-        rc = smk_bu_inode(old_dentry->d_inode, MAY_WRITE, rc);
+        rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_WRITE, rc);
 
         if (rc == 0 && d_is_positive(new_dentry)) {
-                isp = smk_of_inode(new_dentry->d_inode);
+                isp = smk_of_inode(d_backing_inode(new_dentry));
                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
                 rc = smk_curacc(isp, MAY_WRITE, &ad);
-                rc = smk_bu_inode(new_dentry->d_inode, MAY_WRITE, rc);
+                rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_WRITE, rc);
         }
 
         return rc;
@@ -913,7 +913,7 @@ static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
  */
 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
 {
-        struct inode *ip = dentry->d_inode;
+        struct inode *ip = d_backing_inode(dentry);
         struct smk_audit_info ad;
         int rc;
 
@@ -956,8 +956,8 @@ static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
         /*
          * You need write access to the thing you're removing
          */
-        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
-        rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc);
+        rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
+        rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
         if (rc == 0) {
                 /*
                  * You also need write access to the containing directory
@@ -995,15 +995,15 @@ static int smack_inode_rename(struct inode *old_inode,
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 
-        isp = smk_of_inode(old_dentry->d_inode);
+        isp = smk_of_inode(d_backing_inode(old_dentry));
         rc = smk_curacc(isp, MAY_READWRITE, &ad);
-        rc = smk_bu_inode(old_dentry->d_inode, MAY_READWRITE, rc);
+        rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_READWRITE, rc);
 
         if (rc == 0 && d_is_positive(new_dentry)) {
-                isp = smk_of_inode(new_dentry->d_inode);
+                isp = smk_of_inode(d_backing_inode(new_dentry));
                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
                 rc = smk_curacc(isp, MAY_READWRITE, &ad);
-                rc = smk_bu_inode(new_dentry->d_inode, MAY_READWRITE, rc);
+                rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_READWRITE, rc);
         }
         return rc;
 }
@@ -1060,8 +1060,8 @@ static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
-        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
-        rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc);
+        rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
+        rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
         return rc;
 }
 
@@ -1075,7 +1075,7 @@ static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 static int smack_inode_getattr(const struct path *path)
 {
         struct smk_audit_info ad;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_backing_inode(path->dentry);
         int rc;
 
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
@@ -1142,8 +1142,8 @@ static int smack_inode_setxattr(struct dentry *dentry, const char *name,
         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
         if (rc == 0) {
-                rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
-                rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc);
+                rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
+                rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
         }
 
         return rc;
@@ -1164,7 +1164,7 @@ static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
                                       const void *value, size_t size, int flags)
 {
         struct smack_known *skp;
-        struct inode_smack *isp = dentry->d_inode->i_security;
+        struct inode_smack *isp = d_backing_inode(dentry)->i_security;
 
         if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
                 isp->smk_flags |= SMK_INODE_TRANSMUTE;
@@ -1209,8 +1209,8 @@ static int smack_inode_getxattr(struct dentry *dentry, const char *name)
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
-        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
-        rc = smk_bu_inode(dentry->d_inode, MAY_READ, rc);
+        rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_READ, &ad);
+        rc = smk_bu_inode(d_backing_inode(dentry), MAY_READ, rc);
         return rc;
 }
 
@@ -1246,12 +1246,12 @@ static int smack_inode_removexattr(struct dentry *dentry, const char *name)
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
-        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
-        rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc);
+        rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
+        rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
         if (rc != 0)
                 return rc;
 
-        isp = dentry->d_inode->i_security;
+        isp = d_backing_inode(dentry)->i_security;
         /*
          * Don't do anything special for these.
          *      XATTR_NAME_SMACKIPIN
diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c
index 06f719ed63c9..d9682985349e 100644
--- a/security/smack/smackfs.c
+++ b/security/smack/smackfs.c
@@ -2490,7 +2490,7 @@ static int smk_fill_super(struct super_block *sb, void *data, int silent)
                 return rc;
         }
 
-        root_inode = sb->s_root->d_inode;
+        root_inode = d_inode(sb->s_root);
 
         return 0;
 }
diff --git a/security/tomoyo/condition.c b/security/tomoyo/condition.c
index 63681e8be628..6c4528d4b48f 100644
--- a/security/tomoyo/condition.c
+++ b/security/tomoyo/condition.c
@@ -714,7 +714,7 @@ void tomoyo_get_attributes(struct tomoyo_obj_info *obj)
                         dentry = dget_parent(dentry);
                         break;
                 }
-                inode = dentry->d_inode;
+                inode = d_backing_inode(dentry);
                 if (inode) {
                         struct tomoyo_mini_stat *stat = &obj->stat[i];
                         stat->uid  = inode->i_uid;
diff --git a/security/tomoyo/realpath.c b/security/tomoyo/realpath.c
index 1e0d480ff6a6..5077f1968841 100644
--- a/security/tomoyo/realpath.c
+++ b/security/tomoyo/realpath.c
@@ -97,7 +97,7 @@ static char *tomoyo_get_absolute_path(const struct path *path, char * const buff
                 /* go to whatever namespace root we are under */
                 pos = d_absolute_path(path, buffer, buflen - 1);
                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
-                        struct inode *inode = path->dentry->d_inode;
+                        struct inode *inode = d_backing_inode(path->dentry);
                         if (inode && S_ISDIR(inode->i_mode)) {
                                 buffer[buflen - 2] = '/';
                                 buffer[buflen - 1] = '\0';
@@ -125,7 +125,7 @@ static char *tomoyo_get_dentry_path(struct dentry *dentry, char * const buffer,
         if (buflen >= 256) {
                 pos = dentry_path_raw(dentry, buffer, buflen - 1);
                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
-                        struct inode *inode = dentry->d_inode;
+                        struct inode *inode = d_backing_inode(dentry);
                         if (inode && S_ISDIR(inode->i_mode)) {
                                 buffer[buflen - 2] = '/';
                                 buffer[buflen - 1] = '\0';
@@ -168,7 +168,7 @@ static char *tomoyo_get_local_path(struct dentry *dentry, char * const buffer,
         if (!MAJOR(sb->s_dev))
                 goto prepend_filesystem_name;
         {
-                struct inode *inode = sb->s_root->d_inode;
+                struct inode *inode = d_backing_inode(sb->s_root);
                 /*
                  * Use filesystem name if filesystem does not support rename()
                  * operation.
@@ -219,7 +219,7 @@ out:
 static char *tomoyo_get_socket_name(const struct path *path, char * const buffer,
                                     const int buflen)
 {
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = d_backing_inode(path->dentry);
         struct socket *sock = inode ? SOCKET_I(inode) : NULL;
         struct sock *sk = sock ? sock->sk : NULL;
         if (sk) {
@@ -277,7 +277,7 @@ char *tomoyo_realpath_from_path(const struct path *path)
                         pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
                         goto encode;
                 }
-                inode = sb->s_root->d_inode;
+                inode = d_backing_inode(sb->s_root);
                 /*
                  * Get local name for filesystems without rename() operation
                  * or dentry without vfsmount.