157 files changed, 1666 insertions, 2166 deletions

diff --git a/Documentation/filesystems/debugfs.txt b/Documentation/filesystems/debugfs.txt
index 3a863f692728..88ab81c79109 100644
--- a/Documentation/filesystems/debugfs.txt
+++ b/Documentation/filesystems/debugfs.txt
@@ -140,7 +140,7 @@ file.
                                      struct dentry *parent,
                                      struct debugfs_regset32 *regset);
 
-    int debugfs_print_regs32(struct seq_file *s, struct debugfs_reg32 *regs,
+    void debugfs_print_regs32(struct seq_file *s, struct debugfs_reg32 *regs,
                          int nregs, void __iomem *base, char *prefix);
 
 The "base" argument may be 0, but you may want to build the reg32 array
diff --git a/Documentation/filesystems/nfs/Exporting b/Documentation/filesystems/nfs/Exporting
index c8f036a9b13f..520a4becb75c 100644
--- a/Documentation/filesystems/nfs/Exporting
+++ b/Documentation/filesystems/nfs/Exporting
@@ -72,24 +72,11 @@ c/ Helper routines to allocate anonymous dentries, and to help attach
         DCACHE_DISCONNECTED) dentry is allocated and attached.
       In the case of a directory, care is taken that only one dentry
       can ever be attached.
-    d_splice_alias(inode, dentry) or d_materialise_unique(dentry, inode)
-      will introduce a new dentry into the tree; either the passed-in
-      dentry or a preexisting alias for the given inode (such as an
-      anonymous one created by d_obtain_alias), if appropriate.  The two
-      functions differ in their handling of directories with preexisting
-      aliases:
-        d_splice_alias will use any existing IS_ROOT dentry, but it will
-          return -EIO rather than try to move a dentry with a different
-          parent.  This is appropriate for local filesystems, which
-          should never see such an alias unless the filesystem is
-          corrupted somehow (for example, if two on-disk directory
-          entries refer to the same directory.)
-        d_materialise_unique will attempt to move any dentry.  This is
-          appropriate for distributed filesystems, where finding a
-          directory other than where we last cached it may be a normal
-          consequence of concurrent operations on other hosts.
-      Both functions return NULL when the passed-in dentry is used,
-      following the calling convention of ->lookup.
+    d_splice_alias(inode, dentry) will introduce a new dentry into the tree;
+      either the passed-in dentry or a preexisting alias for the given inode
+      (such as an anonymous one created by d_obtain_alias), if appropriate.
+      It returns NULL when the passed-in dentry is used, following the calling
+      convention of ->lookup.
 
  
 Filesystem Issues
diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting
index 0f3a1390bf00..fa2db081505e 100644
--- a/Documentation/filesystems/porting
+++ b/Documentation/filesystems/porting
@@ -463,3 +463,11 @@ in your dentry operations instead.
         of the in-tree instances did).  inode_hash_lock is still held,
         of course, so they are still serialized wrt removal from inode hash,
         as well as wrt set() callback of iget5_locked().
+--
+[mandatory]
+        d_materialise_unique() is gone; d_splice_alias() does everything you
+        need now.  Remember that they have opposite orders of arguments ;-/
+--
+[mandatory]
+        f_dentry is gone; use f_path.dentry, or, better yet, see if you can avoid
+        it entirely.
diff --git a/Documentation/filesystems/seq_file.txt b/Documentation/filesystems/seq_file.txt
index 8ea3e90ace07..b797ed38de46 100644
--- a/Documentation/filesystems/seq_file.txt
+++ b/Documentation/filesystems/seq_file.txt
@@ -180,23 +180,19 @@ output must be passed to the seq_file code. Some utility functions have
 been defined which make this task easy.
 
 Most code will simply use seq_printf(), which works pretty much like
-printk(), but which requires the seq_file pointer as an argument. It is
-common to ignore the return value from seq_printf(), but a function
-producing complicated output may want to check that value and quit if
-something non-zero is returned; an error return means that the seq_file
-buffer has been filled and further output will be discarded.
+printk(), but which requires the seq_file pointer as an argument.
 
 For straight character output, the following functions may be used:
 
-        int seq_putc(struct seq_file *m, char c);
-        int seq_puts(struct seq_file *m, const char *s);
-        int seq_escape(struct seq_file *m, const char *s, const char *esc);
+        seq_putc(struct seq_file *m, char c);
+        seq_puts(struct seq_file *m, const char *s);
+        seq_escape(struct seq_file *m, const char *s, const char *esc);
 
 The first two output a single character and a string, just like one would
 expect. seq_escape() is like seq_puts(), except that any character in s
 which is in the string esc will be represented in octal form in the output.
 
-There is also a pair of functions for printing filenames:
+There are also a pair of functions for printing filenames:
 
         int seq_path(struct seq_file *m, struct path *path, char *esc);
         int seq_path_root(struct seq_file *m, struct path *path,
@@ -209,6 +205,14 @@ root is desired, it can be used with seq_path_root().  Note that, if it
 turns out that path cannot be reached from root, the value of root will be
 changed in seq_file_root() to a root which *does* work.
 
+A function producing complicated output may want to check
+        bool seq_has_overflowed(struct seq_file *m);
+and avoid further seq_<output> calls if true is returned.
+
+A true return from seq_has_overflowed means that the seq_file buffer will
+be discarded and the seq_show function will attempt to allocate a larger
+buffer and retry printing.
+
 
 Making it all work
 
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 20bf204426ca..43ce0507ee25 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -835,7 +835,7 @@ struct file_operations {
         ssize_t (*splice_read)(struct file *, struct pipe_inode_info *, size_t, unsigned int);
         int (*setlease)(struct file *, long arg, struct file_lock **, void **);
         long (*fallocate)(struct file *, int mode, loff_t offset, loff_t len);
-        int (*show_fdinfo)(struct seq_file *m, struct file *f);
+        void (*show_fdinfo)(struct seq_file *m, struct file *f);
 };
 
 Again, all methods are called without any locks being held, unless
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
index f9c732e18284..e51f578636a5 100644
--- a/arch/alpha/kernel/osf_sys.c
+++ b/arch/alpha/kernel/osf_sys.c
@@ -104,11 +104,12 @@ struct osf_dirent_callback {
 };
 
 static int
-osf_filldir(void *__buf, const char *name, int namlen, loff_t offset,
-            u64 ino, unsigned int d_type)
+osf_filldir(struct dir_context *ctx, const char *name, int namlen,
+            loff_t offset, u64 ino, unsigned int d_type)
 {
         struct osf_dirent __user *dirent;
-        struct osf_dirent_callback *buf = (struct osf_dirent_callback *) __buf;
+        struct osf_dirent_callback *buf =
+                container_of(ctx, struct osf_dirent_callback, ctx);
         unsigned int reclen = ALIGN(NAME_OFFSET + namlen + 1, sizeof(u32));
         unsigned int d_ino;
 
diff --git a/arch/parisc/hpux/fs.c b/arch/parisc/hpux/fs.c
index 2bedafea3d94..97a7bf8df348 100644
--- a/arch/parisc/hpux/fs.c
+++ b/arch/parisc/hpux/fs.c
@@ -56,11 +56,12 @@ struct getdents_callback {
 
 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
 
-static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
-                u64 ino, unsigned d_type)
+static int filldir(struct dir_context *ctx, const char *name, int namlen,
+                   loff_t offset, u64 ino, unsigned d_type)
 {
         struct hpux_dirent __user * dirent;
-        struct getdents_callback * buf = (struct getdents_callback *) __buf;
+        struct getdents_callback *buf =
+                container_of(ctx, struct getdents_callback, ctx);
         ino_t d_ino;
         int reclen = ALIGN(NAME_OFFSET(dirent) + namlen + 1, sizeof(long));
 
diff --git a/arch/powerpc/oprofile/cell/spu_task_sync.c b/arch/powerpc/oprofile/cell/spu_task_sync.c
index 28f1af2db1f5..1c27831df1ac 100644
--- a/arch/powerpc/oprofile/cell/spu_task_sync.c
+++ b/arch/powerpc/oprofile/cell/spu_task_sync.c
@@ -331,8 +331,7 @@ get_exec_dcookie_and_offset(struct spu *spu, unsigned int *offsetp,
 
         if (mm->exe_file) {
                 app_cookie = fast_get_dcookie(&mm->exe_file->f_path);
-                pr_debug("got dcookie for %s\n",
-                         mm->exe_file->f_dentry->d_name.name);
+                pr_debug("got dcookie for %pD\n", mm->exe_file);
         }
 
         for (vma = mm->mmap; vma; vma = vma->vm_next) {
@@ -342,15 +341,14 @@ get_exec_dcookie_and_offset(struct spu *spu, unsigned int *offsetp,
                 if (!vma->vm_file)
                         goto fail_no_image_cookie;
 
-                pr_debug("Found spu ELF at %X(object-id:%lx) for file %s\n",
-                         my_offset, spu_ref,
-                         vma->vm_file->f_dentry->d_name.name);
+                pr_debug("Found spu ELF at %X(object-id:%lx) for file %pD\n",
+                         my_offset, spu_ref, vma->vm_file);
                 *offsetp = my_offset;
                 break;
         }
 
         *spu_bin_dcookie = fast_get_dcookie(&vma->vm_file->f_path);
-        pr_debug("got dcookie for %s\n", vma->vm_file->f_dentry->d_name.name);
+        pr_debug("got dcookie for %pD\n", vma->vm_file);
 
         up_read(&mm->mmap_sem);
 
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 87ba7cf99cd7..65d633f20d37 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -164,7 +164,7 @@ static void spufs_prune_dir(struct dentry *dir)
         struct dentry *dentry, *tmp;
 
         mutex_lock(&dir->d_inode->i_mutex);
-        list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) {
+        list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
                 spin_lock(&dentry->d_lock);
                 if (!(d_unhashed(dentry)) && dentry->d_inode) {
                         dget_dlock(dentry);
diff --git a/arch/s390/hypfs/hypfs_dbfs.c b/arch/s390/hypfs/hypfs_dbfs.c
index 2badf2bf9cd7..47fe1055c714 100644
--- a/arch/s390/hypfs/hypfs_dbfs.c
+++ b/arch/s390/hypfs/hypfs_dbfs.c
@@ -83,10 +83,9 @@ static ssize_t dbfs_read(struct file *file, char __user *buf,
 
 static long dbfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct hypfs_dbfs_file *df;
+        struct hypfs_dbfs_file *df = file_inode(file)->i_private;
         long rc;
 
-        df = file->f_path.dentry->d_inode->i_private;
         mutex_lock(&df->lock);
         if (df->unlocked_ioctl)
                 rc = df->unlocked_ioctl(file, cmd, arg);
diff --git a/arch/x86/ia32/ia32_aout.c b/arch/x86/ia32/ia32_aout.c
index df91466f973d..ae6aad1d24f7 100644
--- a/arch/x86/ia32/ia32_aout.c
+++ b/arch/x86/ia32/ia32_aout.c
@@ -342,8 +342,8 @@ static int load_aout_binary(struct linux_binprm *bprm)
                             time_after(jiffies, error_time + 5*HZ)) {
                         printk(KERN_WARNING
                                "fd_offset is not page aligned. Please convert "
-                               "program: %s\n",
-                               bprm->file->f_path.dentry->d_name.name);
+                               "program: %pD\n",
+                               bprm->file);
                         error_time = jiffies;
                 }
 #endif
@@ -429,8 +429,8 @@ static int load_aout_library(struct file *file)
                 if (time_after(jiffies, error_time + 5*HZ)) {
                         printk(KERN_WARNING
                                "N_TXTOFF is not page aligned. Please convert "
-                               "library: %s\n",
-                               file->f_path.dentry->d_name.name);
+                               "library: %pD\n",
+                               file);
                         error_time = jiffies;
                 }
 #endif
diff --git a/drivers/block/drbd/drbd_debugfs.c b/drivers/block/drbd/drbd_debugfs.c
index 900d4d3272d1..9a950022ff88 100644
--- a/drivers/block/drbd/drbd_debugfs.c
+++ b/drivers/block/drbd/drbd_debugfs.c
@@ -419,7 +419,7 @@ static int in_flight_summary_show(struct seq_file *m, void *pos)
         return 0;
 }
 
-/* simple_positive(file->f_dentry) respectively debugfs_positive(),
+/* simple_positive(file->f_path.dentry) respectively debugfs_positive(),
  * but neither is "reachable" from here.
  * So we have our own inline version of it above.  :-( */
 static inline int debugfs_positive(struct dentry *dentry)
@@ -437,14 +437,14 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo
 
         /* Are we still linked,
          * or has debugfs_remove() already been called? */
-        parent = file->f_dentry->d_parent;
+        parent = file->f_path.dentry->d_parent;
         /* not sure if this can happen: */
         if (!parent || !parent->d_inode)
                 goto out;
         /* serialize with d_delete() */
         mutex_lock(&parent->d_inode->i_mutex);
         /* Make sure the object is still alive */
-        if (debugfs_positive(file->f_dentry)
+        if (debugfs_positive(file->f_path.dentry)
         && kref_get_unless_zero(kref))
                 ret = 0;
         mutex_unlock(&parent->d_inode->i_mutex);
diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c
index 7496f55611a5..ef5feeecec84 100644
--- a/drivers/gpu/drm/armada/armada_gem.c
+++ b/drivers/gpu/drm/armada/armada_gem.c
@@ -226,7 +226,7 @@ struct armada_gem_object *armada_gem_alloc_object(struct drm_device *dev,
 
         obj->dev_addr = DMA_ERROR_CODE;
 
-        mapping = obj->obj.filp->f_path.dentry->d_inode->i_mapping;
+        mapping = file_inode(obj->obj.filp)->i_mapping;
         mapping_set_gfp_mask(mapping, GFP_HIGHUSER | __GFP_RECLAIMABLE);
 
         DRM_DEBUG_DRIVER("alloc obj %p size %zu\n", obj, size);
diff --git a/drivers/media/pci/zoran/zoran_procfs.c b/drivers/media/pci/zoran/zoran_procfs.c
index f7ceee0cdefd..437652761093 100644
--- a/drivers/media/pci/zoran/zoran_procfs.c
+++ b/drivers/media/pci/zoran/zoran_procfs.c
@@ -157,8 +157,8 @@ static ssize_t zoran_write(struct file *file, const char __user *buffer,
                 return -EFAULT;
         }
         string[count] = 0;
-        dprintk(4, KERN_INFO "%s: write_proc: name=%s count=%zu zr=%p\n",
-                ZR_DEVNAME(zr), file->f_path.dentry->d_name.name, count, zr);
+        dprintk(4, KERN_INFO "%s: write_proc: name=%pD count=%zu zr=%p\n",
+                ZR_DEVNAME(zr), file, count, zr);
         ldelim = " \t\n";
         tdelim = "=";
         line = strpbrk(sp, ldelim);
diff --git a/drivers/misc/genwqe/card_dev.c b/drivers/misc/genwqe/card_dev.c
index 5918586f2f76..c49d244265ec 100644
--- a/drivers/misc/genwqe/card_dev.c
+++ b/drivers/misc/genwqe/card_dev.c
@@ -395,7 +395,7 @@ static void genwqe_vma_open(struct vm_area_struct *vma)
 static void genwqe_vma_close(struct vm_area_struct *vma)
 {
         unsigned long vsize = vma->vm_end - vma->vm_start;
-        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode = file_inode(vma->vm_file);
         struct dma_mapping *dma_map;
         struct genwqe_dev *cd = container_of(inode->i_cdev, struct genwqe_dev,
                                             cdev_genwqe);
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 9dd3746994a4..4d332dc93b70 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -2222,7 +2222,7 @@ static int tun_chr_close(struct inode *inode, struct file *file)
 }
 
 #ifdef CONFIG_PROC_FS
-static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
+static void tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct tun_struct *tun;
         struct ifreq ifr;
@@ -2238,7 +2238,7 @@ static int tun_chr_show_fdinfo(struct seq_file *m, struct file *f)
         if (tun)
                 tun_put(tun);
 
-        return seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
+        seq_printf(m, "iff:\t%s\n", ifr.ifr_name);
 }
 #endif
 
diff --git a/drivers/s390/char/hmcdrv_dev.c b/drivers/s390/char/hmcdrv_dev.c
index 0c5176179c17..43cee7fcd01c 100644
--- a/drivers/s390/char/hmcdrv_dev.c
+++ b/drivers/s390/char/hmcdrv_dev.c
@@ -136,8 +136,7 @@ static int hmcdrv_dev_open(struct inode *inode, struct file *fp)
         if (rc)
                 module_put(THIS_MODULE);
 
-        pr_debug("open file '/dev/%s' with return code %d\n",
-                 fp->f_dentry->d_name.name, rc);
+        pr_debug("open file '/dev/%pD' with return code %d\n", fp, rc);
         return rc;
 }
 
@@ -146,7 +145,7 @@ static int hmcdrv_dev_open(struct inode *inode, struct file *fp)
  */
 static int hmcdrv_dev_release(struct inode *inode, struct file *fp)
 {
-        pr_debug("closing file '/dev/%s'\n", fp->f_dentry->d_name.name);
+        pr_debug("closing file '/dev/%pD'\n", fp);
         kfree(fp->private_data);
         fp->private_data = NULL;
         hmcdrv_ftp_shutdown();
@@ -231,8 +230,8 @@ static ssize_t hmcdrv_dev_read(struct file *fp, char __user *ubuf,
         retlen = hmcdrv_dev_transfer((char *) fp->private_data,
                                      *pos, ubuf, len);
 
-        pr_debug("read from file '/dev/%s' at %lld returns %zd/%zu\n",
-                 fp->f_dentry->d_name.name, (long long) *pos, retlen, len);
+        pr_debug("read from file '/dev/%pD' at %lld returns %zd/%zu\n",
+                 fp, (long long) *pos, retlen, len);
 
         if (retlen > 0)
                 *pos += retlen;
@@ -248,8 +247,8 @@ static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
 {
         ssize_t retlen;
 
-        pr_debug("writing file '/dev/%s' at pos. %lld with length %zd\n",
-                 fp->f_dentry->d_name.name, (long long) *pos, len);
+        pr_debug("writing file '/dev/%pD' at pos. %lld with length %zd\n",
+                 fp, (long long) *pos, len);
 
         if (!fp->private_data) { /* first expect a cmd write */
                 fp->private_data = kmalloc(len + 1, GFP_KERNEL);
@@ -272,8 +271,7 @@ static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
         if (retlen > 0)
                 *pos += retlen;
 
-        pr_debug("write to file '/dev/%s' returned %zd\n",
-                 fp->f_dentry->d_name.name, retlen);
+        pr_debug("write to file '/dev/%pD' returned %zd\n", fp, retlen);
 
         return retlen;
 }
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 786a2aff7b59..5633e7dadc08 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -968,8 +968,8 @@ lpfc_debugfs_dumpDif_open(struct inode *inode, struct file *file)
                 goto out;
 
         /* Round to page boundary */
-        printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%s\n",
-                __func__, _dump_buf_dif, file->f_dentry->d_name.name);
+        printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%pD\n",
+                __func__, _dump_buf_dif, file);
         debug->buffer = _dump_buf_dif;
         if (!debug->buffer) {
                 kfree(debug);
@@ -1011,7 +1011,7 @@ static ssize_t
 lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
         size_t nbytes, loff_t *ppos)
 {
-        struct dentry *dent = file->f_dentry;
+        struct dentry *dent = file->f_path.dentry;
         struct lpfc_hba *phba = file->private_data;
         char cbuf[32];
         uint64_t tmp = 0;
@@ -1052,7 +1052,7 @@ static ssize_t
 lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
         size_t nbytes, loff_t *ppos)
 {
-        struct dentry *dent = file->f_dentry;
+        struct dentry *dent = file->f_path.dentry;
         struct lpfc_hba *phba = file->private_data;
         char dstbuf[32];
         uint64_t tmp = 0;
diff --git a/drivers/staging/lustre/lustre/libcfs/tracefile.c b/drivers/staging/lustre/lustre/libcfs/tracefile.c
index 7e3f6a45da00..7561030c96e6 100644
--- a/drivers/staging/lustre/lustre/libcfs/tracefile.c
+++ b/drivers/staging/lustre/lustre/libcfs/tracefile.c
@@ -1025,8 +1025,8 @@ static int tracefiled(void *arg)
 
                         if (f_pos >= (off_t)cfs_tracefile_size)
                                 f_pos = 0;
-                        else if (f_pos > i_size_read(filp->f_dentry->d_inode))
-                                f_pos = i_size_read(filp->f_dentry->d_inode);
+                        else if (f_pos > i_size_read(file_inode(filp)))
+                                f_pos = i_size_read(file_inode(filp));
 
                         buf = kmap(tage->page);
                         rc = vfs_write(filp, (__force const char __user *)buf,
diff --git a/drivers/staging/lustre/lustre/llite/dcache.c b/drivers/staging/lustre/lustre/llite/dcache.c
index 439e4875b05c..f692261e9b5c 100644
--- a/drivers/staging/lustre/lustre/llite/dcache.c
+++ b/drivers/staging/lustre/lustre/llite/dcache.c
@@ -151,10 +151,10 @@ static int ll_ddelete(const struct dentry *de)
 {
         LASSERT(de);
 
-        CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
+        CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
                d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
-               de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
-               d_unhashed((struct dentry *)de) ? "" : "hashed,",
+               de, de, de->d_parent, de->d_inode,
+               d_unhashed(de) ? "" : "hashed,",
                list_empty(&de->d_subdirs) ? "" : "subdirs");
 
         /* kernel >= 2.6.38 last refcount is decreased after this function. */
@@ -180,8 +180,8 @@ int ll_d_init(struct dentry *de)
 {
         LASSERT(de != NULL);
 
-        CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
-                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
+        CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
+                de, de, de->d_parent, de->d_inode,
                 d_count(de));
 
         if (de->d_fsdata == NULL) {
@@ -258,10 +258,9 @@ void ll_invalidate_aliases(struct inode *inode)
                inode->i_ino, inode->i_generation, inode);
 
         ll_lock_dcache(inode);
-        ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
-                CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
-                       "inode %p flags %d\n", dentry->d_name.len,
-                       dentry->d_name.name, dentry, dentry->d_parent,
+        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);
 
                 if (unlikely(dentry == dentry->d_sb->s_root)) {
@@ -352,8 +351,8 @@ static int ll_revalidate_nd(struct dentry *dentry, unsigned int flags)
 {
         int rc;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%s, flags=%u\n",
-               dentry->d_name.name, flags);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, flags=%u\n",
+               dentry, flags);
 
         rc = ll_revalidate_dentry(dentry, flags);
         return rc;
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index b0bb7095dde5..a79fd65ec4c6 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -593,7 +593,7 @@ int ll_dir_read(struct inode *inode, struct dir_context *ctx)
 
 static int ll_readdir(struct file *filp, struct dir_context *ctx)
 {
-        struct inode            *inode  = filp->f_dentry->d_inode;
+        struct inode            *inode  = file_inode(filp);
         struct ll_file_data     *lfd    = LUSTRE_FPRIVATE(filp);
         struct ll_sb_info       *sbi    = ll_i2sbi(inode);
         int                     hash64  = sbi->ll_flags & LL_SBI_64BIT_HASH;
@@ -1242,7 +1242,7 @@ ll_getname(const char __user *filename)
 
 static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct obd_ioctl_data *data;
         int rc = 0;
@@ -1389,7 +1389,7 @@ lmv_out_free:
                                 return -EFAULT;
                 }
 
-                if (inode->i_sb->s_root == file->f_dentry)
+                if (is_root_inode(inode))
                         set_default = 1;
 
                 /* in v1 and v3 cases lumv1 points to data */
@@ -1780,8 +1780,7 @@ out_quotactl:
                 return ll_flush_ctx(inode);
 #ifdef CONFIG_FS_POSIX_ACL
         case LL_IOC_RMTACL: {
-            if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
-                inode == inode->i_sb->s_root->d_inode) {
+            if (sbi->ll_flags & LL_SBI_RMT_CLIENT && is_root_inode(inode)) {
                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 
                 LASSERT(fd != NULL);
diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index c99b74117152..a2ae9a68a9a0 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -266,6 +266,10 @@ static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 {
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
         struct ll_inode_info *lli = ll_i2info(inode);
+        int lockmode;
+        __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
+        struct lustre_handle lockh;
+        ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
         int rc = 0;
 
         /* clear group lock, if present */
@@ -292,39 +296,26 @@ static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 
         /* Let's see if we have good enough OPEN lock on the file and if
            we can skip talking to MDS */
-        if (file->f_dentry->d_inode) { /* Can this ever be false? */
-                int lockmode;
-                __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
-                struct lustre_handle lockh;
-                struct inode *inode = file->f_dentry->d_inode;
-                ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
-
-                mutex_lock(&lli->lli_och_mutex);
-                if (fd->fd_omode & FMODE_WRITE) {
-                        lockmode = LCK_CW;
-                        LASSERT(lli->lli_open_fd_write_count);
-                        lli->lli_open_fd_write_count--;
-                } else if (fd->fd_omode & FMODE_EXEC) {
-                        lockmode = LCK_PR;
-                        LASSERT(lli->lli_open_fd_exec_count);
-                        lli->lli_open_fd_exec_count--;
-                } else {
-                        lockmode = LCK_CR;
-                        LASSERT(lli->lli_open_fd_read_count);
-                        lli->lli_open_fd_read_count--;
-                }
-                mutex_unlock(&lli->lli_och_mutex);
 
-                if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
-                                   LDLM_IBITS, &policy, lockmode,
-                                   &lockh)) {
-                        rc = ll_md_real_close(file->f_dentry->d_inode,
-                                              fd->fd_omode);
-                }
+        mutex_lock(&lli->lli_och_mutex);
+        if (fd->fd_omode & FMODE_WRITE) {
+                lockmode = LCK_CW;
+                LASSERT(lli->lli_open_fd_write_count);
+                lli->lli_open_fd_write_count--;
+        } else if (fd->fd_omode & FMODE_EXEC) {
+                lockmode = LCK_PR;
+                LASSERT(lli->lli_open_fd_exec_count);
+                lli->lli_open_fd_exec_count--;
         } else {
-                CERROR("Releasing a file %p with negative dentry %p. Name %s",
-                       file, file->f_dentry, file->f_dentry->d_name.name);
+                lockmode = LCK_CR;
+                LASSERT(lli->lli_open_fd_read_count);
+                lli->lli_open_fd_read_count--;
         }
+        mutex_unlock(&lli->lli_och_mutex);
+
+        if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
+                           LDLM_IBITS, &policy, lockmode, &lockh))
+                rc = ll_md_real_close(inode, fd->fd_omode);
 
 out:
         LUSTRE_FPRIVATE(file) = NULL;
@@ -350,8 +341,7 @@ int ll_file_release(struct inode *inode, struct file *file)
                inode->i_generation, inode);
 
 #ifdef CONFIG_FS_POSIX_ACL
-        if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
-            inode == inode->i_sb->s_root->d_inode) {
+        if (sbi->ll_flags & LL_SBI_RMT_CLIENT && is_root_inode(inode)) {
                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
 
                 LASSERT(fd != NULL);
@@ -363,7 +353,7 @@ int ll_file_release(struct inode *inode, struct file *file)
         }
 #endif
 
-        if (inode->i_sb->s_root != file->f_dentry)
+        if (!is_root_inode(inode))
                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
         fd = LUSTRE_FPRIVATE(file);
         LASSERT(fd != NULL);
@@ -375,7 +365,7 @@ int ll_file_release(struct inode *inode, struct file *file)
             lli->lli_opendir_pid != 0)
                 ll_stop_statahead(inode, lli->lli_opendir_key);
 
-        if (inode->i_sb->s_root == file->f_dentry) {
+        if (is_root_inode(inode)) {
                 LUSTRE_FPRIVATE(file) = NULL;
                 ll_file_data_put(fd);
                 return 0;
@@ -394,21 +384,19 @@ int ll_file_release(struct inode *inode, struct file *file)
         return rc;
 }
 
-static int ll_intent_file_open(struct file *file, void *lmm,
+static int ll_intent_file_open(struct dentry *dentry, void *lmm,
                                int lmmsize, struct lookup_intent *itp)
 {
-        struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
-        struct dentry *parent = file->f_dentry->d_parent;
-        const char *name = file->f_dentry->d_name.name;
-        const int len = file->f_dentry->d_name.len;
+        struct inode *inode = dentry->d_inode;
+        struct ll_sb_info *sbi = ll_i2sbi(inode);
+        struct dentry *parent = dentry->d_parent;
+        const char *name = dentry->d_name.name;
+        const int len = dentry->d_name.len;
         struct md_op_data *op_data;
         struct ptlrpc_request *req;
         __u32 opc = LUSTRE_OPC_ANY;
         int rc;
 
-        if (!parent)
-                return -ENOENT;
-
         /* Usually we come here only for NFSD, and we want open lock.
            But we can also get here with pre 2.6.15 patchless kernels, and in
            that case that lock is also ok */
@@ -425,7 +413,7 @@ static int ll_intent_file_open(struct file *file, void *lmm,
         }
 
         op_data  = ll_prep_md_op_data(NULL, parent->d_inode,
-                                      file->f_dentry->d_inode, name, len,
+                                      inode, name, len,
                                       O_RDWR, opc, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
@@ -441,7 +429,7 @@ static int ll_intent_file_open(struct file *file, void *lmm,
                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
                      it_open_error(DISP_OPEN_OPEN, itp))
                         goto out;
-                ll_release_openhandle(file->f_dentry, itp);
+                ll_release_openhandle(inode, itp);
                 goto out;
         }
 
@@ -456,10 +444,9 @@ static int ll_intent_file_open(struct file *file, void *lmm,
                 goto out;
         }
 
-        rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL, itp);
+        rc = ll_prep_inode(&inode, req, NULL, itp);
         if (!rc && itp->d.lustre.it_lock_mode)
-                ll_set_lock_data(sbi->ll_md_exp, file->f_dentry->d_inode,
-                                 itp, NULL);
+                ll_set_lock_data(sbi->ll_md_exp, inode, itp, NULL);
 
 out:
         ptlrpc_req_finished(req);
@@ -501,7 +488,7 @@ static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
 static int ll_local_open(struct file *file, struct lookup_intent *it,
                          struct ll_file_data *fd, struct obd_client_handle *och)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
 
         LASSERT(!LUSTRE_FPRIVATE(file));
@@ -574,7 +561,7 @@ int ll_file_open(struct inode *inode, struct file *file)
                 spin_unlock(&lli->lli_sa_lock);
         }
 
-        if (inode->i_sb->s_root == file->f_dentry) {
+        if (is_root_inode(inode)) {
                 LUSTRE_FPRIVATE(file) = fd;
                 return 0;
         }
@@ -632,7 +619,7 @@ restart:
                                 goto out_openerr;
                         }
 
-                        ll_release_openhandle(file->f_dentry, it);
+                        ll_release_openhandle(inode, it);
                 }
                 (*och_usecount)++;
 
@@ -652,7 +639,7 @@ restart:
                            result in a deadlock */
                         mutex_unlock(&lli->lli_och_mutex);
                         it->it_create_mode |= M_CHECK_STALE;
-                        rc = ll_intent_file_open(file, NULL, 0, it);
+                        rc = ll_intent_file_open(file->f_path.dentry, NULL, 0, it);
                         it->it_create_mode &= ~M_CHECK_STALE;
                         if (rc)
                                 goto out_openerr;
@@ -1065,7 +1052,7 @@ int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
 static bool file_is_noatime(const struct file *file)
 {
         const struct vfsmount *mnt = file->f_path.mnt;
-        const struct inode *inode = file->f_path.dentry->d_inode;
+        const struct inode *inode = file_inode(file);
 
         /* Adapted from file_accessed() and touch_atime().*/
         if (file->f_flags & O_NOATIME)
@@ -1091,7 +1078,7 @@ static bool file_is_noatime(const struct file *file)
 
 void ll_io_init(struct cl_io *io, const struct file *file, int write)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
         if (write) {
@@ -1117,7 +1104,7 @@ ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
                    struct file *file, enum cl_io_type iot,
                    loff_t *ppos, size_t count)
 {
-        struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
+        struct ll_inode_info *lli = ll_i2info(file_inode(file));
         struct ll_file_data  *fd  = LUSTRE_FPRIVATE(file);
         struct cl_io     *io;
         ssize_t        result;
@@ -1178,20 +1165,20 @@ out:
         /* If any bit been read/written (result != 0), we just return
          * short read/write instead of restart io. */
         if ((result == 0 || result == -ENODATA) && io->ci_need_restart) {
-                CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zd\n",
+                CDEBUG(D_VFSTRACE, "Restart %s on %pD from %lld, count:%zd\n",
                        iot == CIT_READ ? "read" : "write",
-                       file->f_dentry->d_name.name, *ppos, count);
+                       file, *ppos, count);
                 LASSERTF(io->ci_nob == 0, "%zd", io->ci_nob);
                 goto restart;
         }
 
         if (iot == CIT_READ) {
                 if (result >= 0)
-                        ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
+                        ll_stats_ops_tally(ll_i2sbi(file_inode(file)),
                                            LPROC_LL_READ_BYTES, result);
         } else if (iot == CIT_WRITE) {
                 if (result >= 0) {
-                        ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
+                        ll_stats_ops_tally(ll_i2sbi(file_inode(file)),
                                            LPROC_LL_WRITE_BYTES, result);
                         fd->fd_write_failed = false;
                 } else if (result != -ERESTARTSYS) {
@@ -1354,7 +1341,7 @@ static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg)
         return ll_lov_recreate(inode, &oi, ost_idx);
 }
 
-int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
+int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
                              int flags, struct lov_user_md *lum, int lum_size)
 {
         struct lov_stripe_md *lsm = NULL;
@@ -1371,21 +1358,20 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
         }
 
         ll_inode_size_lock(inode);
-        rc = ll_intent_file_open(file, lum, lum_size, &oit);
+        rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
         if (rc)
                 goto out_unlock;
         rc = oit.d.lustre.it_status;
         if (rc < 0)
                 goto out_req_free;
 
-        ll_release_openhandle(file->f_dentry, &oit);
+        ll_release_openhandle(inode, &oit);
 
 out_unlock:
         ll_inode_size_unlock(inode);
         ll_intent_release(&oit);
         ccc_inode_lsm_put(inode, lsm);
 out:
-        cl_lov_delay_create_clear(&file->f_flags);
         return rc;
 out_req_free:
         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
@@ -1499,7 +1485,9 @@ static int ll_lov_setea(struct inode *inode, struct file *file,
                 return -EFAULT;
         }
 
-        rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
+        rc = ll_lov_setstripe_ea_info(inode, file->f_path.dentry, flags, lump,
+                                     lum_size);
+        cl_lov_delay_create_clear(&file->f_flags);
 
         OBD_FREE_LARGE(lump, lum_size);
         return rc;
@@ -1526,7 +1514,9 @@ static int ll_lov_setstripe(struct inode *inode, struct file *file,
                         return -EFAULT;
         }
 
-        rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
+        rc = ll_lov_setstripe_ea_info(inode, file->f_path.dentry, flags, lumv1,
+                                      lum_size);
+        cl_lov_delay_create_clear(&file->f_flags);
         if (rc == 0) {
                 struct lov_stripe_md *lsm;
                 __u32 gen;
@@ -1631,22 +1621,21 @@ int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
 /**
  * Close inode open handle
  *
- * \param dentry [in]     dentry which contains the inode
+ * \param inode  [in]     inode in question
  * \param it     [in,out] intent which contains open info and result
  *
  * \retval 0     success
  * \retval <0    failure
  */
-int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
+int ll_release_openhandle(struct inode *inode, struct lookup_intent *it)
 {
-        struct inode *inode = dentry->d_inode;
         struct obd_client_handle *och;
         int rc;
 
         LASSERT(inode);
 
         /* Root ? Do nothing. */
-        if (dentry->d_inode->i_sb->s_root == dentry)
+        if (is_root_inode(inode))
                 return 0;
 
         /* No open handle to close? Move away */
@@ -1959,8 +1948,8 @@ static int ll_swap_layouts(struct file *file1, struct file *file2,
         if (!llss)
                 return -ENOMEM;
 
-        llss->inode1 = file1->f_dentry->d_inode;
-        llss->inode2 = file2->f_dentry->d_inode;
+        llss->inode1 = file_inode(file1);
+        llss->inode2 = file_inode(file2);
 
         if (!S_ISREG(llss->inode2->i_mode)) {
                 rc = -EINVAL;
@@ -2092,7 +2081,7 @@ putgl:
         rc = 0;
         if (llss->ia2.ia_valid != 0) {
                 mutex_lock(&llss->inode1->i_mutex);
-                rc = ll_setattr(file1->f_dentry, &llss->ia2);
+                rc = ll_setattr(file1->f_path.dentry, &llss->ia2);
                 mutex_unlock(&llss->inode1->i_mutex);
         }
 
@@ -2100,7 +2089,7 @@ putgl:
                 int rc1;
 
                 mutex_lock(&llss->inode2->i_mutex);
-                rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
+                rc1 = ll_setattr(file2->f_path.dentry, &llss->ia1);
                 mutex_unlock(&llss->inode2->i_mutex);
                 if (rc == 0)
                         rc = rc1;
@@ -2185,7 +2174,7 @@ static int ll_hsm_import(struct inode *inode, struct file *file,
 
         mutex_lock(&inode->i_mutex);
 
-        rc = ll_setattr_raw(file->f_dentry, attr, true);
+        rc = ll_setattr_raw(file->f_path.dentry, attr, true);
         if (rc == -ENODATA)
                 rc = 0;
 
@@ -2204,7 +2193,7 @@ out:
 static long
 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct inode            *inode = file->f_dentry->d_inode;
+        struct inode            *inode = file_inode(file);
         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
         int                      flags, rc;
 
@@ -2523,7 +2512,7 @@ ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         loff_t retval, eof = 0;
 
         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
@@ -2547,7 +2536,7 @@ static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
 
 static int ll_flush(struct file *file, fl_owner_t id)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
         int rc, err;
@@ -2622,16 +2611,9 @@ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
         return result;
 }
 
-/*
- * When dentry is provided (the 'else' case), *file->f_dentry may be
- * null and dentry must be used directly rather than pulled from
- * *file->f_dentry as is done otherwise.
- */
-
 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        struct dentry *dentry = file->f_dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_inode_info *lli = ll_i2info(inode);
         struct ptlrpc_request *req;
         struct obd_capa *oc;
@@ -2684,7 +2666,7 @@ int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 static int
 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct ldlm_enqueue_info einfo = {
                 .ei_type        = LDLM_FLOCK,
@@ -2908,8 +2890,8 @@ static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
 
         LASSERT(inode != NULL);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
-               inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
+        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%pd\n",
+               inode->i_ino, inode->i_generation, inode, dentry);
 
         exp = ll_i2mdexp(inode);
 
@@ -3119,7 +3101,7 @@ int ll_inode_permission(struct inode *inode, int mask)
        /* as root inode are NOT getting validated in lookup operation,
         * need to do it before permission check. */
 
-        if (inode == inode->i_sb->s_root->d_inode) {
+        if (is_root_inode(inode)) {
                 rc = __ll_inode_revalidate(inode->i_sb->s_root,
                                            MDS_INODELOCK_LOOKUP);
                 if (rc)
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index 36aa0fd147f2..77d1c12704b4 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -748,7 +748,7 @@ int ll_file_release(struct inode *inode, struct file *file);
 int ll_glimpse_ioctl(struct ll_sb_info *sbi,
                      struct lov_stripe_md *lsm, lstat_t *st);
 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch);
-int ll_release_openhandle(struct dentry *, struct lookup_intent *);
+int ll_release_openhandle(struct inode *, struct lookup_intent *);
 int ll_md_real_close(struct inode *inode, fmode_t fmode);
 void ll_ioepoch_close(struct inode *inode, struct md_op_data *op_data,
                       struct obd_client_handle **och, unsigned long flags);
@@ -763,7 +763,7 @@ struct posix_acl *ll_get_acl(struct inode *inode, int type);
 
 int ll_inode_permission(struct inode *inode, int mask);
 
-int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
+int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
                              int flags, struct lov_user_md *lum,
                              int lum_size);
 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
@@ -1413,7 +1413,7 @@ extern ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
 static inline int ll_file_nolock(const struct file *file)
 {
         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
 
         LASSERT(fd != NULL);
         return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
@@ -1489,8 +1489,8 @@ static inline void __d_lustre_invalidate(struct dentry *dentry)
  */
 static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
 {
-        CDEBUG(D_DENTRY, "invalidate dentry %.*s (%p) parent %p inode %p "
-               "refc %d\n", dentry->d_name.len, dentry->d_name.name, dentry,
+        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));
 
         spin_lock_nested(&dentry->d_lock,
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index a8bcc51057f1..7b6b9e2e0102 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -698,10 +698,8 @@ void lustre_dump_dentry(struct dentry *dentry, int recur)
         list_for_each(tmp, &dentry->d_subdirs)
                 subdirs++;
 
-        CERROR("dentry %p dump: name=%.*s parent=%.*s (%p), inode=%p, count=%u,"
-               " flags=0x%x, fsdata=%p, %d subdirs\n", dentry,
-               dentry->d_name.len, dentry->d_name.name,
-               dentry->d_parent->d_name.len, dentry->d_parent->d_name.name,
+        CERROR("dentry %p dump: name=%pd parent=%p, inode=%p, count=%u,"
+               " flags=0x%x, fsdata=%p, %d subdirs\n", dentry, dentry,
                dentry->d_parent, dentry->d_inode, d_count(dentry),
                dentry->d_flags, dentry->d_fsdata, subdirs);
         if (dentry->d_inode != NULL)
@@ -711,7 +709,7 @@ void lustre_dump_dentry(struct dentry *dentry, int recur)
                 return;
 
         list_for_each(tmp, &dentry->d_subdirs) {
-                struct dentry *d = list_entry(tmp, struct dentry, d_u.d_child);
+                struct dentry *d = list_entry(tmp, struct dentry, d_child);
                 lustre_dump_dentry(d, recur - 1);
         }
 }
diff --git a/drivers/staging/lustre/lustre/llite/llite_mmap.c b/drivers/staging/lustre/lustre/llite/llite_mmap.c
index ae605a6d9dc2..ba1c047ae927 100644
--- a/drivers/staging/lustre/lustre/llite/llite_mmap.c
+++ b/drivers/staging/lustre/lustre/llite/llite_mmap.c
@@ -100,7 +100,7 @@ ll_fault_io_init(struct vm_area_struct *vma, struct lu_env **env_ret,
                  unsigned long *ra_flags)
 {
         struct file            *file = vma->vm_file;
-        struct inode           *inode = file->f_dentry->d_inode;
+        struct inode           *inode = file_inode(file);
         struct cl_io           *io;
         struct cl_fault_io     *fio;
         struct lu_env          *env;
@@ -213,7 +213,7 @@ static int ll_page_mkwrite0(struct vm_area_struct *vma, struct page *vmpage,
         cfs_restore_sigs(set);
 
         if (result == 0) {
-                struct inode *inode = vma->vm_file->f_dentry->d_inode;
+                struct inode *inode = file_inode(vma->vm_file);
                 struct ll_inode_info *lli = ll_i2info(inode);
 
                 lock_page(vmpage);
@@ -396,7 +396,7 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
                         CWARN("app(%s): the page %lu of file %lu is under heavy"
                               " contention.\n",
                               current->comm, vmf->pgoff,
-                              vma->vm_file->f_dentry->d_inode->i_ino);
+                              file_inode(vma->vm_file)->i_ino);
                         printed = true;
                 }
         } while (retry);
@@ -430,7 +430,7 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
  */
 static void ll_vm_open(struct vm_area_struct *vma)
 {
-        struct inode *inode    = vma->vm_file->f_dentry->d_inode;
+        struct inode *inode    = file_inode(vma->vm_file);
         struct ccc_object *vob = cl_inode2ccc(inode);
 
         LASSERT(vma->vm_file);
@@ -443,7 +443,7 @@ static void ll_vm_open(struct vm_area_struct *vma)
  */
 static void ll_vm_close(struct vm_area_struct *vma)
 {
-        struct inode      *inode = vma->vm_file->f_dentry->d_inode;
+        struct inode      *inode = file_inode(vma->vm_file);
         struct ccc_object *vob   = cl_inode2ccc(inode);
 
         LASSERT(vma->vm_file);
@@ -476,7 +476,7 @@ static const struct vm_operations_struct ll_file_vm_ops = {
 
 int ll_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct inode *inode = file->f_dentry->d_inode;
+        struct inode *inode = file_inode(file);
         int rc;
 
         if (ll_file_nolock(file))
diff --git a/drivers/staging/lustre/lustre/llite/llite_nfs.c b/drivers/staging/lustre/lustre/llite/llite_nfs.c
index ae3a12ab7fa1..243a7840457f 100644
--- a/drivers/staging/lustre/lustre/llite/llite_nfs.c
+++ b/drivers/staging/lustre/lustre/llite/llite_nfs.c
@@ -207,13 +207,15 @@ static int ll_encode_fh(struct inode *inode, __u32 *fh, int *plen,
         return LUSTRE_NFS_FID;
 }
 
-static int ll_nfs_get_name_filldir(void *cookie, const char *name, int namelen,
-                                   loff_t hash, u64 ino, unsigned type)
+static int ll_nfs_get_name_filldir(struct dir_context *ctx, const char *name,
+                                   int namelen, loff_t hash, u64 ino,
+                                   unsigned type)
 {
         /* It is hack to access lde_fid for comparison with lgd_fid.
          * So the input 'name' must be part of the 'lu_dirent'. */
         struct lu_dirent *lde = container_of0(name, struct lu_dirent, lde_name);
-        struct ll_getname_data *lgd = cookie;
+        struct ll_getname_data *lgd =
+                container_of(ctx, struct ll_getname_data, ctx);
         struct lu_fid fid;
 
         fid_le_to_cpu(&fid, &lde->lde_fid);
diff --git a/drivers/staging/lustre/lustre/llite/lloop.c b/drivers/staging/lustre/lustre/llite/lloop.c
index 264e5ec3fed6..9e31b789b790 100644
--- a/drivers/staging/lustre/lustre/llite/lloop.c
+++ b/drivers/staging/lustre/lustre/llite/lloop.c
@@ -187,7 +187,7 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
 {
         const struct lu_env  *env   = lo->lo_env;
         struct cl_io     *io    = &lo->lo_io;
-        struct inode     *inode = lo->lo_backing_file->f_dentry->d_inode;
+        struct inode     *inode = file_inode(lo->lo_backing_file);
         struct cl_object     *obj = ll_i2info(inode)->lli_clob;
         pgoff_t        offset;
         int                ret;
@@ -626,7 +626,7 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
                         break;
                 }
                 if (inode == NULL)
-                        inode = lo->lo_backing_file->f_dentry->d_inode;
+                        inode = file_inode(lo->lo_backing_file);
                 if (lo->lo_state == LLOOP_BOUND)
                         fid = ll_i2info(inode)->lli_fid;
                 else
@@ -692,8 +692,7 @@ static enum llioc_iter lloop_ioctl(struct inode *unused, struct file *file,
                                         lo_free = lo;
                                 continue;
                         }
-                        if (lo->lo_backing_file->f_dentry->d_inode ==
-                            file->f_dentry->d_inode)
+                        if (file_inode(lo->lo_backing_file) == file_inode(file))
                                 break;
                 }
                 if (lo || !lo_free) {
diff --git a/drivers/staging/lustre/lustre/llite/namei.c b/drivers/staging/lustre/lustre/llite/namei.c
index 7a68c1e027e0..8e926b385a60 100644
--- a/drivers/staging/lustre/lustre/llite/namei.c
+++ b/drivers/staging/lustre/lustre/llite/namei.c
@@ -54,27 +54,6 @@
 static int ll_create_it(struct inode *, struct dentry *,
                         int, struct lookup_intent *);
 
-/*
- * Check if we have something mounted at the named dchild.
- * In such a case there would always be dentry present.
- */
-static int ll_d_mountpoint(struct dentry *dparent, struct dentry *dchild,
-                           struct qstr *name)
-{
-        int mounted = 0;
-
-        if (unlikely(dchild)) {
-                mounted = d_mountpoint(dchild);
-        } else if (dparent) {
-                dchild = d_lookup(dparent, name);
-                if (dchild) {
-                        mounted = d_mountpoint(dchild);
-                        dput(dchild);
-                }
-        }
-        return mounted;
-}
-
 /* called from iget5_locked->find_inode() under inode_hash_lock spinlock */
 static int ll_test_inode(struct inode *inode, void *opaque)
 {
@@ -167,14 +146,14 @@ static void ll_invalidate_negative_children(struct inode *dir)
         struct ll_d_hlist_node *p;
 
         ll_lock_dcache(dir);
-        ll_d_hlist_for_each_entry(dentry, p, &dir->i_dentry, d_alias) {
+        ll_d_hlist_for_each_entry(dentry, p, &dir->i_dentry, d_u.d_alias) {
                 spin_lock(&dentry->d_lock);
                 if (!list_empty(&dentry->d_subdirs)) {
                         struct dentry *child;
 
                         list_for_each_entry_safe(child, tmp_subdir,
                                                  &dentry->d_subdirs,
-                                                 d_u.d_child) {
+                                                 d_child) {
                                 if (child->d_inode == NULL)
                                         d_lustre_invalidate(child, 1);
                         }
@@ -285,7 +264,7 @@ int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 
                 if ((bits & (MDS_INODELOCK_LOOKUP | MDS_INODELOCK_PERM)) &&
                     inode->i_sb->s_root != NULL &&
-                    inode != inode->i_sb->s_root->d_inode)
+                    is_root_inode(inode))
                         ll_invalidate_aliases(inode);
 
                 iput(inode);
@@ -362,7 +341,7 @@ static struct dentry *ll_find_alias(struct inode *inode, struct dentry *dentry)
         discon_alias = invalid_alias = NULL;
 
         ll_lock_dcache(inode);
-        ll_d_hlist_for_each_entry(alias, p, &inode->i_dentry, d_alias) {
+        ll_d_hlist_for_each_entry(alias, p, &inode->i_dentry, d_u.d_alias) {
                 LASSERT(alias != dentry);
 
                 spin_lock(&alias->d_lock);
@@ -509,8 +488,8 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
                 return ERR_PTR(-ENAMETOOLONG);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-               dentry->d_name.len, dentry->d_name.name, parent->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),intent=%s\n",
+               dentry, parent->i_ino,
                parent->i_generation, parent, LL_IT2STR(it));
 
         if (d_mountpoint(dentry))
@@ -563,7 +542,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         if ((it->it_op & IT_OPEN) && dentry->d_inode &&
             !S_ISREG(dentry->d_inode->i_mode) &&
             !S_ISDIR(dentry->d_inode->i_mode)) {
-                ll_release_openhandle(dentry, it);
+                ll_release_openhandle(dentry->d_inode, it);
         }
         ll_lookup_finish_locks(it, dentry);
 
@@ -586,8 +565,8 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
         struct lookup_intent *itp, it = { .it_op = IT_GETATTR };
         struct dentry *de;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),flags=%u\n",
-               dentry->d_name.len, dentry->d_name.name, parent->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),flags=%u\n",
+               dentry, parent->i_ino,
                parent->i_generation, parent, flags);
 
         /* Optimize away (CREATE && !OPEN). Let .create handle the race. */
@@ -619,9 +598,9 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
         long long lookup_flags = LOOKUP_OPEN;
         int rc = 0;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),file %p,"
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),file %p,"
                            "open_flags %x,mode %x opened %d\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+               dentry, dir->i_ino,
                dir->i_generation, dir, file, open_flags, mode, *opened);
 
         it = kzalloc(sizeof(*it), GFP_NOFS);
@@ -741,8 +720,8 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
         struct inode *inode;
         int rc = 0;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),intent=%s\n",
+               dentry, dir->i_ino,
                dir->i_generation, dir, LL_IT2STR(it));
 
         rc = it_open_error(DISP_OPEN_CREATE, it);
@@ -775,9 +754,9 @@ static void ll_update_times(struct ptlrpc_request *request,
                 LTIME_S(inode->i_ctime) = body->ctime;
 }
 
-static int ll_new_node(struct inode *dir, struct qstr *name,
+static int ll_new_node(struct inode *dir, struct dentry *dentry,
                        const char *tgt, int mode, int rdev,
-                       struct dentry *dchild, __u32 opc)
+                       __u32 opc)
 {
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
@@ -789,8 +768,10 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
         if (unlikely(tgt != NULL))
                 tgt_len = strlen(tgt) + 1;
 
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
-                                     name->len, 0, opc, NULL);
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name,
+                                     dentry->d_name.len,
+                                     0, opc, NULL);
         if (IS_ERR(op_data)) {
                 err = PTR_ERR(op_data);
                 goto err_exit;
@@ -806,27 +787,25 @@ static int ll_new_node(struct inode *dir, struct qstr *name,
 
         ll_update_times(request, dir);
 
-        if (dchild) {
-                err = ll_prep_inode(&inode, request, dchild->d_sb, NULL);
-                if (err)
-                        goto err_exit;
+        err = ll_prep_inode(&inode, request, dir->i_sb, NULL);
+        if (err)
+                goto err_exit;
 
-                d_instantiate(dchild, inode);
-        }
+        d_instantiate(dentry, inode);
 err_exit:
         ptlrpc_req_finished(request);
 
         return err;
 }
 
-static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
-                            unsigned rdev, struct dentry *dchild)
+static int ll_mknod(struct inode *dir, struct dentry *dchild,
+                    umode_t mode, dev_t rdev)
 {
         int err;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir,
-               mode, rdev);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p) mode %o dev %x\n",
+               dchild, dir->i_ino, dir->i_generation, dir,
+               mode, old_encode_dev(rdev));
 
         if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
                 mode &= ~current_umask();
@@ -839,7 +818,8 @@ static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
         case S_IFBLK:
         case S_IFIFO:
         case S_IFSOCK:
-                err = ll_new_node(dir, name, NULL, mode, rdev, dchild,
+                err = ll_new_node(dir, dchild, NULL, mode,
+                                  old_encode_dev(rdev),
                                   LUSTRE_OPC_MKNOD);
                 break;
         case S_IFDIR:
@@ -863,134 +843,25 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 {
         int rc;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),"
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),"
                            "flags=%u, excl=%d\n",
-               dentry->d_name.len, dentry->d_name.name, dir->i_ino,
+               dentry, dir->i_ino,
                dir->i_generation, dir, mode, want_excl);
 
-        rc = ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry);
+        rc = ll_mknod(dir, dentry, mode, 0);
 
         ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE, 1);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, unhashed %d\n",
-               dentry->d_name.len, dentry->d_name.name, d_unhashed(dentry));
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, unhashed %d\n",
+               dentry, d_unhashed(dentry));
 
         return rc;
 }
 
-static int ll_symlink_generic(struct inode *dir, struct qstr *name,
-                              const char *tgt, struct dentry *dchild)
+static inline void ll_get_child_fid(struct dentry *child, struct lu_fid *fid)
 {
-        int err;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%.*s\n",
-               name->len, name->name, dir->i_ino, dir->i_generation,
-               dir, 3000, tgt);
-
-        err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO,
-                          0, dchild, LUSTRE_OPC_SYMLINK);
-
-        if (!err)
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_SYMLINK, 1);
-
-        return err;
-}
-
-static int ll_link_generic(struct inode *src,  struct inode *dir,
-                           struct qstr *name, struct dentry *dchild)
-{
-        struct ll_sb_info *sbi = ll_i2sbi(dir);
-        struct ptlrpc_request *request = NULL;
-        struct md_op_data *op_data;
-        int err;
-
-        CDEBUG(D_VFSTRACE,
-               "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
-               src->i_ino, src->i_generation, src, dir->i_ino,
-               dir->i_generation, dir, name->len, name->name);
-
-        op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
-                                     0, LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                return PTR_ERR(op_data);
-
-        err = md_link(sbi->ll_md_exp, op_data, &request);
-        ll_finish_md_op_data(op_data);
-        if (err)
-                goto out;
-
-        ll_update_times(request, dir);
-        ll_stats_ops_tally(sbi, LPROC_LL_LINK, 1);
-out:
-        ptlrpc_req_finished(request);
-        return err;
-}
-
-static int ll_mkdir_generic(struct inode *dir, struct qstr *name,
-                            int mode, struct dentry *dchild)
-
-{
-        int err;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
-                mode &= ~current_umask();
-        mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR;
-        err = ll_new_node(dir, name, NULL, mode, 0, dchild, LUSTRE_OPC_MKDIR);
-
-        if (!err)
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
-
-        return err;
-}
-
-/* Try to find the child dentry by its name.
-   If found, put the result fid into @fid. */
-static void ll_get_child_fid(struct inode * dir, struct qstr *name,
-                             struct lu_fid *fid)
-{
-        struct dentry *parent, *child;
-
-        parent = ll_d_hlist_entry(dir->i_dentry, struct dentry, d_alias);
-        child = d_lookup(parent, name);
-        if (child) {
-                if (child->d_inode)
-                        *fid = *ll_inode2fid(child->d_inode);
-                dput(child);
-        }
-}
-
-static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
-                            struct dentry *dchild, struct qstr *name)
-{
-        struct ptlrpc_request *request = NULL;
-        struct md_op_data *op_data;
-        int rc;
-
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
-                return -EBUSY;
-
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
-                                     S_IFDIR, LUSTRE_OPC_ANY, NULL);
-        if (IS_ERR(op_data))
-                return PTR_ERR(op_data);
-
-        ll_get_child_fid(dir, name, &op_data->op_fid3);
-        op_data->op_fid2 = op_data->op_fid3;
-        rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
-        ll_finish_md_op_data(op_data);
-        if (rc == 0) {
-                ll_update_times(request, dir);
-                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_RMDIR, 1);
-        }
-
-        ptlrpc_req_finished(request);
-        return rc;
+        if (child->d_inode)
+                *fid = *ll_inode2fid(child->d_inode);
 }
 
 /**
@@ -1099,32 +970,26 @@ out:
         return rc;
 }
 
-/* ll_unlink_generic() doesn't update the inode with the new link count.
+/* ll_unlink() doesn't update the inode with the new link count.
  * Instead, ll_ddelete() and ll_d_iput() will update it based upon if there
  * is any lock existing. They will recycle dentries and inodes based upon locks
  * too. b=20433 */
-static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
-                             struct dentry *dchild, struct qstr *name)
+static int ll_unlink(struct inode * dir, struct dentry *dentry)
 {
         struct ptlrpc_request *request = NULL;
         struct md_op_data *op_data;
         int rc;
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
-
-        /*
-         * XXX: unlink bind mountpoint maybe call to here,
-         * just check it as vfs_unlink does.
-         */
-        if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
-                return -EBUSY;
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
 
-        op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
-                                     name->len, 0, LUSTRE_OPC_ANY, NULL);
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name,
+                                     dentry->d_name.len,
+                                     0, LUSTRE_OPC_ANY, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
 
-        ll_get_child_fid(dir, name, &op_data->op_fid3);
+        ll_get_child_fid(dentry, &op_data->op_fid3);
         op_data->op_fid2 = op_data->op_fid3;
         rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
         ll_finish_md_op_data(op_data);
@@ -1140,95 +1005,140 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
         return rc;
 }
 
-static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
-                             struct dentry *src_dchild, struct qstr *src_name,
-                             struct inode *tgt, struct dentry *tgt_dparent,
-                             struct dentry *tgt_dchild, struct qstr *tgt_name)
+static int ll_mkdir(struct inode *dir, struct dentry *dentry, ll_umode_t mode)
 {
-        struct ptlrpc_request *request = NULL;
-        struct ll_sb_info *sbi = ll_i2sbi(src);
-        struct md_op_data *op_data;
         int err;
 
-        CDEBUG(D_VFSTRACE,
-               "VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
-               "tgt_dir=%lu/%u(%p)\n", src_name->len, src_name->name,
-               src->i_ino, src->i_generation, src, tgt_name->len,
-               tgt_name->name, tgt->i_ino, tgt->i_generation, tgt);
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
 
-        if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) ||
-            ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name)))
-                return -EBUSY;
+        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
+                mode &= ~current_umask();
+        mode = (mode & (S_IRWXUGO|S_ISVTX)) | S_IFDIR;
+        err = ll_new_node(dir, dentry, NULL, mode, 0, LUSTRE_OPC_MKDIR);
 
-        op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0,
-                                     LUSTRE_OPC_ANY, NULL);
+        if (!err)
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_MKDIR, 1);
+
+        return err;
+}
+
+static int ll_rmdir(struct inode *dir, struct dentry *dentry)
+{
+        struct ptlrpc_request *request = NULL;
+        struct md_op_data *op_data;
+        int rc;
+
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p)\n",
+               dentry, dir->i_ino, dir->i_generation, dir);
+
+        op_data = ll_prep_md_op_data(NULL, dir, NULL,
+                                     dentry->d_name.name, 
+                                     dentry->d_name.len,
+                                     S_IFDIR, LUSTRE_OPC_ANY, NULL);
         if (IS_ERR(op_data))
                 return PTR_ERR(op_data);
 
-        ll_get_child_fid(src, src_name, &op_data->op_fid3);
-        ll_get_child_fid(tgt, tgt_name, &op_data->op_fid4);
-        err = md_rename(sbi->ll_md_exp, op_data,
-                        src_name->name, src_name->len,
-                        tgt_name->name, tgt_name->len, &request);
+        ll_get_child_fid(dentry, &op_data->op_fid3);
+        op_data->op_fid2 = op_data->op_fid3;
+        rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
         ll_finish_md_op_data(op_data);
-        if (!err) {
-                ll_update_times(request, src);
-                ll_update_times(request, tgt);
-                ll_stats_ops_tally(sbi, LPROC_LL_RENAME, 1);
-                err = ll_objects_destroy(request, src);
+        if (rc == 0) {
+                ll_update_times(request, dir);
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_RMDIR, 1);
         }
 
         ptlrpc_req_finished(request);
-
-        return err;
+        return rc;
 }
 
-static int ll_mknod(struct inode *dir, struct dentry *dchild, ll_umode_t mode,
-                    dev_t rdev)
+static int ll_symlink(struct inode *dir, struct dentry *dentry,
+                      const char *oldname)
 {
-        return ll_mknod_generic(dir, &dchild->d_name, mode,
-                                old_encode_dev(rdev), dchild);
-}
+        int err;
 
-static int ll_unlink(struct inode * dir, struct dentry *dentry)
-{
-        return ll_unlink_generic(dir, NULL, dentry, &dentry->d_name);
-}
+        CDEBUG(D_VFSTRACE, "VFS Op:name=%pd,dir=%lu/%u(%p),target=%.*s\n",
+               dentry, dir->i_ino, dir->i_generation,
+               dir, 3000, oldname);
 
-static int ll_mkdir(struct inode *dir, struct dentry *dentry, ll_umode_t mode)
-{
-        return ll_mkdir_generic(dir, &dentry->d_name, mode, dentry);
-}
+        err = ll_new_node(dir, dentry, oldname, S_IFLNK | S_IRWXUGO,
+                        0, LUSTRE_OPC_SYMLINK);
 
-static int ll_rmdir(struct inode *dir, struct dentry *dentry)
-{
-        return ll_rmdir_generic(dir, NULL, dentry, &dentry->d_name);
-}
+        if (!err)
+                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_SYMLINK, 1);
 
-static int ll_symlink(struct inode *dir, struct dentry *dentry,
-                      const char *oldname)
-{
-        return ll_symlink_generic(dir, &dentry->d_name, oldname, dentry);
+        return err;
 }
 
 static int ll_link(struct dentry *old_dentry, struct inode *dir,
                    struct dentry *new_dentry)
 {
-        return ll_link_generic(old_dentry->d_inode, dir, &new_dentry->d_name,
-                               new_dentry);
+        struct inode *src = old_dentry->d_inode;
+        struct ll_sb_info *sbi = ll_i2sbi(dir);
+        struct ptlrpc_request *request = NULL;
+        struct md_op_data *op_data;
+        int err;
+
+        CDEBUG(D_VFSTRACE,
+               "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%pd\n",
+               src->i_ino, src->i_generation, src, dir->i_ino,
+               dir->i_generation, dir, new_dentry);
+
+        op_data = ll_prep_md_op_data(NULL, src, dir, new_dentry->d_name.name,
+                                     new_dentry->d_name.len,
+                                     0, LUSTRE_OPC_ANY, NULL);
+        if (IS_ERR(op_data))
+                return PTR_ERR(op_data);
+
+        err = md_link(sbi->ll_md_exp, op_data, &request);
+        ll_finish_md_op_data(op_data);
+        if (err)
+                goto out;
+
+        ll_update_times(request, dir);
+        ll_stats_ops_tally(sbi, LPROC_LL_LINK, 1);
+out:
+        ptlrpc_req_finished(request);
+        return err;
 }
 
 static int ll_rename(struct inode *old_dir, struct dentry *old_dentry,
                      struct inode *new_dir, struct dentry *new_dentry)
 {
+        struct ptlrpc_request *request = NULL;
+        struct ll_sb_info *sbi = ll_i2sbi(old_dir);
+        struct md_op_data *op_data;
         int err;
-        err = ll_rename_generic(old_dir, NULL,
-                                 old_dentry, &old_dentry->d_name,
-                                 new_dir, NULL, new_dentry,
-                                 &new_dentry->d_name);
+
+        CDEBUG(D_VFSTRACE,
+               "VFS Op:oldname=%pd,src_dir=%lu/%u(%p),newname=%pd,"
+               "tgt_dir=%lu/%u(%p)\n", old_dentry,
+               old_dir->i_ino, old_dir->i_generation, old_dir, new_dentry,
+               new_dir->i_ino, new_dir->i_generation, new_dir);
+
+        op_data = ll_prep_md_op_data(NULL, old_dir, new_dir, NULL, 0, 0,
+                                     LUSTRE_OPC_ANY, NULL);
+        if (IS_ERR(op_data))
+                return PTR_ERR(op_data);
+
+        ll_get_child_fid(old_dentry, &op_data->op_fid3);
+        ll_get_child_fid(new_dentry, &op_data->op_fid4);
+        err = md_rename(sbi->ll_md_exp, op_data,
+                        old_dentry->d_name.name,
+                        old_dentry->d_name.len,
+                        new_dentry->d_name.name,
+                        new_dentry->d_name.len, &request);
+        ll_finish_md_op_data(op_data);
         if (!err) {
-                        d_move(old_dentry, new_dentry);
+                ll_update_times(request, old_dir);
+                ll_update_times(request, new_dir);
+                ll_stats_ops_tally(sbi, LPROC_LL_RENAME, 1);
+                err = ll_objects_destroy(request, old_dir);
         }
+
+        ptlrpc_req_finished(request);
+        if (!err)
+                d_move(old_dentry, new_dentry);
         return err;
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/statahead.c b/drivers/staging/lustre/lustre/llite/statahead.c
index 06b71bcf97a7..09d965e76842 100644
--- a/drivers/staging/lustre/lustre/llite/statahead.c
+++ b/drivers/staging/lustre/lustre/llite/statahead.c
@@ -969,8 +969,8 @@ static int ll_agl_thread(void *arg)
         struct l_wait_info      lwi    = { 0 };
 
         thread->t_pid = current_pid();
-        CDEBUG(D_READA, "agl thread started: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "agl thread started: sai %p, parent %pd\n",
+               sai, parent);
 
         atomic_inc(&sbi->ll_agl_total);
         spin_lock(&plli->lli_agl_lock);
@@ -1019,8 +1019,8 @@ static int ll_agl_thread(void *arg)
         spin_unlock(&plli->lli_agl_lock);
         wake_up(&thread->t_ctl_waitq);
         ll_sai_put(sai);
-        CDEBUG(D_READA, "agl thread stopped: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "agl thread stopped: sai %p, parent %pd\n",
+               sai, parent);
         return 0;
 }
 
@@ -1031,8 +1031,8 @@ static void ll_start_agl(struct dentry *parent, struct ll_statahead_info *sai)
         struct ll_inode_info  *plli;
         struct task_struct *task;
 
-        CDEBUG(D_READA, "start agl thread: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n",
+               sai, parent);
 
         plli = ll_i2info(parent->d_inode);
         task = kthread_run(ll_agl_thread, parent,
@@ -1066,8 +1066,8 @@ static int ll_statahead_thread(void *arg)
         struct l_wait_info      lwi    = { 0 };
 
         thread->t_pid = current_pid();
-        CDEBUG(D_READA, "statahead thread starting: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "statahead thread starting: sai %p, parent %pd\n",
+               sai, parent);
 
         if (sbi->ll_flags & LL_SBI_AGL_ENABLED)
                 ll_start_agl(parent, sai);
@@ -1288,8 +1288,8 @@ out:
         wake_up(&thread->t_ctl_waitq);
         ll_sai_put(sai);
         dput(parent);
-        CDEBUG(D_READA, "statahead thread stopped: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "statahead thread stopped: sai %p, parent %pd\n",
+               sai, parent);
         return rc;
 }
 
@@ -1612,10 +1612,9 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                                 } else if ((*dentryp)->d_inode != inode) {
                                         /* revalidate, but inode is recreated */
                                         CDEBUG(D_READA,
-                                              "stale dentry %.*s inode %lu/%u, "
+                                              "stale dentry %pd inode %lu/%u, "
                                               "statahead inode %lu/%u\n",
-                                              (*dentryp)->d_name.len,
-                                              (*dentryp)->d_name.name,
+                                              *dentryp,
                                               (*dentryp)->d_inode->i_ino,
                                               (*dentryp)->d_inode->i_generation,
                                               inode->i_ino,
@@ -1666,9 +1665,9 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
         if (unlikely(sai->sai_inode != parent->d_inode)) {
                 struct ll_inode_info *nlli = ll_i2info(parent->d_inode);
 
-                CWARN("Race condition, someone changed %.*s just now: "
+                CWARN("Race condition, someone changed %pd just now: "
                       "old parent "DFID", new parent "DFID"\n",
-                      (*dentryp)->d_name.len, (*dentryp)->d_name.name,
+                      *dentryp,
                       PFID(&lli->lli_fid), PFID(&nlli->lli_fid));
                 dput(parent);
                 iput(sai->sai_inode);
@@ -1676,8 +1675,8 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                 goto out;
         }
 
-        CDEBUG(D_READA, "start statahead thread: sai %p, parent %.*s\n",
-               sai, parent->d_name.len, parent->d_name.name);
+        CDEBUG(D_READA, "start statahead thread: sai %p, parent %pd\n",
+               sai, parent);
 
         /* The sai buffer already has one reference taken at allocation time,
          * but as soon as we expose the sai by attaching it to the lli that
diff --git a/drivers/staging/lustre/lustre/llite/vvp_io.c b/drivers/staging/lustre/lustre/llite/vvp_io.c
index d3f967a78138..e540a6d286f8 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_io.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_io.c
@@ -108,7 +108,7 @@ static int vvp_io_fault_iter_init(const struct lu_env *env,
         struct inode  *inode = ccc_object_inode(ios->cis_obj);
 
         LASSERT(inode ==
-                cl2ccc_io(env, ios)->cui_fd->fd_file->f_dentry->d_inode);
+                file_inode(cl2ccc_io(env, ios)->cui_fd->fd_file));
         vio->u.fault.ft_mtime = LTIME_S(inode->i_mtime);
         return 0;
 }
@@ -239,7 +239,7 @@ static int vvp_mmap_locks(const struct lu_env *env,
 
                 down_read(&mm->mmap_sem);
                 while ((vma = our_vma(mm, addr, count)) != NULL) {
-                        struct inode *inode = vma->vm_file->f_dentry->d_inode;
+                        struct inode *inode = file_inode(vma->vm_file);
                         int flags = CEF_MUST;
 
                         if (ll_file_nolock(vma->vm_file)) {
diff --git a/drivers/staging/lustre/lustre/llite/xattr.c b/drivers/staging/lustre/lustre/llite/xattr.c
index 252a6194ed9b..3151baf5585c 100644
--- a/drivers/staging/lustre/lustre/llite/xattr.c
+++ b/drivers/staging/lustre/lustre/llite/xattr.c
@@ -241,14 +241,11 @@ int ll_setxattr(struct dentry *dentry, const char *name,
                         lump->lmm_stripe_offset = -1;
 
                 if (lump != NULL && S_ISREG(inode->i_mode)) {
-                        struct file f;
                         int flags = FMODE_WRITE;
                         int lum_size = (lump->lmm_magic == LOV_USER_MAGIC_V1) ?
                                 sizeof(*lump) : sizeof(struct lov_user_md_v3);
 
-                        memset(&f, 0, sizeof(f)); /* f.f_flags is used below */
-                        f.f_dentry = dentry;
-                        rc = ll_lov_setstripe_ea_info(inode, &f, flags, lump,
+                        rc = ll_lov_setstripe_ea_info(inode, dentry, flags, lump,
                                                       lum_size);
                         /* b10667: rc always be 0 here for now */
                         rc = 0;
@@ -519,8 +516,8 @@ ssize_t ll_getxattr(struct dentry *dentry, const char *name,
                 }
 
                 if (size < lmmsize) {
-                        CERROR("server bug: replied size %d > %d for %s (%s)\n",
-                               lmmsize, (int)size, dentry->d_name.name, name);
+                        CERROR("server bug: replied size %d > %d for %pd (%s)\n",
+                               lmmsize, (int)size, dentry, name);
                         rc = -ERANGE;
                         goto out;
                 }
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 296482fc77a9..9ee5343d4884 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -832,7 +832,7 @@ struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
          * moved b under k and client parallely did a lookup for
          * k/b.
          */
-        res = d_materialise_unique(dentry, inode);
+        res = d_splice_alias(inode, dentry);
         if (!res)
                 v9fs_fid_add(dentry, fid);
         else if (!IS_ERR(res))
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index 02b64f4e576a..6054c16b8fae 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -826,8 +826,8 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
         struct dentry *dir_dentry;
         struct posix_acl *dacl = NULL, *pacl = NULL;
 
-        p9_debug(P9_DEBUG_VFS, " %lu,%s mode: %hx MAJOR: %u MINOR: %u\n",
-                 dir->i_ino, dentry->d_name.name, omode,
+        p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n",
+                 dir->i_ino, dentry, omode,
                  MAJOR(rdev), MINOR(rdev));
 
         if (!new_valid_dev(rdev))
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index abc853968fed..937ce8754b24 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -125,7 +125,7 @@ affs_fix_dcache(struct inode *inode, u32 entry_ino)
 {
         struct dentry *dentry;
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
                 if (entry_ino == (u32)(long)dentry->d_fsdata) {
                         dentry->d_fsdata = (void *)inode->i_ino;
                         break;
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index e217c511459b..d0609a282e1d 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -348,9 +348,9 @@ affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s3
         u32 block = 0;
         int retval;
 
-        pr_debug("%s(dir=%u, inode=%u, \"%*s\", type=%d)\n",
+        pr_debug("%s(dir=%u, inode=%u, \"%pd\", type=%d)\n",
                  __func__, (u32)dir->i_ino,
-                 (u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type);
+                 (u32)inode->i_ino, dentry, type);
 
         retval = -EIO;
         bh = affs_bread(sb, inode->i_ino);
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 035bd31556fc..bbc38530e924 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -190,8 +190,7 @@ affs_find_entry(struct inode *dir, struct dentry *dentry)
         toupper_t toupper = affs_get_toupper(sb);
         u32 key;
 
-        pr_debug("%s(\"%.*s\")\n",
-                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
+        pr_debug("%s(\"%pd\")\n", __func__, dentry);
 
         bh = affs_bread(sb, dir->i_ino);
         if (!bh)
@@ -219,8 +218,7 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
         struct buffer_head *bh;
         struct inode *inode = NULL;
 
-        pr_debug("%s(\"%.*s\")\n",
-                 __func__, (int)dentry->d_name.len, dentry->d_name.name);
+        pr_debug("%s(\"%pd\")\n", __func__, dentry);
 
         affs_lock_dir(dir);
         bh = affs_find_entry(dir, dentry);
@@ -250,9 +248,9 @@ affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 int
 affs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("%s(dir=%d, %lu \"%.*s\")\n",
+        pr_debug("%s(dir=%d, %lu \"%pd\")\n",
                  __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
-                (int)dentry->d_name.len, dentry->d_name.name);
+                dentry);
 
         return affs_remove_header(dentry);
 }
@@ -264,9 +262,8 @@ affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
         struct inode    *inode;
         int              error;
 
-        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
-                 __func__, dir->i_ino, (int)dentry->d_name.len,
-                 dentry->d_name.name,mode);
+        pr_debug("%s(%lu,\"%pd\",0%ho)\n",
+                 __func__, dir->i_ino, dentry, mode);
 
         inode = affs_new_inode(dir);
         if (!inode)
@@ -294,9 +291,8 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         struct inode            *inode;
         int                      error;
 
-        pr_debug("%s(%lu,\"%.*s\",0%ho)\n",
-                 __func__, dir->i_ino, (int)dentry->d_name.len,
-                 dentry->d_name.name, mode);
+        pr_debug("%s(%lu,\"%pd\",0%ho)\n",
+                 __func__, dir->i_ino, dentry, mode);
 
         inode = affs_new_inode(dir);
         if (!inode)
@@ -321,9 +317,9 @@ affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 int
 affs_rmdir(struct inode *dir, struct dentry *dentry)
 {
-        pr_debug("%s(dir=%u, %lu \"%.*s\")\n",
+        pr_debug("%s(dir=%u, %lu \"%pd\")\n",
                 __func__, (u32)dir->i_ino, dentry->d_inode->i_ino,
-                 (int)dentry->d_name.len, dentry->d_name.name);
+                 dentry);
 
         return affs_remove_header(dentry);
 }
@@ -338,9 +334,8 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
         int                      i, maxlen, error;
         char                     c, lc;
 
-        pr_debug("%s(%lu,\"%.*s\" -> \"%s\")\n",
-                 __func__, dir->i_ino, (int)dentry->d_name.len,
-                 dentry->d_name.name, symname);
+        pr_debug("%s(%lu,\"%pd\" -> \"%s\")\n",
+                 __func__, dir->i_ino, dentry, symname);
 
         maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
         inode  = affs_new_inode(dir);
@@ -409,9 +404,9 @@ affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 {
         struct inode *inode = old_dentry->d_inode;
 
-        pr_debug("%s(%u, %u, \"%.*s\")\n",
+        pr_debug("%s(%u, %u, \"%pd\")\n",
                  __func__, (u32)inode->i_ino, (u32)dir->i_ino,
-                 (int)dentry->d_name.len,dentry->d_name.name);
+                 dentry);
 
         return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
 }
@@ -424,10 +419,9 @@ affs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct buffer_head *bh = NULL;
         int retval;
 
-        pr_debug("%s(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
-                 __func__, (u32)old_dir->i_ino, (int)old_dentry->d_name.len,
-                 old_dentry->d_name.name, (u32)new_dir->i_ino,
-                (int)new_dentry->d_name.len, new_dentry->d_name.name);
+        pr_debug("%s(old=%u,\"%pd\" to new=%u,\"%pd\")\n",
+                 __func__, (u32)old_dir->i_ino, old_dentry,
+                 (u32)new_dir->i_ino, new_dentry);
 
         retval = affs_check_name(new_dentry->d_name.name,
                                  new_dentry->d_name.len,
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index a1645b88fe8a..4ec35e9130e1 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -26,7 +26,7 @@ static int afs_readdir(struct file *file, struct dir_context *ctx);
 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);
 static int afs_d_delete(const struct dentry *dentry);
 static void afs_d_release(struct dentry *dentry);
-static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
+static int afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,
                                   loff_t fpos, u64 ino, unsigned dtype);
 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                       bool excl);
@@ -391,10 +391,11 @@ static int afs_readdir(struct file *file, struct dir_context *ctx)
  * - if afs_dir_iterate_block() spots this function, it'll pass the FID
  *   uniquifier through dtype
  */
-static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
-                              loff_t fpos, u64 ino, unsigned dtype)
+static int afs_lookup_filldir(struct dir_context *ctx, const char *name,
+                              int nlen, loff_t fpos, u64 ino, unsigned dtype)
 {
-        struct afs_lookup_cookie *cookie = _cookie;
+        struct afs_lookup_cookie *cookie =
+                container_of(ctx, struct afs_lookup_cookie, ctx);
 
         _enter("{%s,%u},%s,%u,,%llu,%u",
                cookie->name.name, cookie->name.len, name, nlen,
@@ -433,7 +434,7 @@ static int afs_do_lookup(struct inode *dir, struct dentry *dentry,
         };
         int ret;
 
-        _enter("{%lu},%p{%s},", dir->i_ino, dentry, dentry->d_name.name);
+        _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
 
         /* search the directory */
         ret = afs_dir_iterate(dir, &cookie.ctx, key);
@@ -465,8 +466,8 @@ static struct inode *afs_try_auto_mntpt(
         struct afs_vnode *vnode = AFS_FS_I(dir);
         struct inode *inode;
 
-        _enter("%d, %p{%s}, {%x:%u}, %p",
-               ret, dentry, devname, vnode->fid.vid, vnode->fid.vnode, key);
+        _enter("%d, %p{%pd}, {%x:%u}, %p",
+               ret, dentry, dentry, vnode->fid.vid, vnode->fid.vnode, key);
 
         if (ret != -ENOENT ||
             !test_bit(AFS_VNODE_AUTOCELL, &vnode->flags))
@@ -501,8 +502,8 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
 
         vnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},%p{%s},",
-               vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name);
+        _enter("{%x:%u},%p{%pd},",
+               vnode->fid.vid, vnode->fid.vnode, dentry, dentry);
 
         ASSERTCMP(dentry->d_inode, ==, NULL);
 
@@ -588,11 +589,11 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
         vnode = AFS_FS_I(dentry->d_inode);
 
         if (dentry->d_inode)
-                _enter("{v={%x:%u} n=%s fl=%lx},",
-                       vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
+                _enter("{v={%x:%u} n=%pd fl=%lx},",
+                       vnode->fid.vid, vnode->fid.vnode, dentry,
                        vnode->flags);
         else
-                _enter("{neg n=%s}", dentry->d_name.name);
+                _enter("{neg n=%pd}", dentry);
 
         key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);
         if (IS_ERR(key))
@@ -607,7 +608,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
                 afs_validate(dir, key);
 
         if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
-                _debug("%s: parent dir deleted", dentry->d_name.name);
+                _debug("%pd: parent dir deleted", dentry);
                 goto out_bad;
         }
 
@@ -625,16 +626,16 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
                 if (!dentry->d_inode)
                         goto out_bad;
                 if (is_bad_inode(dentry->d_inode)) {
-                        printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n",
-                               parent->d_name.name, dentry->d_name.name);
+                        printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
+                               dentry);
                         goto out_bad;
                 }
 
                 /* if the vnode ID has changed, then the dirent points to a
                  * different file */
                 if (fid.vnode != vnode->fid.vnode) {
-                        _debug("%s: dirent changed [%u != %u]",
-                               dentry->d_name.name, fid.vnode,
+                        _debug("%pd: dirent changed [%u != %u]",
+                               dentry, fid.vnode,
                                vnode->fid.vnode);
                         goto not_found;
                 }
@@ -643,8 +644,8 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
                  * been deleted and replaced, and the original vnode ID has
                  * been reused */
                 if (fid.unique != vnode->fid.unique) {
-                        _debug("%s: file deleted (uq %u -> %u I:%u)",
-                               dentry->d_name.name, fid.unique,
+                        _debug("%pd: file deleted (uq %u -> %u I:%u)",
+                               dentry, fid.unique,
                                vnode->fid.unique,
                                dentry->d_inode->i_generation);
                         spin_lock(&vnode->lock);
@@ -656,14 +657,14 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
 
         case -ENOENT:
                 /* the filename is unknown */
-                _debug("%s: dirent not found", dentry->d_name.name);
+                _debug("%pd: dirent not found", dentry);
                 if (dentry->d_inode)
                         goto not_found;
                 goto out_valid;
 
         default:
-                _debug("failed to iterate dir %s: %d",
-                       parent->d_name.name, ret);
+                _debug("failed to iterate dir %pd: %d",
+                       parent, ret);
                 goto out_bad;
         }
 
@@ -681,8 +682,7 @@ not_found:
         spin_unlock(&dentry->d_lock);
 
 out_bad:
-        _debug("dropping dentry %s/%s",
-               parent->d_name.name, dentry->d_name.name);
+        _debug("dropping dentry %pd2", dentry);
         dput(parent);
         key_put(key);
 
@@ -698,7 +698,7 @@ out_bad:
  */
 static int afs_d_delete(const struct dentry *dentry)
 {
-        _enter("%s", dentry->d_name.name);
+        _enter("%pd", dentry);
 
         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
                 goto zap;
@@ -721,7 +721,7 @@ zap:
  */
 static void afs_d_release(struct dentry *dentry)
 {
-        _enter("%s", dentry->d_name.name);
+        _enter("%pd", dentry);
 }
 
 /*
@@ -740,8 +740,8 @@ static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s},%ho",
-               dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
+        _enter("{%x:%u},{%pd},%ho",
+               dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
 
         key = afs_request_key(dvnode->volume->cell);
         if (IS_ERR(key)) {
@@ -801,8 +801,8 @@ static int afs_rmdir(struct inode *dir, struct dentry *dentry)
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s}",
-               dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
+        _enter("{%x:%u},{%pd}",
+               dvnode->fid.vid, dvnode->fid.vnode, dentry);
 
         key = afs_request_key(dvnode->volume->cell);
         if (IS_ERR(key)) {
@@ -843,8 +843,8 @@ static int afs_unlink(struct inode *dir, struct dentry *dentry)
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s}",
-               dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
+        _enter("{%x:%u},{%pd}",
+               dvnode->fid.vid, dvnode->fid.vnode, dentry);
 
         ret = -ENAMETOOLONG;
         if (dentry->d_name.len >= AFSNAMEMAX)
@@ -917,8 +917,8 @@ static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s},%ho,",
-               dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
+        _enter("{%x:%u},{%pd},%ho,",
+               dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
 
         key = afs_request_key(dvnode->volume->cell);
         if (IS_ERR(key)) {
@@ -980,10 +980,10 @@ static int afs_link(struct dentry *from, struct inode *dir,
         vnode = AFS_FS_I(from->d_inode);
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%x:%u},{%s}",
+        _enter("{%x:%u},{%x:%u},{%pd}",
                vnode->fid.vid, vnode->fid.vnode,
                dvnode->fid.vid, dvnode->fid.vnode,
-               dentry->d_name.name);
+               dentry);
 
         key = afs_request_key(dvnode->volume->cell);
         if (IS_ERR(key)) {
@@ -1025,8 +1025,8 @@ static int afs_symlink(struct inode *dir, struct dentry *dentry,
 
         dvnode = AFS_FS_I(dir);
 
-        _enter("{%x:%u},{%s},%s",
-               dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name,
+        _enter("{%x:%u},{%pd},%s",
+               dvnode->fid.vid, dvnode->fid.vnode, dentry,
                content);
 
         ret = -EINVAL;
@@ -1093,11 +1093,11 @@ static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
         orig_dvnode = AFS_FS_I(old_dir);
         new_dvnode = AFS_FS_I(new_dir);
 
-        _enter("{%x:%u},{%x:%u},{%x:%u},{%s}",
+        _enter("{%x:%u},{%x:%u},{%x:%u},{%pd}",
                orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
                vnode->fid.vid, vnode->fid.vnode,
                new_dvnode->fid.vid, new_dvnode->fid.vnode,
-               new_dentry->d_name.name);
+               new_dentry);
 
         key = afs_request_key(orig_dvnode->volume->cell);
         if (IS_ERR(key)) {
diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index 294671288449..8a1d38ef0fc2 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -462,8 +462,8 @@ int afs_setattr(struct dentry *dentry, struct iattr *attr)
         struct key *key;
         int ret;
 
-        _enter("{%x:%u},{n=%s},%x",
-               vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
+        _enter("{%x:%u},{n=%pd},%x",
+               vnode->fid.vid, vnode->fid.vnode, dentry,
                attr->ia_valid);
 
         if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 9682c33d5daf..938c5ab06d5a 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -106,14 +106,7 @@ static struct dentry *afs_mntpt_lookup(struct inode *dir,
                                        struct dentry *dentry,
                                        unsigned int flags)
 {
-        _enter("%p,%p{%p{%s},%s}",
-               dir,
-               dentry,
-               dentry->d_parent,
-               dentry->d_parent ?
-               dentry->d_parent->d_name.name : (const unsigned char *) "",
-               dentry->d_name.name);
-
+        _enter("%p,%p{%pd2}", dir, dentry, dentry);
         return ERR_PTR(-EREMOTE);
 }
 
@@ -122,14 +115,7 @@ static struct dentry *afs_mntpt_lookup(struct inode *dir,
  */
 static int afs_mntpt_open(struct inode *inode, struct file *file)
 {
-        _enter("%p,%p{%p{%s},%s}",
-               inode, file,
-               file->f_path.dentry->d_parent,
-               file->f_path.dentry->d_parent ?
-               file->f_path.dentry->d_parent->d_name.name :
-               (const unsigned char *) "",
-               file->f_path.dentry->d_name.name);
-
+        _enter("%p,%p{%pD2}", inode, file, file);
         return -EREMOTE;
 }
 
@@ -146,7 +132,7 @@ static struct vfsmount *afs_mntpt_do_automount(struct dentry *mntpt)
         bool rwpath = false;
         int ret;
 
-        _enter("{%s}", mntpt->d_name.name);
+        _enter("{%pd}", mntpt);
 
         BUG_ON(!mntpt->d_inode);
 
@@ -242,7 +228,7 @@ struct vfsmount *afs_d_automount(struct path *path)
 {
         struct vfsmount *newmnt;
 
-        _enter("{%s}", path->dentry->d_name.name);
+        _enter("{%pd}", path->dentry);
 
         newmnt = afs_mntpt_do_automount(path->dentry);
         if (IS_ERR(newmnt))
diff --git a/fs/afs/write.c b/fs/afs/write.c
index ab6adfd52516..c13cb08964ed 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -682,14 +682,13 @@ int afs_writeback_all(struct afs_vnode *vnode)
  */
 int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = file->f_mapping->host;
+        struct inode *inode = file_inode(file);
         struct afs_writeback *wb, *xwb;
-        struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
+        struct afs_vnode *vnode = AFS_FS_I(inode);
         int ret;
 
-        _enter("{%x:%u},{n=%s},%d",
-               vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
+        _enter("{%x:%u},{n=%pD},%d",
+               vnode->fid.vid, vnode->fid.vnode, file,
                datasync);
 
         ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index 683a5b9ce22a..bfdbaba9c2ba 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -41,8 +41,7 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
         struct path path = {.mnt = mnt, .dentry = dentry};
         int status = 1;
 
-        DPRINTK("dentry %p %.*s",
-                dentry, (int)dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("dentry %p %pd", dentry, dentry);
 
         path_get(&path);
 
@@ -85,7 +84,7 @@ static struct dentry *get_next_positive_subdir(struct dentry *prev,
         spin_lock(&root->d_lock);
 
         if (prev)
-                next = prev->d_u.d_child.next;
+                next = prev->d_child.next;
         else {
                 prev = dget_dlock(root);
                 next = prev->d_subdirs.next;
@@ -99,13 +98,13 @@ cont:
                 return NULL;
         }
 
-        q = list_entry(next, struct dentry, d_u.d_child);
+        q = list_entry(next, struct dentry, d_child);
 
         spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
         /* Already gone or negative dentry (under construction) - try next */
         if (!d_count(q) || !simple_positive(q)) {
                 spin_unlock(&q->d_lock);
-                next = q->d_u.d_child.next;
+                next = q->d_child.next;
                 goto cont;
         }
         dget_dlock(q);
@@ -155,13 +154,13 @@ again:
                                 goto relock;
                         }
                         spin_unlock(&p->d_lock);
-                        next = p->d_u.d_child.next;
+                        next = p->d_child.next;
                         p = parent;
                         if (next != &parent->d_subdirs)
                                 break;
                 }
         }
-        ret = list_entry(next, struct dentry, d_u.d_child);
+        ret = list_entry(next, struct dentry, d_child);
 
         spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
         /* Negative dentry - try next */
@@ -192,8 +191,7 @@ static int autofs4_direct_busy(struct vfsmount *mnt,
                                 unsigned long timeout,
                                 int do_now)
 {
-        DPRINTK("top %p %.*s",
-                top, (int) top->d_name.len, top->d_name.name);
+        DPRINTK("top %p %pd", top, top);
 
         /* If it's busy update the expiry counters */
         if (!may_umount_tree(mnt)) {
@@ -221,8 +219,7 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
         struct autofs_info *top_ino = autofs4_dentry_ino(top);
         struct dentry *p;
 
-        DPRINTK("top %p %.*s",
-                top, (int)top->d_name.len, top->d_name.name);
+        DPRINTK("top %p %pd", top, top);
 
         /* Negative dentry - give up */
         if (!simple_positive(top))
@@ -230,8 +227,7 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
 
         p = NULL;
         while ((p = get_next_positive_dentry(p, top))) {
-                DPRINTK("dentry %p %.*s",
-                        p, (int) p->d_name.len, p->d_name.name);
+                DPRINTK("dentry %p %pd", p, p);
 
                 /*
                  * Is someone visiting anywhere in the subtree ?
@@ -277,13 +273,11 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
 {
         struct dentry *p;
 
-        DPRINTK("parent %p %.*s",
-                parent, (int)parent->d_name.len, parent->d_name.name);
+        DPRINTK("parent %p %pd", parent, parent);
 
         p = NULL;
         while ((p = get_next_positive_dentry(p, parent))) {
-                DPRINTK("dentry %p %.*s",
-                        p, (int) p->d_name.len, p->d_name.name);
+                DPRINTK("dentry %p %pd", p, p);
 
                 if (d_mountpoint(p)) {
                         /* Can we umount this guy */
@@ -368,8 +362,7 @@ static struct dentry *should_expire(struct dentry *dentry,
          *         offset (autofs-5.0+).
          */
         if (d_mountpoint(dentry)) {
-                DPRINTK("checking mountpoint %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+                DPRINTK("checking mountpoint %p %pd", dentry, dentry);
 
                 /* Can we umount this guy */
                 if (autofs4_mount_busy(mnt, dentry))
@@ -382,8 +375,7 @@ static struct dentry *should_expire(struct dentry *dentry,
         }
 
         if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
-                DPRINTK("checking symlink %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+                DPRINTK("checking symlink %p %pd", dentry, dentry);
                 /*
                  * A symlink can't be "busy" in the usual sense so
                  * just check last used for expire timeout.
@@ -479,8 +471,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
         return NULL;
 
 found:
-        DPRINTK("returning %p %.*s",
-                expired, (int)expired->d_name.len, expired->d_name.name);
+        DPRINTK("returning %p %pd", expired, expired);
         ino->flags |= AUTOFS_INF_EXPIRING;
         smp_mb();
         ino->flags &= ~AUTOFS_INF_NO_RCU;
@@ -489,7 +480,7 @@ found:
         spin_lock(&sbi->lookup_lock);
         spin_lock(&expired->d_parent->d_lock);
         spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
-        list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
+        list_move(&expired->d_parent->d_subdirs, &expired->d_child);
         spin_unlock(&expired->d_lock);
         spin_unlock(&expired->d_parent->d_lock);
         spin_unlock(&sbi->lookup_lock);
@@ -512,8 +503,7 @@ int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
         if (ino->flags & AUTOFS_INF_EXPIRING) {
                 spin_unlock(&sbi->fs_lock);
 
-                DPRINTK("waiting for expire %p name=%.*s",
-                         dentry, dentry->d_name.len, dentry->d_name.name);
+                DPRINTK("waiting for expire %p name=%pd", dentry, dentry);
 
                 status = autofs4_wait(sbi, dentry, NFY_NONE);
                 wait_for_completion(&ino->expire_complete);
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index d76d083f2f06..dbb5b7212ce1 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -108,8 +108,7 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
         struct dentry *dentry = file->f_path.dentry;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 
-        DPRINTK("file=%p dentry=%p %.*s",
-                file, dentry, dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("file=%p dentry=%p %pD", file, dentry, dentry);
 
         if (autofs4_oz_mode(sbi))
                 goto out;
@@ -279,8 +278,7 @@ static int autofs4_mount_wait(struct dentry *dentry, bool rcu_walk)
         if (ino->flags & AUTOFS_INF_PENDING) {
                 if (rcu_walk)
                         return -ECHILD;
-                DPRINTK("waiting for mount name=%.*s",
-                        dentry->d_name.len, dentry->d_name.name);
+                DPRINTK("waiting for mount name=%pd", dentry);
                 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
                 DPRINTK("mount wait done status=%d", status);
         }
@@ -340,8 +338,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         int status;
 
-        DPRINTK("dentry=%p %.*s",
-                dentry, dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("dentry=%p %pd", dentry, dentry);
 
         /* The daemon never triggers a mount. */
         if (autofs4_oz_mode(sbi))
@@ -428,8 +425,7 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         int status;
 
-        DPRINTK("dentry=%p %.*s",
-                dentry, dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("dentry=%p %pd", dentry, dentry);
 
         /* The daemon never waits. */
         if (autofs4_oz_mode(sbi)) {
@@ -504,7 +500,7 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, u
         struct autofs_info *ino;
         struct dentry *active;
 
-        DPRINTK("name = %.*s", dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("name = %pd", dentry);
 
         /* File name too long to exist */
         if (dentry->d_name.len > NAME_MAX)
@@ -558,8 +554,7 @@ static int autofs4_dir_symlink(struct inode *dir,
         size_t size = strlen(symname);
         char *cp;
 
-        DPRINTK("%s <- %.*s", symname,
-                dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("%s <- %pd", symname, dentry);
 
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
@@ -687,7 +682,7 @@ static void autofs_clear_leaf_automount_flags(struct dentry *dentry)
         /* only consider parents below dentrys in the root */
         if (IS_ROOT(parent->d_parent))
                 return;
-        d_child = &dentry->d_u.d_child;
+        d_child = &dentry->d_child;
         /* Set parent managed if it's becoming empty */
         if (d_child->next == &parent->d_subdirs &&
             d_child->prev == &parent->d_subdirs)
@@ -701,8 +696,7 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         struct autofs_info *p_ino;
         
-        DPRINTK("dentry %p, removing %.*s",
-                dentry, dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("dentry %p, removing %pd", dentry, dentry);
 
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
@@ -744,8 +738,7 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, umode_t m
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
 
-        DPRINTK("dentry %p, creating %.*s",
-                dentry, dentry->d_name.len, dentry->d_name.name);
+        DPRINTK("dentry %p, creating %pd", dentry, dentry);
 
         BUG_ON(!ino);
 
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 4cf61ec6b7a8..b94d1cc9cd30 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -172,8 +172,8 @@ befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
         char *utfname;
         const char *name = dentry->d_name.name;
 
-        befs_debug(sb, "---> %s name %s inode %ld", __func__,
-                   dentry->d_name.name, dir->i_ino);
+        befs_debug(sb, "---> %s name %pd inode %ld", __func__,
+                   dentry, dir->i_ino);
 
         /* Convert to UTF-8 */
         if (BEFS_SB(sb)->nls) {
@@ -191,8 +191,7 @@ befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
         }
 
         if (ret == BEFS_BT_NOT_FOUND) {
-                befs_debug(sb, "<--- %s %s not found", __func__,
-                           dentry->d_name.name);
+                befs_debug(sb, "<--- %s %pd not found", __func__, dentry);
                 return ERR_PTR(-ENOENT);
 
         } else if (ret != BEFS_OK || offset == 0) {
@@ -222,10 +221,9 @@ befs_readdir(struct file *file, struct dir_context *ctx)
         size_t keysize;
         unsigned char d_type;
         char keybuf[BEFS_NAME_LEN + 1];
-        const char *dirname = file->f_path.dentry->d_name.name;
 
-        befs_debug(sb, "---> %s name %s, inode %ld, ctx->pos %lld",
-                  __func__, dirname, inode->i_ino, ctx->pos);
+        befs_debug(sb, "---> %s name %pD, inode %ld, ctx->pos %lld",
+                  __func__, file, inode->i_ino, ctx->pos);
 
 more:
         result = befs_btree_read(sb, ds, ctx->pos, BEFS_NAME_LEN + 1,
@@ -233,8 +231,8 @@ more:
 
         if (result == BEFS_ERR) {
                 befs_debug(sb, "<--- %s ERROR", __func__);
-                befs_error(sb, "IO error reading %s (inode %lu)",
-                           dirname, inode->i_ino);
+                befs_error(sb, "IO error reading %pD (inode %lu)",
+                           file, inode->i_ino);
                 return -EIO;
 
         } else if (result == BEFS_BT_END) {
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 929dec08c348..4c556680fa74 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -292,8 +292,8 @@ static int load_aout_binary(struct linux_binprm * bprm)
                 if ((fd_offset & ~PAGE_MASK) != 0 && printk_ratelimit())
                 {
                         printk(KERN_WARNING 
-                               "fd_offset is not page aligned. Please convert program: %s\n",
-                               bprm->file->f_path.dentry->d_name.name);
+                               "fd_offset is not page aligned. Please convert program: %pD\n",
+                               bprm->file);
                 }
 
                 if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
@@ -375,8 +375,8 @@ static int load_aout_library(struct file *file)
                 if (printk_ratelimit())
                 {
                         printk(KERN_WARNING 
-                               "N_TXTOFF is not page aligned. Please convert library: %s\n",
-                               file->f_path.dentry->d_name.name);
+                               "N_TXTOFF is not page aligned. Please convert library: %pD\n",
+                               file);
                 }
                 vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
                 
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index d23362f4464e..ff0dcc016b71 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -5303,7 +5303,7 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
                         return ERR_CAST(inode);
         }
 
-        return d_materialise_unique(dentry, inode);
+        return d_splice_alias(inode, dentry);
 }
 
 unsigned char btrfs_filetype_table[] = {
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 4399f0c3a4ce..080fe66c0349 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -5296,7 +5296,7 @@ long btrfs_ioctl(struct file *file, unsigned int
                 ret = btrfs_start_delalloc_roots(root->fs_info, 0, -1);
                 if (ret)
                         return ret;
-                ret = btrfs_sync_fs(file->f_dentry->d_sb, 1);
+                ret = btrfs_sync_fs(file_inode(file)->i_sb, 1);
                 /*
                  * The transaction thread may want to do more work,
                  * namely it pokes the cleaner ktread that will start
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index e12f189d539b..7f8e83f9d74e 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -102,8 +102,7 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
         struct cachefiles_object *object;
         struct rb_node *p;
 
-        _enter(",'%*.*s'",
-               dentry->d_name.len, dentry->d_name.len, dentry->d_name.name);
+        _enter(",'%pd'", dentry);
 
         write_lock(&cache->active_lock);
 
@@ -273,9 +272,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
         char nbuffer[8 + 8 + 1];
         int ret;
 
-        _enter(",'%*.*s','%*.*s'",
-               dir->d_name.len, dir->d_name.len, dir->d_name.name,
-               rep->d_name.len, rep->d_name.len, rep->d_name.name);
+        _enter(",'%pd','%pd'", dir, rep);
 
         _debug("remove %p from %p", rep, dir);
 
@@ -597,8 +594,7 @@ lookup_again:
         /* if we've found that the terminal object exists, then we need to
          * check its attributes and delete it if it's out of date */
         if (!object->new) {
-                _debug("validate '%*.*s'",
-                       next->d_name.len, next->d_name.len, next->d_name.name);
+                _debug("validate '%pd'", next);
 
                 ret = cachefiles_check_object_xattr(object, auxdata);
                 if (ret == -ESTALE) {
@@ -827,8 +823,8 @@ static struct dentry *cachefiles_check_active(struct cachefiles_cache *cache,
         unsigned long start;
         int ret;
 
-        //_enter(",%*.*s/,%s",
-        //       dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
+        //_enter(",%pd/,%s",
+        //       dir, filename);
 
         /* look up the victim */
         mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
@@ -910,8 +906,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
         struct dentry *victim;
         int ret;
 
-        _enter(",%*.*s/,%s",
-               dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
+        _enter(",%pd/,%s", dir, filename);
 
         victim = cachefiles_check_active(cache, dir, filename);
         if (IS_ERR(victim))
@@ -969,8 +964,8 @@ int cachefiles_check_in_use(struct cachefiles_cache *cache, struct dentry *dir,
 {
         struct dentry *victim;
 
-        //_enter(",%*.*s/,%s",
-        //       dir->d_name.len, dir->d_name.len, dir->d_name.name, filename);
+        //_enter(",%pd/,%s",
+        //       dir, filename);
 
         victim = cachefiles_check_active(cache, dir, filename);
         if (IS_ERR(victim))
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index acbc1f094fb1..a8a68745e11d 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -51,9 +51,8 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
         }
 
         if (ret != -EEXIST) {
-                pr_err("Can't set xattr on %*.*s [%lu] (err %d)\n",
-                       dentry->d_name.len, dentry->d_name.len,
-                       dentry->d_name.name, dentry->d_inode->i_ino,
+                pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
+                       dentry, dentry->d_inode->i_ino,
                        -ret);
                 goto error;
         }
@@ -64,9 +63,8 @@ int cachefiles_check_object_type(struct cachefiles_object *object)
                 if (ret == -ERANGE)
                         goto bad_type_length;
 
-                pr_err("Can't read xattr on %*.*s [%lu] (err %d)\n",
-                       dentry->d_name.len, dentry->d_name.len,
-                       dentry->d_name.name, dentry->d_inode->i_ino,
+                pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
+                       dentry, dentry->d_inode->i_ino,
                        -ret);
                 goto error;
         }
@@ -92,9 +90,8 @@ bad_type_length:
 
 bad_type:
         xtype[2] = 0;
-        pr_err("Cache object %*.*s [%lu] type %s not %s\n",
-               dentry->d_name.len, dentry->d_name.len,
-               dentry->d_name.name, dentry->d_inode->i_ino,
+        pr_err("Cache object %pd [%lu] type %s not %s\n",
+               dentry, dentry->d_inode->i_ino,
                xtype, type);
         ret = -EIO;
         goto error;
diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index 5d5a4c8c8496..1b2355109b9f 100644
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -83,10 +83,9 @@ static int mdsc_show(struct seq_file *s, void *p)
                         if (IS_ERR(path))
                                 path = NULL;
                         spin_lock(&req->r_dentry->d_lock);
-                        seq_printf(s, " #%llx/%.*s (%s)",
+                        seq_printf(s, " #%llx/%pd (%s)",
                                    ceph_ino(req->r_dentry->d_parent->d_inode),
-                                   req->r_dentry->d_name.len,
-                                   req->r_dentry->d_name.name,
+                                   req->r_dentry,
                                    path ? path : "");
                         spin_unlock(&req->r_dentry->d_lock);
                         kfree(path);
@@ -103,11 +102,10 @@ static int mdsc_show(struct seq_file *s, void *p)
                         if (IS_ERR(path))
                                 path = NULL;
                         spin_lock(&req->r_old_dentry->d_lock);
-                        seq_printf(s, " #%llx/%.*s (%s)",
+                        seq_printf(s, " #%llx/%pd (%s)",
                                    req->r_old_dentry_dir ?
                                    ceph_ino(req->r_old_dentry_dir) : 0,
-                                   req->r_old_dentry->d_name.len,
-                                   req->r_old_dentry->d_name.name,
+                                   req->r_old_dentry,
                                    path ? path : "");
                         spin_unlock(&req->r_old_dentry->d_lock);
                         kfree(path);
@@ -150,8 +148,8 @@ static int dentry_lru_show(struct seq_file *s, void *ptr)
         spin_lock(&mdsc->dentry_lru_lock);
         list_for_each_entry(di, &mdsc->dentry_lru, lru) {
                 struct dentry *dentry = di->dentry;
-                seq_printf(s, "%p %p\t%.*s\n",
-                           di, dentry, dentry->d_name.len, dentry->d_name.name);
+                seq_printf(s, "%p %p\t%pd\n",
+                           di, dentry, dentry);
         }
         spin_unlock(&mdsc->dentry_lru_lock);
 
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index e6d63f8f98c0..681a8537b64f 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -111,7 +111,7 @@ static int fpos_cmp(loff_t l, loff_t r)
 /*
  * When possible, we try to satisfy a readdir by peeking at the
  * dcache.  We make this work by carefully ordering dentries on
- * d_u.d_child when we initially get results back from the MDS, and
+ * d_child when we initially get results back from the MDS, and
  * falling back to a "normal" sync readdir if any dentries in the dir
  * are dropped.
  *
@@ -123,7 +123,7 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
                             u32 shared_gen)
 {
         struct ceph_file_info *fi = file->private_data;
-        struct dentry *parent = file->f_dentry;
+        struct dentry *parent = file->f_path.dentry;
         struct inode *dir = parent->d_inode;
         struct list_head *p;
         struct dentry *dentry, *last;
@@ -147,11 +147,11 @@ static int __dcache_readdir(struct file *file,  struct dir_context *ctx,
                 p = parent->d_subdirs.prev;
                 dout(" initial p %p/%p\n", p->prev, p->next);
         } else {
-                p = last->d_u.d_child.prev;
+                p = last->d_child.prev;
         }
 
 more:
-        dentry = list_entry(p, struct dentry, d_u.d_child);
+        dentry = list_entry(p, struct dentry, d_child);
         di = ceph_dentry(dentry);
         while (1) {
                 dout(" p %p/%p %s d_subdirs %p/%p\n", p->prev, p->next,
@@ -168,13 +168,13 @@ more:
                     ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
                     fpos_cmp(ctx->pos, di->offset) <= 0)
                         break;
-                dout(" skipping %p %.*s at %llu (%llu)%s%s\n", dentry,
-                     dentry->d_name.len, dentry->d_name.name, di->offset,
+                dout(" skipping %p %pd at %llu (%llu)%s%s\n", dentry,
+                     dentry, di->offset,
                      ctx->pos, d_unhashed(dentry) ? " unhashed" : "",
                      !dentry->d_inode ? " null" : "");
                 spin_unlock(&dentry->d_lock);
                 p = p->prev;
-                dentry = list_entry(p, struct dentry, d_u.d_child);
+                dentry = list_entry(p, struct dentry, d_child);
                 di = ceph_dentry(dentry);
         }
 
@@ -190,8 +190,8 @@ more:
                 goto out;
         }
 
-        dout(" %llu (%llu) dentry %p %.*s %p\n", di->offset, ctx->pos,
-             dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
+        dout(" %llu (%llu) dentry %p %pd %p\n", di->offset, ctx->pos,
+             dentry, dentry, dentry->d_inode);
         if (!dir_emit(ctx, dentry->d_name.name,
                       dentry->d_name.len,
                       ceph_translate_ino(dentry->d_sb, dentry->d_inode->i_ino),
@@ -274,7 +274,7 @@ static int ceph_readdir(struct file *file, struct dir_context *ctx)
                 off = 1;
         }
         if (ctx->pos == 1) {
-                ino_t ino = parent_ino(file->f_dentry);
+                ino_t ino = parent_ino(file->f_path.dentry);
                 dout("readdir off 1 -> '..'\n");
                 if (!dir_emit(ctx, "..", 2,
                             ceph_translate_ino(inode->i_sb, ino),
@@ -337,7 +337,7 @@ more:
                 }
                 req->r_inode = inode;
                 ihold(inode);
-                req->r_dentry = dget(file->f_dentry);
+                req->r_dentry = dget(file->f_path.dentry);
                 /* hints to request -> mds selection code */
                 req->r_direct_mode = USE_AUTH_MDS;
                 req->r_direct_hash = ceph_frag_value(frag);
@@ -538,8 +538,8 @@ int ceph_handle_snapdir(struct ceph_mds_request *req,
             strcmp(dentry->d_name.name,
                    fsc->mount_options->snapdir_name) == 0) {
                 struct inode *inode = ceph_get_snapdir(parent);
-                dout("ENOENT on snapdir %p '%.*s', linking to snapdir %p\n",
-                     dentry, dentry->d_name.len, dentry->d_name.name, inode);
+                dout("ENOENT on snapdir %p '%pd', linking to snapdir %p\n",
+                     dentry, dentry, inode);
                 BUG_ON(!d_unhashed(dentry));
                 d_add(dentry, inode);
                 err = 0;
@@ -603,8 +603,8 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
         int op;
         int err;
 
-        dout("lookup %p dentry %p '%.*s'\n",
-             dir, dentry, dentry->d_name.len, dentry->d_name.name);
+        dout("lookup %p dentry %p '%pd'\n",
+             dir, dentry, dentry);
 
         if (dentry->d_name.len > NAME_MAX)
                 return ERR_PTR(-ENAMETOOLONG);
@@ -774,8 +774,8 @@ static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         if (ceph_snap(dir) == CEPH_SNAPDIR) {
                 /* mkdir .snap/foo is a MKSNAP */
                 op = CEPH_MDS_OP_MKSNAP;
-                dout("mksnap dir %p snap '%.*s' dn %p\n", dir,
-                     dentry->d_name.len, dentry->d_name.name, dentry);
+                dout("mksnap dir %p snap '%pd' dn %p\n", dir,
+                     dentry, dentry);
         } else if (ceph_snap(dir) == CEPH_NOSNAP) {
                 dout("mkdir dir %p dn %p mode 0%ho\n", dir, dentry, mode);
                 op = CEPH_MDS_OP_MKDIR;
@@ -888,8 +888,7 @@ static int ceph_unlink(struct inode *dir, struct dentry *dentry)
 
         if (ceph_snap(dir) == CEPH_SNAPDIR) {
                 /* rmdir .snap/foo is RMSNAP */
-                dout("rmsnap dir %p '%.*s' dn %p\n", dir, dentry->d_name.len,
-                     dentry->d_name.name, dentry);
+                dout("rmsnap dir %p '%pd' dn %p\n", dir, dentry, dentry);
                 op = CEPH_MDS_OP_RMSNAP;
         } else if (ceph_snap(dir) == CEPH_NOSNAP) {
                 dout("unlink/rmdir dir %p dn %p inode %p\n",
@@ -1063,16 +1062,15 @@ static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags)
         if (flags & LOOKUP_RCU)
                 return -ECHILD;
 
-        dout("d_revalidate %p '%.*s' inode %p offset %lld\n", dentry,
-             dentry->d_name.len, dentry->d_name.name, dentry->d_inode,
-             ceph_dentry(dentry)->offset);
+        dout("d_revalidate %p '%pd' inode %p offset %lld\n", dentry,
+             dentry, dentry->d_inode, 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 '%.*s' inode %p is SNAPPED\n", dentry,
-                     dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
+                dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry,
+                     dentry, dentry->d_inode);
                 valid = 1;
         } else if (dentry->d_inode &&
                    ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) {
@@ -1265,8 +1263,7 @@ void ceph_dentry_lru_add(struct dentry *dn)
         struct ceph_dentry_info *di = ceph_dentry(dn);
         struct ceph_mds_client *mdsc;
 
-        dout("dentry_lru_add %p %p '%.*s'\n", di, dn,
-             dn->d_name.len, dn->d_name.name);
+        dout("dentry_lru_add %p %p '%pd'\n", di, dn, dn);
         mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
         spin_lock(&mdsc->dentry_lru_lock);
         list_add_tail(&di->lru, &mdsc->dentry_lru);
@@ -1279,8 +1276,8 @@ void ceph_dentry_lru_touch(struct dentry *dn)
         struct ceph_dentry_info *di = ceph_dentry(dn);
         struct ceph_mds_client *mdsc;
 
-        dout("dentry_lru_touch %p %p '%.*s' (offset %lld)\n", di, dn,
-             dn->d_name.len, dn->d_name.name, di->offset);
+        dout("dentry_lru_touch %p %p '%pd' (offset %lld)\n", di, dn, dn,
+             di->offset);
         mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
         spin_lock(&mdsc->dentry_lru_lock);
         list_move_tail(&di->lru, &mdsc->dentry_lru);
@@ -1292,8 +1289,7 @@ void ceph_dentry_lru_del(struct dentry *dn)
         struct ceph_dentry_info *di = ceph_dentry(dn);
         struct ceph_mds_client *mdsc;
 
-        dout("dentry_lru_del %p %p '%.*s'\n", di, dn,
-             dn->d_name.len, dn->d_name.name);
+        dout("dentry_lru_del %p %p '%pd'\n", di, dn, dn);
         mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
         spin_lock(&mdsc->dentry_lru_lock);
         list_del_init(&di->lru);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index d7e0da8366e6..9f8e3572040e 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -211,7 +211,7 @@ int ceph_open(struct inode *inode, struct file *file)
 
         req->r_num_caps = 1;
         if (flags & O_CREAT)
-                parent_inode = ceph_get_dentry_parent_inode(file->f_dentry);
+                parent_inode = ceph_get_dentry_parent_inode(file->f_path.dentry);
         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
         iput(parent_inode);
         if (!err)
@@ -238,8 +238,8 @@ int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
         struct ceph_acls_info acls = {};
         int err;
 
-        dout("atomic_open %p dentry %p '%.*s' %s flags %d mode 0%o\n",
-             dir, dentry, dentry->d_name.len, dentry->d_name.name,
+        dout("atomic_open %p dentry %p '%pd' %s flags %d mode 0%o\n",
+             dir, dentry, dentry,
              d_unhashed(dentry) ? "unhashed" : "hashed", flags, mode);
 
         if (dentry->d_name.len > NAME_MAX)
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 7b6139004401..a5593d51d035 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -967,7 +967,7 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
         /* dn must be unhashed */
         if (!d_unhashed(dn))
                 d_drop(dn);
-        realdn = d_materialise_unique(dn, in);
+        realdn = d_splice_alias(in, dn);
         if (IS_ERR(realdn)) {
                 pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
                        PTR_ERR(realdn), dn, in, ceph_vinop(in));
@@ -1186,20 +1186,18 @@ retry_lookup:
                         struct inode *olddir = req->r_old_dentry_dir;
                         BUG_ON(!olddir);
 
-                        dout(" src %p '%.*s' dst %p '%.*s'\n",
+                        dout(" src %p '%pd' dst %p '%pd'\n",
                              req->r_old_dentry,
-                             req->r_old_dentry->d_name.len,
-                             req->r_old_dentry->d_name.name,
-                             dn, dn->d_name.len, dn->d_name.name);
+                             req->r_old_dentry,
+                             dn, dn);
                         dout("fill_trace doing d_move %p -> %p\n",
                              req->r_old_dentry, dn);
 
                         d_move(req->r_old_dentry, dn);
-                        dout(" src %p '%.*s' dst %p '%.*s'\n",
+                        dout(" src %p '%pd' dst %p '%pd'\n",
+                             req->r_old_dentry,
                              req->r_old_dentry,
-                             req->r_old_dentry->d_name.len,
-                             req->r_old_dentry->d_name.name,
-                             dn, dn->d_name.len, dn->d_name.name);
+                             dn, dn);
 
                         /* ensure target dentry is invalidated, despite
                            rehashing bug in vfs_rename_dir */
@@ -1399,7 +1397,7 @@ retry_lookup:
                         /* reorder parent's d_subdirs */
                         spin_lock(&parent->d_lock);
                         spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
-                        list_move(&dn->d_u.d_child, &parent->d_subdirs);
+                        list_move(&dn->d_child, &parent->d_subdirs);
                         spin_unlock(&dn->d_lock);
                         spin_unlock(&parent->d_lock);
                 }
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 9d7996e8e793..d72fe37f5420 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -209,8 +209,7 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 
 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 {
-        struct super_block *sb = file->f_path.dentry->d_sb;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
+        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
         struct TCP_Server_Info *server = tcon->ses->server;
 
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 02a33e529904..6e139111fdb2 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -1168,6 +1168,12 @@ CIFS_SB(struct super_block *sb)
         return sb->s_fs_info;
 }
 
+static inline struct cifs_sb_info *
+CIFS_FILE_SB(struct file *file)
+{
+        return CIFS_SB(file_inode(file)->i_sb);
+}
+
 static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb)
 {
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 3e4d00a06c44..d535e168a9d3 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1586,7 +1586,7 @@ int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
                         tcon->ses->server);
 
-        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        cifs_sb = CIFS_FILE_SB(file);
         netfid = cfile->fid.netfid;
         cinode = CIFS_I(file_inode(file));
 
@@ -2305,7 +2305,7 @@ int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
         struct cifs_tcon *tcon;
         struct TCP_Server_Info *server;
         struct cifsFileInfo *smbfile = file->private_data;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
         struct inode *inode = file->f_mapping->host;
 
         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
@@ -2585,7 +2585,7 @@ cifs_iovec_write(struct file *file, struct iov_iter *from, loff_t *poffset)
         iov_iter_truncate(from, len);
 
         INIT_LIST_HEAD(&wdata_list);
-        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        cifs_sb = CIFS_FILE_SB(file);
         open_file = file->private_data;
         tcon = tlink_tcon(open_file->tlink);
 
@@ -3010,7 +3010,7 @@ ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
                 return 0;
 
         INIT_LIST_HEAD(&rdata_list);
-        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        cifs_sb = CIFS_FILE_SB(file);
         open_file = file->private_data;
         tcon = tlink_tcon(open_file->tlink);
 
@@ -3155,7 +3155,7 @@ cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
         __u32 pid;
 
         xid = get_xid();
-        cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        cifs_sb = CIFS_FILE_SB(file);
 
         /* FIXME: set up handlers for larger reads and/or convert to async */
         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
@@ -3462,7 +3462,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
         int rc;
         struct list_head tmplist;
         struct cifsFileInfo *open_file = file->private_data;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
         struct TCP_Server_Info *server;
         pid_t pid;
 
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 197cb503d528..0c3ce464cae4 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -895,7 +895,7 @@ inode_has_hashed_dentries(struct inode *inode)
         struct dentry *dentry;
 
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
                         spin_unlock(&inode->i_lock);
                         return true;
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 803030c9ab68..8eaf20a80649 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -123,7 +123,7 @@ cifs_prime_dcache(struct dentry *parent, struct qstr *name,
         if (!inode)
                 goto out;
 
-        alias = d_materialise_unique(dentry, inode);
+        alias = d_splice_alias(inode, dentry);
         if (alias && !IS_ERR(alias))
                 dput(alias);
 out:
@@ -261,7 +261,7 @@ initiate_cifs_search(const unsigned int xid, struct file *file)
         int rc = 0;
         char *full_path = NULL;
         struct cifsFileInfo *cifsFile;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
         struct tcon_link *tlink = NULL;
         struct cifs_tcon *tcon;
         struct TCP_Server_Info *server;
@@ -561,7 +561,7 @@ find_cifs_entry(const unsigned int xid, struct cifs_tcon *tcon, loff_t pos,
         loff_t first_entry_in_buffer;
         loff_t index_to_find = pos;
         struct cifsFileInfo *cfile = file->private_data;
-        struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
+        struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
         struct TCP_Server_Info *server = tcon->ses->server;
         /* check if index in the buffer */
 
@@ -679,7 +679,7 @@ static int cifs_filldir(char *find_entry, struct file *file,
                 char *scratch_buf, unsigned int max_len)
 {
         struct cifsFileInfo *file_info = file->private_data;
-        struct super_block *sb = file->f_path.dentry->d_sb;
+        struct super_block *sb = file_inode(file)->i_sb;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         struct cifs_dirent de = { NULL, };
         struct cifs_fattr fattr;
@@ -753,7 +753,7 @@ static int cifs_filldir(char *find_entry, struct file *file,
                  */
                 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
 
-        cifs_prime_dcache(file->f_dentry, &name, &fattr);
+        cifs_prime_dcache(file->f_path.dentry, &name, &fattr);
 
         ino = cifs_uniqueid_to_ino_t(fattr.cf_uniqueid);
         return !dir_emit(ctx, name.name, name.len, ino, fattr.cf_dtype);
diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 278f8fdeb9ef..46ee6f238985 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -92,7 +92,7 @@ static void coda_flag_children(struct dentry *parent, int flag)
         struct dentry *de;
 
         spin_lock(&parent->d_lock);
-        list_for_each_entry(de, &parent->d_subdirs, d_u.d_child) {
+        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);
diff --git a/fs/coda/coda_linux.c b/fs/coda/coda_linux.c
index 1326d38960db..f1714cfb589c 100644
--- a/fs/coda/coda_linux.c
+++ b/fs/coda/coda_linux.c
@@ -40,12 +40,6 @@ int coda_iscontrol(const char *name, size_t length)
                 (strncmp(name, CODA_CONTROL, CODA_CONTROLLEN) == 0));
 }
 
-/* recognize /coda inode */
-int coda_isroot(struct inode *i)
-{
-    return ( i->i_sb->s_root->d_inode == i );
-}
-
 unsigned short coda_flags_to_cflags(unsigned short flags)
 {
         unsigned short coda_flags = 0;
diff --git a/fs/coda/coda_linux.h b/fs/coda/coda_linux.h
index d42b725b1d21..d6f7a76a1f5b 100644
--- a/fs/coda/coda_linux.h
+++ b/fs/coda/coda_linux.h
@@ -52,7 +52,6 @@ int coda_setattr(struct dentry *, struct iattr *);
 
 /* this file:  heloers */
 char *coda_f2s(struct CodaFid *f);
-int coda_isroot(struct inode *i);
 int coda_iscontrol(const char *name, size_t length);
 
 void coda_vattr_to_iattr(struct inode *, struct coda_vattr *);
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 9c3dedc000d1..7ff025966e4f 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -107,7 +107,7 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsig
         }
 
         /* control object, create inode on the fly */
-        if (coda_isroot(dir) && coda_iscontrol(name, length)) {
+        if (is_root_inode(dir) && coda_iscontrol(name, length)) {
                 inode = coda_cnode_makectl(sb);
                 type = CODA_NOCACHE;
         } else {
@@ -195,7 +195,7 @@ static int coda_create(struct inode *dir, struct dentry *de, umode_t mode, bool
         struct CodaFid newfid;
         struct coda_vattr attrs;
 
-        if (coda_isroot(dir) && coda_iscontrol(name, length))
+        if (is_root_inode(dir) && coda_iscontrol(name, length))
                 return -EPERM;
 
         error = venus_create(dir->i_sb, coda_i2f(dir), name, length, 
@@ -227,7 +227,7 @@ static int coda_mkdir(struct inode *dir, struct dentry *de, umode_t mode)
         int error;
         struct CodaFid newfid;
 
-        if (coda_isroot(dir) && coda_iscontrol(name, len))
+        if (is_root_inode(dir) && coda_iscontrol(name, len))
                 return -EPERM;
 
         attrs.va_mode = mode;
@@ -261,7 +261,7 @@ static int coda_link(struct dentry *source_de, struct inode *dir_inode,
         int len = de->d_name.len;
         int error;
 
-        if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
+        if (is_root_inode(dir_inode) && coda_iscontrol(name, len))
                 return -EPERM;
 
         error = venus_link(dir_inode->i_sb, coda_i2f(inode),
@@ -287,7 +287,7 @@ static int coda_symlink(struct inode *dir_inode, struct dentry *de,
         int symlen;
         int error;
 
-        if (coda_isroot(dir_inode) && coda_iscontrol(name, len))
+        if (is_root_inode(dir_inode) && coda_iscontrol(name, len))
                 return -EPERM;
 
         symlen = strlen(symname);
@@ -507,7 +507,7 @@ static int coda_dentry_revalidate(struct dentry *de, unsigned int flags)
                 return -ECHILD;
 
         inode = de->d_inode;
-        if (!inode || coda_isroot(inode))
+        if (!inode || is_root_inode(inode))
                 goto out;
         if (is_bad_inode(inode))
                 goto bad;
diff --git a/fs/compat.c b/fs/compat.c
index b13df99f3534..6fd272d455e4 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -847,10 +847,12 @@ struct compat_readdir_callback {
         int result;
 };
 
-static int compat_fillonedir(void *__buf, const char *name, int namlen,
-                        loff_t offset, u64 ino, unsigned int d_type)
+static int compat_fillonedir(struct dir_context *ctx, const char *name,
+                             int namlen, loff_t offset, u64 ino,
+                             unsigned int d_type)
 {
-        struct compat_readdir_callback *buf = __buf;
+        struct compat_readdir_callback *buf =
+                container_of(ctx, struct compat_readdir_callback, ctx);
         struct compat_old_linux_dirent __user *dirent;
         compat_ulong_t d_ino;
 
@@ -915,11 +917,12 @@ struct compat_getdents_callback {
         int error;
 };
 
-static int compat_filldir(void *__buf, const char *name, int namlen,
+static int compat_filldir(struct dir_context *ctx, const char *name, int namlen,
                 loff_t offset, u64 ino, unsigned int d_type)
 {
         struct compat_linux_dirent __user * dirent;
-        struct compat_getdents_callback *buf = __buf;
+        struct compat_getdents_callback *buf =
+                container_of(ctx, struct compat_getdents_callback, ctx);
         compat_ulong_t d_ino;
         int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
                 namlen + 2, sizeof(compat_long_t));
@@ -1001,11 +1004,13 @@ struct compat_getdents_callback64 {
         int error;
 };
 
-static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
-                     u64 ino, unsigned int d_type)
+static int compat_filldir64(struct dir_context *ctx, const char *name,
+                            int namlen, loff_t offset, u64 ino,
+                            unsigned int d_type)
 {
         struct linux_dirent64 __user *dirent;
-        struct compat_getdents_callback64 *buf = __buf;
+        struct compat_getdents_callback64 *buf =
+                container_of(ctx, struct compat_getdents_callback64, ctx);
         int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
                 sizeof(u64));
         u64 off;
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 668dcabc5695..c9c298bd3058 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -386,7 +386,7 @@ static void remove_dir(struct dentry * d)
         if (d->d_inode)
                 simple_rmdir(parent->d_inode,d);
 
-        pr_debug(" o %s removing done (%d)\n",d->d_name.name, d_count(d));
+        pr_debug(" o %pd removing done (%d)\n", d, d_count(d));
 
         dput(parent);
 }
diff --git a/fs/dcache.c b/fs/dcache.c
index 5bc72b07fde2..e368d4f412f9 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -44,7 +44,7 @@
 /*
  * Usage:
  * dcache->d_inode->i_lock protects:
- *   - i_dentry, d_alias, d_inode of aliases
+ *   - i_dentry, d_u.d_alias, d_inode of aliases
  * dcache_hash_bucket lock protects:
  *   - the dcache hash table
  * s_anon bl list spinlock protects:
@@ -59,7 +59,7 @@
  *   - d_unhashed()
  *   - d_parent and d_subdirs
  *   - childrens' d_child and d_parent
- *   - d_alias, d_inode
+ *   - d_u.d_alias, d_inode
  *
  * Ordering:
  * dentry->d_inode->i_lock
@@ -252,14 +252,12 @@ static void __d_free(struct rcu_head *head)
 {
         struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
 
-        WARN_ON(!hlist_unhashed(&dentry->d_alias));
         kmem_cache_free(dentry_cache, dentry); 
 }
 
 static void __d_free_external(struct rcu_head *head)
 {
         struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
-        WARN_ON(!hlist_unhashed(&dentry->d_alias));
         kfree(external_name(dentry));
         kmem_cache_free(dentry_cache, dentry); 
 }
@@ -271,6 +269,7 @@ static inline int dname_external(const struct dentry *dentry)
 
 static void dentry_free(struct dentry *dentry)
 {
+        WARN_ON(!hlist_unhashed(&dentry->d_u.d_alias));
         if (unlikely(dname_external(dentry))) {
                 struct external_name *p = external_name(dentry);
                 if (likely(atomic_dec_and_test(&p->u.count))) {
@@ -311,7 +310,7 @@ static void dentry_iput(struct dentry * dentry)
         struct inode *inode = dentry->d_inode;
         if (inode) {
                 dentry->d_inode = NULL;
-                hlist_del_init(&dentry->d_alias);
+                hlist_del_init(&dentry->d_u.d_alias);
                 spin_unlock(&dentry->d_lock);
                 spin_unlock(&inode->i_lock);
                 if (!inode->i_nlink)
@@ -336,7 +335,7 @@ static void dentry_unlink_inode(struct dentry * dentry)
         struct inode *inode = dentry->d_inode;
         __d_clear_type(dentry);
         dentry->d_inode = NULL;
-        hlist_del_init(&dentry->d_alias);
+        hlist_del_init(&dentry->d_u.d_alias);
         dentry_rcuwalk_barrier(dentry);
         spin_unlock(&dentry->d_lock);
         spin_unlock(&inode->i_lock);
@@ -496,7 +495,7 @@ static void __dentry_kill(struct dentry *dentry)
         }
         /* if it was on the hash then remove it */
         __d_drop(dentry);
-        list_del(&dentry->d_u.d_child);
+        __list_del_entry(&dentry->d_child);
         /*
          * Inform d_walk() that we are no longer attached to the
          * dentry tree
@@ -722,7 +721,7 @@ static struct dentry *__d_find_alias(struct inode *inode)
 
 again:
         discon_alias = NULL;
-        hlist_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
                 spin_lock(&alias->d_lock);
                 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
                         if (IS_ROOT(alias) &&
@@ -772,7 +771,7 @@ void d_prune_aliases(struct inode *inode)
         struct dentry *dentry;
 restart:
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
                 spin_lock(&dentry->d_lock);
                 if (!dentry->d_lockref.count) {
                         struct dentry *parent = lock_parent(dentry);
@@ -1051,7 +1050,7 @@ repeat:
 resume:
         while (next != &this_parent->d_subdirs) {
                 struct list_head *tmp = next;
-                struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
+                struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
                 next = tmp->next;
 
                 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@@ -1083,33 +1082,31 @@ resume:
         /*
          * All done at this level ... ascend and resume the search.
          */
+        rcu_read_lock();
+ascend:
         if (this_parent != parent) {
                 struct dentry *child = this_parent;
                 this_parent = child->d_parent;
 
-                rcu_read_lock();
                 spin_unlock(&child->d_lock);
                 spin_lock(&this_parent->d_lock);
 
-                /*
-                 * might go back up the wrong parent if we have had a rename
-                 * or deletion
-                 */
-                if (this_parent != child->d_parent ||
-                         (child->d_flags & DCACHE_DENTRY_KILLED) ||
-                         need_seqretry(&rename_lock, seq)) {
-                        spin_unlock(&this_parent->d_lock);
-                        rcu_read_unlock();
+                /* might go back up the wrong parent if we have had a rename. */
+                if (need_seqretry(&rename_lock, seq))
                         goto rename_retry;
+                next = child->d_child.next;
+                while (unlikely(child->d_flags & DCACHE_DENTRY_KILLED)) {
+                        if (next == &this_parent->d_subdirs)
+                                goto ascend;
+                        child = list_entry(next, struct dentry, d_child);
+                        next = next->next;
                 }
                 rcu_read_unlock();
-                next = child->d_u.d_child.next;
                 goto resume;
         }
-        if (need_seqretry(&rename_lock, seq)) {
-                spin_unlock(&this_parent->d_lock);
+        if (need_seqretry(&rename_lock, seq))
                 goto rename_retry;
-        }
+        rcu_read_unlock();
         if (finish)
                 finish(data);
 
@@ -1119,6 +1116,9 @@ out_unlock:
         return;
 
 rename_retry:
+        spin_unlock(&this_parent->d_lock);
+        rcu_read_unlock();
+        BUG_ON(seq & 1);
         if (!retry)
                 return;
         seq = 1;
@@ -1455,8 +1455,8 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
         INIT_HLIST_BL_NODE(&dentry->d_hash);
         INIT_LIST_HEAD(&dentry->d_lru);
         INIT_LIST_HEAD(&dentry->d_subdirs);
-        INIT_HLIST_NODE(&dentry->d_alias);
-        INIT_LIST_HEAD(&dentry->d_u.d_child);
+        INIT_HLIST_NODE(&dentry->d_u.d_alias);
+        INIT_LIST_HEAD(&dentry->d_child);
         d_set_d_op(dentry, dentry->d_sb->s_d_op);
 
         this_cpu_inc(nr_dentry);
@@ -1486,7 +1486,7 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
          */
         __dget_dlock(parent);
         dentry->d_parent = parent;
-        list_add(&dentry->d_u.d_child, &parent->d_subdirs);
+        list_add(&dentry->d_child, &parent->d_subdirs);
         spin_unlock(&parent->d_lock);
 
         return dentry;
@@ -1579,7 +1579,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
         spin_lock(&dentry->d_lock);
         __d_set_type(dentry, add_flags);
         if (inode)
-                hlist_add_head(&dentry->d_alias, &inode->i_dentry);
+                hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
         dentry->d_inode = inode;
         dentry_rcuwalk_barrier(dentry);
         spin_unlock(&dentry->d_lock);
@@ -1603,7 +1603,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
  
 void d_instantiate(struct dentry *entry, struct inode * inode)
 {
-        BUG_ON(!hlist_unhashed(&entry->d_alias));
+        BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
         if (inode)
                 spin_lock(&inode->i_lock);
         __d_instantiate(entry, inode);
@@ -1642,7 +1642,7 @@ static struct dentry *__d_instantiate_unique(struct dentry *entry,
                 return NULL;
         }
 
-        hlist_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
                 /*
                  * Don't need alias->d_lock here, because aliases with
                  * d_parent == entry->d_parent are not subject to name or
@@ -1668,7 +1668,7 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
 {
         struct dentry *result;
 
-        BUG_ON(!hlist_unhashed(&entry->d_alias));
+        BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
 
         if (inode)
                 spin_lock(&inode->i_lock);
@@ -1699,7 +1699,7 @@ EXPORT_SYMBOL(d_instantiate_unique);
  */
 int d_instantiate_no_diralias(struct dentry *entry, struct inode *inode)
 {
-        BUG_ON(!hlist_unhashed(&entry->d_alias));
+        BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
 
         spin_lock(&inode->i_lock);
         if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry)) {
@@ -1738,7 +1738,7 @@ static struct dentry * __d_find_any_alias(struct inode *inode)
 
         if (hlist_empty(&inode->i_dentry))
                 return NULL;
-        alias = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+        alias = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
         __dget(alias);
         return alias;
 }
@@ -1800,7 +1800,7 @@ static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
         spin_lock(&tmp->d_lock);
         tmp->d_inode = inode;
         tmp->d_flags |= add_flags;
-        hlist_add_head(&tmp->d_alias, &inode->i_dentry);
+        hlist_add_head(&tmp->d_u.d_alias, &inode->i_dentry);
         hlist_bl_lock(&tmp->d_sb->s_anon);
         hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);
         hlist_bl_unlock(&tmp->d_sb->s_anon);
@@ -1889,51 +1889,19 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
          * if not go ahead and create it now.
          */
         found = d_hash_and_lookup(dentry->d_parent, name);
-        if (unlikely(IS_ERR(found)))
-                goto err_out;
         if (!found) {
                 new = d_alloc(dentry->d_parent, name);
                 if (!new) {
                         found = ERR_PTR(-ENOMEM);
-                        goto err_out;
-                }
-
-                found = d_splice_alias(inode, new);
-                if (found) {
-                        dput(new);
-                        return found;
-                }
-                return new;
-        }
-
-        /*
-         * If a matching dentry exists, and it's not negative use it.
-         *
-         * Decrement the reference count to balance the iget() done
-         * earlier on.
-         */
-        if (found->d_inode) {
-                if (unlikely(found->d_inode != inode)) {
-                        /* This can't happen because bad inodes are unhashed. */
-                        BUG_ON(!is_bad_inode(inode));
-                        BUG_ON(!is_bad_inode(found->d_inode));
+                } else {
+                        found = d_splice_alias(inode, new);
+                        if (found) {
+                                dput(new);
+                                return found;
+                        }
+                        return new;
                 }
-                iput(inode);
-                return found;
         }
-
-        /*
-         * Negative dentry: instantiate it unless the inode is a directory and
-         * already has a dentry.
-         */
-        new = d_splice_alias(inode, found);
-        if (new) {
-                dput(found);
-                found = new;
-        }
-        return found;
-
-err_out:
         iput(inode);
         return found;
 }
@@ -2235,7 +2203,7 @@ int d_validate(struct dentry *dentry, struct dentry *dparent)
         struct dentry *child;
 
         spin_lock(&dparent->d_lock);
-        list_for_each_entry(child, &dparent->d_subdirs, d_u.d_child) {
+        list_for_each_entry(child, &dparent->d_subdirs, d_child) {
                 if (dentry == child) {
                         spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
                         __dget_dlock(dentry);
@@ -2393,6 +2361,8 @@ static void swap_names(struct dentry *dentry, struct dentry *target)
                          */
                         unsigned int i;
                         BUILD_BUG_ON(!IS_ALIGNED(DNAME_INLINE_LEN, sizeof(long)));
+                        kmemcheck_mark_initialized(dentry->d_iname, DNAME_INLINE_LEN);
+                        kmemcheck_mark_initialized(target->d_iname, DNAME_INLINE_LEN);
                         for (i = 0; i < DNAME_INLINE_LEN / sizeof(long); i++) {
                                 swap(((long *) &dentry->d_iname)[i],
                                      ((long *) &target->d_iname)[i]);
@@ -2526,13 +2496,13 @@ static void __d_move(struct dentry *dentry, struct dentry *target,
                 /* splicing a tree */
                 dentry->d_parent = target->d_parent;
                 target->d_parent = target;
-                list_del_init(&target->d_u.d_child);
-                list_move(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
+                list_del_init(&target->d_child);
+                list_move(&dentry->d_child, &dentry->d_parent->d_subdirs);
         } else {
                 /* swapping two dentries */
                 swap(dentry->d_parent, target->d_parent);
-                list_move(&target->d_u.d_child, &target->d_parent->d_subdirs);
-                list_move(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
+                list_move(&target->d_child, &target->d_parent->d_subdirs);
+                list_move(&dentry->d_child, &dentry->d_parent->d_subdirs);
                 if (exchange)
                         fsnotify_d_move(target);
                 fsnotify_d_move(dentry);
@@ -2608,11 +2578,11 @@ struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2)
  * Note: If ever the locking in lock_rename() changes, then please
  * remember to update this too...
  */
-static struct dentry *__d_unalias(struct inode *inode,
+static int __d_unalias(struct inode *inode,
                 struct dentry *dentry, struct dentry *alias)
 {
         struct mutex *m1 = NULL, *m2 = NULL;
-        struct dentry *ret = ERR_PTR(-EBUSY);
+        int ret = -EBUSY;
 
         /* If alias and dentry share a parent, then no extra locks required */
         if (alias->d_parent == dentry->d_parent)
@@ -2627,7 +2597,7 @@ static struct dentry *__d_unalias(struct inode *inode,
         m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
         __d_move(alias, dentry, false);
-        ret = alias;
+        ret = 0;
 out_err:
         spin_unlock(&inode->i_lock);
         if (m2)
@@ -2662,130 +2632,57 @@ out_err:
  */
 struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 {
-        struct dentry *new = NULL;
-
         if (IS_ERR(inode))
                 return ERR_CAST(inode);
 
-        if (inode && S_ISDIR(inode->i_mode)) {
-                spin_lock(&inode->i_lock);
-                new = __d_find_any_alias(inode);
-                if (new) {
-                        if (!IS_ROOT(new)) {
-                                spin_unlock(&inode->i_lock);
-                                dput(new);
-                                iput(inode);
-                                return ERR_PTR(-EIO);
-                        }
-                        if (d_ancestor(new, dentry)) {
-                                spin_unlock(&inode->i_lock);
-                                dput(new);
-                                iput(inode);
-                                return ERR_PTR(-EIO);
-                        }
-                        write_seqlock(&rename_lock);
-                        __d_move(new, dentry, false);
-                        write_sequnlock(&rename_lock);
-                        spin_unlock(&inode->i_lock);
-                        security_d_instantiate(new, inode);
-                        iput(inode);
-                } else {
-                        /* already taking inode->i_lock, so d_add() by hand */
-                        __d_instantiate(dentry, inode);
-                        spin_unlock(&inode->i_lock);
-                        security_d_instantiate(dentry, inode);
-                        d_rehash(dentry);
-                }
-        } else {
-                d_instantiate(dentry, inode);
-                if (d_unhashed(dentry))
-                        d_rehash(dentry);
-        }
-        return new;
-}
-EXPORT_SYMBOL(d_splice_alias);
-
-/**
- * d_materialise_unique - introduce an inode into the tree
- * @dentry: candidate dentry
- * @inode: inode to bind to the dentry, to which aliases may be attached
- *
- * Introduces an dentry into the tree, substituting an extant disconnected
- * root directory alias in its place if there is one. Caller must hold the
- * i_mutex of the parent directory.
- */
-struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
-{
-        struct dentry *actual;
-
         BUG_ON(!d_unhashed(dentry));
 
         if (!inode) {
-                actual = dentry;
                 __d_instantiate(dentry, NULL);
-                d_rehash(actual);
-                goto out_nolock;
+                goto out;
         }
-
         spin_lock(&inode->i_lock);
-
         if (S_ISDIR(inode->i_mode)) {
-                struct dentry *alias;
-
-                /* Does an aliased dentry already exist? */
-                alias = __d_find_alias(inode);
-                if (alias) {
-                        actual = alias;
+                struct dentry *new = __d_find_any_alias(inode);
+                if (unlikely(new)) {
                         write_seqlock(&rename_lock);
-
-                        if (d_ancestor(alias, dentry)) {
-                                /* Check for loops */
-                                actual = ERR_PTR(-ELOOP);
+                        if (unlikely(d_ancestor(new, dentry))) {
+                                write_sequnlock(&rename_lock);
                                 spin_unlock(&inode->i_lock);
-                        } else if (IS_ROOT(alias)) {
-                                /* Is this an anonymous mountpoint that we
-                                 * could splice into our tree? */
-                                __d_move(alias, dentry, false);
+                                dput(new);
+                                new = ERR_PTR(-ELOOP);
+                                pr_warn_ratelimited(
+                                        "VFS: Lookup of '%s' in %s %s"
+                                        " would have caused loop\n",
+                                        dentry->d_name.name,
+                                        inode->i_sb->s_type->name,
+                                        inode->i_sb->s_id);
+                        } else if (!IS_ROOT(new)) {
+                                int err = __d_unalias(inode, dentry, new);
                                 write_sequnlock(&rename_lock);
-                                goto found;
+                                if (err) {
+                                        dput(new);
+                                        new = ERR_PTR(err);
+                                }
                         } else {
-                                /* Nope, but we must(!) avoid directory
-                                 * aliasing. This drops inode->i_lock */
-                                actual = __d_unalias(inode, dentry, alias);
-                        }
-                        write_sequnlock(&rename_lock);
-                        if (IS_ERR(actual)) {
-                                if (PTR_ERR(actual) == -ELOOP)
-                                        pr_warn_ratelimited(
-                                                "VFS: Lookup of '%s' in %s %s"
-                                                " would have caused loop\n",
-                                                dentry->d_name.name,
-                                                inode->i_sb->s_type->name,
-                                                inode->i_sb->s_id);
-                                dput(alias);
+                                __d_move(new, dentry, false);
+                                write_sequnlock(&rename_lock);
+                                spin_unlock(&inode->i_lock);
+                                security_d_instantiate(new, inode);
                         }
-                        goto out_nolock;
+                        iput(inode);
+                        return new;
                 }
         }
-
-        /* Add a unique reference */
-        actual = __d_instantiate_unique(dentry, inode);
-        if (!actual)
-                actual = dentry;
-
-        d_rehash(actual);
-found:
+        /* already taking inode->i_lock, so d_add() by hand */
+        __d_instantiate(dentry, inode);
         spin_unlock(&inode->i_lock);
-out_nolock:
-        if (actual == dentry) {
-                security_d_instantiate(dentry, inode);
-                return NULL;
-        }
-
-        iput(inode);
-        return actual;
+out:
+        security_d_instantiate(dentry, inode);
+        d_rehash(dentry);
+        return NULL;
 }
-EXPORT_SYMBOL_GPL(d_materialise_unique);
+EXPORT_SYMBOL(d_splice_alias);
 
 static int prepend(char **buffer, int *buflen, const char *str, int namelen)
 {
@@ -3321,7 +3218,7 @@ void d_tmpfile(struct dentry *dentry, struct inode *inode)
 {
         inode_dec_link_count(inode);
         BUG_ON(dentry->d_name.name != dentry->d_iname ||
-                !hlist_unhashed(&dentry->d_alias) ||
+                !hlist_unhashed(&dentry->d_u.d_alias) ||
                 !d_unlinked(dentry));
         spin_lock(&dentry->d_parent->d_lock);
         spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index 76c08c2beb2f..8e0f2f410189 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -692,18 +692,19 @@ EXPORT_SYMBOL_GPL(debugfs_create_u32_array);
  * because some peripherals have several blocks of identical registers,
  * for example configuration of dma channels
  */
-int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
-                           int nregs, void __iomem *base, char *prefix)
+void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+                          int nregs, void __iomem *base, char *prefix)
 {
-        int i, ret = 0;
+        int i;
 
         for (i = 0; i < nregs; i++, regs++) {
                 if (prefix)
-                        ret += seq_printf(s, "%s", prefix);
-                ret += seq_printf(s, "%s = 0x%08x\n", regs->name,
-                                  readl(base + regs->offset));
+                        seq_printf(s, "%s", prefix);
+                seq_printf(s, "%s = 0x%08x\n", regs->name,
+                           readl(base + regs->offset));
+                if (seq_has_overflowed(s))
+                        break;
         }
-        return ret;
 }
 EXPORT_SYMBOL_GPL(debugfs_print_regs32);
 
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 1e3b99d3db0d..05f2960ed7c3 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -553,7 +553,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
          * use the d_u.d_child as the rcu head and corrupt this list.
          */
         spin_lock(&parent->d_lock);
-        list_for_each_entry(child, &parent->d_subdirs, d_u.d_child) {
+        list_for_each_entry(child, &parent->d_subdirs, d_child) {
                 if (!debugfs_positive(child))
                         continue;
 
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index 1323c568e362..eea64912c9c0 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -48,8 +48,8 @@ static char *print_lockmode(int mode)
         }
 }
 
-static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
-                              struct dlm_rsb *res)
+static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *res)
 {
         seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
 
@@ -68,21 +68,17 @@ static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
         if (lkb->lkb_wait_type)
                 seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
 
-        return seq_puts(s, "\n");
+        seq_puts(s, "\n");
 }
 
-static int print_format1(struct dlm_rsb *res, struct seq_file *s)
+static void print_format1(struct dlm_rsb *res, struct seq_file *s)
 {
         struct dlm_lkb *lkb;
         int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
-        int rv;
 
         lock_rsb(res);
 
-        rv = seq_printf(s, "\nResource %p Name (len=%d) \"",
-                        res, res->res_length);
-        if (rv)
-                goto out;
+        seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
 
         for (i = 0; i < res->res_length; i++) {
                 if (isprint(res->res_name[i]))
@@ -92,17 +88,16 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
         }
 
         if (res->res_nodeid > 0)
-                rv = seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
-                                res->res_nodeid);
+                seq_printf(s, "\"\nLocal Copy, Master is node %d\n",
+                           res->res_nodeid);
         else if (res->res_nodeid == 0)
-                rv = seq_puts(s, "\"\nMaster Copy\n");
+                seq_puts(s, "\"\nMaster Copy\n");
         else if (res->res_nodeid == -1)
-                rv = seq_printf(s, "\"\nLooking up master (lkid %x)\n",
-                                res->res_first_lkid);
+                seq_printf(s, "\"\nLooking up master (lkid %x)\n",
+                           res->res_first_lkid);
         else
-                rv = seq_printf(s, "\"\nInvalid master %d\n",
-                                res->res_nodeid);
-        if (rv)
+                seq_printf(s, "\"\nInvalid master %d\n", res->res_nodeid);
+        if (seq_has_overflowed(s))
                 goto out;
 
         /* Print the LVB: */
@@ -116,8 +111,8 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
                 }
                 if (rsb_flag(res, RSB_VALNOTVALID))
                         seq_puts(s, " (INVALID)");
-                rv = seq_puts(s, "\n");
-                if (rv)
+                seq_puts(s, "\n");
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
@@ -125,32 +120,30 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
         recover_list = !list_empty(&res->res_recover_list);
 
         if (root_list || recover_list) {
-                rv = seq_printf(s, "Recovery: root %d recover %d flags %lx "
-                                "count %d\n", root_list, recover_list,
-                                res->res_flags, res->res_recover_locks_count);
-                if (rv)
-                        goto out;
+                seq_printf(s, "Recovery: root %d recover %d flags %lx count %d\n",
+                           root_list, recover_list,
+                           res->res_flags, res->res_recover_locks_count);
         }
 
         /* Print the locks attached to this resource */
         seq_puts(s, "Granted Queue\n");
         list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         seq_puts(s, "Conversion Queue\n");
         list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         seq_puts(s, "Waiting Queue\n");
         list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) {
-                rv = print_format1_lock(s, lkb, res);
-                if (rv)
+                print_format1_lock(s, lkb, res);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
@@ -159,23 +152,23 @@ static int print_format1(struct dlm_rsb *res, struct seq_file *s)
 
         seq_puts(s, "Lookup Queue\n");
         list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
-                rv = seq_printf(s, "%08x %s", lkb->lkb_id,
-                                print_lockmode(lkb->lkb_rqmode));
+                seq_printf(s, "%08x %s",
+                           lkb->lkb_id, print_lockmode(lkb->lkb_rqmode));
                 if (lkb->lkb_wait_type)
                         seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
-                rv = seq_puts(s, "\n");
+                seq_puts(s, "\n");
+                if (seq_has_overflowed(s))
+                        goto out;
         }
  out:
         unlock_rsb(res);
-        return rv;
 }
 
-static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
-                              struct dlm_rsb *r)
+static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *r)
 {
         u64 xid = 0;
         u64 us;
-        int rv;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 if (lkb->lkb_ua)
@@ -188,103 +181,97 @@ static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
         /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us
            r_nodeid r_len r_name */
 
-        rv = seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
-                        lkb->lkb_id,
-                        lkb->lkb_nodeid,
-                        lkb->lkb_remid,
-                        lkb->lkb_ownpid,
-                        (unsigned long long)xid,
-                        lkb->lkb_exflags,
-                        lkb->lkb_flags,
-                        lkb->lkb_status,
-                        lkb->lkb_grmode,
-                        lkb->lkb_rqmode,
-                        (unsigned long long)us,
-                        r->res_nodeid,
-                        r->res_length,
-                        r->res_name);
-        return rv;
+        seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
+                   lkb->lkb_id,
+                   lkb->lkb_nodeid,
+                   lkb->lkb_remid,
+                   lkb->lkb_ownpid,
+                   (unsigned long long)xid,
+                   lkb->lkb_exflags,
+                   lkb->lkb_flags,
+                   lkb->lkb_status,
+                   lkb->lkb_grmode,
+                   lkb->lkb_rqmode,
+                   (unsigned long long)us,
+                   r->res_nodeid,
+                   r->res_length,
+                   r->res_name);
 }
 
-static int print_format2(struct dlm_rsb *r, struct seq_file *s)
+static void print_format2(struct dlm_rsb *r, struct seq_file *s)
 {
         struct dlm_lkb *lkb;
-        int rv = 0;
 
         lock_rsb(r);
 
         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
-                rv = print_format2_lock(s, lkb, r);
-                if (rv)
+                print_format2_lock(s, lkb, r);
+                if (seq_has_overflowed(s))
                         goto out;
         }
  out:
         unlock_rsb(r);
-        return rv;
 }
 
-static int print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
+static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
                               int rsb_lookup)
 {
         u64 xid = 0;
-        int rv;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 if (lkb->lkb_ua)
                         xid = lkb->lkb_ua->xid;
         }
 
-        rv = seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
-                        lkb->lkb_id,
-                        lkb->lkb_nodeid,
-                        lkb->lkb_remid,
-                        lkb->lkb_ownpid,
-                        (unsigned long long)xid,
-                        lkb->lkb_exflags,
-                        lkb->lkb_flags,
-                        lkb->lkb_status,
-                        lkb->lkb_grmode,
-                        lkb->lkb_rqmode,
-                        lkb->lkb_last_bast.mode,
-                        rsb_lookup,
-                        lkb->lkb_wait_type,
-                        lkb->lkb_lvbseq,
-                        (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
-                        (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
-        return rv;
+        seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
+                   lkb->lkb_id,
+                   lkb->lkb_nodeid,
+                   lkb->lkb_remid,
+                   lkb->lkb_ownpid,
+                   (unsigned long long)xid,
+                   lkb->lkb_exflags,
+                   lkb->lkb_flags,
+                   lkb->lkb_status,
+                   lkb->lkb_grmode,
+                   lkb->lkb_rqmode,
+                   lkb->lkb_last_bast.mode,
+                   rsb_lookup,
+                   lkb->lkb_wait_type,
+                   lkb->lkb_lvbseq,
+                   (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
+                   (unsigned long long)ktime_to_ns(lkb->lkb_last_bast_time));
 }
 
-static int print_format3(struct dlm_rsb *r, struct seq_file *s)
+static void print_format3(struct dlm_rsb *r, struct seq_file *s)
 {
         struct dlm_lkb *lkb;
         int i, lvblen = r->res_ls->ls_lvblen;
         int print_name = 1;
-        int rv;
 
         lock_rsb(r);
 
-        rv = seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
-                        r,
-                        r->res_nodeid,
-                        r->res_first_lkid,
-                        r->res_flags,
-                        !list_empty(&r->res_root_list),
-                        !list_empty(&r->res_recover_list),
-                        r->res_recover_locks_count,
-                        r->res_length);
-        if (rv)
+        seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
+                   r,
+                   r->res_nodeid,
+                   r->res_first_lkid,
+                   r->res_flags,
+                   !list_empty(&r->res_root_list),
+                   !list_empty(&r->res_recover_list),
+                   r->res_recover_locks_count,
+                   r->res_length);
+        if (seq_has_overflowed(s))
                 goto out;
 
         for (i = 0; i < r->res_length; i++) {
@@ -292,7 +279,7 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                         print_name = 0;
         }
 
-        seq_printf(s, "%s", print_name ? "str " : "hex");
+        seq_puts(s, print_name ? "str " : "hex");
 
         for (i = 0; i < r->res_length; i++) {
                 if (print_name)
@@ -300,8 +287,8 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_puts(s, "\n");
-        if (rv)
+        seq_puts(s, "\n");
+        if (seq_has_overflowed(s))
                 goto out;
 
         if (!r->res_lvbptr)
@@ -311,65 +298,62 @@ static int print_format3(struct dlm_rsb *r, struct seq_file *s)
 
         for (i = 0; i < lvblen; i++)
                 seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
-        rv = seq_puts(s, "\n");
-        if (rv)
+        seq_puts(s, "\n");
+        if (seq_has_overflowed(s))
                 goto out;
 
  do_locks:
         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
-                rv = print_format3_lock(s, lkb, 0);
-                if (rv)
+                print_format3_lock(s, lkb, 0);
+                if (seq_has_overflowed(s))
                         goto out;
         }
 
         list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) {
-                rv = print_format3_lock(s, lkb, 1);
-                if (rv)
+                print_format3_lock(s, lkb, 1);
+                if (seq_has_overflowed(s))
                         goto out;
         }
  out:
         unlock_rsb(r);
-        return rv;
 }
 
-static int print_format4(struct dlm_rsb *r, struct seq_file *s)
+static void print_format4(struct dlm_rsb *r, struct seq_file *s)
 {
         int our_nodeid = dlm_our_nodeid();
         int print_name = 1;
-        int i, rv;
+        int i;
 
         lock_rsb(r);
 
-        rv = seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
-                        r,
-                        r->res_nodeid,
-                        r->res_master_nodeid,
-                        r->res_dir_nodeid,
-                        our_nodeid,
-                        r->res_toss_time,
-                        r->res_flags,
-                        r->res_length);
-        if (rv)
-                goto out;
+        seq_printf(s, "rsb %p %d %d %d %d %lu %lx %d ",
+                   r,
+                   r->res_nodeid,
+                   r->res_master_nodeid,
+                   r->res_dir_nodeid,
+                   our_nodeid,
+                   r->res_toss_time,
+                   r->res_flags,
+                   r->res_length);
 
         for (i = 0; i < r->res_length; i++) {
                 if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
                         print_name = 0;
         }
 
-        seq_printf(s, "%s", print_name ? "str " : "hex");
+        seq_puts(s, print_name ? "str " : "hex");
 
         for (i = 0; i < r->res_length; i++) {
                 if (print_name)
@@ -377,10 +361,9 @@ static int print_format4(struct dlm_rsb *r, struct seq_file *s)
                 else
                         seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
         }
-        rv = seq_puts(s, "\n");
- out:
+        seq_puts(s, "\n");
+
         unlock_rsb(r);
-        return rv;
 }
 
 struct rsbtbl_iter {
@@ -390,47 +373,45 @@ struct rsbtbl_iter {
         int header;
 };
 
-/* seq_printf returns -1 if the buffer is full, and 0 otherwise.
-   If the buffer is full, seq_printf can be called again, but it
-   does nothing and just returns -1.  So, the these printing routines
-   periodically check the return value to avoid wasting too much time
-   trying to print to a full buffer. */
+/*
+ * If the buffer is full, seq_printf can be called again, but it
+ * does nothing.  So, the these printing routines periodically check
+ * seq_has_overflowed to avoid wasting too much time trying to print to
+ * a full buffer.
+ */
 
 static int table_seq_show(struct seq_file *seq, void *iter_ptr)
 {
         struct rsbtbl_iter *ri = iter_ptr;
-        int rv = 0;
 
         switch (ri->format) {
         case 1:
-                rv = print_format1(ri->rsb, seq);
+                print_format1(ri->rsb, seq);
                 break;
         case 2:
                 if (ri->header) {
-                        seq_printf(seq, "id nodeid remid pid xid exflags "
-                                        "flags sts grmode rqmode time_ms "
-                                        "r_nodeid r_len r_name\n");
+                        seq_puts(seq, "id nodeid remid pid xid exflags flags sts grmode rqmode time_ms r_nodeid r_len r_name\n");
                         ri->header = 0;
                 }
-                rv = print_format2(ri->rsb, seq);
+                print_format2(ri->rsb, seq);
                 break;
         case 3:
                 if (ri->header) {
-                        seq_printf(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
+                        seq_puts(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
                         ri->header = 0;
                 }
-                rv = print_format3(ri->rsb, seq);
+                print_format3(ri->rsb, seq);
                 break;
         case 4:
                 if (ri->header) {
-                        seq_printf(seq, "version 4 rsb 2\n");
+                        seq_puts(seq, "version 4 rsb 2\n");
                         ri->header = 0;
                 }
-                rv = print_format4(ri->rsb, seq);
+                print_format4(ri->rsb, seq);
                 break;
         }
 
-        return rv;
+        return 0;
 }
 
 static const struct seq_operations format1_seq_ops;
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 2f6735dbf1a9..c2d6604667b0 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1373,7 +1373,7 @@ out:
 int ecryptfs_read_xattr_region(char *page_virt, struct inode *ecryptfs_inode)
 {
         struct dentry *lower_dentry =
-                ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry;
+                ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
         ssize_t size;
         int rc = 0;
 
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index f5bce9096555..80154ec4f8c2 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -75,11 +75,11 @@ struct ecryptfs_getdents_callback {
 
 /* Inspired by generic filldir in fs/readdir.c */
 static int
-ecryptfs_filldir(void *dirent, const char *lower_name, int lower_namelen,
-                 loff_t offset, u64 ino, unsigned int d_type)
+ecryptfs_filldir(struct dir_context *ctx, const char *lower_name,
+                 int lower_namelen, loff_t offset, u64 ino, unsigned int d_type)
 {
         struct ecryptfs_getdents_callback *buf =
-            (struct ecryptfs_getdents_callback *)dirent;
+                container_of(ctx, struct ecryptfs_getdents_callback, ctx);
         size_t name_size;
         char *name;
         int rc;
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 564a1fa34b99..4626976794e7 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -419,7 +419,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
         ssize_t size;
         void *xattr_virt;
         struct dentry *lower_dentry =
-                ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry;
+                ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry;
         struct inode *lower_inode = lower_dentry->d_inode;
         int rc;
 
diff --git a/fs/efivarfs/file.c b/fs/efivarfs/file.c
index cdb2971192a5..90001da9abfd 100644
--- a/fs/efivarfs/file.c
+++ b/fs/efivarfs/file.c
@@ -47,8 +47,8 @@ static ssize_t efivarfs_file_write(struct file *file,
 
         if (bytes == -ENOENT) {
                 drop_nlink(inode);
-                d_delete(file->f_dentry);
-                dput(file->f_dentry);
+                d_delete(file->f_path.dentry);
+                dput(file->f_path.dentry);
         } else {
                 mutex_lock(&inode->i_mutex);
                 i_size_write(inode, datasize + sizeof(attributes));
diff --git a/fs/eventfd.c b/fs/eventfd.c
index d6a88e7812f3..4b0a226024fa 100644
--- a/fs/eventfd.c
+++ b/fs/eventfd.c
@@ -287,17 +287,14 @@ static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t c
 }
 
 #ifdef CONFIG_PROC_FS
-static int eventfd_show_fdinfo(struct seq_file *m, struct file *f)
+static void eventfd_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct eventfd_ctx *ctx = f->private_data;
-        int ret;
 
         spin_lock_irq(&ctx->wqh.lock);
-        ret = seq_printf(m, "eventfd-count: %16llx\n",
-                         (unsigned long long)ctx->count);
+        seq_printf(m, "eventfd-count: %16llx\n",
+                   (unsigned long long)ctx->count);
         spin_unlock_irq(&ctx->wqh.lock);
-
-        return ret;
 }
 #endif
 
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 7bcfff900f05..d77f94491352 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -870,25 +870,22 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
 }
 
 #ifdef CONFIG_PROC_FS
-static int ep_show_fdinfo(struct seq_file *m, struct file *f)
+static void ep_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct eventpoll *ep = f->private_data;
         struct rb_node *rbp;
-        int ret = 0;
 
         mutex_lock(&ep->mtx);
         for (rbp = rb_first(&ep->rbr); rbp; rbp = rb_next(rbp)) {
                 struct epitem *epi = rb_entry(rbp, struct epitem, rbn);
 
-                ret = seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
-                                 epi->ffd.fd, epi->event.events,
-                                 (long long)epi->event.data);
-                if (ret)
+                seq_printf(m, "tfd: %8d events: %8x data: %16llx\n",
+                           epi->ffd.fd, epi->event.events,
+                           (long long)epi->event.data);
+                if (seq_has_overflowed(m))
                         break;
         }
         mutex_unlock(&ep->mtx);
-
-        return ret;
 }
 #endif
 
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index b01fbfb51f43..fdfd206c737a 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -50,7 +50,7 @@ find_acceptable_alias(struct dentry *result,
 
         inode = result->d_inode;
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
                 dget(dentry);
                 spin_unlock(&inode->i_lock);
                 if (toput)
@@ -241,10 +241,11 @@ struct getdents_callback {
  * A rather strange filldir function to capture
  * the name matching the specified inode number.
  */
-static int filldir_one(void * __buf, const char * name, int len,
+static int filldir_one(struct dir_context *ctx, const char *name, int len,
                         loff_t pos, u64 ino, unsigned int d_type)
 {
-        struct getdents_callback *buf = __buf;
+        struct getdents_callback *buf =
+                container_of(ctx, struct getdents_callback, ctx);
         int result = 0;
 
         buf->sequence++;
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 3963ede84eb0..c5d6bb939d19 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -702,10 +702,11 @@ static int fat_readdir(struct file *file, struct dir_context *ctx)
 }
 
 #define FAT_IOCTL_FILLDIR_FUNC(func, dirent_type)                          \
-static int func(void *__buf, const char *name, int name_len,               \
+static int func(struct dir_context *ctx, const char *name, int name_len,   \
                              loff_t offset, u64 ino, unsigned int d_type)  \
 {                                                                          \
-        struct fat_ioctl_filldir_callback *buf = __buf;                    \
+        struct fat_ioctl_filldir_callback *buf =                           \
+                container_of(ctx, struct fat_ioctl_filldir_callback, ctx); \
         struct dirent_type __user *d1 = buf->dirent;                       \
         struct dirent_type __user *d2 = d1 + 1;                            \
                                                                            \
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index dbab798f5caf..df562cc87763 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -372,7 +372,7 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         if (inode && get_node_id(inode) == FUSE_ROOT_ID)
                 goto out_iput;
 
-        newent = d_materialise_unique(entry, inode);
+        newent = d_splice_alias(inode, entry);
         err = PTR_ERR(newent);
         if (IS_ERR(newent))
                 goto out_err;
@@ -1320,7 +1320,7 @@ static int fuse_direntplus_link(struct file *file,
         if (!inode)
                 goto out;
 
-        alias = d_materialise_unique(dentry, inode);
+        alias = d_splice_alias(inode, dentry);
         err = PTR_ERR(alias);
         if (IS_ERR(alias))
                 goto out;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index caa8d95b24e8..bf50259012ab 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1988,7 +1988,7 @@ static int fuse_write_begin(struct file *file, struct address_space *mapping,
                 struct page **pagep, void **fsdata)
 {
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-        struct fuse_conn *fc = get_fuse_conn(file->f_dentry->d_inode);
+        struct fuse_conn *fc = get_fuse_conn(file_inode(file));
         struct page *page;
         loff_t fsize;
         int err = -ENOMEM;
diff --git a/fs/gfs2/export.c b/fs/gfs2/export.c
index 8b9b3775e2e7..c41d255b6a7b 100644
--- a/fs/gfs2/export.c
+++ b/fs/gfs2/export.c
@@ -69,10 +69,12 @@ struct get_name_filldir {
         char *name;
 };
 
-static int get_name_filldir(void *opaque, const char *name, int length,
-                            loff_t offset, u64 inum, unsigned int type)
+static int get_name_filldir(struct dir_context *ctx, const char *name,
+                            int length, loff_t offset, u64 inum,
+                            unsigned int type)
 {
-        struct get_name_filldir *gnfd = opaque;
+        struct get_name_filldir *gnfd =
+                container_of(ctx, struct get_name_filldir, ctx);
 
         if (inum != gnfd->inum.no_addr)
                 return 0;
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index 4338ff32959d..5f2755117ce7 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -548,10 +548,11 @@ struct hppfs_dirent {
         struct dentry *dentry;
 };
 
-static int hppfs_filldir(void *d, const char *name, int size,
+static int hppfs_filldir(struct dir_context *ctx, const char *name, int size,
                          loff_t offset, u64 inode, unsigned int type)
 {
-        struct hppfs_dirent *dirent = d;
+        struct hppfs_dirent *dirent =
+                container_of(ctx, struct hppfs_dirent, ctx);
 
         if (file_removed(dirent->dentry, name))
                 return 0;
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index d59c7defb1ef..38fdc533f4ec 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -84,7 +84,7 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
         struct inode *iplist[2];
         struct tblock *tblk;
 
-        jfs_info("jfs_create: dip:0x%p name:%s", dip, dentry->d_name.name);
+        jfs_info("jfs_create: dip:0x%p name:%pd", dip, dentry);
 
         dquot_initialize(dip);
 
@@ -216,7 +216,7 @@ static int jfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
         struct inode *iplist[2];
         struct tblock *tblk;
 
-        jfs_info("jfs_mkdir: dip:0x%p name:%s", dip, dentry->d_name.name);
+        jfs_info("jfs_mkdir: dip:0x%p name:%pd", dip, dentry);
 
         dquot_initialize(dip);
 
@@ -352,7 +352,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
         struct inode *iplist[2];
         struct tblock *tblk;
 
-        jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
+        jfs_info("jfs_rmdir: dip:0x%p name:%pd", dip, dentry);
 
         /* Init inode for quota operations. */
         dquot_initialize(dip);
@@ -480,7 +480,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
         s64 new_size = 0;
         int commit_flag;
 
-        jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
+        jfs_info("jfs_unlink: dip:0x%p name:%pd", dip, dentry);
 
         /* Init inode for quota operations. */
         dquot_initialize(dip);
@@ -797,8 +797,7 @@ static int jfs_link(struct dentry *old_dentry,
         struct btstack btstack;
         struct inode *iplist[2];
 
-        jfs_info("jfs_link: %s %s", old_dentry->d_name.name,
-                 dentry->d_name.name);
+        jfs_info("jfs_link: %pd %pd", old_dentry, dentry);
 
         dquot_initialize(dir);
 
@@ -1082,8 +1081,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         int commit_flag;
 
 
-        jfs_info("jfs_rename: %s %s", old_dentry->d_name.name,
-                 new_dentry->d_name.name);
+        jfs_info("jfs_rename: %pd %pd", old_dentry, new_dentry);
 
         dquot_initialize(old_dir);
         dquot_initialize(new_dir);
@@ -1355,7 +1353,7 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
         if (!new_valid_dev(rdev))
                 return -EINVAL;
 
-        jfs_info("jfs_mknod: %s", dentry->d_name.name);
+        jfs_info("jfs_mknod: %pd", dentry);
 
         dquot_initialize(dir);
 
@@ -1444,7 +1442,7 @@ static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, unsig
         struct component_name key;
         int rc;
 
-        jfs_info("jfs_lookup: name = %s", dentry->d_name.name);
+        jfs_info("jfs_lookup: name = %pd", dentry);
 
         if ((rc = get_UCSname(&key, dentry)))
                 return ERR_PTR(rc);
diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index 1c771931bb60..37989f02a226 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -807,7 +807,7 @@ static struct dentry *kernfs_iop_lookup(struct inode *dir,
         }
 
         /* instantiate and hash dentry */
-        ret = d_materialise_unique(dentry, inode);
+        ret = d_splice_alias(inode, dentry);
  out_unlock:
         mutex_unlock(&kernfs_mutex);
         return ret;
diff --git a/fs/libfs.c b/fs/libfs.c
index 171d2846f2a3..005843ce5dbd 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -114,18 +114,18 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
 
                         spin_lock(&dentry->d_lock);
                         /* d_lock not required for cursor */
-                        list_del(&cursor->d_u.d_child);
+                        list_del(&cursor->d_child);
                         p = dentry->d_subdirs.next;
                         while (n && p != &dentry->d_subdirs) {
                                 struct dentry *next;
-                                next = list_entry(p, struct dentry, d_u.d_child);
+                                next = list_entry(p, struct dentry, d_child);
                                 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
                                 if (simple_positive(next))
                                         n--;
                                 spin_unlock(&next->d_lock);
                                 p = p->next;
                         }
-                        list_add_tail(&cursor->d_u.d_child, p);
+                        list_add_tail(&cursor->d_child, p);
                         spin_unlock(&dentry->d_lock);
                 }
         }
@@ -150,7 +150,7 @@ int dcache_readdir(struct file *file, struct dir_context *ctx)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct dentry *cursor = file->private_data;
-        struct list_head *p, *q = &cursor->d_u.d_child;
+        struct list_head *p, *q = &cursor->d_child;
 
         if (!dir_emit_dots(file, ctx))
                 return 0;
@@ -159,7 +159,7 @@ int dcache_readdir(struct file *file, struct dir_context *ctx)
                 list_move(q, &dentry->d_subdirs);
 
         for (p = q->next; p != &dentry->d_subdirs; p = p->next) {
-                struct dentry *next = list_entry(p, struct dentry, d_u.d_child);
+                struct dentry *next = list_entry(p, struct dentry, d_child);
                 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
                 if (!simple_positive(next)) {
                         spin_unlock(&next->d_lock);
@@ -287,7 +287,7 @@ int simple_empty(struct dentry *dentry)
         int ret = 0;
 
         spin_lock(&dentry->d_lock);
-        list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
+        list_for_each_entry(child, &dentry->d_subdirs, d_child) {
                 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
                 if (simple_positive(child)) {
                         spin_unlock(&child->d_lock);
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index b6f3b84b6e99..d12ff4e2dbe7 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -408,7 +408,7 @@ nlmsvc_match_sb(void *datap, struct nlm_file *file)
 {
         struct super_block *sb = datap;
 
-        return sb == file->f_file->f_path.dentry->d_sb;
+        return sb == file_inode(file->f_file)->i_sb;
 }
 
 /**
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 7cb751dfbeef..008960101520 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -198,8 +198,8 @@ ncp_single_volume(struct ncp_server *server)
 
 static inline int ncp_is_server_root(struct inode *inode)
 {
-        return (!ncp_single_volume(NCP_SERVER(inode)) &&
-                inode == inode->i_sb->s_root->d_inode);
+        return !ncp_single_volume(NCP_SERVER(inode)) &&
+                is_root_inode(inode);
 }
 
 
@@ -403,7 +403,7 @@ ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
 
         /* If a pointer is invalid, we search the dentry. */
         spin_lock(&parent->d_lock);
-        list_for_each_entry(dent, &parent->d_subdirs, d_u.d_child) {
+        list_for_each_entry(dent, &parent->d_subdirs, d_child) {
                 if ((unsigned long)dent->d_fsdata == fpos) {
                         if (dent->d_inode)
                                 dget(dent);
@@ -685,8 +685,7 @@ static void
 ncp_read_volume_list(struct file *file, struct dir_context *ctx,
                         struct ncp_cache_control *ctl)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct ncp_server *server = NCP_SERVER(inode);
         struct ncp_volume_info info;
         struct ncp_entry_info entry;
@@ -721,8 +720,7 @@ static void
 ncp_do_readdir(struct file *file, struct dir_context *ctx,
                                                 struct ncp_cache_control *ctl)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *dir = dentry->d_inode;
+        struct inode *dir = file_inode(file);
         struct ncp_server *server = NCP_SERVER(dir);
         struct nw_search_sequence seq;
         struct ncp_entry_info entry;
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 77640a8bfb87..1dd7007f974d 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -100,8 +100,7 @@ out:
 static ssize_t
 ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(file);
         size_t already_read = 0;
         off_t pos;
         size_t bufsize;
@@ -109,7 +108,7 @@ ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         void* freepage;
         size_t freelen;
 
-        ncp_dbg(1, "enter %pd2\n", dentry);
+        ncp_dbg(1, "enter %pD2\n", file);
 
         pos = *ppos;
 
@@ -167,7 +166,7 @@ ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 
         file_accessed(file);
 
-        ncp_dbg(1, "exit %pd2\n", dentry);
+        ncp_dbg(1, "exit %pD2\n", file);
 outrel:
         ncp_inode_close(inode);         
         return already_read ? already_read : error;
@@ -176,15 +175,14 @@ outrel:
 static ssize_t
 ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(file);
         size_t already_written = 0;
         off_t pos;
         size_t bufsize;
         int errno;
         void* bouncebuffer;
 
-        ncp_dbg(1, "enter %pd2\n", dentry);
+        ncp_dbg(1, "enter %pD2\n", file);
         if ((ssize_t) count < 0)
                 return -EINVAL;
         pos = *ppos;
@@ -263,7 +261,7 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
                         i_size_write(inode, pos);
                 mutex_unlock(&inode->i_mutex);
         }
-        ncp_dbg(1, "exit %pd2\n", dentry);
+        ncp_dbg(1, "exit %pD2\n", file);
 outrel:
         ncp_inode_close(inode);         
         return already_written ? already_written : errno;
diff --git a/fs/ncpfs/mmap.c b/fs/ncpfs/mmap.c
index b359d12eb359..33b873b259a8 100644
--- a/fs/ncpfs/mmap.c
+++ b/fs/ncpfs/mmap.c
@@ -30,9 +30,7 @@
 static int ncp_file_mmap_fault(struct vm_area_struct *area,
                                         struct vm_fault *vmf)
 {
-        struct file *file = area->vm_file;
-        struct dentry *dentry = file->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(area->vm_file);
         char *pg_addr;
         unsigned int already_read;
         unsigned int count;
diff --git a/fs/ncpfs/ncplib_kernel.h b/fs/ncpfs/ncplib_kernel.h
index 52cb19d66ecb..b785f74bfe3c 100644
--- a/fs/ncpfs/ncplib_kernel.h
+++ b/fs/ncpfs/ncplib_kernel.h
@@ -191,7 +191,7 @@ ncp_renew_dentries(struct dentry *parent)
         struct dentry *dentry;
 
         spin_lock(&parent->d_lock);
-        list_for_each_entry(dentry, &parent->d_subdirs, d_u.d_child) {
+        list_for_each_entry(dentry, &parent->d_subdirs, d_child) {
                 if (dentry->d_fsdata == NULL)
                         ncp_age_dentry(server, dentry);
                 else
@@ -207,7 +207,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
         struct dentry *dentry;
 
         spin_lock(&parent->d_lock);
-        list_for_each_entry(dentry, &parent->d_subdirs, d_u.d_child) {
+        list_for_each_entry(dentry, &parent->d_subdirs, d_child) {
                 dentry->d_fsdata = NULL;
                 ncp_age_dentry(server, dentry);
         }
diff --git a/fs/nfs/blocklayout/rpc_pipefs.c b/fs/nfs/blocklayout/rpc_pipefs.c
index acbf9ca4018c..dbe5839cdeba 100644
--- a/fs/nfs/blocklayout/rpc_pipefs.c
+++ b/fs/nfs/blocklayout/rpc_pipefs.c
@@ -112,7 +112,7 @@ out_unlock:
 static ssize_t bl_pipe_downcall(struct file *filp, const char __user *src,
                          size_t mlen)
 {
-        struct nfs_net *nn = net_generic(filp->f_dentry->d_sb->s_fs_info,
+        struct nfs_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info,
                                          nfs_net_id);
 
         if (mlen != sizeof (struct bl_dev_msg))
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 6e62155abf26..9b0c55cb2a2e 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -133,7 +133,7 @@ out:
 static int
 nfs_closedir(struct inode *inode, struct file *filp)
 {
-        put_nfs_open_dir_context(filp->f_path.dentry->d_inode, filp->private_data);
+        put_nfs_open_dir_context(file_inode(filp), filp->private_data);
         return 0;
 }
 
@@ -499,7 +499,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         if (IS_ERR(inode))
                 goto out;
 
-        alias = d_materialise_unique(dentry, inode);
+        alias = d_splice_alias(inode, dentry);
         if (IS_ERR(alias))
                 goto out;
         else if (alias) {
@@ -1393,7 +1393,7 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in
         nfs_advise_use_readdirplus(dir);
 
 no_entry:
-        res = d_materialise_unique(dentry, inode);
+        res = d_splice_alias(inode, dentry);
         if (res != NULL) {
                 if (IS_ERR(res))
                         goto out_unblock_sillyrename;
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 880618a8b048..9ac3846cb59e 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -51,14 +51,14 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                 /*
                  * Ensure that this dentry is invisible to d_find_alias().
                  * Otherwise, it may be spliced into the tree by
-                 * d_materialise_unique if a parent directory from the same
+                 * d_splice_alias if a parent directory from the same
                  * filesystem gets mounted at a later time.
                  * 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(&sb->s_root->d_lock);
-                hlist_del_init(&sb->s_root->d_alias);
+                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);
         }
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index a25490ae6c62..cc6a76072009 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -245,10 +245,11 @@ struct nfs4_dir_ctx {
 };
 
 static int
-nfsd4_build_namelist(void *arg, const char *name, int namlen,
+nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen,
                 loff_t offset, u64 ino, unsigned int d_type)
 {
-        struct nfs4_dir_ctx *ctx = arg;
+        struct nfs4_dir_ctx *ctx =
+                container_of(__ctx, struct nfs4_dir_ctx, ctx);
         struct name_list *entry;
 
         if (namlen != HEXDIR_LEN - 1)
@@ -704,7 +705,7 @@ cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
         struct cld_upcall *tmp, *cup;
         struct cld_msg __user *cmsg = (struct cld_msg __user *)src;
         uint32_t xid;
-        struct nfsd_net *nn = net_generic(filp->f_dentry->d_sb->s_fs_info,
+        struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info,
                                                 nfsd_net_id);
         struct cld_net *cn = nn->cld_net;
 
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index eeea7a90eb87..b1eed4dd2eab 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -1886,7 +1886,7 @@ static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
                         goto out_free;
                 }
                 p = xdr_encode_opaque(p, dentry->d_name.name, len);
-                dprintk("/%s", dentry->d_name.name);
+                dprintk("/%pd", dentry);
                 spin_unlock(&dentry->d_lock);
                 dput(dentry);
                 ncomponents--;
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index ca73ca79a0ee..9506ea565610 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -231,6 +231,10 @@ static struct file_operations reply_cache_stats_operations = {
  * payload - write methods
  */
 
+static inline struct net *netns(struct file *file)
+{
+        return file_inode(file)->i_sb->s_fs_info;
+}
 
 /**
  * write_unlock_ip - Release all locks used by a client
@@ -252,7 +256,7 @@ static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
         struct sockaddr *sap = (struct sockaddr *)&address;
         size_t salen = sizeof(address);
         char *fo_path;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
+        struct net *net = netns(file);
 
         /* sanity check */
         if (size == 0)
@@ -350,7 +354,6 @@ static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
         int len;
         struct auth_domain *dom;
         struct knfsd_fh fh;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
 
         if (size == 0)
                 return -EINVAL;
@@ -385,7 +388,7 @@ static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
         if (!dom)
                 return -ENOMEM;
 
-        len = exp_rootfh(net, dom, path, &fh,  maxsize);
+        len = exp_rootfh(netns(file), dom, path, &fh,  maxsize);
         auth_domain_put(dom);
         if (len)
                 return len;
@@ -429,7 +432,7 @@ static ssize_t write_threads(struct file *file, char *buf, size_t size)
 {
         char *mesg = buf;
         int rv;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
+        struct net *net = netns(file);
 
         if (size > 0) {
                 int newthreads;
@@ -480,7 +483,7 @@ static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
         int len;
         int npools;
         int *nthreads;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
+        struct net *net = netns(file);
 
         mutex_lock(&nfsd_mutex);
         npools = nfsd_nrpools(net);
@@ -543,8 +546,7 @@ static ssize_t __write_versions(struct file *file, char *buf, size_t size)
         unsigned minor;
         ssize_t tlen = 0;
         char *sep;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 
         if (size>0) {
                 if (nn->nfsd_serv)
@@ -830,10 +832,9 @@ static ssize_t __write_ports(struct file *file, char *buf, size_t size,
 static ssize_t write_ports(struct file *file, char *buf, size_t size)
 {
         ssize_t rv;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
 
         mutex_lock(&nfsd_mutex);
-        rv = __write_ports(file, buf, size, net);
+        rv = __write_ports(file, buf, size, netns(file));
         mutex_unlock(&nfsd_mutex);
         return rv;
 }
@@ -865,8 +866,7 @@ int nfsd_max_blksize;
 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
 {
         char *mesg = buf;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 
         if (size > 0) {
                 int bsize;
@@ -915,8 +915,7 @@ static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
 static ssize_t write_maxconn(struct file *file, char *buf, size_t size)
 {
         char *mesg = buf;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
         unsigned int maxconn = nn->max_connections;
 
         if (size > 0) {
@@ -997,8 +996,7 @@ static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
  */
 static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
 {
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
         return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn);
 }
 
@@ -1014,8 +1012,7 @@ static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
  */
 static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
 {
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
         return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn);
 }
 
@@ -1071,8 +1068,7 @@ static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
 {
         ssize_t rv;
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 
         mutex_lock(&nfsd_mutex);
         rv = __write_recoverydir(file, buf, size, nn);
@@ -1102,8 +1098,7 @@ static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
  */
 static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
 {
-        struct net *net = file->f_dentry->d_sb->s_fs_info;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 
         if (size > 0) {
                 switch(buf[0]) {
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 989129e2d6ea..0a82e3c033ee 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -930,7 +930,6 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                                 unsigned long *cnt, int *stablep)
 {
         struct svc_export       *exp;
-        struct dentry           *dentry;
         struct inode            *inode;
         mm_segment_t            oldfs;
         __be32                  err = 0;
@@ -949,8 +948,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                  */
                 current->flags |= PF_LESS_THROTTLE;
 
-        dentry = file->f_path.dentry;
-        inode = dentry->d_inode;
+        inode = file_inode(file);
         exp   = fhp->fh_export;
 
         use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp);
@@ -1819,10 +1817,12 @@ struct readdir_data {
         int             full;
 };
 
-static int nfsd_buffered_filldir(void *__buf, const char *name, int namlen,
-                                 loff_t offset, u64 ino, unsigned int d_type)
+static int nfsd_buffered_filldir(struct dir_context *ctx, const char *name,
+                                 int namlen, loff_t offset, u64 ino,
+                                 unsigned int d_type)
 {
-        struct readdir_data *buf = __buf;
+        struct readdir_data *buf =
+                container_of(ctx, struct readdir_data, ctx);
         struct buffered_dirent *de = (void *)(buf->dirent + buf->used);
         unsigned int reclen;
 
@@ -1842,7 +1842,7 @@ static int nfsd_buffered_filldir(void *__buf, const char *name, int namlen,
         return 0;
 }
 
-static __be32 nfsd_buffered_readdir(struct file *file, filldir_t func,
+static __be32 nfsd_buffered_readdir(struct file *file, nfsd_filldir_t func,
                                     struct readdir_cd *cdp, loff_t *offsetp)
 {
         struct buffered_dirent *de;
@@ -1926,7 +1926,7 @@ static __be32 nfsd_buffered_readdir(struct file *file, filldir_t func,
  */
 __be32
 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 
-             struct readdir_cd *cdp, filldir_t func)
+             struct readdir_cd *cdp, nfsd_filldir_t func)
 {
         __be32          err;
         struct file     *file;
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index c2ff3f14e5f6..b1796d6ee538 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -36,7 +36,7 @@
 /*
  * Callback function for readdir
  */
-typedef int (*nfsd_dirop_t)(struct inode *, struct dentry *, int, int);
+typedef int (*nfsd_filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
 
 /* nfsd/vfs.c */
 int             nfsd_racache_init(int);
@@ -95,7 +95,7 @@ __be32		nfsd_rename(struct svc_rqst *,
 __be32          nfsd_unlink(struct svc_rqst *, struct svc_fh *, int type,
                                 char *name, int len);
 __be32          nfsd_readdir(struct svc_rqst *, struct svc_fh *,
-                             loff_t *, struct readdir_cd *, filldir_t);
+                             loff_t *, struct readdir_cd *, nfsd_filldir_t);
 __be32          nfsd_statfs(struct svc_rqst *, struct svc_fh *,
                                 struct kstatfs *, int access);
 
diff --git a/fs/notify/fdinfo.c b/fs/notify/fdinfo.c
index 9d7e2b9659cb..6ffd220eb14d 100644
--- a/fs/notify/fdinfo.c
+++ b/fs/notify/fdinfo.c
@@ -20,25 +20,24 @@
 
 #if defined(CONFIG_INOTIFY_USER) || defined(CONFIG_FANOTIFY)
 
-static int show_fdinfo(struct seq_file *m, struct file *f,
-                       int (*show)(struct seq_file *m, struct fsnotify_mark *mark))
+static void show_fdinfo(struct seq_file *m, struct file *f,
+                        void (*show)(struct seq_file *m,
+                                     struct fsnotify_mark *mark))
 {
         struct fsnotify_group *group = f->private_data;
         struct fsnotify_mark *mark;
-        int ret = 0;
 
         mutex_lock(&group->mark_mutex);
         list_for_each_entry(mark, &group->marks_list, g_list) {
-                ret = show(m, mark);
-                if (ret)
+                show(m, mark);
+                if (seq_has_overflowed(m))
                         break;
         }
         mutex_unlock(&group->mark_mutex);
-        return ret;
 }
 
 #if defined(CONFIG_EXPORTFS)
-static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
 {
         struct {
                 struct file_handle handle;
@@ -52,71 +51,62 @@ static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
         ret = exportfs_encode_inode_fh(inode, (struct fid *)f.handle.f_handle, &size, 0);
         if ((ret == FILEID_INVALID) || (ret < 0)) {
                 WARN_ONCE(1, "Can't encode file handler for inotify: %d\n", ret);
-                return 0;
+                return;
         }
 
         f.handle.handle_type = ret;
         f.handle.handle_bytes = size * sizeof(u32);
 
-        ret = seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
-                         f.handle.handle_bytes, f.handle.handle_type);
+        seq_printf(m, "fhandle-bytes:%x fhandle-type:%x f_handle:",
+                   f.handle.handle_bytes, f.handle.handle_type);
 
         for (i = 0; i < f.handle.handle_bytes; i++)
-                ret |= seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
-
-        return ret;
+                seq_printf(m, "%02x", (int)f.handle.f_handle[i]);
 }
 #else
-static int show_mark_fhandle(struct seq_file *m, struct inode *inode)
+static void show_mark_fhandle(struct seq_file *m, struct inode *inode)
 {
-        return 0;
 }
 #endif
 
 #ifdef CONFIG_INOTIFY_USER
 
-static int inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+static void inotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 {
         struct inotify_inode_mark *inode_mark;
         struct inode *inode;
-        int ret = 0;
 
         if (!(mark->flags & (FSNOTIFY_MARK_FLAG_ALIVE | FSNOTIFY_MARK_FLAG_INODE)))
-                return 0;
+                return;
 
         inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
         inode = igrab(mark->i.inode);
         if (inode) {
-                ret = seq_printf(m, "inotify wd:%x ino:%lx sdev:%x "
-                                 "mask:%x ignored_mask:%x ",
-                                 inode_mark->wd, inode->i_ino,
-                                 inode->i_sb->s_dev,
-                                 mark->mask, mark->ignored_mask);
-                ret |= show_mark_fhandle(m, inode);
-                ret |= seq_putc(m, '\n');
+                seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:%x ",
+                           inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
+                           mark->mask, mark->ignored_mask);
+                show_mark_fhandle(m, inode);
+                seq_putc(m, '\n');
                 iput(inode);
         }
-
-        return ret;
 }
 
-int inotify_show_fdinfo(struct seq_file *m, struct file *f)
+void inotify_show_fdinfo(struct seq_file *m, struct file *f)
 {
-        return show_fdinfo(m, f, inotify_fdinfo);
+        show_fdinfo(m, f, inotify_fdinfo);
 }
 
 #endif /* CONFIG_INOTIFY_USER */
 
 #ifdef CONFIG_FANOTIFY
 
-static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
+static void fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
 {
         unsigned int mflags = 0;
         struct inode *inode;
-        int ret = 0;
 
         if (!(mark->flags & FSNOTIFY_MARK_FLAG_ALIVE))
-                return 0;
+                return;
 
         if (mark->flags & FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY)
                 mflags |= FAN_MARK_IGNORED_SURV_MODIFY;
@@ -124,26 +114,22 @@ static int fanotify_fdinfo(struct seq_file *m, struct fsnotify_mark *mark)
         if (mark->flags & FSNOTIFY_MARK_FLAG_INODE) {
                 inode = igrab(mark->i.inode);
                 if (!inode)
-                        goto out;
-                ret = seq_printf(m, "fanotify ino:%lx sdev:%x "
-                                 "mflags:%x mask:%x ignored_mask:%x ",
-                                 inode->i_ino, inode->i_sb->s_dev,
-                                 mflags, mark->mask, mark->ignored_mask);
-                ret |= show_mark_fhandle(m, inode);
-                ret |= seq_putc(m, '\n');
+                        return;
+                seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
+                           inode->i_ino, inode->i_sb->s_dev,
+                           mflags, mark->mask, mark->ignored_mask);
+                show_mark_fhandle(m, inode);
+                seq_putc(m, '\n');
                 iput(inode);
         } else if (mark->flags & FSNOTIFY_MARK_FLAG_VFSMOUNT) {
                 struct mount *mnt = real_mount(mark->m.mnt);
 
-                ret = seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x "
-                                 "ignored_mask:%x\n", mnt->mnt_id, mflags,
-                                 mark->mask, mark->ignored_mask);
+                seq_printf(m, "fanotify mnt_id:%x mflags:%x mask:%x ignored_mask:%x\n",
+                           mnt->mnt_id, mflags, mark->mask, mark->ignored_mask);
         }
-out:
-        return ret;
 }
 
-int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
+void fanotify_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct fsnotify_group *group = f->private_data;
         unsigned int flags = 0;
@@ -169,7 +155,7 @@ int fanotify_show_fdinfo(struct seq_file *m, struct file *f)
         seq_printf(m, "fanotify flags:%x event-flags:%x\n",
                    flags, group->fanotify_data.f_flags);
 
-        return show_fdinfo(m, f, fanotify_fdinfo);
+        show_fdinfo(m, f, fanotify_fdinfo);
 }
 
 #endif /* CONFIG_FANOTIFY */
diff --git a/fs/notify/fdinfo.h b/fs/notify/fdinfo.h
index 556afda990e9..9664c4904d6b 100644
--- a/fs/notify/fdinfo.h
+++ b/fs/notify/fdinfo.h
@@ -10,11 +10,11 @@ struct file;
 #ifdef CONFIG_PROC_FS
 
 #ifdef CONFIG_INOTIFY_USER
-extern int inotify_show_fdinfo(struct seq_file *m, struct file *f);
+void inotify_show_fdinfo(struct seq_file *m, struct file *f);
 #endif
 
 #ifdef CONFIG_FANOTIFY
-extern int fanotify_show_fdinfo(struct seq_file *m, struct file *f);
+void fanotify_show_fdinfo(struct seq_file *m, struct file *f);
 #endif
 
 #else /* CONFIG_PROC_FS */
diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
index 89326acd4561..41e39102743a 100644
--- a/fs/notify/fsnotify.c
+++ b/fs/notify/fsnotify.c
@@ -63,14 +63,14 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode)
         spin_lock(&inode->i_lock);
         /* run all of the dentries associated with this inode.  Since this is a
          * directory, there damn well better only be one item on this list */
-        hlist_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
                 struct dentry *child;
 
                 /* run all of the children of the original inode and fix their
                  * d_flags to indicate parental interest (their parent is the
                  * original inode) */
                 spin_lock(&alias->d_lock);
-                list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {
+                list_for_each_entry(child, &alias->d_subdirs, d_child) {
                         if (!child->d_inode)
                                 continue;
 
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index 436f36037e09..b3973c2fd190 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -111,8 +111,8 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
         unsigned long dent_ino;
         int uname_len;
 
-        ntfs_debug("Looking up %s in directory inode 0x%lx.",
-                        dent->d_name.name, dir_ino->i_ino);
+        ntfs_debug("Looking up %pd in directory inode 0x%lx.",
+                        dent, dir_ino->i_ino);
         /* Convert the name of the dentry to Unicode. */
         uname_len = ntfs_nlstoucs(vol, dent->d_name.name, dent->d_name.len,
                         &uname);
diff --git a/fs/ocfs2/dcache.c b/fs/ocfs2/dcache.c
index e2e05a106beb..4fda7a5f3088 100644
--- a/fs/ocfs2/dcache.c
+++ b/fs/ocfs2/dcache.c
@@ -172,7 +172,7 @@ struct dentry *ocfs2_find_local_alias(struct inode *inode,
         struct dentry *dentry;
 
         spin_lock(&inode->i_lock);
-        hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
                 spin_lock(&dentry->d_lock);
                 if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
                         trace_ocfs2_find_local_alias(dentry->d_name.len,
@@ -251,8 +251,8 @@ int ocfs2_dentry_attach_lock(struct dentry *dentry,
 
         if (dl) {
                 mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
-                                " \"%.*s\": old parent: %llu, new: %llu\n",
-                                dentry->d_name.len, dentry->d_name.name,
+                                " \"%pd\": old parent: %llu, new: %llu\n",
+                                dentry,
                                 (unsigned long long)parent_blkno,
                                 (unsigned long long)dl->dl_parent_blkno);
                 return 0;
@@ -277,8 +277,8 @@ int ocfs2_dentry_attach_lock(struct dentry *dentry,
                                 (unsigned long long)OCFS2_I(inode)->ip_blkno);
 
                 mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
-                                " \"%.*s\": old parent: %llu, new: %llu\n",
-                                dentry->d_name.len, dentry->d_name.name,
+                                " \"%pd\": old parent: %llu, new: %llu\n",
+                                dentry,
                                 (unsigned long long)parent_blkno,
                                 (unsigned long long)dl->dl_parent_blkno);
 
@@ -406,17 +406,15 @@ static void ocfs2_dentry_iput(struct dentry *dentry, struct inode *inode)
                         if (inode)
                                 ino = (unsigned long long)OCFS2_I(inode)->ip_blkno;
                         mlog(ML_ERROR, "Dentry is missing cluster lock. "
-                             "inode: %llu, d_flags: 0x%x, d_name: %.*s\n",
-                             ino, dentry->d_flags, dentry->d_name.len,
-                             dentry->d_name.name);
+                             "inode: %llu, d_flags: 0x%x, d_name: %pd\n",
+                             ino, dentry->d_flags, dentry);
                 }
 
                 goto out;
         }
 
-        mlog_bug_on_msg(dl->dl_count == 0, "dentry: %.*s, count: %u\n",
-                        dentry->d_name.len, dentry->d_name.name,
-                        dl->dl_count);
+        mlog_bug_on_msg(dl->dl_count == 0, "dentry: %pd, count: %u\n",
+                        dentry, dl->dl_count);
 
         ocfs2_dentry_lock_put(OCFS2_SB(dentry->d_sb), dl);
 
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 0717662b4aef..c43d9b4a1ec0 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -2073,10 +2073,12 @@ struct ocfs2_empty_dir_priv {
         unsigned seen_other;
         unsigned dx_dir;
 };
-static int ocfs2_empty_dir_filldir(void *priv, const char *name, int name_len,
-                                   loff_t pos, u64 ino, unsigned type)
+static int ocfs2_empty_dir_filldir(struct dir_context *ctx, const char *name,
+                                   int name_len, loff_t pos, u64 ino,
+                                   unsigned type)
 {
-        struct ocfs2_empty_dir_priv *p = priv;
+        struct ocfs2_empty_dir_priv *p =
+                container_of(ctx, struct ocfs2_empty_dir_priv, ctx);
 
         /*
          * Check the positions of "." and ".." records to be sure
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index 09b7d9dac71d..57c40e34f56f 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -565,8 +565,8 @@ static int dlmfs_unlink(struct inode *dir,
          * to acquire a lock, this basically destroys our lockres. */
         status = user_dlm_destroy_lock(&DLMFS_I(inode)->ip_lockres);
         if (status < 0) {
-                mlog(ML_ERROR, "unlink %.*s, error %d from destroy\n",
-                     dentry->d_name.len, dentry->d_name.name, status);
+                mlog(ML_ERROR, "unlink %pd, error %d from destroy\n",
+                     dentry, status);
                 goto bail;
         }
         status = simple_unlink(dir, dentry);
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 21262f2b1654..37297c14f9a3 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -3725,8 +3725,7 @@ static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
                         break;
                 spin_unlock(&dentry_attach_lock);
 
-                mlog(0, "d_delete(%.*s);\n", dentry->d_name.len,
-                     dentry->d_name.name);
+                mlog(0, "d_delete(%pd);\n", dentry);
 
                 /*
                  * The following dcache calls may do an
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 4b0c68849b36..4f502382180f 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -1982,10 +1982,12 @@ struct ocfs2_orphan_filldir_priv {
         struct ocfs2_super      *osb;
 };
 
-static int ocfs2_orphan_filldir(void *priv, const char *name, int name_len,
-                                loff_t pos, u64 ino, unsigned type)
+static int ocfs2_orphan_filldir(struct dir_context *ctx, const char *name,
+                                int name_len, loff_t pos, u64 ino,
+                                unsigned type)
 {
-        struct ocfs2_orphan_filldir_priv *p = priv;
+        struct ocfs2_orphan_filldir_priv *p =
+                container_of(ctx, struct ocfs2_orphan_filldir_priv, ctx);
         struct inode *iter;
 
         if (name_len == 1 && !strncmp(".", name, 1))
diff --git a/fs/open.c b/fs/open.c
index de92c13b58be..b1bf3d542d5d 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -516,7 +516,7 @@ SYSCALL_DEFINE2(fchmod, unsigned int, fd, umode_t, mode)
         int err = -EBADF;
 
         if (f.file) {
-                audit_inode(NULL, f.file->f_path.dentry, 0);
+                audit_file(f.file);
                 err = chmod_common(&f.file->f_path, mode);
                 fdput(f);
         }
@@ -642,7 +642,7 @@ SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
         error = mnt_want_write_file(f.file);
         if (error)
                 goto out_fput;
-        audit_inode(NULL, f.file->f_path.dentry, 0);
+        audit_file(f.file);
         error = chown_common(&f.file->f_path, user, group);
         mnt_drop_write_file(f.file);
 out_fput:
diff --git a/fs/overlayfs/readdir.c b/fs/overlayfs/readdir.c
index ab1e3dcbed95..c0205990a9f5 100644
--- a/fs/overlayfs/readdir.c
+++ b/fs/overlayfs/readdir.c
@@ -180,10 +180,12 @@ static void ovl_cache_put(struct ovl_dir_file *od, struct dentry *dentry)
         }
 }
 
-static int ovl_fill_merge(void *buf, const char *name, int namelen,
-                          loff_t offset, u64 ino, unsigned int d_type)
+static int ovl_fill_merge(struct dir_context *ctx, const char *name,
+                          int namelen, loff_t offset, u64 ino,
+                          unsigned int d_type)
 {
-        struct ovl_readdir_data *rdd = buf;
+        struct ovl_readdir_data *rdd =
+                container_of(ctx, struct ovl_readdir_data, ctx);
 
         rdd->count++;
         if (!rdd->is_merge)
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 772efa45a452..64891f3e41bd 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2789,7 +2789,7 @@ retry:
 int proc_pid_readdir(struct file *file, struct dir_context *ctx)
 {
         struct tgid_iter iter;
-        struct pid_namespace *ns = file->f_dentry->d_sb->s_fs_info;
+        struct pid_namespace *ns = file_inode(file)->i_sb->s_fs_info;
         loff_t pos = ctx->pos;
 
         if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
@@ -3095,7 +3095,7 @@ static int proc_task_readdir(struct file *file, struct dir_context *ctx)
         /* f_version caches the tgid value that the last readdir call couldn't
          * return. lseek aka telldir automagically resets f_version to 0.
          */
-        ns = file->f_dentry->d_sb->s_fs_info;
+        ns = inode->i_sb->s_fs_info;
         tid = (int)file->f_version;
         file->f_version = 0;
         for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);
diff --git a/fs/proc/fd.c b/fs/proc/fd.c
index e11d7c590bb0..8e5ad83b629a 100644
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -53,7 +53,8 @@ static int seq_show(struct seq_file *m, void *v)
                            (long long)file->f_pos, f_flags,
                            real_mount(file->f_path.mnt)->mnt_id);
                 if (file->f_op->show_fdinfo)
-                        ret = file->f_op->show_fdinfo(m, file);
+                        file->f_op->show_fdinfo(m, file);
+                ret = seq_has_overflowed(m);
                 fput(file);
         }
 
diff --git a/fs/readdir.c b/fs/readdir.c
index 33fd92208cb7..ced679179cac 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -74,10 +74,11 @@ struct readdir_callback {
         int result;
 };
 
-static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset,
-                      u64 ino, unsigned int d_type)
+static int fillonedir(struct dir_context *ctx, const char *name, int namlen,
+                      loff_t offset, u64 ino, unsigned int d_type)
 {
-        struct readdir_callback *buf = (struct readdir_callback *) __buf;
+        struct readdir_callback *buf =
+                container_of(ctx, struct readdir_callback, ctx);
         struct old_linux_dirent __user * dirent;
         unsigned long d_ino;
 
@@ -148,11 +149,12 @@ struct getdents_callback {
         int error;
 };
 
-static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
-                   u64 ino, unsigned int d_type)
+static int filldir(struct dir_context *ctx, const char *name, int namlen,
+                   loff_t offset, u64 ino, unsigned int d_type)
 {
         struct linux_dirent __user * dirent;
-        struct getdents_callback * buf = (struct getdents_callback *) __buf;
+        struct getdents_callback *buf =
+                container_of(ctx, struct getdents_callback, ctx);
         unsigned long d_ino;
         int reclen = ALIGN(offsetof(struct linux_dirent, d_name) + namlen + 2,
                 sizeof(long));
@@ -232,11 +234,12 @@ struct getdents_callback64 {
         int error;
 };
 
-static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
-                     u64 ino, unsigned int d_type)
+static int filldir64(struct dir_context *ctx, const char *name, int namlen,
+                     loff_t offset, u64 ino, unsigned int d_type)
 {
         struct linux_dirent64 __user *dirent;
-        struct getdents_callback64 * buf = (struct getdents_callback64 *) __buf;
+        struct getdents_callback64 *buf =
+                container_of(ctx, struct getdents_callback64, ctx);
         int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
                 sizeof(u64));
 
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 7c36898af402..04b06146bae2 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -188,10 +188,11 @@ struct reiserfs_dentry_buf {
 };
 
 static int
-fill_with_dentries(void *buf, const char *name, int namelen, loff_t offset,
-                    u64 ino, unsigned int d_type)
+fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
+                   loff_t offset, u64 ino, unsigned int d_type)
 {
-        struct reiserfs_dentry_buf *dbuf = buf;
+        struct reiserfs_dentry_buf *dbuf =
+                container_of(ctx, struct reiserfs_dentry_buf, ctx);
         struct dentry *dentry;
 
         WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
@@ -209,9 +210,9 @@ fill_with_dentries(void *buf, const char *name, int namelen, loff_t offset,
         } else if (!dentry->d_inode) {
                 /* A directory entry exists, but no file? */
                 reiserfs_error(dentry->d_sb, "xattr-20003",
-                               "Corrupted directory: xattr %s listed but "
-                               "not found for file %s.\n",
-                               dentry->d_name.name, dbuf->xadir->d_name.name);
+                               "Corrupted directory: xattr %pd listed but "
+                               "not found for file %pd.\n",
+                               dentry, dbuf->xadir);
                 dput(dentry);
                 return -EIO;
         }
@@ -824,10 +825,12 @@ struct listxattr_buf {
         struct dentry *dentry;
 };
 
-static int listxattr_filler(void *buf, const char *name, int namelen,
-                            loff_t offset, u64 ino, unsigned int d_type)
+static int listxattr_filler(struct dir_context *ctx, const char *name,
+                            int namelen, loff_t offset, u64 ino,
+                            unsigned int d_type)
 {
-        struct listxattr_buf *b = (struct listxattr_buf *)buf;
+        struct listxattr_buf *b =
+                container_of(ctx, struct listxattr_buf, ctx);
         size_t size;
 
         if (name[0] != '.' ||
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 3857b720cb1b..353948ba1c5b 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -16,17 +16,6 @@
 #include <asm/uaccess.h>
 #include <asm/page.h>
 
-
-/*
- * seq_files have a buffer which can may overflow. When this happens a larger
- * buffer is reallocated and all the data will be printed again.
- * The overflow state is true when m->count == m->size.
- */
-static bool seq_overflow(struct seq_file *m)
-{
-        return m->count == m->size;
-}
-
 static void seq_set_overflow(struct seq_file *m)
 {
         m->count = m->size;
@@ -124,7 +113,7 @@ static int traverse(struct seq_file *m, loff_t offset)
                         error = 0;
                         m->count = 0;
                 }
-                if (seq_overflow(m))
+                if (seq_has_overflowed(m))
                         goto Eoverflow;
                 if (pos + m->count > offset) {
                         m->from = offset - pos;
@@ -267,7 +256,7 @@ Fill:
                         break;
                 }
                 err = m->op->show(m, p);
-                if (seq_overflow(m) || err) {
+                if (seq_has_overflowed(m) || err) {
                         m->count = offs;
                         if (likely(err <= 0))
                                 break;
diff --git a/fs/signalfd.c b/fs/signalfd.c
index 424b7b65321f..7e412ad74836 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -230,7 +230,7 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
 }
 
 #ifdef CONFIG_PROC_FS
-static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
+static void signalfd_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct signalfd_ctx *ctx = f->private_data;
         sigset_t sigmask;
@@ -238,8 +238,6 @@ static int signalfd_show_fdinfo(struct seq_file *m, struct file *f)
         sigmask = ctx->sigmask;
         signotset(&sigmask);
         render_sigset_t(m, "sigmask:\t", &sigmask);
-
-        return 0;
 }
 #endif
 
diff --git a/fs/sync.c b/fs/sync.c
index bdc729d80e5e..01d9f18a70b5 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -154,7 +154,7 @@ SYSCALL_DEFINE1(syncfs, int, fd)
 
         if (!f.file)
                 return -EBADF;
-        sb = f.file->f_dentry->d_sb;
+        sb = f.file->f_path.dentry->d_sb;
 
         down_read(&sb->s_umount);
         ret = sync_filesystem(sb);
diff --git a/fs/timerfd.c b/fs/timerfd.c
index b46ffa94372a..b94fa6c3c6eb 100644
--- a/fs/timerfd.c
+++ b/fs/timerfd.c
@@ -288,7 +288,7 @@ static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
 }
 
 #ifdef CONFIG_PROC_FS
-static int timerfd_show(struct seq_file *m, struct file *file)
+static void timerfd_show(struct seq_file *m, struct file *file)
 {
         struct timerfd_ctx *ctx = file->private_data;
         struct itimerspec t;
@@ -298,18 +298,19 @@ static int timerfd_show(struct seq_file *m, struct file *file)
         t.it_interval = ktime_to_timespec(ctx->tintv);
         spin_unlock_irq(&ctx->wqh.lock);
 
-        return seq_printf(m,
-                          "clockid: %d\n"
-                          "ticks: %llu\n"
-                          "settime flags: 0%o\n"
-                          "it_value: (%llu, %llu)\n"
-                          "it_interval: (%llu, %llu)\n",
-                          ctx->clockid, (unsigned long long)ctx->ticks,
-                          ctx->settime_flags,
-                          (unsigned long long)t.it_value.tv_sec,
-                          (unsigned long long)t.it_value.tv_nsec,
-                          (unsigned long long)t.it_interval.tv_sec,
-                          (unsigned long long)t.it_interval.tv_nsec);
+        seq_printf(m,
+                   "clockid: %d\n"
+                   "ticks: %llu\n"
+                   "settime flags: 0%o\n"
+                   "it_value: (%llu, %llu)\n"
+                   "it_interval: (%llu, %llu)\n",
+                   ctx->clockid,
+                   (unsigned long long)ctx->ticks,
+                   ctx->settime_flags,
+                   (unsigned long long)t.it_value.tv_sec,
+                   (unsigned long long)t.it_value.tv_nsec,
+                   (unsigned long long)t.it_interval.tv_sec,
+                   (unsigned long long)t.it_interval.tv_nsec);
 }
 #else
 #define timerfd_show NULL
diff --git a/fs/xattr.c b/fs/xattr.c
index 64e83efb742d..4ef698549e31 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -405,16 +405,14 @@ SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
                 const void __user *,value, size_t, size, int, flags)
 {
         struct fd f = fdget(fd);
-        struct dentry *dentry;
         int error = -EBADF;
 
         if (!f.file)
                 return error;
-        dentry = f.file->f_path.dentry;
-        audit_inode(NULL, dentry, 0);
+        audit_file(f.file);
         error = mnt_want_write_file(f.file);
         if (!error) {
-                error = setxattr(dentry, name, value, size, flags);
+                error = setxattr(f.file->f_path.dentry, name, value, size, flags);
                 mnt_drop_write_file(f.file);
         }
         fdput(f);
@@ -509,7 +507,7 @@ SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
 
         if (!f.file)
                 return error;
-        audit_inode(NULL, f.file->f_path.dentry, 0);
+        audit_file(f.file);
         error = getxattr(f.file->f_path.dentry, name, value, size);
         fdput(f);
         return error;
@@ -590,7 +588,7 @@ SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
 
         if (!f.file)
                 return error;
-        audit_inode(NULL, f.file->f_path.dentry, 0);
+        audit_file(f.file);
         error = listxattr(f.file->f_path.dentry, list, size);
         fdput(f);
         return error;
@@ -651,16 +649,14 @@ SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
 {
         struct fd f = fdget(fd);
-        struct dentry *dentry;
         int error = -EBADF;
 
         if (!f.file)
                 return error;
-        dentry = f.file->f_path.dentry;
-        audit_inode(NULL, dentry, 0);
+        audit_file(f.file);
         error = mnt_want_write_file(f.file);
         if (!error) {
-                error = removexattr(dentry, name);
+                error = removexattr(f.file->f_path.dentry, name);
                 mnt_drop_write_file(f.file);
         }
         fdput(f);
diff --git a/include/linux/audit.h b/include/linux/audit.h
index e58fe7df8b9c..0c04917c2f12 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -130,6 +130,7 @@ extern void audit_putname(struct filename *name);
 #define AUDIT_INODE_HIDDEN      2       /* audit record should be hidden */
 extern void __audit_inode(struct filename *name, const struct dentry *dentry,
                                 unsigned int flags);
+extern void __audit_file(const struct file *);
 extern void __audit_inode_child(const struct inode *parent,
                                 const struct dentry *dentry,
                                 const unsigned char type);
@@ -183,6 +184,11 @@ static inline void audit_inode(struct filename *name,
                 __audit_inode(name, dentry, flags);
         }
 }
+static inline void audit_file(struct file *file)
+{
+        if (unlikely(!audit_dummy_context()))
+                __audit_file(file);
+}
 static inline void audit_inode_parent_hidden(struct filename *name,
                                                 const struct dentry *dentry)
 {
@@ -357,6 +363,9 @@ static inline void audit_inode(struct filename *name,
                                 const struct dentry *dentry,
                                 unsigned int parent)
 { }
+static inline void audit_file(struct file *file)
+{
+}
 static inline void audit_inode_parent_hidden(struct filename *name,
                                 const struct dentry *dentry)
 { }
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 1d5196889048..27b0c9105da5 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -367,8 +367,8 @@ struct css_set {
  * struct cftype: handler definitions for cgroup control files
  *
  * When reading/writing to a file:
- *      - the cgroup to use is file->f_dentry->d_parent->d_fsdata
- *      - the 'cftype' of the file is file->f_dentry->d_fsdata
+ *      - the cgroup to use is file->f_path.dentry->d_parent->d_fsdata
+ *      - the 'cftype' of the file is file->f_path.dentry->d_fsdata
  */
 
 /* cftype->flags */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index b2a2a08523bf..5a813988e6d4 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -124,15 +124,15 @@ struct dentry {
         void *d_fsdata;                 /* fs-specific data */
 
         struct list_head d_lru;         /* LRU list */
+        struct list_head d_child;       /* child of parent list */
+        struct list_head d_subdirs;     /* our children */
         /*
-         * d_child and d_rcu can share memory
+         * d_alias and d_rcu can share memory
          */
         union {
-                struct list_head d_child;       /* child of parent list */
+                struct hlist_node d_alias;      /* inode alias list */
                 struct rcu_head d_rcu;
         } d_u;
-        struct list_head d_subdirs;     /* our children */
-        struct hlist_node d_alias;      /* inode alias list */
 };
 
 /*
@@ -230,7 +230,6 @@ extern seqlock_t rename_lock;
  */
 extern void d_instantiate(struct dentry *, struct inode *);
 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
-extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
 extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 4d0b4d1aa132..d84f8c254a87 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -92,8 +92,8 @@ struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
                                      struct dentry *parent,
                                      struct debugfs_regset32 *regset);
 
-int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
-                         int nregs, void __iomem *base, char *prefix);
+void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+                          int nregs, void __iomem *base, char *prefix);
 
 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
                                         struct dentry *parent,
@@ -233,10 +233,9 @@ static inline struct dentry *debugfs_create_regset32(const char *name,
         return ERR_PTR(-ENODEV);
 }
 
-static inline int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+static inline void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
                          int nregs, void __iomem *base, char *prefix)
 {
-        return 0;
 }
 
 static inline bool debugfs_initialized(void)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index f21b15804917..bb29b02d9bb6 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -786,7 +786,6 @@ struct file {
                 struct rcu_head         fu_rcuhead;
         } f_u;
         struct path             f_path;
-#define f_dentry        f_path.dentry
         struct inode            *f_inode;       /* cached value */
         const struct file_operations    *f_op;
 
@@ -1465,7 +1464,10 @@ int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
-typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
+struct dir_context;
+typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
+                         unsigned);
+
 struct dir_context {
         const filldir_t actor;
         loff_t pos;
@@ -1511,7 +1513,7 @@ struct file_operations {
         int (*setlease)(struct file *, long, struct file_lock **, void **);
         long (*fallocate)(struct file *file, int mode, loff_t offset,
                           loff_t len);
-        int (*show_fdinfo)(struct seq_file *m, struct file *f);
+        void (*show_fdinfo)(struct seq_file *m, struct file *f);
 };
 
 struct inode_operations {
@@ -2787,6 +2789,11 @@ static inline void inode_has_no_xattr(struct inode *inode)
                 inode->i_flags |= S_NOSEC;
 }
 
+static inline bool is_root_inode(struct inode *inode)
+{
+        return inode == inode->i_sb->s_root->d_inode;
+}
+
 static inline bool dir_emit(struct dir_context *ctx,
                             const char *name, int namelen,
                             u64 ino, unsigned type)
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 52e0097f61f0..cf6a9daaaf6d 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -43,6 +43,21 @@ struct seq_operations {
 #define SEQ_SKIP 1
 
 /**
+ * seq_has_overflowed - check if the buffer has overflowed
+ * @m: the seq_file handle
+ *
+ * seq_files have a buffer which may overflow. When this happens a larger
+ * buffer is reallocated and all the data will be printed again.
+ * The overflow state is true when m->count == m->size.
+ *
+ * Returns true if the buffer received more than it can hold.
+ */
+static inline bool seq_has_overflowed(struct seq_file *m)
+{
+        return m->count == m->size;
+}
+
+/**
  * seq_get_buf - get buffer to write arbitrary data to
  * @m: the seq_file handle
  * @bufp: the beginning of the buffer is stored here
diff --git a/include/linux/uio.h b/include/linux/uio.h
index 9b1581414cd4..bd8569a14c4a 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -31,6 +31,7 @@ struct iov_iter {
         size_t count;
         union {
                 const struct iovec *iov;
+                const struct kvec *kvec;
                 const struct bio_vec *bvec;
         };
         unsigned long nr_segs;
@@ -82,10 +83,13 @@ size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i);
 size_t copy_to_iter(void *addr, size_t bytes, struct iov_iter *i);
 size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i);
+size_t copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i);
 size_t iov_iter_zero(size_t bytes, struct iov_iter *);
 unsigned long iov_iter_alignment(const struct iov_iter *i);
 void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
                         unsigned long nr_segs, size_t count);
+void iov_iter_kvec(struct iov_iter *i, int direction, const struct kvec *iov,
+                        unsigned long nr_segs, size_t count);
 ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
                         size_t maxsize, unsigned maxpages, size_t *start);
 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
@@ -123,6 +127,8 @@ static inline void iov_iter_reexpand(struct iov_iter *i, size_t count)
 {
         i->count = count;
 }
+size_t csum_and_copy_to_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
+size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
 
 int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
 int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len);
diff --git a/include/net/netfilter/nf_conntrack_core.h b/include/net/netfilter/nf_conntrack_core.h
index cc0c18827602..f2f0fa3bb150 100644
--- a/include/net/netfilter/nf_conntrack_core.h
+++ b/include/net/netfilter/nf_conntrack_core.h
@@ -72,7 +72,7 @@ static inline int nf_conntrack_confirm(struct sk_buff *skb)
         return ret;
 }
 
-int
+void
 print_tuple(struct seq_file *s, const struct nf_conntrack_tuple *tuple,
             const struct nf_conntrack_l3proto *l3proto,
             const struct nf_conntrack_l4proto *proto);
diff --git a/include/net/netfilter/nf_conntrack_l3proto.h b/include/net/netfilter/nf_conntrack_l3proto.h
index adc1fa3dd7ab..cdc920b4c4c2 100644
--- a/include/net/netfilter/nf_conntrack_l3proto.h
+++ b/include/net/netfilter/nf_conntrack_l3proto.h
@@ -38,8 +38,8 @@ struct nf_conntrack_l3proto {
                              const struct nf_conntrack_tuple *orig);
 
         /* Print out the per-protocol part of the tuple. */
-        int (*print_tuple)(struct seq_file *s,
-                           const struct nf_conntrack_tuple *);
+        void (*print_tuple)(struct seq_file *s,
+                            const struct nf_conntrack_tuple *);
 
         /*
          * Called before tracking. 
diff --git a/include/net/netfilter/nf_conntrack_l4proto.h b/include/net/netfilter/nf_conntrack_l4proto.h
index 4c8d573830b7..1f7061313d54 100644
--- a/include/net/netfilter/nf_conntrack_l4proto.h
+++ b/include/net/netfilter/nf_conntrack_l4proto.h
@@ -56,11 +56,11 @@ struct nf_conntrack_l4proto {
                      u_int8_t pf, unsigned int hooknum);
 
         /* Print out the per-protocol part of the tuple. Return like seq_* */
-        int (*print_tuple)(struct seq_file *s,
-                           const struct nf_conntrack_tuple *);
+        void (*print_tuple)(struct seq_file *s,
+                            const struct nf_conntrack_tuple *);
 
         /* Print out the private part of the conntrack. */
-        int (*print_conntrack)(struct seq_file *s, struct nf_conn *);
+        void (*print_conntrack)(struct seq_file *s, struct nf_conn *);
 
         /* Return the array of timeouts for this protocol. */
         unsigned int *(*get_timeouts)(struct net *net);
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 4fcf39af1776..7635a1cf99f3 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -990,7 +990,7 @@ SYSCALL_DEFINE5(mq_timedsend, mqd_t, mqdes, const char __user *, u_msg_ptr,
                 goto out_fput;
         }
         info = MQUEUE_I(inode);
-        audit_inode(NULL, f.file->f_path.dentry, 0);
+        audit_file(f.file);
 
         if (unlikely(!(f.file->f_mode & FMODE_WRITE))) {
                 ret = -EBADF;
@@ -1106,7 +1106,7 @@ SYSCALL_DEFINE5(mq_timedreceive, mqd_t, mqdes, char __user *, u_msg_ptr,
                 goto out_fput;
         }
         info = MQUEUE_I(inode);
-        audit_inode(NULL, f.file->f_path.dentry, 0);
+        audit_file(f.file);
 
         if (unlikely(!(f.file->f_mode & FMODE_READ))) {
                 ret = -EBADF;
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index e420a0c41b5f..c75522a83678 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -1897,6 +1897,11 @@ out:
         audit_copy_inode(n, dentry, inode);
 }
 
+void __audit_file(const struct file *file)
+{
+        __audit_inode(NULL, file->f_path.dentry, 0);
+}
+
 /**
  * __audit_inode_child - collect inode info for created/removed objects
  * @parent: inode of dentry parent
@@ -2373,7 +2378,7 @@ int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
         ax->d.next = context->aux;
         context->aux = (void *)ax;
 
-        dentry = dget(bprm->file->f_dentry);
+        dentry = dget(bprm->file->f_path.dentry);
         get_vfs_caps_from_disk(dentry, &vcaps);
         dput(dentry);
 
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 3e19d3ebc29c..113b837470cd 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -614,7 +614,7 @@ static inline int perf_cgroup_connect(int fd, struct perf_event *event,
         if (!f.file)
                 return -EBADF;
 
-        css = css_tryget_online_from_dir(f.file->f_dentry,
+        css = css_tryget_online_from_dir(f.file->f_path.dentry,
                                          &perf_event_cgrp_subsys);
         if (IS_ERR(css)) {
                 ret = PTR_ERR(css);
diff --git a/kernel/taskstats.c b/kernel/taskstats.c
index b312fcc73024..670fff88a961 100644
--- a/kernel/taskstats.c
+++ b/kernel/taskstats.c
@@ -459,7 +459,7 @@ static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
         stats = nla_data(na);
         memset(stats, 0, sizeof(*stats));
 
-        rc = cgroupstats_build(stats, f.file->f_dentry);
+        rc = cgroupstats_build(stats, f.file->f_path.dentry);
         if (rc < 0) {
                 nlmsg_free(rep_skb);
                 goto err;
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 92f4a6cee172..426962b04183 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -6417,7 +6417,7 @@ static int instance_mkdir (struct inode *inode, struct dentry *dentry, umode_t m
         int ret;
 
         /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
         if (WARN_ON_ONCE(parent != trace_instance_dir))
                 return -ENOENT;
 
@@ -6444,7 +6444,7 @@ static int instance_rmdir(struct inode *inode, struct dentry *dentry)
         int ret;
 
         /* Paranoid: Make sure the parent is the "instances" directory */
-        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+        parent = hlist_entry(inode->i_dentry.first, struct dentry, d_u.d_alias);
         if (WARN_ON_ONCE(parent != trace_instance_dir))
                 return -ENOENT;
 
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 0cc51edde3a8..1b0df1e504f0 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -461,7 +461,7 @@ 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_u.d_child) {
+                list_for_each_entry(child, &dir->d_subdirs, d_child) {
                         if (child->d_inode)     /* probably unneeded */
                                 child->d_inode->i_private = NULL;
                 }
diff --git a/mm/iov_iter.c b/mm/iov_iter.c
index e34a3cb6aad6..a1599ca4ab0e 100644
--- a/mm/iov_iter.c
+++ b/mm/iov_iter.c
@@ -3,95 +3,136 @@
 #include <linux/pagemap.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
-
-static size_t copy_to_iter_iovec(void *from, size_t bytes, struct iov_iter *i)
-{
-        size_t skip, copy, left, wanted;
-        const struct iovec *iov;
-        char __user *buf;
-
-        if (unlikely(bytes > i->count))
-                bytes = i->count;
-
-        if (unlikely(!bytes))
-                return 0;
-
-        wanted = bytes;
-        iov = i->iov;
-        skip = i->iov_offset;
-        buf = iov->iov_base + skip;
-        copy = min(bytes, iov->iov_len - skip);
-
-        left = __copy_to_user(buf, from, copy);
-        copy -= left;
-        skip += copy;
-        from += copy;
-        bytes -= copy;
-        while (unlikely(!left && bytes)) {
-                iov++;
-                buf = iov->iov_base;
-                copy = min(bytes, iov->iov_len);
-                left = __copy_to_user(buf, from, copy);
-                copy -= left;
-                skip = copy;
-                from += copy;
-                bytes -= copy;
-        }
-
-        if (skip == iov->iov_len) {
-                iov++;
-                skip = 0;
-        }
-        i->count -= wanted - bytes;
-        i->nr_segs -= iov - i->iov;
-        i->iov = iov;
-        i->iov_offset = skip;
-        return wanted - bytes;
-}
-
-static size_t copy_from_iter_iovec(void *to, size_t bytes, struct iov_iter *i)
-{
-        size_t skip, copy, left, wanted;
-        const struct iovec *iov;
-        char __user *buf;
-
-        if (unlikely(bytes > i->count))
-                bytes = i->count;
-
-        if (unlikely(!bytes))
-                return 0;
-
-        wanted = bytes;
-        iov = i->iov;
-        skip = i->iov_offset;
-        buf = iov->iov_base + skip;
-        copy = min(bytes, iov->iov_len - skip);
-
-        left = __copy_from_user(to, buf, copy);
-        copy -= left;
-        skip += copy;
-        to += copy;
-        bytes -= copy;
-        while (unlikely(!left && bytes)) {
-                iov++;
-                buf = iov->iov_base;
-                copy = min(bytes, iov->iov_len);
-                left = __copy_from_user(to, buf, copy);
-                copy -= left;
-                skip = copy;
-                to += copy;
-                bytes -= copy;
-        }
-
-        if (skip == iov->iov_len) {
-                iov++;
-                skip = 0;
-        }
-        i->count -= wanted - bytes;
-        i->nr_segs -= iov - i->iov;
-        i->iov = iov;
-        i->iov_offset = skip;
-        return wanted - bytes;
+#include <net/checksum.h>
+
+#define iterate_iovec(i, n, __v, __p, skip, STEP) {     \
+        size_t left;                                    \
+        size_t wanted = n;                              \
+        __p = i->iov;                                   \
+        __v.iov_len = min(n, __p->iov_len - skip);      \
+        if (likely(__v.iov_len)) {                      \
+                __v.iov_base = __p->iov_base + skip;    \
+                left = (STEP);                          \
+                __v.iov_len -= left;                    \
+                skip += __v.iov_len;                    \
+                n -= __v.iov_len;                       \
+        } else {                                        \
+                left = 0;                               \
+        }                                               \
+        while (unlikely(!left && n)) {                  \
+                __p++;                                  \
+                __v.iov_len = min(n, __p->iov_len);     \
+                if (unlikely(!__v.iov_len))             \
+                        continue;                       \
+                __v.iov_base = __p->iov_base;           \
+                left = (STEP);                          \
+                __v.iov_len -= left;                    \
+                skip = __v.iov_len;                     \
+                n -= __v.iov_len;                       \
+        }                                               \
+        n = wanted - n;                                 \
+}
+
+#define iterate_kvec(i, n, __v, __p, skip, STEP) {      \
+        size_t wanted = n;                              \
+        __p = i->kvec;                                  \
+        __v.iov_len = min(n, __p->iov_len - skip);      \
+        if (likely(__v.iov_len)) {                      \
+                __v.iov_base = __p->iov_base + skip;    \
+                (void)(STEP);                           \
+                skip += __v.iov_len;                    \
+                n -= __v.iov_len;                       \
+        }                                               \
+        while (unlikely(n)) {                           \
+                __p++;                                  \
+                __v.iov_len = min(n, __p->iov_len);     \
+                if (unlikely(!__v.iov_len))             \
+                        continue;                       \
+                __v.iov_base = __p->iov_base;           \
+                (void)(STEP);                           \
+                skip = __v.iov_len;                     \
+                n -= __v.iov_len;                       \
+        }                                               \
+        n = wanted;                                     \
+}
+
+#define iterate_bvec(i, n, __v, __p, skip, STEP) {      \
+        size_t wanted = n;                              \
+        __p = i->bvec;                                  \
+        __v.bv_len = min_t(size_t, n, __p->bv_len - skip);      \
+        if (likely(__v.bv_len)) {                       \
+                __v.bv_page = __p->bv_page;             \
+                __v.bv_offset = __p->bv_offset + skip;  \
+                (void)(STEP);                           \
+                skip += __v.bv_len;                     \
+                n -= __v.bv_len;                        \
+        }                                               \
+        while (unlikely(n)) {                           \
+                __p++;                                  \
+                __v.bv_len = min_t(size_t, n, __p->bv_len);     \
+                if (unlikely(!__v.bv_len))              \
+                        continue;                       \
+                __v.bv_page = __p->bv_page;             \
+                __v.bv_offset = __p->bv_offset;         \
+                (void)(STEP);                           \
+                skip = __v.bv_len;                      \
+                n -= __v.bv_len;                        \
+        }                                               \
+        n = wanted;                                     \
+}
+
+#define iterate_all_kinds(i, n, v, I, B, K) {                   \
+        size_t skip = i->iov_offset;                            \
+        if (unlikely(i->type & ITER_BVEC)) {                    \
+                const struct bio_vec *bvec;                     \
+                struct bio_vec v;                               \
+                iterate_bvec(i, n, v, bvec, skip, (B))          \
+        } else if (unlikely(i->type & ITER_KVEC)) {             \
+                const struct kvec *kvec;                        \
+                struct kvec v;                                  \
+                iterate_kvec(i, n, v, kvec, skip, (K))          \
+        } else {                                                \
+                const struct iovec *iov;                        \
+                struct iovec v;                                 \
+                iterate_iovec(i, n, v, iov, skip, (I))          \
+        }                                                       \
+}
+
+#define iterate_and_advance(i, n, v, I, B, K) {                 \
+        size_t skip = i->iov_offset;                            \
+        if (unlikely(i->type & ITER_BVEC)) {                    \
+                const struct bio_vec *bvec;                     \
+                struct bio_vec v;                               \
+                iterate_bvec(i, n, v, bvec, skip, (B))          \
+                if (skip == bvec->bv_len) {                     \
+                        bvec++;                                 \
+                        skip = 0;                               \
+                }                                               \
+                i->nr_segs -= bvec - i->bvec;                   \
+                i->bvec = bvec;                                 \
+        } else if (unlikely(i->type & ITER_KVEC)) {             \
+                const struct kvec *kvec;                        \
+                struct kvec v;                                  \
+                iterate_kvec(i, n, v, kvec, skip, (K))          \
+                if (skip == kvec->iov_len) {                    \
+                        kvec++;                                 \
+                        skip = 0;                               \
+                }                                               \
+                i->nr_segs -= kvec - i->kvec;                   \
+                i->kvec = kvec;                                 \
+        } else {                                                \
+                const struct iovec *iov;                        \
+                struct iovec v;                                 \
+                iterate_iovec(i, n, v, iov, skip, (I))          \
+                if (skip == iov->iov_len) {                     \
+                        iov++;                                  \
+                        skip = 0;                               \
+                }                                               \
+                i->nr_segs -= iov - i->iov;                     \
+                i->iov = iov;                                   \
+        }                                                       \
+        i->count -= n;                                          \
+        i->iov_offset = skip;                                   \
 }
 
 static size_t copy_page_to_iter_iovec(struct page *page, size_t offset, size_t bytes,
@@ -256,134 +297,6 @@ done:
         return wanted - bytes;
 }
 
-static size_t zero_iovec(size_t bytes, struct iov_iter *i)
-{
-        size_t skip, copy, left, wanted;
-        const struct iovec *iov;
-        char __user *buf;
-
-        if (unlikely(bytes > i->count))
-                bytes = i->count;
-
-        if (unlikely(!bytes))
-                return 0;
-
-        wanted = bytes;
-        iov = i->iov;
-        skip = i->iov_offset;
-        buf = iov->iov_base + skip;
-        copy = min(bytes, iov->iov_len - skip);
-
-        left = __clear_user(buf, copy);
-        copy -= left;
-        skip += copy;
-        bytes -= copy;
-
-        while (unlikely(!left && bytes)) {
-                iov++;
-                buf = iov->iov_base;
-                copy = min(bytes, iov->iov_len);
-                left = __clear_user(buf, copy);
-                copy -= left;
-                skip = copy;
-                bytes -= copy;
-        }
-
-        if (skip == iov->iov_len) {
-                iov++;
-                skip = 0;
-        }
-        i->count -= wanted - bytes;
-        i->nr_segs -= iov - i->iov;
-        i->iov = iov;
-        i->iov_offset = skip;
-        return wanted - bytes;
-}
-
-static size_t __iovec_copy_from_user_inatomic(char *vaddr,
-                        const struct iovec *iov, size_t base, size_t bytes)
-{
-        size_t copied = 0, left = 0;
-
-        while (bytes) {
-                char __user *buf = iov->iov_base + base;
-                int copy = min(bytes, iov->iov_len - base);
-
-                base = 0;
-                left = __copy_from_user_inatomic(vaddr, buf, copy);
-                copied += copy;
-                bytes -= copy;
-                vaddr += copy;
-                iov++;
-
-                if (unlikely(left))
-                        break;
-        }
-        return copied - left;
-}
-
-/*
- * Copy as much as we can into the page and return the number of bytes which
- * were successfully copied.  If a fault is encountered then return the number of
- * bytes which were copied.
- */
-static size_t copy_from_user_atomic_iovec(struct page *page,
-                struct iov_iter *i, unsigned long offset, size_t bytes)
-{
-        char *kaddr;
-        size_t copied;
-
-        kaddr = kmap_atomic(page);
-        if (likely(i->nr_segs == 1)) {
-                int left;
-                char __user *buf = i->iov->iov_base + i->iov_offset;
-                left = __copy_from_user_inatomic(kaddr + offset, buf, bytes);
-                copied = bytes - left;
-        } else {
-                copied = __iovec_copy_from_user_inatomic(kaddr + offset,
-                                                i->iov, i->iov_offset, bytes);
-        }
-        kunmap_atomic(kaddr);
-
-        return copied;
-}
-
-static void advance_iovec(struct iov_iter *i, size_t bytes)
-{
-        BUG_ON(i->count < bytes);
-
-        if (likely(i->nr_segs == 1)) {
-                i->iov_offset += bytes;
-                i->count -= bytes;
-        } else {
-                const struct iovec *iov = i->iov;
-                size_t base = i->iov_offset;
-                unsigned long nr_segs = i->nr_segs;
-
-                /*
-                 * The !iov->iov_len check ensures we skip over unlikely
-                 * zero-length segments (without overruning the iovec).
-                 */
-                while (bytes || unlikely(i->count && !iov->iov_len)) {
-                        int copy;
-
-                        copy = min(bytes, iov->iov_len - base);
-                        BUG_ON(!i->count || i->count < copy);
-                        i->count -= copy;
-                        bytes -= copy;
-                        base += copy;
-                        if (iov->iov_len == base) {
-                                iov++;
-                                nr_segs--;
-                                base = 0;
-                        }
-                }
-                i->iov = iov;
-                i->iov_offset = base;
-                i->nr_segs = nr_segs;
-        }
-}
-
 /*
  * Fault in the first iovec of the given iov_iter, to a maximum length
  * of bytes. Returns 0 on success, or non-zero if the memory could not be
@@ -395,7 +308,7 @@ static void advance_iovec(struct iov_iter *i, size_t bytes)
  */
 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
 {
-        if (!(i->type & ITER_BVEC)) {
+        if (!(i->type & (ITER_BVEC|ITER_KVEC))) {
                 char __user *buf = i->iov->iov_base + i->iov_offset;
                 bytes = min(bytes, i->iov->iov_len - i->iov_offset);
                 return fault_in_pages_readable(buf, bytes);
@@ -404,136 +317,25 @@ int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
 }
 EXPORT_SYMBOL(iov_iter_fault_in_readable);
 
-static unsigned long alignment_iovec(const struct iov_iter *i)
-{
-        const struct iovec *iov = i->iov;
-        unsigned long res;
-        size_t size = i->count;
-        size_t n;
-
-        if (!size)
-                return 0;
-
-        res = (unsigned long)iov->iov_base + i->iov_offset;
-        n = iov->iov_len - i->iov_offset;
-        if (n >= size)
-                return res | size;
-        size -= n;
-        res |= n;
-        while (size > (++iov)->iov_len) {
-                res |= (unsigned long)iov->iov_base | iov->iov_len;
-                size -= iov->iov_len;
-        }
-        res |= (unsigned long)iov->iov_base | size;
-        return res;
-}
-
 void iov_iter_init(struct iov_iter *i, int direction,
                         const struct iovec *iov, unsigned long nr_segs,
                         size_t count)
 {
         /* It will get better.  Eventually... */
-        if (segment_eq(get_fs(), KERNEL_DS))
+        if (segment_eq(get_fs(), KERNEL_DS)) {
                 direction |= ITER_KVEC;
-        i->type = direction;
-        i->iov = iov;
+                i->type = direction;
+                i->kvec = (struct kvec *)iov;
+        } else {
+                i->type = direction;
+                i->iov = iov;
+        }
         i->nr_segs = nr_segs;
         i->iov_offset = 0;
         i->count = count;
 }
 EXPORT_SYMBOL(iov_iter_init);
 
-static ssize_t get_pages_iovec(struct iov_iter *i,
-                   struct page **pages, size_t maxsize, unsigned maxpages,
-                   size_t *start)
-{
-        size_t offset = i->iov_offset;
-        const struct iovec *iov = i->iov;
-        size_t len;
-        unsigned long addr;
-        int n;
-        int res;
-
-        len = iov->iov_len - offset;
-        if (len > i->count)
-                len = i->count;
-        if (len > maxsize)
-                len = maxsize;
-        addr = (unsigned long)iov->iov_base + offset;
-        len += *start = addr & (PAGE_SIZE - 1);
-        if (len > maxpages * PAGE_SIZE)
-                len = maxpages * PAGE_SIZE;
-        addr &= ~(PAGE_SIZE - 1);
-        n = (len + PAGE_SIZE - 1) / PAGE_SIZE;
-        res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, pages);
-        if (unlikely(res < 0))
-                return res;
-        return (res == n ? len : res * PAGE_SIZE) - *start;
-}
-
-static ssize_t get_pages_alloc_iovec(struct iov_iter *i,
-                   struct page ***pages, size_t maxsize,
-                   size_t *start)
-{
-        size_t offset = i->iov_offset;
-        const struct iovec *iov = i->iov;
-        size_t len;
-        unsigned long addr;
-        void *p;
-        int n;
-        int res;
-
-        len = iov->iov_len - offset;
-        if (len > i->count)
-                len = i->count;
-        if (len > maxsize)
-                len = maxsize;
-        addr = (unsigned long)iov->iov_base + offset;
-        len += *start = addr & (PAGE_SIZE - 1);
-        addr &= ~(PAGE_SIZE - 1);
-        n = (len + PAGE_SIZE - 1) / PAGE_SIZE;
-        
-        p = kmalloc(n * sizeof(struct page *), GFP_KERNEL);
-        if (!p)
-                p = vmalloc(n * sizeof(struct page *));
-        if (!p)
-                return -ENOMEM;
-
-        res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, p);
-        if (unlikely(res < 0)) {
-                kvfree(p);
-                return res;
-        }
-        *pages = p;
-        return (res == n ? len : res * PAGE_SIZE) - *start;
-}
-
-static int iov_iter_npages_iovec(const struct iov_iter *i, int maxpages)
-{
-        size_t offset = i->iov_offset;
-        size_t size = i->count;
-        const struct iovec *iov = i->iov;
-        int npages = 0;
-        int n;
-
-        for (n = 0; size && n < i->nr_segs; n++, iov++) {
-                unsigned long addr = (unsigned long)iov->iov_base + offset;
-                size_t len = iov->iov_len - offset;
-                offset = 0;
-                if (unlikely(!len))     /* empty segment */
-                        continue;
-                if (len > size)
-                        len = size;
-                npages += (addr + len + PAGE_SIZE - 1) / PAGE_SIZE
-                          - addr / PAGE_SIZE;
-                if (npages >= maxpages) /* don't bother going further */
-                        return maxpages;
-                size -= len;
-                offset = 0;
-        }
-        return min(npages, maxpages);
-}
-
 static void memcpy_from_page(char *to, struct page *page, size_t offset, size_t len)
 {
         char *from = kmap_atomic(page);
@@ -555,293 +357,78 @@ static void memzero_page(struct page *page, size_t offset, size_t len)
         kunmap_atomic(addr);
 }
 
-static size_t copy_to_iter_bvec(void *from, size_t bytes, struct iov_iter *i)
+size_t copy_to_iter(void *addr, size_t bytes, struct iov_iter *i)
 {
-        size_t skip, copy, wanted;
-        const struct bio_vec *bvec;
-
+        char *from = addr;
         if (unlikely(bytes > i->count))
                 bytes = i->count;
 
         if (unlikely(!bytes))
                 return 0;
 
-        wanted = bytes;
-        bvec = i->bvec;
-        skip = i->iov_offset;
-        copy = min_t(size_t, bytes, bvec->bv_len - skip);
+        iterate_and_advance(i, bytes, v,
+                __copy_to_user(v.iov_base, (from += v.iov_len) - v.iov_len,
+                               v.iov_len),
+                memcpy_to_page(v.bv_page, v.bv_offset,
+                               (from += v.bv_len) - v.bv_len, v.bv_len),
+                memcpy(v.iov_base, (from += v.iov_len) - v.iov_len, v.iov_len)
+        )
 
-        memcpy_to_page(bvec->bv_page, skip + bvec->bv_offset, from, copy);
-        skip += copy;
-        from += copy;
-        bytes -= copy;
-        while (bytes) {
-                bvec++;
-                copy = min(bytes, (size_t)bvec->bv_len);
-                memcpy_to_page(bvec->bv_page, bvec->bv_offset, from, copy);
-                skip = copy;
-                from += copy;
-                bytes -= copy;
-        }
-        if (skip == bvec->bv_len) {
-                bvec++;
-                skip = 0;
-        }
-        i->count -= wanted - bytes;
-        i->nr_segs -= bvec - i->bvec;
-        i->bvec = bvec;
-        i->iov_offset = skip;
-        return wanted - bytes;
+        return bytes;
 }
+EXPORT_SYMBOL(copy_to_iter);
 
-static size_t copy_from_iter_bvec(void *to, size_t bytes, struct iov_iter *i)
+size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
 {
-        size_t skip, copy, wanted;
-        const struct bio_vec *bvec;
-
+        char *to = addr;
         if (unlikely(bytes > i->count))
                 bytes = i->count;
 
         if (unlikely(!bytes))
                 return 0;
 
-        wanted = bytes;
-        bvec = i->bvec;
-        skip = i->iov_offset;
-
-        copy = min(bytes, bvec->bv_len - skip);
+        iterate_and_advance(i, bytes, v,
+                __copy_from_user((to += v.iov_len) - v.iov_len, v.iov_base,
+                                 v.iov_len),
+                memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
+                                 v.bv_offset, v.bv_len),
+                memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
+        )
 
-        memcpy_from_page(to, bvec->bv_page, bvec->bv_offset + skip, copy);
-
-        to += copy;
-        skip += copy;
-        bytes -= copy;
-
-        while (bytes) {
-                bvec++;
-                copy = min(bytes, (size_t)bvec->bv_len);
-                memcpy_from_page(to, bvec->bv_page, bvec->bv_offset, copy);
-                skip = copy;
-                to += copy;
-                bytes -= copy;
-        }
-        if (skip == bvec->bv_len) {
-                bvec++;
-                skip = 0;
-        }
-        i->count -= wanted;
-        i->nr_segs -= bvec - i->bvec;
-        i->bvec = bvec;
-        i->iov_offset = skip;
-        return wanted;
-}
-
-static size_t copy_page_to_iter_bvec(struct page *page, size_t offset,
-                                        size_t bytes, struct iov_iter *i)
-{
-        void *kaddr = kmap_atomic(page);
-        size_t wanted = copy_to_iter_bvec(kaddr + offset, bytes, i);
-        kunmap_atomic(kaddr);
-        return wanted;
-}
-
-static size_t copy_page_from_iter_bvec(struct page *page, size_t offset,
-                                        size_t bytes, struct iov_iter *i)
-{
-        void *kaddr = kmap_atomic(page);
-        size_t wanted = copy_from_iter_bvec(kaddr + offset, bytes, i);
-        kunmap_atomic(kaddr);
-        return wanted;
+        return bytes;
 }
+EXPORT_SYMBOL(copy_from_iter);
 
-static size_t zero_bvec(size_t bytes, struct iov_iter *i)
+size_t copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
 {
-        size_t skip, copy, wanted;
-        const struct bio_vec *bvec;
-
+        char *to = addr;
         if (unlikely(bytes > i->count))
                 bytes = i->count;
 
         if (unlikely(!bytes))
                 return 0;
 
-        wanted = bytes;
-        bvec = i->bvec;
-        skip = i->iov_offset;
-        copy = min_t(size_t, bytes, bvec->bv_len - skip);
-
-        memzero_page(bvec->bv_page, skip + bvec->bv_offset, copy);
-        skip += copy;
-        bytes -= copy;
-        while (bytes) {
-                bvec++;
-                copy = min(bytes, (size_t)bvec->bv_len);
-                memzero_page(bvec->bv_page, bvec->bv_offset, copy);
-                skip = copy;
-                bytes -= copy;
-        }
-        if (skip == bvec->bv_len) {
-                bvec++;
-                skip = 0;
-        }
-        i->count -= wanted - bytes;
-        i->nr_segs -= bvec - i->bvec;
-        i->bvec = bvec;
-        i->iov_offset = skip;
-        return wanted - bytes;
-}
+        iterate_and_advance(i, bytes, v,
+                __copy_from_user_nocache((to += v.iov_len) - v.iov_len,
+                                         v.iov_base, v.iov_len),
+                memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
+                                 v.bv_offset, v.bv_len),
+                memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
+        )
 
-static size_t copy_from_user_bvec(struct page *page,
-                struct iov_iter *i, unsigned long offset, size_t bytes)
-{
-        char *kaddr;
-        size_t left;
-        const struct bio_vec *bvec;
-        size_t base = i->iov_offset;
-
-        kaddr = kmap_atomic(page);
-        for (left = bytes, bvec = i->bvec; left; bvec++, base = 0) {
-                size_t copy = min(left, bvec->bv_len - base);
-                if (!bvec->bv_len)
-                        continue;
-                memcpy_from_page(kaddr + offset, bvec->bv_page,
-                                 bvec->bv_offset + base, copy);
-                offset += copy;
-                left -= copy;
-        }
-        kunmap_atomic(kaddr);
         return bytes;
 }
-
-static void advance_bvec(struct iov_iter *i, size_t bytes)
-{
-        BUG_ON(i->count < bytes);
-
-        if (likely(i->nr_segs == 1)) {
-                i->iov_offset += bytes;
-                i->count -= bytes;
-        } else {
-                const struct bio_vec *bvec = i->bvec;
-                size_t base = i->iov_offset;
-                unsigned long nr_segs = i->nr_segs;
-
-                /*
-                 * The !iov->iov_len check ensures we skip over unlikely
-                 * zero-length segments (without overruning the iovec).
-                 */
-                while (bytes || unlikely(i->count && !bvec->bv_len)) {
-                        int copy;
-
-                        copy = min(bytes, bvec->bv_len - base);
-                        BUG_ON(!i->count || i->count < copy);
-                        i->count -= copy;
-                        bytes -= copy;
-                        base += copy;
-                        if (bvec->bv_len == base) {
-                                bvec++;
-                                nr_segs--;
-                                base = 0;
-                        }
-                }
-                i->bvec = bvec;
-                i->iov_offset = base;
-                i->nr_segs = nr_segs;
-        }
-}
-
-static unsigned long alignment_bvec(const struct iov_iter *i)
-{
-        const struct bio_vec *bvec = i->bvec;
-        unsigned long res;
-        size_t size = i->count;
-        size_t n;
-
-        if (!size)
-                return 0;
-
-        res = bvec->bv_offset + i->iov_offset;
-        n = bvec->bv_len - i->iov_offset;
-        if (n >= size)
-                return res | size;
-        size -= n;
-        res |= n;
-        while (size > (++bvec)->bv_len) {
-                res |= bvec->bv_offset | bvec->bv_len;
-                size -= bvec->bv_len;
-        }
-        res |= bvec->bv_offset | size;
-        return res;
-}
-
-static ssize_t get_pages_bvec(struct iov_iter *i,
-                   struct page **pages, size_t maxsize, unsigned maxpages,
-                   size_t *start)
-{
-        const struct bio_vec *bvec = i->bvec;
-        size_t len = bvec->bv_len - i->iov_offset;
-        if (len > i->count)
-                len = i->count;
-        if (len > maxsize)
-                len = maxsize;
-        /* can't be more than PAGE_SIZE */
-        *start = bvec->bv_offset + i->iov_offset;
-
-        get_page(*pages = bvec->bv_page);
-
-        return len;
-}
-
-static ssize_t get_pages_alloc_bvec(struct iov_iter *i,
-                   struct page ***pages, size_t maxsize,
-                   size_t *start)
-{
-        const struct bio_vec *bvec = i->bvec;
-        size_t len = bvec->bv_len - i->iov_offset;
-        if (len > i->count)
-                len = i->count;
-        if (len > maxsize)
-                len = maxsize;
-        *start = bvec->bv_offset + i->iov_offset;
-
-        *pages = kmalloc(sizeof(struct page *), GFP_KERNEL);
-        if (!*pages)
-                return -ENOMEM;
-
-        get_page(**pages = bvec->bv_page);
-
-        return len;
-}
-
-static int iov_iter_npages_bvec(const struct iov_iter *i, int maxpages)
-{
-        size_t offset = i->iov_offset;
-        size_t size = i->count;
-        const struct bio_vec *bvec = i->bvec;
-        int npages = 0;
-        int n;
-
-        for (n = 0; size && n < i->nr_segs; n++, bvec++) {
-                size_t len = bvec->bv_len - offset;
-                offset = 0;
-                if (unlikely(!len))     /* empty segment */
-                        continue;
-                if (len > size)
-                        len = size;
-                npages++;
-                if (npages >= maxpages) /* don't bother going further */
-                        return maxpages;
-                size -= len;
-                offset = 0;
-        }
-        return min(npages, maxpages);
-}
+EXPORT_SYMBOL(copy_from_iter_nocache);
 
 size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i)
 {
-        if (i->type & ITER_BVEC)
-                return copy_page_to_iter_bvec(page, offset, bytes, i);
-        else
+        if (i->type & (ITER_BVEC|ITER_KVEC)) {
+                void *kaddr = kmap_atomic(page);
+                size_t wanted = copy_to_iter(kaddr + offset, bytes, i);
+                kunmap_atomic(kaddr);
+                return wanted;
+        } else
                 return copy_page_to_iter_iovec(page, offset, bytes, i);
 }
 EXPORT_SYMBOL(copy_page_to_iter);
@@ -849,57 +436,53 @@ EXPORT_SYMBOL(copy_page_to_iter);
 size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i)
 {
-        if (i->type & ITER_BVEC)
-                return copy_page_from_iter_bvec(page, offset, bytes, i);
-        else
+        if (i->type & (ITER_BVEC|ITER_KVEC)) {
+                void *kaddr = kmap_atomic(page);
+                size_t wanted = copy_from_iter(kaddr + offset, bytes, i);
+                kunmap_atomic(kaddr);
+                return wanted;
+        } else
                 return copy_page_from_iter_iovec(page, offset, bytes, i);
 }
 EXPORT_SYMBOL(copy_page_from_iter);
 
-size_t copy_to_iter(void *addr, size_t bytes, struct iov_iter *i)
+size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
 {
-        if (i->type & ITER_BVEC)
-                return copy_to_iter_bvec(addr, bytes, i);
-        else
-                return copy_to_iter_iovec(addr, bytes, i);
-}
-EXPORT_SYMBOL(copy_to_iter);
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
 
-size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
-{
-        if (i->type & ITER_BVEC)
-                return copy_from_iter_bvec(addr, bytes, i);
-        else
-                return copy_from_iter_iovec(addr, bytes, i);
-}
-EXPORT_SYMBOL(copy_from_iter);
+        if (unlikely(!bytes))
+                return 0;
 
-size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
-{
-        if (i->type & ITER_BVEC) {
-                return zero_bvec(bytes, i);
-        } else {
-                return zero_iovec(bytes, i);
-        }
+        iterate_and_advance(i, bytes, v,
+                __clear_user(v.iov_base, v.iov_len),
+                memzero_page(v.bv_page, v.bv_offset, v.bv_len),
+                memset(v.iov_base, 0, v.iov_len)
+        )
+
+        return bytes;
 }
 EXPORT_SYMBOL(iov_iter_zero);
 
 size_t iov_iter_copy_from_user_atomic(struct page *page,
                 struct iov_iter *i, unsigned long offset, size_t bytes)
 {
-        if (i->type & ITER_BVEC)
-                return copy_from_user_bvec(page, i, offset, bytes);
-        else
-                return copy_from_user_atomic_iovec(page, i, offset, bytes);
+        char *kaddr = kmap_atomic(page), *p = kaddr + offset;
+        iterate_all_kinds(i, bytes, v,
+                __copy_from_user_inatomic((p += v.iov_len) - v.iov_len,
+                                          v.iov_base, v.iov_len),
+                memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page,
+                                 v.bv_offset, v.bv_len),
+                memcpy((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
+        )
+        kunmap_atomic(kaddr);
+        return bytes;
 }
 EXPORT_SYMBOL(iov_iter_copy_from_user_atomic);
 
 void iov_iter_advance(struct iov_iter *i, size_t size)
 {
-        if (i->type & ITER_BVEC)
-                advance_bvec(i, size);
-        else
-                advance_iovec(i, size);
+        iterate_and_advance(i, size, v, 0, 0, 0)
 }
 EXPORT_SYMBOL(iov_iter_advance);
 
@@ -917,12 +500,33 @@ size_t iov_iter_single_seg_count(const struct iov_iter *i)
 }
 EXPORT_SYMBOL(iov_iter_single_seg_count);
 
+void iov_iter_kvec(struct iov_iter *i, int direction,
+                        const struct kvec *iov, unsigned long nr_segs,
+                        size_t count)
+{
+        BUG_ON(!(direction & ITER_KVEC));
+        i->type = direction;
+        i->kvec = (struct kvec *)iov;
+        i->nr_segs = nr_segs;
+        i->iov_offset = 0;
+        i->count = count;
+}
+EXPORT_SYMBOL(iov_iter_kvec);
+
 unsigned long iov_iter_alignment(const struct iov_iter *i)
 {
-        if (i->type & ITER_BVEC)
-                return alignment_bvec(i);
-        else
-                return alignment_iovec(i);
+        unsigned long res = 0;
+        size_t size = i->count;
+
+        if (!size)
+                return 0;
+
+        iterate_all_kinds(i, size, v,
+                (res |= (unsigned long)v.iov_base | v.iov_len, 0),
+                res |= v.bv_offset | v.bv_len,
+                res |= (unsigned long)v.iov_base | v.iov_len
+        )
+        return res;
 }
 EXPORT_SYMBOL(iov_iter_alignment);
 
@@ -930,29 +534,207 @@ ssize_t iov_iter_get_pages(struct iov_iter *i,
                    struct page **pages, size_t maxsize, unsigned maxpages,
                    size_t *start)
 {
-        if (i->type & ITER_BVEC)
-                return get_pages_bvec(i, pages, maxsize, maxpages, start);
-        else
-                return get_pages_iovec(i, pages, maxsize, maxpages, start);
+        if (maxsize > i->count)
+                maxsize = i->count;
+
+        if (!maxsize)
+                return 0;
+
+        iterate_all_kinds(i, maxsize, v, ({
+                unsigned long addr = (unsigned long)v.iov_base;
+                size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
+                int n;
+                int res;
+
+                if (len > maxpages * PAGE_SIZE)
+                        len = maxpages * PAGE_SIZE;
+                addr &= ~(PAGE_SIZE - 1);
+                n = DIV_ROUND_UP(len, PAGE_SIZE);
+                res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, pages);
+                if (unlikely(res < 0))
+                        return res;
+                return (res == n ? len : res * PAGE_SIZE) - *start;
+        0;}),({
+                /* can't be more than PAGE_SIZE */
+                *start = v.bv_offset;
+                get_page(*pages = v.bv_page);
+                return v.bv_len;
+        }),({
+                return -EFAULT;
+        })
+        )
+        return 0;
 }
 EXPORT_SYMBOL(iov_iter_get_pages);
 
+static struct page **get_pages_array(size_t n)
+{
+        struct page **p = kmalloc(n * sizeof(struct page *), GFP_KERNEL);
+        if (!p)
+                p = vmalloc(n * sizeof(struct page *));
+        return p;
+}
+
 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
                    struct page ***pages, size_t maxsize,
                    size_t *start)
 {
-        if (i->type & ITER_BVEC)
-                return get_pages_alloc_bvec(i, pages, maxsize, start);
-        else
-                return get_pages_alloc_iovec(i, pages, maxsize, start);
+        struct page **p;
+
+        if (maxsize > i->count)
+                maxsize = i->count;
+
+        if (!maxsize)
+                return 0;
+
+        iterate_all_kinds(i, maxsize, v, ({
+                unsigned long addr = (unsigned long)v.iov_base;
+                size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
+                int n;
+                int res;
+
+                addr &= ~(PAGE_SIZE - 1);
+                n = DIV_ROUND_UP(len, PAGE_SIZE);
+                p = get_pages_array(n);
+                if (!p)
+                        return -ENOMEM;
+                res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, p);
+                if (unlikely(res < 0)) {
+                        kvfree(p);
+                        return res;
+                }
+                *pages = p;
+                return (res == n ? len : res * PAGE_SIZE) - *start;
+        0;}),({
+                /* can't be more than PAGE_SIZE */
+                *start = v.bv_offset;
+                *pages = p = get_pages_array(1);
+                if (!p)
+                        return -ENOMEM;
+                get_page(*p = v.bv_page);
+                return v.bv_len;
+        }),({
+                return -EFAULT;
+        })
+        )
+        return 0;
 }
 EXPORT_SYMBOL(iov_iter_get_pages_alloc);
 
+size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
+                               struct iov_iter *i)
+{
+        char *to = addr;
+        __wsum sum, next;
+        size_t off = 0;
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        sum = *csum;
+        iterate_and_advance(i, bytes, v, ({
+                int err = 0;
+                next = csum_and_copy_from_user(v.iov_base, 
+                                               (to += v.iov_len) - v.iov_len,
+                                               v.iov_len, 0, &err);
+                if (!err) {
+                        sum = csum_block_add(sum, next, off);
+                        off += v.iov_len;
+                }
+                err ? v.iov_len : 0;
+        }), ({
+                char *p = kmap_atomic(v.bv_page);
+                next = csum_partial_copy_nocheck(p + v.bv_offset,
+                                                 (to += v.bv_len) - v.bv_len,
+                                                 v.bv_len, 0);
+                kunmap_atomic(p);
+                sum = csum_block_add(sum, next, off);
+                off += v.bv_len;
+        }),({
+                next = csum_partial_copy_nocheck(v.iov_base,
+                                                 (to += v.iov_len) - v.iov_len,
+                                                 v.iov_len, 0);
+                sum = csum_block_add(sum, next, off);
+                off += v.iov_len;
+        })
+        )
+        *csum = sum;
+        return bytes;
+}
+EXPORT_SYMBOL(csum_and_copy_from_iter);
+
+size_t csum_and_copy_to_iter(void *addr, size_t bytes, __wsum *csum,
+                             struct iov_iter *i)
+{
+        char *from = addr;
+        __wsum sum, next;
+        size_t off = 0;
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        sum = *csum;
+        iterate_and_advance(i, bytes, v, ({
+                int err = 0;
+                next = csum_and_copy_to_user((from += v.iov_len) - v.iov_len,
+                                             v.iov_base, 
+                                             v.iov_len, 0, &err);
+                if (!err) {
+                        sum = csum_block_add(sum, next, off);
+                        off += v.iov_len;
+                }
+                err ? v.iov_len : 0;
+        }), ({
+                char *p = kmap_atomic(v.bv_page);
+                next = csum_partial_copy_nocheck((from += v.bv_len) - v.bv_len,
+                                                 p + v.bv_offset,
+                                                 v.bv_len, 0);
+                kunmap_atomic(p);
+                sum = csum_block_add(sum, next, off);
+                off += v.bv_len;
+        }),({
+                next = csum_partial_copy_nocheck((from += v.iov_len) - v.iov_len,
+                                                 v.iov_base,
+                                                 v.iov_len, 0);
+                sum = csum_block_add(sum, next, off);
+                off += v.iov_len;
+        })
+        )
+        *csum = sum;
+        return bytes;
+}
+EXPORT_SYMBOL(csum_and_copy_to_iter);
+
 int iov_iter_npages(const struct iov_iter *i, int maxpages)
 {
-        if (i->type & ITER_BVEC)
-                return iov_iter_npages_bvec(i, maxpages);
-        else
-                return iov_iter_npages_iovec(i, maxpages);
+        size_t size = i->count;
+        int npages = 0;
+
+        if (!size)
+                return 0;
+
+        iterate_all_kinds(i, size, v, ({
+                unsigned long p = (unsigned long)v.iov_base;
+                npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
+                        - p / PAGE_SIZE;
+                if (npages >= maxpages)
+                        return maxpages;
+        0;}),({
+                npages++;
+                if (npages >= maxpages)
+                        return maxpages;
+        }),({
+                unsigned long p = (unsigned long)v.iov_base;
+                npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
+                        - p / PAGE_SIZE;
+                if (npages >= maxpages)
+                        return maxpages;
+        })
+        )
+        return npages;
 }
 EXPORT_SYMBOL(iov_iter_npages);
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index d6ac0e33e150..ee48428cf8e3 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -5064,7 +5064,7 @@ static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
          *
          * DO NOT ADD NEW FILES.
          */
-        name = cfile.file->f_dentry->d_name.name;
+        name = cfile.file->f_path.dentry->d_name.name;
 
         if (!strcmp(name, "memory.usage_in_bytes")) {
                 event->register_event = mem_cgroup_usage_register_event;
@@ -5088,7 +5088,7 @@ static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
          * automatically removed on cgroup destruction but the removal is
          * asynchronous, so take an extra ref on @css.
          */
-        cfile_css = css_tryget_online_from_dir(cfile.file->f_dentry->d_parent,
+        cfile_css = css_tryget_online_from_dir(cfile.file->f_path.dentry->d_parent,
                                                &memory_cgrp_subsys);
         ret = -EINVAL;
         if (IS_ERR(cfile_css))
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
index a054fe083431..5c61328b7704 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
@@ -56,11 +56,11 @@ static bool ipv4_invert_tuple(struct nf_conntrack_tuple *tuple,
         return true;
 }
 
-static int ipv4_print_tuple(struct seq_file *s,
+static void ipv4_print_tuple(struct seq_file *s,
                             const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "src=%pI4 dst=%pI4 ",
-                          &tuple->src.u3.ip, &tuple->dst.u3.ip);
+        seq_printf(s, "src=%pI4 dst=%pI4 ",
+                   &tuple->src.u3.ip, &tuple->dst.u3.ip);
 }
 
 static int ipv4_get_l4proto(const struct sk_buff *skb, unsigned int nhoff,
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
index 4c48e434bb1f..a460a87e14f8 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c
@@ -94,7 +94,7 @@ static void ct_seq_stop(struct seq_file *s, void *v)
 }
 
 #ifdef CONFIG_NF_CONNTRACK_SECMARK
-static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
+static void ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 {
         int ret;
         u32 len;
@@ -102,17 +102,15 @@ static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 
         ret = security_secid_to_secctx(ct->secmark, &secctx, &len);
         if (ret)
-                return 0;
+                return;
 
-        ret = seq_printf(s, "secctx=%s ", secctx);
+        seq_printf(s, "secctx=%s ", secctx);
 
         security_release_secctx(secctx, len);
-        return ret;
 }
 #else
-static inline int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
+static inline void ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 {
-        return 0;
 }
 #endif
 
@@ -141,47 +139,52 @@ static int ct_seq_show(struct seq_file *s, void *v)
         NF_CT_ASSERT(l4proto);
 
         ret = -ENOSPC;
-        if (seq_printf(s, "%-8s %u %ld ",
-                      l4proto->name, nf_ct_protonum(ct),
-                      timer_pending(&ct->timeout)
-                      ? (long)(ct->timeout.expires - jiffies)/HZ : 0) != 0)
-                goto release;
+        seq_printf(s, "%-8s %u %ld ",
+                   l4proto->name, nf_ct_protonum(ct),
+                   timer_pending(&ct->timeout)
+                   ? (long)(ct->timeout.expires - jiffies)/HZ : 0);
+
+        if (l4proto->print_conntrack)
+                l4proto->print_conntrack(s, ct);
 
-        if (l4proto->print_conntrack && l4proto->print_conntrack(s, ct))
+        if (seq_has_overflowed(s))
                 goto release;
 
-        if (print_tuple(s, &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
-                        l3proto, l4proto))
+        print_tuple(s, &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
+                    l3proto, l4proto);
+
+        if (seq_has_overflowed(s))
                 goto release;
 
         if (seq_print_acct(s, ct, IP_CT_DIR_ORIGINAL))
                 goto release;
 
         if (!(test_bit(IPS_SEEN_REPLY_BIT, &ct->status)))
-                if (seq_printf(s, "[UNREPLIED] "))
-                        goto release;
+                seq_printf(s, "[UNREPLIED] ");
 
-        if (print_tuple(s, &ct->tuplehash[IP_CT_DIR_REPLY].tuple,
-                        l3proto, l4proto))
+        print_tuple(s, &ct->tuplehash[IP_CT_DIR_REPLY].tuple,
+                    l3proto, l4proto);
+
+        if (seq_has_overflowed(s))
                 goto release;
 
         if (seq_print_acct(s, ct, IP_CT_DIR_REPLY))
                 goto release;
 
         if (test_bit(IPS_ASSURED_BIT, &ct->status))
-                if (seq_printf(s, "[ASSURED] "))
-                        goto release;
+                seq_printf(s, "[ASSURED] ");
 
 #ifdef CONFIG_NF_CONNTRACK_MARK
-        if (seq_printf(s, "mark=%u ", ct->mark))
-                goto release;
+        seq_printf(s, "mark=%u ", ct->mark);
 #endif
 
-        if (ct_show_secctx(s, ct))
-                goto release;
+        ct_show_secctx(s, ct);
 
-        if (seq_printf(s, "use=%u\n", atomic_read(&ct->ct_general.use)))
+        seq_printf(s, "use=%u\n", atomic_read(&ct->ct_general.use));
+
+        if (seq_has_overflowed(s))
                 goto release;
+
         ret = 0;
 release:
         nf_ct_put(ct);
diff --git a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
index b91b2641adda..80d5554b9a88 100644
--- a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
@@ -72,13 +72,13 @@ static bool icmp_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int icmp_print_tuple(struct seq_file *s,
+static void icmp_print_tuple(struct seq_file *s,
                             const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "type=%u code=%u id=%u ",
-                          tuple->dst.u.icmp.type,
-                          tuple->dst.u.icmp.code,
-                          ntohs(tuple->src.u.icmp.id));
+        seq_printf(s, "type=%u code=%u id=%u ",
+                   tuple->dst.u.icmp.type,
+                   tuple->dst.u.icmp.code,
+                   ntohs(tuple->src.u.icmp.id));
 }
 
 static unsigned int *icmp_get_timeouts(struct net *net)
diff --git a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
index 4cbc6b290dd5..b68d0e59c1f8 100644
--- a/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c
@@ -60,11 +60,11 @@ static bool ipv6_invert_tuple(struct nf_conntrack_tuple *tuple,
         return true;
 }
 
-static int ipv6_print_tuple(struct seq_file *s,
+static void ipv6_print_tuple(struct seq_file *s,
                             const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "src=%pI6 dst=%pI6 ",
-                          tuple->src.u3.ip6, tuple->dst.u3.ip6);
+        seq_printf(s, "src=%pI6 dst=%pI6 ",
+                   tuple->src.u3.ip6, tuple->dst.u3.ip6);
 }
 
 static int ipv6_get_l4proto(const struct sk_buff *skb, unsigned int nhoff,
diff --git a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
index b3807c5cb888..90388d606483 100644
--- a/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
+++ b/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c
@@ -84,13 +84,13 @@ static bool icmpv6_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int icmpv6_print_tuple(struct seq_file *s,
+static void icmpv6_print_tuple(struct seq_file *s,
                               const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "type=%u code=%u id=%u ",
-                          tuple->dst.u.icmp.type,
-                          tuple->dst.u.icmp.code,
-                          ntohs(tuple->src.u.icmp.id));
+        seq_printf(s, "type=%u code=%u id=%u ",
+                   tuple->dst.u.icmp.type,
+                   tuple->dst.u.icmp.code,
+                   ntohs(tuple->src.u.icmp.id));
 }
 
 static unsigned int *icmpv6_get_timeouts(struct net *net)
diff --git a/net/netfilter/nf_conntrack_l3proto_generic.c b/net/netfilter/nf_conntrack_l3proto_generic.c
index e7eb807fe07d..cf9ace70bece 100644
--- a/net/netfilter/nf_conntrack_l3proto_generic.c
+++ b/net/netfilter/nf_conntrack_l3proto_generic.c
@@ -49,10 +49,9 @@ static bool generic_invert_tuple(struct nf_conntrack_tuple *tuple,
         return true;
 }
 
-static int generic_print_tuple(struct seq_file *s,
-                            const struct nf_conntrack_tuple *tuple)
+static void generic_print_tuple(struct seq_file *s,
+                                const struct nf_conntrack_tuple *tuple)
 {
-        return 0;
 }
 
 static int generic_get_l4proto(const struct sk_buff *skb, unsigned int nhoff,
diff --git a/net/netfilter/nf_conntrack_proto_dccp.c b/net/netfilter/nf_conntrack_proto_dccp.c
index cb372f96f10d..6dd995c7c72b 100644
--- a/net/netfilter/nf_conntrack_proto_dccp.c
+++ b/net/netfilter/nf_conntrack_proto_dccp.c
@@ -618,17 +618,17 @@ out_invalid:
         return -NF_ACCEPT;
 }
 
-static int dccp_print_tuple(struct seq_file *s,
-                            const struct nf_conntrack_tuple *tuple)
+static void dccp_print_tuple(struct seq_file *s,
+                             const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "sport=%hu dport=%hu ",
-                          ntohs(tuple->src.u.dccp.port),
-                          ntohs(tuple->dst.u.dccp.port));
+        seq_printf(s, "sport=%hu dport=%hu ",
+                   ntohs(tuple->src.u.dccp.port),
+                   ntohs(tuple->dst.u.dccp.port));
 }
 
-static int dccp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
+static void dccp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
-        return seq_printf(s, "%s ", dccp_state_names[ct->proto.dccp.state]);
+        seq_printf(s, "%s ", dccp_state_names[ct->proto.dccp.state]);
 }
 
 #if IS_ENABLED(CONFIG_NF_CT_NETLINK)
diff --git a/net/netfilter/nf_conntrack_proto_generic.c b/net/netfilter/nf_conntrack_proto_generic.c
index 957c1db66652..60865f110309 100644
--- a/net/netfilter/nf_conntrack_proto_generic.c
+++ b/net/netfilter/nf_conntrack_proto_generic.c
@@ -63,10 +63,9 @@ static bool generic_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int generic_print_tuple(struct seq_file *s,
-                               const struct nf_conntrack_tuple *tuple)
+static void generic_print_tuple(struct seq_file *s,
+                                const struct nf_conntrack_tuple *tuple)
 {
-        return 0;
 }
 
 static unsigned int *generic_get_timeouts(struct net *net)
diff --git a/net/netfilter/nf_conntrack_proto_gre.c b/net/netfilter/nf_conntrack_proto_gre.c
index d5665739e3b1..7648674f29c3 100644
--- a/net/netfilter/nf_conntrack_proto_gre.c
+++ b/net/netfilter/nf_conntrack_proto_gre.c
@@ -226,20 +226,20 @@ static bool gre_pkt_to_tuple(const struct sk_buff *skb, unsigned int dataoff,
 }
 
 /* print gre part of tuple */
-static int gre_print_tuple(struct seq_file *s,
-                           const struct nf_conntrack_tuple *tuple)
+static void gre_print_tuple(struct seq_file *s,
+                            const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "srckey=0x%x dstkey=0x%x ",
-                          ntohs(tuple->src.u.gre.key),
-                          ntohs(tuple->dst.u.gre.key));
+        seq_printf(s, "srckey=0x%x dstkey=0x%x ",
+                   ntohs(tuple->src.u.gre.key),
+                   ntohs(tuple->dst.u.gre.key));
 }
 
 /* print private data for conntrack */
-static int gre_print_conntrack(struct seq_file *s, struct nf_conn *ct)
+static void gre_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
-        return seq_printf(s, "timeout=%u, stream_timeout=%u ",
-                          (ct->proto.gre.timeout / HZ),
-                          (ct->proto.gre.stream_timeout / HZ));
+        seq_printf(s, "timeout=%u, stream_timeout=%u ",
+                   (ct->proto.gre.timeout / HZ),
+                   (ct->proto.gre.stream_timeout / HZ));
 }
 
 static unsigned int *gre_get_timeouts(struct net *net)
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 1314d33f6bcf..b45da90fad32 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -166,16 +166,16 @@ static bool sctp_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int sctp_print_tuple(struct seq_file *s,
-                            const struct nf_conntrack_tuple *tuple)
+static void sctp_print_tuple(struct seq_file *s,
+                             const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "sport=%hu dport=%hu ",
-                          ntohs(tuple->src.u.sctp.port),
-                          ntohs(tuple->dst.u.sctp.port));
+        seq_printf(s, "sport=%hu dport=%hu ",
+                   ntohs(tuple->src.u.sctp.port),
+                   ntohs(tuple->dst.u.sctp.port));
 }
 
 /* Print out the private part of the conntrack. */
-static int sctp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
+static void sctp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         enum sctp_conntrack state;
 
@@ -183,7 +183,7 @@ static int sctp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
         state = ct->proto.sctp.state;
         spin_unlock_bh(&ct->lock);
 
-        return seq_printf(s, "%s ", sctp_conntrack_names[state]);
+        seq_printf(s, "%s ", sctp_conntrack_names[state]);
 }
 
 #define for_each_sctp_chunk(skb, sch, _sch, offset, dataoff, count)     \
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index d87b6423ffb2..5caa0c41bf26 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -302,16 +302,16 @@ static bool tcp_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int tcp_print_tuple(struct seq_file *s,
-                           const struct nf_conntrack_tuple *tuple)
+static void tcp_print_tuple(struct seq_file *s,
+                            const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "sport=%hu dport=%hu ",
-                          ntohs(tuple->src.u.tcp.port),
-                          ntohs(tuple->dst.u.tcp.port));
+        seq_printf(s, "sport=%hu dport=%hu ",
+                   ntohs(tuple->src.u.tcp.port),
+                   ntohs(tuple->dst.u.tcp.port));
 }
 
 /* Print out the private part of the conntrack. */
-static int tcp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
+static void tcp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
 {
         enum tcp_conntrack state;
 
@@ -319,7 +319,7 @@ static int tcp_print_conntrack(struct seq_file *s, struct nf_conn *ct)
         state = ct->proto.tcp.state;
         spin_unlock_bh(&ct->lock);
 
-        return seq_printf(s, "%s ", tcp_conntrack_names[state]);
+        seq_printf(s, "%s ", tcp_conntrack_names[state]);
 }
 
 static unsigned int get_conntrack_index(const struct tcphdr *tcph)
diff --git a/net/netfilter/nf_conntrack_proto_udp.c b/net/netfilter/nf_conntrack_proto_udp.c
index 9d7721cbce4b..6957281ffee5 100644
--- a/net/netfilter/nf_conntrack_proto_udp.c
+++ b/net/netfilter/nf_conntrack_proto_udp.c
@@ -63,12 +63,12 @@ static bool udp_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int udp_print_tuple(struct seq_file *s,
-                           const struct nf_conntrack_tuple *tuple)
+static void udp_print_tuple(struct seq_file *s,
+                            const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "sport=%hu dport=%hu ",
-                          ntohs(tuple->src.u.udp.port),
-                          ntohs(tuple->dst.u.udp.port));
+        seq_printf(s, "sport=%hu dport=%hu ",
+                   ntohs(tuple->src.u.udp.port),
+                   ntohs(tuple->dst.u.udp.port));
 }
 
 static unsigned int *udp_get_timeouts(struct net *net)
diff --git a/net/netfilter/nf_conntrack_proto_udplite.c b/net/netfilter/nf_conntrack_proto_udplite.c
index 2750e6c69f82..c5903d1649f9 100644
--- a/net/netfilter/nf_conntrack_proto_udplite.c
+++ b/net/netfilter/nf_conntrack_proto_udplite.c
@@ -71,12 +71,12 @@ static bool udplite_invert_tuple(struct nf_conntrack_tuple *tuple,
 }
 
 /* Print out the per-protocol part of the tuple. */
-static int udplite_print_tuple(struct seq_file *s,
-                               const struct nf_conntrack_tuple *tuple)
+static void udplite_print_tuple(struct seq_file *s,
+                                const struct nf_conntrack_tuple *tuple)
 {
-        return seq_printf(s, "sport=%hu dport=%hu ",
-                          ntohs(tuple->src.u.udp.port),
-                          ntohs(tuple->dst.u.udp.port));
+        seq_printf(s, "sport=%hu dport=%hu ",
+                   ntohs(tuple->src.u.udp.port),
+                   ntohs(tuple->dst.u.udp.port));
 }
 
 static unsigned int *udplite_get_timeouts(struct net *net)
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index cf65a1e040dd..fc823fa5dcf5 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -36,12 +36,13 @@
 MODULE_LICENSE("GPL");
 
 #ifdef CONFIG_NF_CONNTRACK_PROCFS
-int
+void
 print_tuple(struct seq_file *s, const struct nf_conntrack_tuple *tuple,
             const struct nf_conntrack_l3proto *l3proto,
             const struct nf_conntrack_l4proto *l4proto)
 {
-        return l3proto->print_tuple(s, tuple) || l4proto->print_tuple(s, tuple);
+        l3proto->print_tuple(s, tuple);
+        l4proto->print_tuple(s, tuple);
 }
 EXPORT_SYMBOL_GPL(print_tuple);
 
@@ -119,7 +120,7 @@ static void ct_seq_stop(struct seq_file *s, void *v)
 }
 
 #ifdef CONFIG_NF_CONNTRACK_SECMARK
-static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
+static void ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 {
         int ret;
         u32 len;
@@ -127,22 +128,20 @@ static int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 
         ret = security_secid_to_secctx(ct->secmark, &secctx, &len);
         if (ret)
-                return 0;
+                return;
 
-        ret = seq_printf(s, "secctx=%s ", secctx);
+        seq_printf(s, "secctx=%s ", secctx);
 
         security_release_secctx(secctx, len);
-        return ret;
 }
 #else
-static inline int ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
+static inline void ct_show_secctx(struct seq_file *s, const struct nf_conn *ct)
 {
-        return 0;
 }
 #endif
 
 #ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
-static int ct_show_delta_time(struct seq_file *s, const struct nf_conn *ct)
+static void ct_show_delta_time(struct seq_file *s, const struct nf_conn *ct)
 {
         struct ct_iter_state *st = s->private;
         struct nf_conn_tstamp *tstamp;
@@ -156,16 +155,15 @@ static int ct_show_delta_time(struct seq_file *s, const struct nf_conn *ct)
                 else
                         delta_time = 0;
 
-                return seq_printf(s, "delta-time=%llu ",
-                                  (unsigned long long)delta_time);
+                seq_printf(s, "delta-time=%llu ",
+                           (unsigned long long)delta_time);
         }
-        return 0;
+        return;
 }
 #else
-static inline int
+static inline void
 ct_show_delta_time(struct seq_file *s, const struct nf_conn *ct)
 {
-        return 0;
 }
 #endif
 
@@ -192,55 +190,54 @@ static int ct_seq_show(struct seq_file *s, void *v)
         NF_CT_ASSERT(l4proto);
 
         ret = -ENOSPC;
-        if (seq_printf(s, "%-8s %u %-8s %u %ld ",
-                       l3proto->name, nf_ct_l3num(ct),
-                       l4proto->name, nf_ct_protonum(ct),
-                       timer_pending(&ct->timeout)
-                       ? (long)(ct->timeout.expires - jiffies)/HZ : 0) != 0)
-                goto release;
+        seq_printf(s, "%-8s %u %-8s %u %ld ",
+                   l3proto->name, nf_ct_l3num(ct),
+                   l4proto->name, nf_ct_protonum(ct),
+                   timer_pending(&ct->timeout)
+                   ? (long)(ct->timeout.expires - jiffies)/HZ : 0);
 
-        if (l4proto->print_conntrack && l4proto->print_conntrack(s, ct))
-                goto release;
+        if (l4proto->print_conntrack)
+                l4proto->print_conntrack(s, ct);
+
+        print_tuple(s, &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
+                    l3proto, l4proto);
 
-        if (print_tuple(s, &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple,
-                        l3proto, l4proto))
+        if (seq_has_overflowed(s))
                 goto release;
 
         if (seq_print_acct(s, ct, IP_CT_DIR_ORIGINAL))
                 goto release;
 
         if (!(test_bit(IPS_SEEN_REPLY_BIT, &ct->status)))
-                if (seq_printf(s, "[UNREPLIED] "))
-                        goto release;
+                seq_printf(s, "[UNREPLIED] ");
 
-        if (print_tuple(s, &ct->tuplehash[IP_CT_DIR_REPLY].tuple,
-                        l3proto, l4proto))
-                goto release;
+        print_tuple(s, &ct->tuplehash[IP_CT_DIR_REPLY].tuple,
+                    l3proto, l4proto);
 
         if (seq_print_acct(s, ct, IP_CT_DIR_REPLY))
                 goto release;
 
         if (test_bit(IPS_ASSURED_BIT, &ct->status))
-                if (seq_printf(s, "[ASSURED] "))
-                        goto release;
+                seq_printf(s, "[ASSURED] ");
 
-#if defined(CONFIG_NF_CONNTRACK_MARK)
-        if (seq_printf(s, "mark=%u ", ct->mark))
+        if (seq_has_overflowed(s))
                 goto release;
+
+#if defined(CONFIG_NF_CONNTRACK_MARK)
+        seq_printf(s, "mark=%u ", ct->mark);
 #endif
 
-        if (ct_show_secctx(s, ct))
-                goto release;
+        ct_show_secctx(s, ct);
 
 #ifdef CONFIG_NF_CONNTRACK_ZONES
-        if (seq_printf(s, "zone=%u ", nf_ct_zone(ct)))
-                goto release;
+        seq_printf(s, "zone=%u ", nf_ct_zone(ct));
 #endif
 
-        if (ct_show_delta_time(s, ct))
-                goto release;
+        ct_show_delta_time(s, ct);
+
+        seq_printf(s, "use=%u\n", atomic_read(&ct->ct_general.use));
 
-        if (seq_printf(s, "use=%u\n", atomic_read(&ct->ct_general.use)))
+        if (seq_has_overflowed(s))
                 goto release;
 
         ret = 0;
diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
index d7197649dba6..6e3b9117db1f 100644
--- a/net/netfilter/nf_log.c
+++ b/net/netfilter/nf_log.c
@@ -294,19 +294,19 @@ static int seq_show(struct seq_file *s, void *v)
 {
         loff_t *pos = v;
         const struct nf_logger *logger;
-        int i, ret;
+        int i;
         struct net *net = seq_file_net(s);
 
         logger = rcu_dereference_protected(net->nf.nf_loggers[*pos],
                                            lockdep_is_held(&nf_log_mutex));
 
         if (!logger)
-                ret = seq_printf(s, "%2lld NONE (", *pos);
+                seq_printf(s, "%2lld NONE (", *pos);
         else
-                ret = seq_printf(s, "%2lld %s (", *pos, logger->name);
+                seq_printf(s, "%2lld %s (", *pos, logger->name);
 
-        if (ret < 0)
-                return ret;
+        if (seq_has_overflowed(s))
+                return -ENOSPC;
 
         for (i = 0; i < NF_LOG_TYPE_MAX; i++) {
                 if (loggers[*pos][i] == NULL)
@@ -314,17 +314,19 @@ static int seq_show(struct seq_file *s, void *v)
 
                 logger = rcu_dereference_protected(loggers[*pos][i],
                                            lockdep_is_held(&nf_log_mutex));
-                ret = seq_printf(s, "%s", logger->name);
-                if (ret < 0)
-                        return ret;
-                if (i == 0 && loggers[*pos][i + 1] != NULL) {
-                        ret = seq_printf(s, ",");
-                        if (ret < 0)
-                                return ret;
-                }
+                seq_printf(s, "%s", logger->name);
+                if (i == 0 && loggers[*pos][i + 1] != NULL)
+                        seq_printf(s, ",");
+
+                if (seq_has_overflowed(s))
+                        return -ENOSPC;
         }
 
-        return seq_printf(s, ")\n");
+        seq_printf(s, ")\n");
+
+        if (seq_has_overflowed(s))
+                return -ENOSPC;
+        return 0;
 }
 
 static const struct seq_operations nflog_seq_ops = {
diff --git a/net/netfilter/nfnetlink_queue_core.c b/net/netfilter/nfnetlink_queue_core.c
index 7c60ccd61a3e..0db8515e76da 100644
--- a/net/netfilter/nfnetlink_queue_core.c
+++ b/net/netfilter/nfnetlink_queue_core.c
@@ -1242,12 +1242,13 @@ static int seq_show(struct seq_file *s, void *v)
 {
         const struct nfqnl_instance *inst = v;
 
-        return seq_printf(s, "%5d %6d %5d %1d %5d %5d %5d %8d %2d\n",
-                          inst->queue_num,
-                          inst->peer_portid, inst->queue_total,
-                          inst->copy_mode, inst->copy_range,
-                          inst->queue_dropped, inst->queue_user_dropped,
-                          inst->id_sequence, 1);
+        seq_printf(s, "%5d %6d %5d %1d %5d %5d %5d %8d %2d\n",
+                   inst->queue_num,
+                   inst->peer_portid, inst->queue_total,
+                   inst->copy_mode, inst->copy_range,
+                   inst->queue_dropped, inst->queue_user_dropped,
+                   inst->id_sequence, 1);
+        return seq_has_overflowed(s);
 }
 
 static const struct seq_operations nfqnl_seq_ops = {
diff --git a/net/netfilter/x_tables.c b/net/netfilter/x_tables.c
index 133eb4772f12..51a459c3c649 100644
--- a/net/netfilter/x_tables.c
+++ b/net/netfilter/x_tables.c
@@ -947,9 +947,10 @@ static int xt_table_seq_show(struct seq_file *seq, void *v)
 {
         struct xt_table *table = list_entry(v, struct xt_table, list);
 
-        if (strlen(table->name))
-                return seq_printf(seq, "%s\n", table->name);
-        else
+        if (strlen(table->name)) {
+                seq_printf(seq, "%s\n", table->name);
+                return seq_has_overflowed(seq);
+        } else
                 return 0;
 }
 
@@ -1086,8 +1087,10 @@ static int xt_match_seq_show(struct seq_file *seq, void *v)
                 if (trav->curr == trav->head)
                         return 0;
                 match = list_entry(trav->curr, struct xt_match, list);
-                return (*match->name == '\0') ? 0 :
-                       seq_printf(seq, "%s\n", match->name);
+                if (*match->name == '\0')
+                        return 0;
+                seq_printf(seq, "%s\n", match->name);
+                return seq_has_overflowed(seq);
         }
         return 0;
 }
@@ -1139,8 +1142,10 @@ static int xt_target_seq_show(struct seq_file *seq, void *v)
                 if (trav->curr == trav->head)
                         return 0;
                 target = list_entry(trav->curr, struct xt_target, list);
-                return (*target->name == '\0') ? 0 :
-                       seq_printf(seq, "%s\n", target->name);
+                if (*target->name == '\0')
+                        return 0;
+                seq_printf(seq, "%s\n", target->name);
+                return seq_has_overflowed(seq);
         }
         return 0;
 }
diff --git a/net/netfilter/xt_hashlimit.c b/net/netfilter/xt_hashlimit.c
index 05fbc2a0be46..178696852bde 100644
--- a/net/netfilter/xt_hashlimit.c
+++ b/net/netfilter/xt_hashlimit.c
@@ -789,7 +789,6 @@ static void dl_seq_stop(struct seq_file *s, void *v)
 static int dl_seq_real_show(struct dsthash_ent *ent, u_int8_t family,
                                    struct seq_file *s)
 {
-        int res;
         const struct xt_hashlimit_htable *ht = s->private;
 
         spin_lock(&ent->lock);
@@ -798,33 +797,32 @@ static int dl_seq_real_show(struct dsthash_ent *ent, u_int8_t family,
 
         switch (family) {
         case NFPROTO_IPV4:
-                res = seq_printf(s, "%ld %pI4:%u->%pI4:%u %u %u %u\n",
-                                 (long)(ent->expires - jiffies)/HZ,
-                                 &ent->dst.ip.src,
-                                 ntohs(ent->dst.src_port),
-                                 &ent->dst.ip.dst,
-                                 ntohs(ent->dst.dst_port),
-                                 ent->rateinfo.credit, ent->rateinfo.credit_cap,
-                                 ent->rateinfo.cost);
+                seq_printf(s, "%ld %pI4:%u->%pI4:%u %u %u %u\n",
+                           (long)(ent->expires - jiffies)/HZ,
+                           &ent->dst.ip.src,
+                           ntohs(ent->dst.src_port),
+                           &ent->dst.ip.dst,
+                           ntohs(ent->dst.dst_port),
+                           ent->rateinfo.credit, ent->rateinfo.credit_cap,
+                           ent->rateinfo.cost);
                 break;
 #if IS_ENABLED(CONFIG_IP6_NF_IPTABLES)
         case NFPROTO_IPV6:
-                res = seq_printf(s, "%ld %pI6:%u->%pI6:%u %u %u %u\n",
-                                 (long)(ent->expires - jiffies)/HZ,
-                                 &ent->dst.ip6.src,
-                                 ntohs(ent->dst.src_port),
-                                 &ent->dst.ip6.dst,
-                                 ntohs(ent->dst.dst_port),
-                                 ent->rateinfo.credit, ent->rateinfo.credit_cap,
-                                 ent->rateinfo.cost);
+                seq_printf(s, "%ld %pI6:%u->%pI6:%u %u %u %u\n",
+                           (long)(ent->expires - jiffies)/HZ,
+                           &ent->dst.ip6.src,
+                           ntohs(ent->dst.src_port),
+                           &ent->dst.ip6.dst,
+                           ntohs(ent->dst.dst_port),
+                           ent->rateinfo.credit, ent->rateinfo.credit_cap,
+                           ent->rateinfo.cost);
                 break;
 #endif
         default:
                 BUG();
-                res = 0;
         }
         spin_unlock(&ent->lock);
-        return res;
+        return seq_has_overflowed(s);
 }
 
 static int dl_seq_show(struct seq_file *s, void *v)
diff --git a/security/commoncap.c b/security/commoncap.c
index bab0611afc1e..2915d8503054 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -446,7 +446,7 @@ static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_c
         if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
                 return 0;
 
-        dentry = dget(bprm->file->f_dentry);
+        dentry = dget(bprm->file->f_path.dentry);
 
         rc = get_vfs_caps_from_disk(dentry, &vcaps);
         if (rc < 0) {
diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
index 86885979918c..f92be1b14089 100644
--- a/security/integrity/ima/ima_api.c
+++ b/security/integrity/ima/ima_api.c
@@ -196,7 +196,7 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
 {
         const char *audit_cause = "failed";
         struct inode *inode = file_inode(file);
-        const char *filename = file->f_dentry->d_name.name;
+        const char *filename = file->f_path.dentry->d_name.name;
         int result = 0;
         struct {
                 struct ima_digest_data hdr;
@@ -204,7 +204,7 @@ int ima_collect_measurement(struct integrity_iint_cache *iint,
         } hash;
 
         if (xattr_value)
-                *xattr_len = ima_read_xattr(file->f_dentry, xattr_value);
+                *xattr_len = ima_read_xattr(file->f_path.dentry, xattr_value);
 
         if (!(iint->flags & IMA_COLLECTED)) {
                 u64 i_version = file_inode(file)->i_version;
diff --git a/security/integrity/ima/ima_appraise.c b/security/integrity/ima/ima_appraise.c
index 7c8f41e618b6..fffcdb0b31f0 100644
--- a/security/integrity/ima/ima_appraise.c
+++ b/security/integrity/ima/ima_appraise.c
@@ -189,7 +189,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_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         enum integrity_status status = INTEGRITY_UNKNOWN;
         int rc = xattr_len, hash_start = 0;
@@ -289,7 +289,7 @@ out:
  */
 void ima_update_xattr(struct integrity_iint_cache *iint, struct file *file)
 {
-        struct dentry *dentry = file->f_dentry;
+        struct dentry *dentry = file->f_path.dentry;
         int rc = 0;
 
         /* do not collect and update hash for digital signatures */
diff --git a/security/integrity/ima/ima_template_lib.c b/security/integrity/ima/ima_template_lib.c
index 1506f0248572..bcfc36cbde6a 100644
--- a/security/integrity/ima/ima_template_lib.c
+++ b/security/integrity/ima/ima_template_lib.c
@@ -284,7 +284,7 @@ static int ima_eventname_init_common(struct integrity_iint_cache *iint,
         }
 
         if (file) {
-                cur_filename = file->f_dentry->d_name.name;
+                cur_filename = file->f_path.dentry->d_name.name;
                 cur_filename_len = strlen(cur_filename);
         } else
                 /*
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index c71737f6d1cc..33db1ad4fd10 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -1200,7 +1200,7 @@ static void sel_remove_entries(struct dentry *de)
         spin_lock(&de->d_lock);
         node = de->d_subdirs.next;
         while (node != &de->d_subdirs) {
-                struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
+                struct dentry *d = list_entry(node, struct dentry, d_child);
 
                 spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
                 list_del_init(node);
@@ -1674,12 +1674,12 @@ static void sel_remove_classes(void)
 
         list_for_each(class_node, &class_dir->d_subdirs) {
                 struct dentry *class_subdir = list_entry(class_node,
-                                        struct dentry, d_u.d_child);
+                                        struct dentry, d_child);
                 struct list_head *class_subdir_node;
 
                 list_for_each(class_subdir_node, &class_subdir->d_subdirs) {
                         struct dentry *d = list_entry(class_subdir_node,
-                                                struct dentry, d_u.d_child);
+                                                struct dentry, d_child);
 
                         if (d->d_inode)
                                 if (d->d_inode->i_mode & S_IFDIR)
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index d515ec25ae9f..433ae61e7f42 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -166,9 +166,9 @@ static int smk_bu_file(struct file *file, int mode, int rc)
                 return rc;
 
         smk_bu_mode(mode, acc);
-        pr_info("Smack Bringup: (%s %s %s) file=(%s %ld %s) %s\n",
+        pr_info("Smack Bringup: (%s %s %s) file=(%s %ld %pD) %s\n",
                 sskp->smk_known, (char *)file->f_security, acc,
-                inode->i_sb->s_id, inode->i_ino, file->f_dentry->d_name.name,
+                inode->i_sb->s_id, inode->i_ino, file,
                 current->comm);
         return 0;
 }
@@ -189,9 +189,9 @@ static int smk_bu_credfile(const struct cred *cred, struct file *file,
                 return rc;
 
         smk_bu_mode(mode, acc);
-        pr_info("Smack Bringup: (%s %s %s) file=(%s %ld %s) %s\n",
+        pr_info("Smack Bringup: (%s %s %s) file=(%s %ld %pD) %s\n",
                 sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
-                inode->i_sb->s_id, inode->i_ino, file->f_dentry->d_name.name,
+                inode->i_sb->s_id, inode->i_ino, file,
                 current->comm);
         return 0;
 }