136 files changed, 1226 insertions, 1417 deletions

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/Makefile b/fs/Makefile
index 34393376eaa2..bedff48e8fdc 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -104,7 +104,7 @@ obj-$(CONFIG_QNX6FS_FS)		+= qnx6/
 obj-$(CONFIG_AUTOFS4_FS)        += autofs4/
 obj-$(CONFIG_ADFS_FS)           += adfs/
 obj-$(CONFIG_FUSE_FS)           += fuse/
-obj-$(CONFIG_OVERLAYFS_FS)      += overlayfs/
+obj-$(CONFIG_OVERLAY_FS)        += overlayfs/
 obj-$(CONFIG_UDF_FS)            += udf/
 obj-$(CONFIG_SUN_OPENPROMFS)    += openpromfs/
 obj-$(CONFIG_OMFS_FS)           += omfs/
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/block_dev.c b/fs/block_dev.c
index cc9d4114cda0..1d9c9f3754f8 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1585,7 +1585,7 @@ ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from)
 }
 EXPORT_SYMBOL_GPL(blkdev_write_iter);
 
-static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
+ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
 {
         struct file *file = iocb->ki_filp;
         struct inode *bd_inode = file->f_mapping->host;
@@ -1599,6 +1599,7 @@ static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
         iov_iter_truncate(to, size);
         return generic_file_read_iter(iocb, to);
 }
+EXPORT_SYMBOL_GPL(blkdev_read_iter);
 
 /*
  * Try to release a page associated with block device when the system
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 19bc6162fb8e..150822ee0a0b 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -80,13 +80,6 @@ noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
 {
         int i;
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        /* lockdep really cares that we take all of these spinlocks
-         * in the right order.  If any of the locks in the path are not
-         * currently blocking, it is going to complain.  So, make really
-         * really sure by forcing the path to blocking before we clear
-         * the path blocking.
-         */
         if (held) {
                 btrfs_set_lock_blocking_rw(held, held_rw);
                 if (held_rw == BTRFS_WRITE_LOCK)
@@ -95,7 +88,6 @@ noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
                         held_rw = BTRFS_READ_LOCK_BLOCKING;
         }
         btrfs_set_path_blocking(p);
-#endif
 
         for (i = BTRFS_MAX_LEVEL - 1; i >= 0; i--) {
                 if (p->nodes[i] && p->locks[i]) {
@@ -107,10 +99,8 @@ noinline void btrfs_clear_path_blocking(struct btrfs_path *p,
                 }
         }
 
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
         if (held)
                 btrfs_clear_lock_blocking_rw(held, held_rw);
-#endif
 }
 
 /* this also releases the path */
@@ -2893,7 +2883,7 @@ cow_done:
                                         }
                                         p->locks[level] = BTRFS_WRITE_LOCK;
                                 } else {
-                                        err = btrfs_try_tree_read_lock(b);
+                                        err = btrfs_tree_read_lock_atomic(b);
                                         if (!err) {
                                                 btrfs_set_path_blocking(p);
                                                 btrfs_tree_read_lock(b);
@@ -3025,7 +3015,7 @@ again:
                         }
 
                         level = btrfs_header_level(b);
-                        err = btrfs_try_tree_read_lock(b);
+                        err = btrfs_tree_read_lock_atomic(b);
                         if (!err) {
                                 btrfs_set_path_blocking(p);
                                 btrfs_tree_read_lock(b);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index d557264ee974..fe69edda11fb 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3276,7 +3276,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root, unsigned long count);
 int btrfs_async_run_delayed_refs(struct btrfs_root *root,
                                  unsigned long count, int wait);
-int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
+int btrfs_lookup_data_extent(struct btrfs_root *root, u64 start, u64 len);
 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root, u64 bytenr,
                              u64 offset, int metadata, u64 *refs, u64 *flags);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 1ad0f47ac850..1bf9f897065d 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -3817,19 +3817,19 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
         struct btrfs_super_block *sb = fs_info->super_copy;
         int ret = 0;
 
-        if (sb->root_level > BTRFS_MAX_LEVEL) {
-                printk(KERN_ERR "BTRFS: tree_root level too big: %d > %d\n",
-                                sb->root_level, BTRFS_MAX_LEVEL);
+        if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
+                printk(KERN_ERR "BTRFS: tree_root level too big: %d >= %d\n",
+                                btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
                 ret = -EINVAL;
         }
-        if (sb->chunk_root_level > BTRFS_MAX_LEVEL) {
-                printk(KERN_ERR "BTRFS: chunk_root level too big: %d > %d\n",
-                                sb->chunk_root_level, BTRFS_MAX_LEVEL);
+        if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
+                printk(KERN_ERR "BTRFS: chunk_root level too big: %d >= %d\n",
+                                btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
                 ret = -EINVAL;
         }
-        if (sb->log_root_level > BTRFS_MAX_LEVEL) {
-                printk(KERN_ERR "BTRFS: log_root level too big: %d > %d\n",
-                                sb->log_root_level, BTRFS_MAX_LEVEL);
+        if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
+                printk(KERN_ERR "BTRFS: log_root level too big: %d >= %d\n",
+                                btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
                 ret = -EINVAL;
         }
 
@@ -3837,15 +3837,15 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
          * The common minimum, we don't know if we can trust the nodesize/sectorsize
          * items yet, they'll be verified later. Issue just a warning.
          */
-        if (!IS_ALIGNED(sb->root, 4096))
+        if (!IS_ALIGNED(btrfs_super_root(sb), 4096))
                 printk(KERN_WARNING "BTRFS: tree_root block unaligned: %llu\n",
                                 sb->root);
-        if (!IS_ALIGNED(sb->chunk_root, 4096))
+        if (!IS_ALIGNED(btrfs_super_chunk_root(sb), 4096))
                 printk(KERN_WARNING "BTRFS: tree_root block unaligned: %llu\n",
                                 sb->chunk_root);
-        if (!IS_ALIGNED(sb->log_root, 4096))
+        if (!IS_ALIGNED(btrfs_super_log_root(sb), 4096))
                 printk(KERN_WARNING "BTRFS: tree_root block unaligned: %llu\n",
-                                sb->log_root);
+                                btrfs_super_log_root(sb));
 
         if (memcmp(fs_info->fsid, sb->dev_item.fsid, BTRFS_UUID_SIZE) != 0) {
                 printk(KERN_ERR "BTRFS: dev_item UUID does not match fsid: %pU != %pU\n",
@@ -3857,13 +3857,13 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
          * Hint to catch really bogus numbers, bitflips or so, more exact checks are
          * done later
          */
-        if (sb->num_devices > (1UL << 31))
+        if (btrfs_super_num_devices(sb) > (1UL << 31))
                 printk(KERN_WARNING "BTRFS: suspicious number of devices: %llu\n",
-                                sb->num_devices);
+                                btrfs_super_num_devices(sb));
 
-        if (sb->bytenr != BTRFS_SUPER_INFO_OFFSET) {
+        if (btrfs_super_bytenr(sb) != BTRFS_SUPER_INFO_OFFSET) {
                 printk(KERN_ERR "BTRFS: super offset mismatch %llu != %u\n",
-                                sb->bytenr, BTRFS_SUPER_INFO_OFFSET);
+                                btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
                 ret = -EINVAL;
         }
 
@@ -3871,14 +3871,15 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
          * The generation is a global counter, we'll trust it more than the others
          * but it's still possible that it's the one that's wrong.
          */
-        if (sb->generation < sb->chunk_root_generation)
+        if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
                 printk(KERN_WARNING
                         "BTRFS: suspicious: generation < chunk_root_generation: %llu < %llu\n",
-                        sb->generation, sb->chunk_root_generation);
-        if (sb->generation < sb->cache_generation && sb->cache_generation != (u64)-1)
+                        btrfs_super_generation(sb), btrfs_super_chunk_root_generation(sb));
+        if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
+            && btrfs_super_cache_generation(sb) != (u64)-1)
                 printk(KERN_WARNING
                         "BTRFS: suspicious: generation < cache_generation: %llu < %llu\n",
-                        sb->generation, sb->cache_generation);
+                        btrfs_super_generation(sb), btrfs_super_cache_generation(sb));
 
         return ret;
 }
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index d56589571012..47c1ba141082 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -710,8 +710,8 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
         rcu_read_unlock();
 }
 
-/* simple helper to search for an existing extent at a given offset */
-int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
+/* simple helper to search for an existing data extent at a given offset */
+int btrfs_lookup_data_extent(struct btrfs_root *root, u64 start, u64 len)
 {
         int ret;
         struct btrfs_key key;
@@ -726,12 +726,6 @@ int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
         key.type = BTRFS_EXTENT_ITEM_KEY;
         ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
                                 0, 0);
-        if (ret > 0) {
-                btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
-                if (key.objectid == start &&
-                    key.type == BTRFS_METADATA_ITEM_KEY)
-                        ret = 0;
-        }
         btrfs_free_path(path);
         return ret;
 }
@@ -786,7 +780,6 @@ search_again:
         else
                 key.type = BTRFS_EXTENT_ITEM_KEY;
 
-again:
         ret = btrfs_search_slot(trans, root->fs_info->extent_root,
                                 &key, path, 0, 0);
         if (ret < 0)
@@ -802,13 +795,6 @@ again:
                             key.offset == root->nodesize)
                                 ret = 0;
                 }
-                if (ret) {
-                        key.objectid = bytenr;
-                        key.type = BTRFS_EXTENT_ITEM_KEY;
-                        key.offset = root->nodesize;
-                        btrfs_release_path(path);
-                        goto again;
-                }
         }
 
         if (ret == 0) {
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 783a94355efd..84a2d1868271 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -413,7 +413,7 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
         ret = 0;
 fail:
         while (ret < 0 && !list_empty(&tmplist)) {
-                sums = list_entry(&tmplist, struct btrfs_ordered_sum, list);
+                sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list);
                 list_del(&sums->list);
                 kfree(sums);
         }
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/btrfs/locking.c b/fs/btrfs/locking.c
index 5665d2149249..f8229ef1b46d 100644
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -128,6 +128,26 @@ again:
 }
 
 /*
+ * take a spinning read lock.
+ * returns 1 if we get the read lock and 0 if we don't
+ * this won't wait for blocking writers
+ */
+int btrfs_tree_read_lock_atomic(struct extent_buffer *eb)
+{
+        if (atomic_read(&eb->blocking_writers))
+                return 0;
+
+        read_lock(&eb->lock);
+        if (atomic_read(&eb->blocking_writers)) {
+                read_unlock(&eb->lock);
+                return 0;
+        }
+        atomic_inc(&eb->read_locks);
+        atomic_inc(&eb->spinning_readers);
+        return 1;
+}
+
+/*
  * returns 1 if we get the read lock and 0 if we don't
  * this won't wait for blocking writers
  */
@@ -158,9 +178,7 @@ int btrfs_try_tree_write_lock(struct extent_buffer *eb)
             atomic_read(&eb->blocking_readers))
                 return 0;
 
-        if (!write_trylock(&eb->lock))
-                return 0;
-
+        write_lock(&eb->lock);
         if (atomic_read(&eb->blocking_writers) ||
             atomic_read(&eb->blocking_readers)) {
                 write_unlock(&eb->lock);
diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h
index b81e0e9a4894..c44a9d5f5362 100644
--- a/fs/btrfs/locking.h
+++ b/fs/btrfs/locking.h
@@ -35,6 +35,8 @@ void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw);
 void btrfs_assert_tree_locked(struct extent_buffer *eb);
 int btrfs_try_tree_read_lock(struct extent_buffer *eb);
 int btrfs_try_tree_write_lock(struct extent_buffer *eb);
+int btrfs_tree_read_lock_atomic(struct extent_buffer *eb);
+
 
 static inline void btrfs_tree_unlock_rw(struct extent_buffer *eb, int rw)
 {
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index a2b97ef10317..54bd91ece35b 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -2151,6 +2151,7 @@ static void __exit exit_btrfs_fs(void)
         extent_map_exit();
         extent_io_exit();
         btrfs_interface_exit();
+        btrfs_end_io_wq_exit();
         unregister_filesystem(&btrfs_fs_type);
         btrfs_exit_sysfs();
         btrfs_cleanup_fs_uuids();
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 1475979e5718..286213cec861 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -672,7 +672,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
                          * is this extent already allocated in the extent
                          * allocation tree?  If so, just add a reference
                          */
-                        ret = btrfs_lookup_extent(root, ins.objectid,
+                        ret = btrfs_lookup_data_extent(root, ins.objectid,
                                                 ins.offset);
                         if (ret == 0) {
                                 ret = btrfs_inc_extent_ref(trans, root,
diff --git a/fs/buffer.c b/fs/buffer.c
index 6c48f20eddd4..20805db2c987 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -128,21 +128,15 @@ __clear_page_buffers(struct page *page)
         page_cache_release(page);
 }
 
-
-static int quiet_error(struct buffer_head *bh)
-{
-        if (!test_bit(BH_Quiet, &bh->b_state) && printk_ratelimit())
-                return 0;
-        return 1;
-}
-
-
-static void buffer_io_error(struct buffer_head *bh)
+static void buffer_io_error(struct buffer_head *bh, char *msg)
 {
         char b[BDEVNAME_SIZE];
-        printk(KERN_ERR "Buffer I/O error on device %s, logical block %Lu\n",
+
+        if (!test_bit(BH_Quiet, &bh->b_state))
+                printk_ratelimited(KERN_ERR
+                        "Buffer I/O error on dev %s, logical block %llu%s\n",
                         bdevname(bh->b_bdev, b),
-                        (unsigned long long)bh->b_blocknr);
+                        (unsigned long long)bh->b_blocknr, msg);
 }
 
 /*
@@ -177,17 +171,10 @@ EXPORT_SYMBOL(end_buffer_read_sync);
 
 void end_buffer_write_sync(struct buffer_head *bh, int uptodate)
 {
-        char b[BDEVNAME_SIZE];
-
         if (uptodate) {
                 set_buffer_uptodate(bh);
         } else {
-                if (!quiet_error(bh)) {
-                        buffer_io_error(bh);
-                        printk(KERN_WARNING "lost page write due to "
-                                        "I/O error on %s\n",
-                                       bdevname(bh->b_bdev, b));
-                }
+                buffer_io_error(bh, ", lost sync page write");
                 set_buffer_write_io_error(bh);
                 clear_buffer_uptodate(bh);
         }
@@ -304,8 +291,7 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
                 set_buffer_uptodate(bh);
         } else {
                 clear_buffer_uptodate(bh);
-                if (!quiet_error(bh))
-                        buffer_io_error(bh);
+                buffer_io_error(bh, ", async page read");
                 SetPageError(page);
         }
 
@@ -353,7 +339,6 @@ still_busy:
  */
 void end_buffer_async_write(struct buffer_head *bh, int uptodate)
 {
-        char b[BDEVNAME_SIZE];
         unsigned long flags;
         struct buffer_head *first;
         struct buffer_head *tmp;
@@ -365,12 +350,7 @@ void end_buffer_async_write(struct buffer_head *bh, int uptodate)
         if (uptodate) {
                 set_buffer_uptodate(bh);
         } else {
-                if (!quiet_error(bh)) {
-                        buffer_io_error(bh);
-                        printk(KERN_WARNING "lost page write due to "
-                                        "I/O error on %s\n",
-                               bdevname(bh->b_bdev, b));
-                }
+                buffer_io_error(bh, ", lost async page write");
                 set_bit(AS_EIO, &page->mapping->flags);
                 set_buffer_write_io_error(bh);
                 clear_buffer_uptodate(bh);
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/caps.c b/fs/ceph/caps.c
index 659f2ea9e6f7..cefca661464b 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -2638,7 +2638,7 @@ static void handle_cap_flush_ack(struct inode *inode, u64 flush_tid,
 
         for (i = 0; i < CEPH_CAP_BITS; i++)
                 if ((dirty & (1 << i)) &&
-                    flush_tid == ci->i_cap_flush_tid[i])
+                    (u16)flush_tid == ci->i_cap_flush_tid[i])
                         cleaned |= 1 << i;
 
         dout("handle_cap_flush_ack inode %p mds%d seq %d on %s cleaned %s,"
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 8fd2a95860ba..d116ca8ce4c0 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 3ffef7f4e5cd..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,12 +771,13 @@ 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);
                         if (likely(!dentry->d_lockref.count)) {
                                 __dentry_kill(dentry);
+                                dput(parent);
                                 goto restart;
                         }
                         if (parent)
@@ -1050,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);
@@ -1082,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);
 
@@ -1118,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;
@@ -1454,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);
@@ -1485,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;
@@ -1578,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);
@@ -1602,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);
@@ -1641,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
@@ -1667,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);
@@ -1698,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)) {
@@ -1737,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;
 }
@@ -1799,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);
@@ -1888,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;
 }
@@ -2234,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);
@@ -2392,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]);
@@ -2525,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);
@@ -2607,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)
@@ -2626,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)
@@ -2661,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)
 {
@@ -3320,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/ext3/super.c b/fs/ext3/super.c
index 7015db0bafd1..eb742d0e67ff 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1354,13 +1354,6 @@ set_qf_format:
                                         "not specified.");
                         return 0;
                 }
-        } else {
-                if (sbi->s_jquota_fmt) {
-                        ext3_msg(sb, KERN_ERR, "error: journaled quota format "
-                                        "specified with no journaling "
-                                        "enabled.");
-                        return 0;
-                }
         }
 #endif
         return 1;
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 37043d0b2be8..0b16fb4c06d3 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3603,11 +3603,10 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
                 }
         }
 
-        allocated = ext4_split_extent(handle, inode, ppath,
-                                      &split_map, split_flag, flags);
-        if (allocated < 0)
-                err = allocated;
-
+        err = ext4_split_extent(handle, inode, ppath, &split_map, split_flag,
+                                flags);
+        if (err > 0)
+                err = 0;
 out:
         /* If we have gotten a failure, don't zero out status tree */
         if (!err)
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index aca7b24a4432..8131be8c0af3 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -137,10 +137,10 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                         iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos);
         }
 
+        iocb->private = &overwrite;
         if (o_direct) {
                 blk_start_plug(&plug);
 
-                iocb->private = &overwrite;
 
                 /* check whether we do a DIO overwrite or not */
                 if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 8012a5daf401..ac644c31ca67 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -887,6 +887,10 @@ got:
                 struct buffer_head *block_bitmap_bh;
 
                 block_bitmap_bh = ext4_read_block_bitmap(sb, group);
+                if (!block_bitmap_bh) {
+                        err = -EIO;
+                        goto out;
+                }
                 BUFFER_TRACE(block_bitmap_bh, "get block bitmap access");
                 err = ext4_journal_get_write_access(handle, block_bitmap_bh);
                 if (err) {
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index e9777f93cf05..3356ab5395f4 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -4959,7 +4959,12 @@ int ext4_change_inode_journal_flag(struct inode *inode, int val)
         if (val)
                 ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
         else {
-                jbd2_journal_flush(journal);
+                err = jbd2_journal_flush(journal);
+                if (err < 0) {
+                        jbd2_journal_unlock_updates(journal);
+                        ext4_inode_resume_unlocked_dio(inode);
+                        return err;
+                }
                 ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
         }
         ext4_set_aops(inode);
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 123798c5ac31..426211882f72 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1816,31 +1816,39 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
                 hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
         hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
         ext4fs_dirhash(name, namelen, &hinfo);
+        memset(frames, 0, sizeof(frames));
         frame = frames;
         frame->entries = entries;
         frame->at = entries;
         frame->bh = bh;
         bh = bh2;
 
-        ext4_handle_dirty_dx_node(handle, dir, frame->bh);
-        ext4_handle_dirty_dirent_node(handle, dir, bh);
+        retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
+        if (retval)
+                goto out_frames;        
+        retval = ext4_handle_dirty_dirent_node(handle, dir, bh);
+        if (retval)
+                goto out_frames;        
 
         de = do_split(handle,dir, &bh, frame, &hinfo);
         if (IS_ERR(de)) {
-                /*
-                 * Even if the block split failed, we have to properly write
-                 * out all the changes we did so far. Otherwise we can end up
-                 * with corrupted filesystem.
-                 */
-                ext4_mark_inode_dirty(handle, dir);
-                dx_release(frames);
-                return PTR_ERR(de);
+                retval = PTR_ERR(de);
+                goto out_frames;
         }
         dx_release(frames);
 
         retval = add_dirent_to_buf(handle, dentry, inode, de, bh);
         brelse(bh);
         return retval;
+out_frames:
+        /*
+         * Even if the block split failed, we have to properly write
+         * out all the changes we did so far. Otherwise we can end up
+         * with corrupted filesystem.
+         */
+        ext4_mark_inode_dirty(handle, dir);
+        dx_release(frames);
+        return retval;
 }
 
 /*
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index f298c60f907d..ca4588388fc3 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1081,7 +1081,7 @@ static void update_backups(struct super_block *sb, int blk_off, char *data,
                         break;
 
                 if (meta_bg == 0)
-                        backup_block = group * bpg + blk_off;
+                        backup_block = ((ext4_fsblk_t)group) * bpg + blk_off;
                 else
                         backup_block = (ext4_group_first_block_no(sb, group) +
                                         ext4_bg_has_super(sb, group));
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 1eda6ab0ef9d..2c9e6864abd9 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -3526,6 +3526,10 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
         set_opt(sb, POSIX_ACL);
 #endif
+        /* don't forget to enable journal_csum when metadata_csum is enabled. */
+        if (ext4_has_metadata_csum(sb))
+                set_opt(sb, JOURNAL_CHECKSUM);
+
         if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
                 set_opt(sb, JOURNAL_DATA);
         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
@@ -3943,7 +3947,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_MMP) &&
             !(sb->s_flags & MS_RDONLY))
                 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
-                        goto failed_mount3;
+                        goto failed_mount3a;
 
         /*
          * The first inode we look at is the journal inode.  Don't try
@@ -3952,7 +3956,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         if (!test_opt(sb, NOLOAD) &&
             EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
                 if (ext4_load_journal(sb, es, journal_devnum))
-                        goto failed_mount3;
+                        goto failed_mount3a;
         } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
               EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
                 ext4_msg(sb, KERN_ERR, "required journal recovery "
@@ -4240,6 +4244,7 @@ failed_mount_wq:
                 jbd2_journal_destroy(sbi->s_journal);
                 sbi->s_journal = NULL;
         }
+failed_mount3a:
         ext4_es_unregister_shrinker(sbi);
 failed_mount3:
         del_timer_sync(&sbi->s_err_report);
@@ -4841,6 +4846,14 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                 goto restore_opts;
         }
 
+        if ((old_opts.s_mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) ^
+            test_opt(sb, JOURNAL_CHECKSUM)) {
+                ext4_msg(sb, KERN_ERR, "changing journal_checksum "
+                         "during remount not supported");
+                err = -EINVAL;
+                goto restore_opts;
+        }
+
         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
                 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
                         ext4_msg(sb, KERN_ERR, "can't mount with "
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/gfs2/inode.c b/fs/gfs2/inode.c
index c4ed823d150e..6e2917433170 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -596,7 +596,6 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
         struct gfs2_inode *dip = GFS2_I(dir), *ip;
         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
         struct gfs2_glock *io_gl;
-        struct dentry *d;
         int error, free_vfs_inode = 0;
         u32 aflags = 0;
         unsigned blocks = 1;
@@ -624,22 +623,18 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
         inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
         error = PTR_ERR(inode);
         if (!IS_ERR(inode)) {
-                d = d_splice_alias(inode, dentry);
-                error = PTR_ERR(d);
-                if (IS_ERR(d)) {
-                        inode = ERR_CAST(d);
+                if (S_ISDIR(inode->i_mode)) {
+                        iput(inode);
+                        inode = ERR_PTR(-EISDIR);
                         goto fail_gunlock;
                 }
+                d_instantiate(dentry, inode);
                 error = 0;
                 if (file) {
-                        if (S_ISREG(inode->i_mode)) {
-                                WARN_ON(d != NULL);
+                        if (S_ISREG(inode->i_mode))
                                 error = finish_open(file, dentry, gfs2_open_common, opened);
-                        } else {
-                                error = finish_no_open(file, d);
-                        }
-                } else {
-                        dput(d);
+                        else
+                                error = finish_no_open(file, NULL);
                 }
                 gfs2_glock_dq_uninit(ghs);
                 return error;
@@ -1254,11 +1249,8 @@ static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
         if (d != NULL)
                 dentry = d;
         if (dentry->d_inode) {
-                if (!(*opened & FILE_OPENED)) {
-                        if (d == NULL)
-                                dget(dentry);
-                        return finish_no_open(file, dentry);
-                }
+                if (!(*opened & FILE_OPENED))
+                        return finish_no_open(file, d);
                 dput(d);
                 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/isofs/inode.c b/fs/isofs/inode.c
index 881b3bd0143f..d67a16f2a45d 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -29,13 +29,9 @@
 #define BEQUIET
 
 static int isofs_hashi(const struct dentry *parent, struct qstr *qstr);
-static int isofs_hash(const struct dentry *parent, struct qstr *qstr);
 static int isofs_dentry_cmpi(const struct dentry *parent,
                 const struct dentry *dentry,
                 unsigned int len, const char *str, const struct qstr *name);
-static int isofs_dentry_cmp(const struct dentry *parent,
-                const struct dentry *dentry,
-                unsigned int len, const char *str, const struct qstr *name);
 
 #ifdef CONFIG_JOLIET
 static int isofs_hashi_ms(const struct dentry *parent, struct qstr *qstr);
@@ -135,10 +131,6 @@ static const struct super_operations isofs_sops = {
 
 static const struct dentry_operations isofs_dentry_ops[] = {
         {
-                .d_hash         = isofs_hash,
-                .d_compare      = isofs_dentry_cmp,
-        },
-        {
                 .d_hash         = isofs_hashi,
                 .d_compare      = isofs_dentry_cmpi,
         },
@@ -182,27 +174,6 @@ struct iso9660_options{
  * Compute the hash for the isofs name corresponding to the dentry.
  */
 static int
-isofs_hash_common(struct qstr *qstr, int ms)
-{
-        const char *name;
-        int len;
-
-        len = qstr->len;
-        name = qstr->name;
-        if (ms) {
-                while (len && name[len-1] == '.')
-                        len--;
-        }
-
-        qstr->hash = full_name_hash(name, len);
-
-        return 0;
-}
-
-/*
- * Compute the hash for the isofs name corresponding to the dentry.
- */
-static int
 isofs_hashi_common(struct qstr *qstr, int ms)
 {
         const char *name;
@@ -258,32 +229,40 @@ static int isofs_dentry_cmp_common(
 }
 
 static int
-isofs_hash(const struct dentry *dentry, struct qstr *qstr)
-{
-        return isofs_hash_common(qstr, 0);
-}
-
-static int
 isofs_hashi(const struct dentry *dentry, struct qstr *qstr)
 {
         return isofs_hashi_common(qstr, 0);
 }
 
 static int
-isofs_dentry_cmp(const struct dentry *parent, const struct dentry *dentry,
+isofs_dentry_cmpi(const struct dentry *parent, const struct dentry *dentry,
                 unsigned int len, const char *str, const struct qstr *name)
 {
-        return isofs_dentry_cmp_common(len, str, name, 0, 0);
+        return isofs_dentry_cmp_common(len, str, name, 0, 1);
 }
 
+#ifdef CONFIG_JOLIET
+/*
+ * Compute the hash for the isofs name corresponding to the dentry.
+ */
 static int
-isofs_dentry_cmpi(const struct dentry *parent, const struct dentry *dentry,
-                unsigned int len, const char *str, const struct qstr *name)
+isofs_hash_common(struct qstr *qstr, int ms)
 {
-        return isofs_dentry_cmp_common(len, str, name, 0, 1);
+        const char *name;
+        int len;
+
+        len = qstr->len;
+        name = qstr->name;
+        if (ms) {
+                while (len && name[len-1] == '.')
+                        len--;
+        }
+
+        qstr->hash = full_name_hash(name, len);
+
+        return 0;
 }
 
-#ifdef CONFIG_JOLIET
 static int
 isofs_hash_ms(const struct dentry *dentry, struct qstr *qstr)
 {
@@ -930,7 +909,8 @@ root_found:
         if (opt.check == 'r')
                 table++;
 
-        s->s_d_op = &isofs_dentry_ops[table];
+        if (table)
+                s->s_d_op = &isofs_dentry_ops[table - 1];
 
         /* get the root dentry */
         s->s_root = d_make_root(inode);
diff --git a/fs/isofs/namei.c b/fs/isofs/namei.c
index 95295640d9c8..7b543e6b6526 100644
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
@@ -18,25 +18,10 @@ static int
 isofs_cmp(struct dentry *dentry, const char *compare, int dlen)
 {
         struct qstr qstr;
-
-        if (!compare)
-                return 1;
-
-        /* check special "." and ".." files */
-        if (dlen == 1) {
-                /* "." */
-                if (compare[0] == 0) {
-                        if (!dentry->d_name.len)
-                                return 0;
-                        compare = ".";
-                } else if (compare[0] == 1) {
-                        compare = "..";
-                        dlen = 2;
-                }
-        }
-
         qstr.name = compare;
         qstr.len = dlen;
+        if (likely(!dentry->d_op))
+                return dentry->d_name.len != dlen || memcmp(dentry->d_name.name, compare, dlen);
         return dentry->d_op->d_compare(NULL, NULL, dentry->d_name.len, dentry->d_name.name, &qstr);
 }
 
@@ -146,7 +131,8 @@ isofs_find_entry(struct inode *dir, struct dentry *dentry,
                                 (!(de->flags[-sbi->s_high_sierra] & 1))) &&
                         (sbi->s_showassoc ||
                                 (!(de->flags[-sbi->s_high_sierra] & 4)))) {
-                        match = (isofs_cmp(dentry, dpnt, dlen) == 0);
+                        if (dpnt && (dlen > 1 || dpnt[0] > 1))
+                                match = (isofs_cmp(dentry, dpnt, dlen) == 0);
                 }
                 if (match) {
                         isofs_normalize_block_and_offset(de,
diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index 8898bbd2b61e..dcead636c33b 100644
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -93,6 +93,7 @@
 #include <linux/bio.h>
 #endif
 #include <linux/log2.h>
+#include <linux/hash.h>
 
 static struct kmem_cache *revoke_record_cache;
 static struct kmem_cache *revoke_table_cache;
@@ -129,15 +130,11 @@ static void flush_descriptor(journal_t *, struct journal_head *, int, int);
 
 /* Utility functions to maintain the revoke table */
 
-/* Borrowed from buffer.c: this is a tried and tested block hash function */
 static inline int hash(journal_t *journal, unsigned int block)
 {
         struct jbd_revoke_table_s *table = journal->j_revoke;
-        int hash_shift = table->hash_shift;
 
-        return ((block << (hash_shift - 6)) ^
-                (block >> 13) ^
-                (block << (hash_shift - 12))) & (table->hash_size - 1);
+        return hash_32(block, table->hash_shift);
 }
 
 static int insert_revoke_hash(journal_t *journal, unsigned int blocknr,
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index d5e95a175c92..c6cbaef2bda1 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -92,6 +92,7 @@
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <linux/log2.h>
+#include <linux/hash.h>
 #endif
 
 static struct kmem_cache *jbd2_revoke_record_cache;
@@ -130,16 +131,9 @@ static void flush_descriptor(journal_t *, struct buffer_head *, int, int);
 
 /* Utility functions to maintain the revoke table */
 
-/* Borrowed from buffer.c: this is a tried and tested block hash function */
 static inline int hash(journal_t *journal, unsigned long long block)
 {
-        struct jbd2_revoke_table_s *table = journal->j_revoke;
-        int hash_shift = table->hash_shift;
-        int hash = (int)block ^ (int)((block >> 31) >> 1);
-
-        return ((hash << (hash_shift - 6)) ^
-                (hash >> 13) ^
-                (hash << (hash_shift - 12))) & (table->hash_size - 1);
+        return hash_64(block, journal->j_revoke->hash_shift);
 }
 
 static int insert_revoke_hash(journal_t *journal, unsigned long long blocknr,
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/namei.c b/fs/namei.c
index 42df664e95e5..db5fe86319e6 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2497,7 +2497,7 @@ struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
         }
 
         mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
-        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
+        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT2);
         return NULL;
 }
 EXPORT_SYMBOL(lock_rename);
@@ -3154,7 +3154,8 @@ static int do_tmpfile(int dfd, struct filename *pathname,
         if (error)
                 goto out2;
         audit_inode(pathname, nd->path.dentry, 0);
-        error = may_open(&nd->path, op->acc_mode, op->open_flag);
+        /* Don't check for other permissions, the inode was just created */
+        error = may_open(&nd->path, MAY_OPEN, op->open_flag);
         if (error)
                 goto out2;
         file->f_path.mnt = nd->path.mnt;
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/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 5228f201d3d5..4f46f7a05289 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -378,7 +378,7 @@ bl_write_pagelist(struct nfs_pgio_header *header, int sync)
         loff_t offset = header->args.offset;
         size_t count = header->args.count;
         struct page **pages = header->args.pages;
-        int pg_index = pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
+        int pg_index = header->args.pgbase >> PAGE_CACHE_SHIFT;
         unsigned int pg_len;
         struct blk_plug plug;
         int i;
diff --git a/fs/nfs/blocklayout/rpc_pipefs.c b/fs/nfs/blocklayout/rpc_pipefs.c
index e966c023b1b7..dbe5839cdeba 100644
--- a/fs/nfs/blocklayout/rpc_pipefs.c
+++ b/fs/nfs/blocklayout/rpc_pipefs.c
@@ -65,17 +65,18 @@ bl_resolve_deviceid(struct nfs_server *server, struct pnfs_block_volume *b,
 
         dprintk("%s CREATING PIPEFS MESSAGE\n", __func__);
 
+        mutex_lock(&nn->bl_mutex);
         bl_pipe_msg.bl_wq = &nn->bl_wq;
 
         b->simple.len += 4;     /* single volume */
         if (b->simple.len > PAGE_SIZE)
-                return -EIO;
+                goto out_unlock;
 
         memset(msg, 0, sizeof(*msg));
         msg->len = sizeof(*bl_msg) + b->simple.len;
         msg->data = kzalloc(msg->len, gfp_mask);
         if (!msg->data)
-                goto out;
+                goto out_free_data;
 
         bl_msg = msg->data;
         bl_msg->type = BL_DEVICE_MOUNT,
@@ -87,7 +88,7 @@ bl_resolve_deviceid(struct nfs_server *server, struct pnfs_block_volume *b,
         rc = rpc_queue_upcall(nn->bl_device_pipe, msg);
         if (rc < 0) {
                 remove_wait_queue(&nn->bl_wq, &wq);
-                goto out;
+                goto out_free_data;
         }
 
         set_current_state(TASK_UNINTERRUPTIBLE);
@@ -97,19 +98,21 @@ bl_resolve_deviceid(struct nfs_server *server, struct pnfs_block_volume *b,
         if (reply->status != BL_DEVICE_REQUEST_PROC) {
                 printk(KERN_WARNING "%s failed to decode device: %d\n",
                         __func__, reply->status);
-                goto out;
+                goto out_free_data;
         }
 
         dev = MKDEV(reply->major, reply->minor);
-out:
+out_free_data:
         kfree(msg->data);
+out_unlock:
+        mutex_unlock(&nn->bl_mutex);
         return dev;
 }
 
 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))
@@ -232,6 +235,7 @@ static int nfs4blocklayout_net_init(struct net *net)
         struct nfs_net *nn = net_generic(net, nfs_net_id);
         struct dentry *dentry;
 
+        mutex_init(&nn->bl_mutex);
         init_waitqueue_head(&nn->bl_wq);
         nn->bl_device_pipe = rpc_mkpipe_data(&bl_upcall_ops, 0);
         if (IS_ERR(nn->bl_device_pipe))
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 5853f53db732..7f3f60641344 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -125,6 +125,8 @@ again:
                         continue;
                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
                         continue;
+                if (!nfs4_valid_open_stateid(state))
+                        continue;
                 if (!nfs4_stateid_match(&state->stateid, stateid))
                         continue;
                 get_nfs_open_context(ctx);
@@ -193,7 +195,11 @@ static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *
 {
         int res = 0;
 
-        res = nfs4_proc_delegreturn(inode, delegation->cred, &delegation->stateid, issync);
+        if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
+                res = nfs4_proc_delegreturn(inode,
+                                delegation->cred,
+                                &delegation->stateid,
+                                issync);
         nfs_free_delegation(delegation);
         return res;
 }
@@ -380,11 +386,13 @@ static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation
 {
         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
         struct nfs_inode *nfsi = NFS_I(inode);
-        int err;
+        int err = 0;
 
         if (delegation == NULL)
                 return 0;
         do {
+                if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
+                        break;
                 err = nfs_delegation_claim_opens(inode, &delegation->stateid);
                 if (!issync || err != -EAGAIN)
                         break;
@@ -605,10 +613,23 @@ static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *cl
         rcu_read_unlock();
 }
 
+static void nfs_revoke_delegation(struct inode *inode)
+{
+        struct nfs_delegation *delegation;
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation != NULL) {
+                set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
+                nfs_mark_return_delegation(NFS_SERVER(inode), delegation);
+        }
+        rcu_read_unlock();
+}
+
 void nfs_remove_bad_delegation(struct inode *inode)
 {
         struct nfs_delegation *delegation;
 
+        nfs_revoke_delegation(inode);
         delegation = nfs_inode_detach_delegation(inode);
         if (delegation) {
                 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
diff --git a/fs/nfs/delegation.h b/fs/nfs/delegation.h
index 5c1cce39297f..e3c20a3ccc93 100644
--- a/fs/nfs/delegation.h
+++ b/fs/nfs/delegation.h
@@ -31,6 +31,7 @@ enum {
         NFS_DELEGATION_RETURN_IF_CLOSED,
         NFS_DELEGATION_REFERENCED,
         NFS_DELEGATION_RETURNING,
+        NFS_DELEGATION_REVOKED,
 };
 
 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 06e8cfcbb670..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;
@@ -1527,6 +1527,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                 case -ENOENT:
                         d_drop(dentry);
                         d_add(dentry, NULL);
+                        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
                         break;
                 case -EISDIR:
                 case -ENOTDIR:
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 20cffc830468..10bf07280f4a 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -266,6 +266,7 @@ static void nfs_direct_req_free(struct kref *kref)
 {
         struct nfs_direct_req *dreq = container_of(kref, struct nfs_direct_req, kref);
 
+        nfs_free_pnfs_ds_cinfo(&dreq->ds_cinfo);
         if (dreq->l_ctx != NULL)
                 nfs_put_lock_context(dreq->l_ctx);
         if (dreq->ctx != NULL)
diff --git a/fs/nfs/filelayout/filelayout.c b/fs/nfs/filelayout/filelayout.c
index 46fab1cb455a..7afb52f6a25a 100644
--- a/fs/nfs/filelayout/filelayout.c
+++ b/fs/nfs/filelayout/filelayout.c
@@ -145,9 +145,6 @@ static int filelayout_async_handle_error(struct rpc_task *task,
         case -NFS4ERR_DELEG_REVOKED:
         case -NFS4ERR_ADMIN_REVOKED:
         case -NFS4ERR_BAD_STATEID:
-                if (state == NULL)
-                        break;
-                nfs_remove_bad_delegation(state->inode);
         case -NFS4ERR_OPENMODE:
                 if (state == NULL)
                         break;
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/nfs/inode.c b/fs/nfs/inode.c
index 6388a59f2add..00689a8a85e4 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -626,7 +626,7 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
         struct inode *inode = dentry->d_inode;
         int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
-        int err;
+        int err = 0;
 
         trace_nfs_getattr_enter(inode);
         /* Flush out writes to the server in order to update c/mtime.  */
diff --git a/fs/nfs/netns.h b/fs/nfs/netns.h
index ef221fb8a183..f0e06e4acbef 100644
--- a/fs/nfs/netns.h
+++ b/fs/nfs/netns.h
@@ -19,6 +19,7 @@ struct nfs_net {
         struct rpc_pipe *bl_device_pipe;
         struct bl_dev_msg bl_mount_reply;
         wait_queue_head_t bl_wq;
+        struct mutex bl_mutex;
         struct list_head nfs_client_list;
         struct list_head nfs_volume_list;
 #if IS_ENABLED(CONFIG_NFS_V4)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 405bd95c1f58..69dc20a743f9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -370,11 +370,6 @@ static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struc
                 case -NFS4ERR_DELEG_REVOKED:
                 case -NFS4ERR_ADMIN_REVOKED:
                 case -NFS4ERR_BAD_STATEID:
-                        if (inode != NULL && nfs4_have_delegation(inode, FMODE_READ)) {
-                                nfs_remove_bad_delegation(inode);
-                                exception->retry = 1;
-                                break;
-                        }
                         if (state == NULL)
                                 break;
                         ret = nfs4_schedule_stateid_recovery(server, state);
@@ -1654,7 +1649,7 @@ static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct
                         nfs_inode_find_state_and_recover(state->inode,
                                         stateid);
                         nfs4_schedule_stateid_recovery(server, state);
-                        return 0;
+                        return -EAGAIN;
                 case -NFS4ERR_DELAY:
                 case -NFS4ERR_GRACE:
                         set_bit(NFS_DELEGATED_STATE, &state->flags);
@@ -2109,46 +2104,60 @@ static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *sta
         return ret;
 }
 
+static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state)
+{
+        nfs_remove_bad_delegation(state->inode);
+        write_seqlock(&state->seqlock);
+        nfs4_stateid_copy(&state->stateid, &state->open_stateid);
+        write_sequnlock(&state->seqlock);
+        clear_bit(NFS_DELEGATED_STATE, &state->flags);
+}
+
+static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
+{
+        if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
+                nfs_finish_clear_delegation_stateid(state);
+}
+
+static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
+{
+        /* NFSv4.0 doesn't allow for delegation recovery on open expire */
+        nfs40_clear_delegation_stateid(state);
+        return nfs4_open_expired(sp, state);
+}
+
 #if defined(CONFIG_NFS_V4_1)
-static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
+static void nfs41_check_delegation_stateid(struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
-        nfs4_stateid *stateid = &state->stateid;
+        nfs4_stateid stateid;
         struct nfs_delegation *delegation;
-        struct rpc_cred *cred = NULL;
-        int status = -NFS4ERR_BAD_STATEID;
-
-        /* If a state reset has been done, test_stateid is unneeded */
-        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
-                return;
+        struct rpc_cred *cred;
+        int status;
 
         /* Get the delegation credential for use by test/free_stateid */
         rcu_read_lock();
         delegation = rcu_dereference(NFS_I(state->inode)->delegation);
-        if (delegation != NULL &&
-            nfs4_stateid_match(&delegation->stateid, stateid)) {
-                cred = get_rpccred(delegation->cred);
-                rcu_read_unlock();
-                status = nfs41_test_stateid(server, stateid, cred);
-                trace_nfs4_test_delegation_stateid(state, NULL, status);
-        } else
+        if (delegation == NULL) {
                 rcu_read_unlock();
+                return;
+        }
+
+        nfs4_stateid_copy(&stateid, &delegation->stateid);
+        cred = get_rpccred(delegation->cred);
+        rcu_read_unlock();
+        status = nfs41_test_stateid(server, &stateid, cred);
+        trace_nfs4_test_delegation_stateid(state, NULL, status);
 
         if (status != NFS_OK) {
                 /* Free the stateid unless the server explicitly
                  * informs us the stateid is unrecognized. */
                 if (status != -NFS4ERR_BAD_STATEID)
-                        nfs41_free_stateid(server, stateid, cred);
-                nfs_remove_bad_delegation(state->inode);
-
-                write_seqlock(&state->seqlock);
-                nfs4_stateid_copy(&state->stateid, &state->open_stateid);
-                write_sequnlock(&state->seqlock);
-                clear_bit(NFS_DELEGATED_STATE, &state->flags);
+                        nfs41_free_stateid(server, &stateid, cred);
+                nfs_finish_clear_delegation_stateid(state);
         }
 
-        if (cred != NULL)
-                put_rpccred(cred);
+        put_rpccred(cred);
 }
 
 /**
@@ -2192,7 +2201,7 @@ static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *st
 {
         int status;
 
-        nfs41_clear_delegation_stateid(state);
+        nfs41_check_delegation_stateid(state);
         status = nfs41_check_open_stateid(state);
         if (status != NFS_OK)
                 status = nfs4_open_expired(sp, state);
@@ -2231,19 +2240,8 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
         seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
 
         ret = _nfs4_proc_open(opendata);
-        if (ret != 0) {
-                if (ret == -ENOENT) {
-                        dentry = opendata->dentry;
-                        if (dentry->d_inode)
-                                d_delete(dentry);
-                        else if (d_unhashed(dentry))
-                                d_add(dentry, NULL);
-
-                        nfs_set_verifier(dentry,
-                                         nfs_save_change_attribute(opendata->dir->d_inode));
-                }
+        if (ret != 0)
                 goto out;
-        }
 
         state = nfs4_opendata_to_nfs4_state(opendata);
         ret = PTR_ERR(state);
@@ -4841,9 +4839,6 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server,
                 case -NFS4ERR_DELEG_REVOKED:
                 case -NFS4ERR_ADMIN_REVOKED:
                 case -NFS4ERR_BAD_STATEID:
-                        if (state == NULL)
-                                break;
-                        nfs_remove_bad_delegation(state->inode);
                 case -NFS4ERR_OPENMODE:
                         if (state == NULL)
                                 break;
@@ -8341,7 +8336,7 @@ static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
         .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
         .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
-        .recover_open   = nfs4_open_expired,
+        .recover_open   = nfs40_open_expired,
         .recover_lock   = nfs4_lock_expired,
         .establish_clid = nfs4_init_clientid,
 };
@@ -8408,8 +8403,7 @@ static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
                 | NFS_CAP_CHANGE_ATTR
                 | NFS_CAP_POSIX_LOCK
                 | NFS_CAP_STATEID_NFSV41
-                | NFS_CAP_ATOMIC_OPEN_V1
-                | NFS_CAP_SEEK,
+                | NFS_CAP_ATOMIC_OPEN_V1,
         .init_client = nfs41_init_client,
         .shutdown_client = nfs41_shutdown_client,
         .match_stateid = nfs41_match_stateid,
@@ -8431,7 +8425,8 @@ static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
                 | NFS_CAP_CHANGE_ATTR
                 | NFS_CAP_POSIX_LOCK
                 | NFS_CAP_STATEID_NFSV41
-                | NFS_CAP_ATOMIC_OPEN_V1,
+                | NFS_CAP_ATOMIC_OPEN_V1
+                | NFS_CAP_SEEK,
         .init_client = nfs41_init_client,
         .shutdown_client = nfs41_shutdown_client,
         .match_stateid = nfs41_match_stateid,
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 12493846a2d3..f83b02dc9166 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -715,8 +715,6 @@ static void nfs_inode_remove_request(struct nfs_page *req)
 
         if (test_and_clear_bit(PG_INODE_REF, &req->wb_flags))
                 nfs_release_request(req);
-        else
-                WARN_ON_ONCE(1);
 }
 
 static void
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index cdeb3cfd6f32..0beb023f25ac 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -1272,7 +1272,8 @@ static bool need_wrongsec_check(struct svc_rqst *rqstp)
          */
         if (argp->opcnt == resp->opcnt)
                 return false;
-
+        if (next->opnum == OP_ILLEGAL)
+                return false;
         nextd = OPDESC(next);
         /*
          * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
@@ -1589,7 +1590,8 @@ static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op
 static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
                                        struct nfsd4_op *op)
 {
-        return NFS4_MAX_SESSIONID_LEN + 20;
+        return (op_encode_hdr_size
+                + XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
 }
 
 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
@@ -1893,6 +1895,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
                 .op_func = (nfsd4op_func)nfsd4_sequence,
                 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
                 .op_name = "OP_SEQUENCE",
+                .op_rsize_bop = (nfsd4op_rsize)nfsd4_sequence_rsize,
         },
         [OP_DESTROY_CLIENTID] = {
                 .op_func = (nfsd4op_func)nfsd4_destroy_clientid,
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 9d3e9c50066a..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;
 
@@ -229,8 +229,16 @@ int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
                                               &fsnotify_mark_srcu);
         }
 
+        /*
+         * We need to merge inode & vfsmount mark lists so that inode mark
+         * ignore masks are properly reflected for mount mark notifications.
+         * That's why this traversal is so complicated...
+         */
         while (inode_node || vfsmount_node) {
-                inode_group = vfsmount_group = NULL;
+                inode_group = NULL;
+                inode_mark = NULL;
+                vfsmount_group = NULL;
+                vfsmount_mark = NULL;
 
                 if (inode_node) {
                         inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu),
@@ -244,21 +252,19 @@ int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
                         vfsmount_group = vfsmount_mark->group;
                 }
 
-                if (inode_group > vfsmount_group) {
-                        /* handle inode */
-                        ret = send_to_group(to_tell, inode_mark, NULL, mask,
-                                            data, data_is, cookie, file_name);
-                        /* we didn't use the vfsmount_mark */
-                        vfsmount_group = NULL;
-                } else if (vfsmount_group > inode_group) {
-                        ret = send_to_group(to_tell, NULL, vfsmount_mark, mask,
-                                            data, data_is, cookie, file_name);
-                        inode_group = NULL;
-                } else {
-                        ret = send_to_group(to_tell, inode_mark, vfsmount_mark,
-                                            mask, data, data_is, cookie,
-                                            file_name);
+                if (inode_group && vfsmount_group) {
+                        int cmp = fsnotify_compare_groups(inode_group,
+                                                          vfsmount_group);
+                        if (cmp > 0) {
+                                inode_group = NULL;
+                                inode_mark = NULL;
+                        } else if (cmp < 0) {
+                                vfsmount_group = NULL;
+                                vfsmount_mark = NULL;
+                        }
                 }
+                ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
+                                    data, data_is, cookie, file_name);
 
                 if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
                         goto out;
diff --git a/fs/notify/fsnotify.h b/fs/notify/fsnotify.h
index 9c0898c4cfe1..3b68b0ae0a97 100644
--- a/fs/notify/fsnotify.h
+++ b/fs/notify/fsnotify.h
@@ -12,6 +12,10 @@ extern void fsnotify_flush_notify(struct fsnotify_group *group);
 /* protects reads of inode and vfsmount marks list */
 extern struct srcu_struct fsnotify_mark_srcu;
 
+/* compare two groups for sorting of marks lists */
+extern int fsnotify_compare_groups(struct fsnotify_group *a,
+                                   struct fsnotify_group *b);
+
 extern void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *fsn_mark,
                                                 __u32 mask);
 /* add a mark to an inode */
diff --git a/fs/notify/inode_mark.c b/fs/notify/inode_mark.c
index 9ce062218de9..dfbf5447eea4 100644
--- a/fs/notify/inode_mark.c
+++ b/fs/notify/inode_mark.c
@@ -194,6 +194,7 @@ int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
 {
         struct fsnotify_mark *lmark, *last = NULL;
         int ret = 0;
+        int cmp;
 
         mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
 
@@ -219,11 +220,8 @@ int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
                         goto out;
                 }
 
-                if (mark->group->priority < lmark->group->priority)
-                        continue;
-
-                if ((mark->group->priority == lmark->group->priority) &&
-                    (mark->group < lmark->group))
+                cmp = fsnotify_compare_groups(lmark->group, mark->group);
+                if (cmp < 0)
                         continue;
 
                 hlist_add_before_rcu(&mark->i.i_list, &lmark->i.i_list);
@@ -288,20 +286,25 @@ void fsnotify_unmount_inodes(struct list_head *list)
                 spin_unlock(&inode->i_lock);
 
                 /* In case the dropping of a reference would nuke next_i. */
-                if ((&next_i->i_sb_list != list) &&
-                    atomic_read(&next_i->i_count)) {
+                while (&next_i->i_sb_list != list) {
                         spin_lock(&next_i->i_lock);
-                        if (!(next_i->i_state & (I_FREEING | I_WILL_FREE))) {
+                        if (!(next_i->i_state & (I_FREEING | I_WILL_FREE)) &&
+                                                atomic_read(&next_i->i_count)) {
                                 __iget(next_i);
                                 need_iput = next_i;
+                                spin_unlock(&next_i->i_lock);
+                                break;
                         }
                         spin_unlock(&next_i->i_lock);
+                        next_i = list_entry(next_i->i_sb_list.next,
+                                                struct inode, i_sb_list);
                 }
 
                 /*
-                 * We can safely drop inode_sb_list_lock here because we hold
-                 * references on both inode and next_i.  Also no new inodes
-                 * will be added since the umount has begun.
+                 * We can safely drop inode_sb_list_lock here because either
+                 * we actually hold references on both inode and next_i or
+                 * end of list.  Also no new inodes will be added since the
+                 * umount has begun.
                  */
                 spin_unlock(&inode_sb_list_lock);
 
diff --git a/fs/notify/mark.c b/fs/notify/mark.c
index d90deaa08e78..34c38fabf514 100644
--- a/fs/notify/mark.c
+++ b/fs/notify/mark.c
@@ -210,6 +210,42 @@ void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mas
 }
 
 /*
+ * Sorting function for lists of fsnotify marks.
+ *
+ * Fanotify supports different notification classes (reflected as priority of
+ * notification group). Events shall be passed to notification groups in
+ * decreasing priority order. To achieve this marks in notification lists for
+ * inodes and vfsmounts are sorted so that priorities of corresponding groups
+ * are descending.
+ *
+ * Furthermore correct handling of the ignore mask requires processing inode
+ * and vfsmount marks of each group together. Using the group address as
+ * further sort criterion provides a unique sorting order and thus we can
+ * merge inode and vfsmount lists of marks in linear time and find groups
+ * present in both lists.
+ *
+ * A return value of 1 signifies that b has priority over a.
+ * A return value of 0 signifies that the two marks have to be handled together.
+ * A return value of -1 signifies that a has priority over b.
+ */
+int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
+{
+        if (a == b)
+                return 0;
+        if (!a)
+                return 1;
+        if (!b)
+                return -1;
+        if (a->priority < b->priority)
+                return 1;
+        if (a->priority > b->priority)
+                return -1;
+        if (a < b)
+                return 1;
+        return -1;
+}
+
+/*
  * Attach an initialized mark to a given group and fs object.
  * These marks may be used for the fsnotify backend to determine which
  * event types should be delivered to which group.
diff --git a/fs/notify/vfsmount_mark.c b/fs/notify/vfsmount_mark.c
index ac851e8376b1..faefa72a11eb 100644
--- a/fs/notify/vfsmount_mark.c
+++ b/fs/notify/vfsmount_mark.c
@@ -153,6 +153,7 @@ int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
         struct mount *m = real_mount(mnt);
         struct fsnotify_mark *lmark, *last = NULL;
         int ret = 0;
+        int cmp;
 
         mark->flags |= FSNOTIFY_MARK_FLAG_VFSMOUNT;
 
@@ -178,11 +179,8 @@ int fsnotify_add_vfsmount_mark(struct fsnotify_mark *mark,
                         goto out;
                 }
 
-                if (mark->group->priority < lmark->group->priority)
-                        continue;
-
-                if ((mark->group->priority == lmark->group->priority) &&
-                    (mark->group < lmark->group))
+                cmp = fsnotify_compare_groups(lmark->group, mark->group);
+                if (cmp < 0)
                         continue;
 
                 hlist_add_before_rcu(&mark->m.m_list, &lmark->m.m_list);
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/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 97de0fbd9f78..a96044004064 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -925,7 +925,7 @@ static int o2net_send_tcp_msg(struct socket *sock, struct kvec *vec,
                               size_t veclen, size_t total)
 {
         int ret;
-        struct msghdr msg;
+        struct msghdr msg = {.msg_flags = 0,};
 
         if (sock == NULL) {
                 ret = -EINVAL;
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/ocfs2/namei.c b/fs/ocfs2/namei.c
index 8add6f1030d7..b931e04e3388 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -158,7 +158,7 @@ bail_add:
                  * NOTE: This dentry already has ->d_op set from
                  * ocfs2_get_parent() and ocfs2_get_dentry()
                  */
-                if (ret)
+                if (!IS_ERR_OR_NULL(ret))
                         dentry = ret;
 
                 status = ocfs2_dentry_attach_lock(dentry, inode,
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/Kconfig b/fs/overlayfs/Kconfig
index e60125976873..34355818a2e0 100644
--- a/fs/overlayfs/Kconfig
+++ b/fs/overlayfs/Kconfig
@@ -1,4 +1,4 @@
-config OVERLAYFS_FS
+config OVERLAY_FS
         tristate "Overlay filesystem support"
         help
           An overlay filesystem combines two filesystems - an 'upper' filesystem
diff --git a/fs/overlayfs/Makefile b/fs/overlayfs/Makefile
index 8f91889480d0..900daed3e91d 100644
--- a/fs/overlayfs/Makefile
+++ b/fs/overlayfs/Makefile
@@ -2,6 +2,6 @@
 # Makefile for the overlay filesystem.
 #
 
-obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o
+obj-$(CONFIG_OVERLAY_FS) += overlay.o
 
-overlayfs-objs := super.o inode.o dir.o readdir.o copy_up.o
+overlay-objs := super.o inode.o dir.o readdir.o copy_up.o
diff --git a/fs/overlayfs/dir.c b/fs/overlayfs/dir.c
index 15cd91ad9940..8ffc4b980f1b 100644
--- a/fs/overlayfs/dir.c
+++ b/fs/overlayfs/dir.c
@@ -284,8 +284,7 @@ out:
         return ERR_PTR(err);
 }
 
-static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry,
-                                                enum ovl_path_type type)
+static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry)
 {
         int err;
         struct dentry *ret = NULL;
@@ -294,8 +293,17 @@ static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry,
         err = ovl_check_empty_dir(dentry, &list);
         if (err)
                 ret = ERR_PTR(err);
-        else if (type == OVL_PATH_MERGE)
-                ret = ovl_clear_empty(dentry, &list);
+        else {
+                /*
+                 * If no upperdentry then skip clearing whiteouts.
+                 *
+                 * Can race with copy-up, since we don't hold the upperdir
+                 * mutex.  Doesn't matter, since copy-up can't create a
+                 * non-empty directory from an empty one.
+                 */
+                if (ovl_dentry_upper(dentry))
+                        ret = ovl_clear_empty(dentry, &list);
+        }
 
         ovl_cache_free(&list);
 
@@ -487,8 +495,7 @@ out:
         return err;
 }
 
-static int ovl_remove_and_whiteout(struct dentry *dentry,
-                                   enum ovl_path_type type, bool is_dir)
+static int ovl_remove_and_whiteout(struct dentry *dentry, bool is_dir)
 {
         struct dentry *workdir = ovl_workdir(dentry);
         struct inode *wdir = workdir->d_inode;
@@ -500,7 +507,7 @@ static int ovl_remove_and_whiteout(struct dentry *dentry,
         int err;
 
         if (is_dir) {
-                opaquedir = ovl_check_empty_and_clear(dentry, type);
+                opaquedir = ovl_check_empty_and_clear(dentry);
                 err = PTR_ERR(opaquedir);
                 if (IS_ERR(opaquedir))
                         goto out;
@@ -515,9 +522,10 @@ static int ovl_remove_and_whiteout(struct dentry *dentry,
         if (IS_ERR(whiteout))
                 goto out_unlock;
 
-        if (type == OVL_PATH_LOWER) {
+        upper = ovl_dentry_upper(dentry);
+        if (!upper) {
                 upper = lookup_one_len(dentry->d_name.name, upperdir,
-                                           dentry->d_name.len);
+                                       dentry->d_name.len);
                 err = PTR_ERR(upper);
                 if (IS_ERR(upper))
                         goto kill_whiteout;
@@ -529,7 +537,6 @@ static int ovl_remove_and_whiteout(struct dentry *dentry,
         } else {
                 int flags = 0;
 
-                upper = ovl_dentry_upper(dentry);
                 if (opaquedir)
                         upper = opaquedir;
                 err = -ESTALE;
@@ -648,7 +655,7 @@ static int ovl_do_remove(struct dentry *dentry, bool is_dir)
                 cap_raise(override_cred->cap_effective, CAP_CHOWN);
                 old_cred = override_creds(override_cred);
 
-                err = ovl_remove_and_whiteout(dentry, type, is_dir);
+                err = ovl_remove_and_whiteout(dentry, is_dir);
 
                 revert_creds(old_cred);
                 put_cred(override_cred);
@@ -781,7 +788,7 @@ static int ovl_rename2(struct inode *olddir, struct dentry *old,
         }
 
         if (overwrite && (new_type == OVL_PATH_LOWER || new_type == OVL_PATH_MERGE) && new_is_dir) {
-                opaquedir = ovl_check_empty_and_clear(new, new_type);
+                opaquedir = ovl_check_empty_and_clear(new);
                 err = PTR_ERR(opaquedir);
                 if (IS_ERR(opaquedir)) {
                         opaquedir = NULL;
diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c
index af2d18c9fcee..07d74b24913b 100644
--- a/fs/overlayfs/inode.c
+++ b/fs/overlayfs/inode.c
@@ -235,26 +235,36 @@ out:
         return err;
 }
 
+static bool ovl_need_xattr_filter(struct dentry *dentry,
+                                  enum ovl_path_type type)
+{
+        return type == OVL_PATH_UPPER && S_ISDIR(dentry->d_inode->i_mode);
+}
+
 ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
                      void *value, size_t size)
 {
-        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
-            ovl_is_private_xattr(name))
+        struct path realpath;
+        enum ovl_path_type type = ovl_path_real(dentry, &realpath);
+
+        if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name))
                 return -ENODATA;
 
-        return vfs_getxattr(ovl_dentry_real(dentry), name, value, size);
+        return vfs_getxattr(realpath.dentry, name, value, size);
 }
 
 ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
 {
+        struct path realpath;
+        enum ovl_path_type type = ovl_path_real(dentry, &realpath);
         ssize_t res;
         int off;
 
-        res = vfs_listxattr(ovl_dentry_real(dentry), list, size);
+        res = vfs_listxattr(realpath.dentry, list, size);
         if (res <= 0 || size == 0)
                 return res;
 
-        if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE)
+        if (!ovl_need_xattr_filter(dentry, type))
                 return res;
 
         /* filter out private xattrs */
@@ -279,17 +289,16 @@ int ovl_removexattr(struct dentry *dentry, const char *name)
 {
         int err;
         struct path realpath;
-        enum ovl_path_type type;
+        enum ovl_path_type type = ovl_path_real(dentry, &realpath);
 
         err = ovl_want_write(dentry);
         if (err)
                 goto out;
 
-        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
-            ovl_is_private_xattr(name))
+        err = -ENODATA;
+        if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name))
                 goto out_drop_write;
 
-        type = ovl_path_real(dentry, &realpath);
         if (type == OVL_PATH_LOWER) {
                 err = vfs_getxattr(realpath.dentry, name, NULL, 0);
                 if (err < 0)
diff --git a/fs/overlayfs/readdir.c b/fs/overlayfs/readdir.c
index 910553f37aca..c0205990a9f5 100644
--- a/fs/overlayfs/readdir.c
+++ b/fs/overlayfs/readdir.c
@@ -21,9 +21,10 @@ struct ovl_cache_entry {
         unsigned int len;
         unsigned int type;
         u64 ino;
-        bool is_whiteout;
         struct list_head l_node;
         struct rb_node node;
+        bool is_whiteout;
+        bool is_cursor;
         char name[];
 };
 
@@ -92,6 +93,7 @@ static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len,
                 p->type = d_type;
                 p->ino = ino;
                 p->is_whiteout = false;
+                p->is_cursor = false;
         }
 
         return p;
@@ -166,7 +168,7 @@ static void ovl_cache_put(struct ovl_dir_file *od, struct dentry *dentry)
 {
         struct ovl_dir_cache *cache = od->cache;
 
-        list_del(&od->cursor.l_node);
+        list_del_init(&od->cursor.l_node);
         WARN_ON(cache->refcount <= 0);
         cache->refcount--;
         if (!cache->refcount) {
@@ -178,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)
@@ -251,7 +255,7 @@ static int ovl_dir_mark_whiteouts(struct dentry *dir,
 
         mutex_lock(&dir->d_inode->i_mutex);
         list_for_each_entry(p, rdd->list, l_node) {
-                if (!p->name)
+                if (p->is_cursor)
                         continue;
 
                 if (p->type != DT_CHR)
@@ -272,11 +276,11 @@ static int ovl_dir_mark_whiteouts(struct dentry *dir,
         return 0;
 }
 
-static inline int ovl_dir_read_merged(struct path *upperpath,
-                                      struct path *lowerpath,
-                                      struct list_head *list)
+static int ovl_dir_read_merged(struct dentry *dentry, struct list_head *list)
 {
         int err;
+        struct path lowerpath;
+        struct path upperpath;
         struct ovl_readdir_data rdd = {
                 .ctx.actor = ovl_fill_merge,
                 .list = list,
@@ -284,30 +288,32 @@ static inline int ovl_dir_read_merged(struct path *upperpath,
                 .is_merge = false,
         };
 
-        if (upperpath->dentry) {
-                err = ovl_dir_read(upperpath, &rdd);
+        ovl_path_lower(dentry, &lowerpath);
+        ovl_path_upper(dentry, &upperpath);
+
+        if (upperpath.dentry) {
+                err = ovl_dir_read(&upperpath, &rdd);
                 if (err)
                         goto out;
 
-                if (lowerpath->dentry) {
-                        err = ovl_dir_mark_whiteouts(upperpath->dentry, &rdd);
+                if (lowerpath.dentry) {
+                        err = ovl_dir_mark_whiteouts(upperpath.dentry, &rdd);
                         if (err)
                                 goto out;
                 }
         }
-        if (lowerpath->dentry) {
+        if (lowerpath.dentry) {
                 /*
                  * Insert lowerpath entries before upperpath ones, this allows
                  * offsets to be reasonably constant
                  */
                 list_add(&rdd.middle, rdd.list);
                 rdd.is_merge = true;
-                err = ovl_dir_read(lowerpath, &rdd);
+                err = ovl_dir_read(&lowerpath, &rdd);
                 list_del(&rdd.middle);
         }
 out:
         return err;
-
 }
 
 static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
@@ -316,7 +322,7 @@ static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
         loff_t off = 0;
 
         list_for_each_entry(p, &od->cache->entries, l_node) {
-                if (!p->name)
+                if (p->is_cursor)
                         continue;
                 if (off >= pos)
                         break;
@@ -328,8 +334,6 @@ static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
 static struct ovl_dir_cache *ovl_cache_get(struct dentry *dentry)
 {
         int res;
-        struct path lowerpath;
-        struct path upperpath;
         struct ovl_dir_cache *cache;
 
         cache = ovl_dir_cache(dentry);
@@ -346,10 +350,7 @@ static struct ovl_dir_cache *ovl_cache_get(struct dentry *dentry)
         cache->refcount = 1;
         INIT_LIST_HEAD(&cache->entries);
 
-        ovl_path_lower(dentry, &lowerpath);
-        ovl_path_upper(dentry, &upperpath);
-
-        res = ovl_dir_read_merged(&upperpath, &lowerpath, &cache->entries);
+        res = ovl_dir_read_merged(dentry, &cache->entries);
         if (res) {
                 ovl_cache_free(&cache->entries);
                 kfree(cache);
@@ -389,7 +390,7 @@ static int ovl_iterate(struct file *file, struct dir_context *ctx)
 
                 p = list_entry(od->cursor.l_node.next, struct ovl_cache_entry, l_node);
                 /* Skip cursors */
-                if (p->name) {
+                if (!p->is_cursor) {
                         if (!p->is_whiteout) {
                                 if (!dir_emit(ctx, p->name, p->len, p->ino, p->type))
                                         break;
@@ -451,15 +452,16 @@ static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
         /*
          * Need to check if we started out being a lower dir, but got copied up
          */
-        if (!od->is_upper && ovl_path_type(dentry) == OVL_PATH_MERGE) {
+        if (!od->is_upper && ovl_path_type(dentry) != OVL_PATH_LOWER) {
                 struct inode *inode = file_inode(file);
 
-                realfile = od->upperfile;
+                realfile = lockless_dereference(od->upperfile);
                 if (!realfile) {
                         struct path upperpath;
 
                         ovl_path_upper(dentry, &upperpath);
                         realfile = ovl_path_open(&upperpath, O_RDONLY);
+                        smp_mb__before_spinlock();
                         mutex_lock(&inode->i_mutex);
                         if (!od->upperfile) {
                                 if (IS_ERR(realfile)) {
@@ -518,6 +520,7 @@ static int ovl_dir_open(struct inode *inode, struct file *file)
         od->realfile = realfile;
         od->is_real = (type != OVL_PATH_MERGE);
         od->is_upper = (type != OVL_PATH_LOWER);
+        od->cursor.is_cursor = true;
         file->private_data = od;
 
         return 0;
@@ -535,14 +538,9 @@ const struct file_operations ovl_dir_operations = {
 int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
 {
         int err;
-        struct path lowerpath;
-        struct path upperpath;
         struct ovl_cache_entry *p;
 
-        ovl_path_upper(dentry, &upperpath);
-        ovl_path_lower(dentry, &lowerpath);
-
-        err = ovl_dir_read_merged(&upperpath, &lowerpath, list);
+        err = ovl_dir_read_merged(dentry, list);
         if (err)
                 return err;
 
@@ -569,7 +567,7 @@ void ovl_cleanup_whiteouts(struct dentry *upper, struct list_head *list)
 {
         struct ovl_cache_entry *p;
 
-        mutex_lock_nested(&upper->d_inode->i_mutex, I_MUTEX_PARENT);
+        mutex_lock_nested(&upper->d_inode->i_mutex, I_MUTEX_CHILD);
         list_for_each_entry(p, list, l_node) {
                 struct dentry *dentry;
 
diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index 08b704cebfc4..f16d318b71f8 100644
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -24,7 +24,7 @@ MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
 MODULE_DESCRIPTION("Overlay filesystem");
 MODULE_LICENSE("GPL");
 
-#define OVERLAYFS_SUPER_MAGIC 0x794c764f
+#define OVERLAYFS_SUPER_MAGIC 0x794c7630
 
 struct ovl_config {
         char *lowerdir;
@@ -84,12 +84,7 @@ enum ovl_path_type ovl_path_type(struct dentry *dentry)
 
 static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
 {
-        struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry);
-        /*
-         * Make sure to order reads to upperdentry wrt ovl_dentry_update()
-         */
-        smp_read_barrier_depends();
-        return upperdentry;
+        return lockless_dereference(oe->__upperdentry);
 }
 
 void ovl_path_upper(struct dentry *dentry, struct path *path)
@@ -462,11 +457,34 @@ static const match_table_t ovl_tokens = {
         {OPT_ERR,                       NULL}
 };
 
+static char *ovl_next_opt(char **s)
+{
+        char *sbegin = *s;
+        char *p;
+
+        if (sbegin == NULL)
+                return NULL;
+
+        for (p = sbegin; *p; p++) {
+                if (*p == '\\') {
+                        p++;
+                        if (!*p)
+                                break;
+                } else if (*p == ',') {
+                        *p = '\0';
+                        *s = p + 1;
+                        return sbegin;
+                }
+        }
+        *s = NULL;
+        return sbegin;
+}
+
 static int ovl_parse_opt(char *opt, struct ovl_config *config)
 {
         char *p;
 
-        while ((p = strsep(&opt, ",")) != NULL) {
+        while ((p = ovl_next_opt(&opt)) != NULL) {
                 int token;
                 substring_t args[MAX_OPT_ARGS];
 
@@ -554,15 +572,34 @@ out_dput:
         goto out_unlock;
 }
 
+static void ovl_unescape(char *s)
+{
+        char *d = s;
+
+        for (;; s++, d++) {
+                if (*s == '\\')
+                        s++;
+                *d = *s;
+                if (!*s)
+                        break;
+        }
+}
+
 static int ovl_mount_dir(const char *name, struct path *path)
 {
         int err;
+        char *tmp = kstrdup(name, GFP_KERNEL);
+
+        if (!tmp)
+                return -ENOMEM;
 
-        err = kern_path(name, LOOKUP_FOLLOW, path);
+        ovl_unescape(tmp);
+        err = kern_path(tmp, LOOKUP_FOLLOW, path);
         if (err) {
-                pr_err("overlayfs: failed to resolve '%s': %i\n", name, err);
+                pr_err("overlayfs: failed to resolve '%s': %i\n", tmp, err);
                 err = -EINVAL;
         }
+        kfree(tmp);
         return err;
 }
 
@@ -776,11 +813,11 @@ static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
 
 static struct file_system_type ovl_fs_type = {
         .owner          = THIS_MODULE,
-        .name           = "overlayfs",
+        .name           = "overlay",
         .mount          = ovl_mount,
         .kill_sb        = kill_anon_super,
 };
-MODULE_ALIAS_FS("overlayfs");
+MODULE_ALIAS_FS("overlay");
 
 static int __init ovl_init(void)
 {
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/quota/dquot.c b/fs/quota/dquot.c
index 8b663b2d9562..6b4527216a7f 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -634,7 +634,7 @@ int dquot_writeback_dquots(struct super_block *sb, int type)
                         dqstats_inc(DQST_LOOKUPS);
                         err = sb->dq_op->write_dquot(dquot);
                         if (!ret && err)
-                                err = ret;
+                                ret = err;
                         dqput(dquot);
                         spin_lock(&dq_list_lock);
                 }
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/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 92e8f99a5857..281002689d64 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1338,7 +1338,10 @@ xfs_free_file_space(
         goto out;
 }
 
-
+/*
+ * Preallocate and zero a range of a file. This mechanism has the allocation
+ * semantics of fallocate and in addition converts data in the range to zeroes.
+ */
 int
 xfs_zero_file_space(
         struct xfs_inode        *ip,
@@ -1346,65 +1349,30 @@ xfs_zero_file_space(
         xfs_off_t               len)
 {
         struct xfs_mount        *mp = ip->i_mount;
-        uint                    granularity;
-        xfs_off_t               start_boundary;
-        xfs_off_t               end_boundary;
+        uint                    blksize;
         int                     error;
 
         trace_xfs_zero_file_space(ip);
 
-        granularity = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
+        blksize = 1 << mp->m_sb.sb_blocklog;
 
         /*
-         * Round the range of extents we are going to convert inwards.  If the
-         * offset is aligned, then it doesn't get changed so we zero from the
-         * start of the block offset points to.
+         * Punch a hole and prealloc the range. We use hole punch rather than
+         * unwritten extent conversion for two reasons:
+         *
+         * 1.) Hole punch handles partial block zeroing for us.
+         *
+         * 2.) If prealloc returns ENOSPC, the file range is still zero-valued
+         * by virtue of the hole punch.
          */
-        start_boundary = round_up(offset, granularity);
-        end_boundary = round_down(offset + len, granularity);
-
-        ASSERT(start_boundary >= offset);
-        ASSERT(end_boundary <= offset + len);
-
-        if (start_boundary < end_boundary - 1) {
-                /*
-                 * Writeback the range to ensure any inode size updates due to
-                 * appending writes make it to disk (otherwise we could just
-                 * punch out the delalloc blocks).
-                 */
-                error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
-                                start_boundary, end_boundary - 1);
-                if (error)
-                        goto out;
-                truncate_pagecache_range(VFS_I(ip), start_boundary,
-                                         end_boundary - 1);
-
-                /* convert the blocks */
-                error = xfs_alloc_file_space(ip, start_boundary,
-                                        end_boundary - start_boundary - 1,
-                                        XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT);
-                if (error)
-                        goto out;
-
-                /* We've handled the interior of the range, now for the edges */
-                if (start_boundary != offset) {
-                        error = xfs_iozero(ip, offset, start_boundary - offset);
-                        if (error)
-                                goto out;
-                }
-
-                if (end_boundary != offset + len)
-                        error = xfs_iozero(ip, end_boundary,
-                                           offset + len - end_boundary);
-
-        } else {
-                /*
-                 * It's either a sub-granularity range or the range spanned lies
-                 * partially across two adjacent blocks.
-                 */
-                error = xfs_iozero(ip, offset, len);
-        }
+        error = xfs_free_file_space(ip, offset, len);
+        if (error)
+                goto out;
 
+        error = xfs_alloc_file_space(ip, round_down(offset, blksize),
+                                     round_up(offset + len, blksize) -
+                                     round_down(offset, blksize),
+                                     XFS_BMAPI_PREALLOC);
 out:
         return error;
 
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index f1deb961a296..894924a5129b 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -236,8 +236,10 @@ xfs_bulkstat_grab_ichunk(
         XFS_WANT_CORRUPTED_RETURN(stat == 1);
 
         /* Check if the record contains the inode in request */
-        if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino)
-                return -EINVAL;
+        if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino) {
+                *icount = 0;
+                return 0;
+        }
 
         idx = agino - irec->ir_startino + 1;
         if (idx < XFS_INODES_PER_CHUNK &&
@@ -262,75 +264,76 @@ xfs_bulkstat_grab_ichunk(
 
 #define XFS_BULKSTAT_UBLEFT(ubleft)     ((ubleft) >= statstruct_size)
 
+struct xfs_bulkstat_agichunk {
+        char            __user **ac_ubuffer;/* pointer into user's buffer */
+        int             ac_ubleft;      /* bytes left in user's buffer */
+        int             ac_ubelem;      /* spaces used in user's buffer */
+};
+
 /*
  * Process inodes in chunk with a pointer to a formatter function
  * that will iget the inode and fill in the appropriate structure.
  */
-int
+static int
 xfs_bulkstat_ag_ichunk(
         struct xfs_mount                *mp,
         xfs_agnumber_t                  agno,
         struct xfs_inobt_rec_incore     *irbp,
         bulkstat_one_pf                 formatter,
         size_t                          statstruct_size,
-        struct xfs_bulkstat_agichunk    *acp)
+        struct xfs_bulkstat_agichunk    *acp,
+        xfs_agino_t                     *last_agino)
 {
-        xfs_ino_t                       lastino = acp->ac_lastino;
         char                            __user **ubufp = acp->ac_ubuffer;
-        int                             ubleft = acp->ac_ubleft;
-        int                             ubelem = acp->ac_ubelem;
-        int                             chunkidx, clustidx;
+        int                             chunkidx;
         int                             error = 0;
-        xfs_agino_t                     agino;
+        xfs_agino_t                     agino = irbp->ir_startino;
 
-        for (agino = irbp->ir_startino, chunkidx = clustidx = 0;
-             XFS_BULKSTAT_UBLEFT(ubleft) &&
-             irbp->ir_freecount < XFS_INODES_PER_CHUNK;
-             chunkidx++, clustidx++, agino++) {
-                int             fmterror;       /* bulkstat formatter result */
+        for (chunkidx = 0; chunkidx < XFS_INODES_PER_CHUNK;
+             chunkidx++, agino++) {
+                int             fmterror;
                 int             ubused;
-                xfs_ino_t       ino = XFS_AGINO_TO_INO(mp, agno, agino);
 
-                ASSERT(chunkidx < XFS_INODES_PER_CHUNK);
+                /* inode won't fit in buffer, we are done */
+                if (acp->ac_ubleft < statstruct_size)
+                        break;
 
                 /* Skip if this inode is free */
-                if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free) {
-                        lastino = ino;
+                if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free)
                         continue;
-                }
-
-                /*
-                 * Count used inodes as free so we can tell when the
-                 * chunk is used up.
-                 */
-                irbp->ir_freecount++;
 
                 /* Get the inode and fill in a single buffer */
                 ubused = statstruct_size;
-                error = formatter(mp, ino, *ubufp, ubleft, &ubused, &fmterror);
-                if (fmterror == BULKSTAT_RV_NOTHING) {
-                        if (error && error != -ENOENT && error != -EINVAL) {
-                                ubleft = 0;
-                                break;
-                        }
-                        lastino = ino;
-                        continue;
-                }
-                if (fmterror == BULKSTAT_RV_GIVEUP) {
-                        ubleft = 0;
+                error = formatter(mp, XFS_AGINO_TO_INO(mp, agno, agino),
+                                  *ubufp, acp->ac_ubleft, &ubused, &fmterror);
+
+                if (fmterror == BULKSTAT_RV_GIVEUP ||
+                    (error && error != -ENOENT && error != -EINVAL)) {
+                        acp->ac_ubleft = 0;
                         ASSERT(error);
                         break;
                 }
-                if (*ubufp)
-                        *ubufp += ubused;
-                ubleft -= ubused;
-                ubelem++;
-                lastino = ino;
+
+                /* be careful not to leak error if at end of chunk */
+                if (fmterror == BULKSTAT_RV_NOTHING || error) {
+                        error = 0;
+                        continue;
+                }
+
+                *ubufp += ubused;
+                acp->ac_ubleft -= ubused;
+                acp->ac_ubelem++;
         }
 
-        acp->ac_lastino = lastino;
-        acp->ac_ubleft = ubleft;
-        acp->ac_ubelem = ubelem;
+        /*
+         * Post-update *last_agino. At this point, agino will always point one
+         * inode past the last inode we processed successfully. Hence we
+         * substract that inode when setting the *last_agino cursor so that we
+         * return the correct cookie to userspace. On the next bulkstat call,
+         * the inode under the lastino cookie will be skipped as we have already
+         * processed it here.
+         */
+        *last_agino = agino - 1;
 
         return error;
 }
@@ -353,45 +356,33 @@ xfs_bulkstat(
         xfs_agino_t             agino;  /* inode # in allocation group */
         xfs_agnumber_t          agno;   /* allocation group number */
         xfs_btree_cur_t         *cur;   /* btree cursor for ialloc btree */
-        int                     end_of_ag; /* set if we've seen the ag end */
-        int                     error;  /* error code */
-        int                     fmterror;/* bulkstat formatter result */
-        int                     i;      /* loop index */
-        int                     icount; /* count of inodes good in irbuf */
         size_t                  irbsize; /* size of irec buffer in bytes */
-        xfs_ino_t               ino;    /* inode number (filesystem) */
-        xfs_inobt_rec_incore_t  *irbp;  /* current irec buffer pointer */
         xfs_inobt_rec_incore_t  *irbuf; /* start of irec buffer */
-        xfs_inobt_rec_incore_t  *irbufend; /* end of good irec buffer entries */
-        xfs_ino_t               lastino; /* last inode number returned */
         int                     nirbuf; /* size of irbuf */
-        int                     rval;   /* return value error code */
-        int                     tmp;    /* result value from btree calls */
         int                     ubcount; /* size of user's buffer */
-        int                     ubleft; /* bytes left in user's buffer */
-        char                    __user *ubufp;  /* pointer into user's buffer */
-        int                     ubelem; /* spaces used in user's buffer */
+        struct xfs_bulkstat_agichunk ac;
+        int                     error = 0;
 
         /*
          * Get the last inode value, see if there's nothing to do.
          */
-        ino = (xfs_ino_t)*lastinop;
-        lastino = ino;
-        agno = XFS_INO_TO_AGNO(mp, ino);
-        agino = XFS_INO_TO_AGINO(mp, ino);
+        agno = XFS_INO_TO_AGNO(mp, *lastinop);
+        agino = XFS_INO_TO_AGINO(mp, *lastinop);
         if (agno >= mp->m_sb.sb_agcount ||
-            ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
+            *lastinop != XFS_AGINO_TO_INO(mp, agno, agino)) {
                 *done = 1;
                 *ubcountp = 0;
                 return 0;
         }
 
         ubcount = *ubcountp; /* statstruct's */
-        ubleft = ubcount * statstruct_size; /* bytes */
-        *ubcountp = ubelem = 0;
+        ac.ac_ubuffer = &ubuffer;
+        ac.ac_ubleft = ubcount * statstruct_size; /* bytes */;
+        ac.ac_ubelem = 0;
+
+        *ubcountp = 0;
         *done = 0;
-        fmterror = 0;
-        ubufp = ubuffer;
+
         irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4);
         if (!irbuf)
                 return -ENOMEM;
@@ -402,9 +393,13 @@ xfs_bulkstat(
          * Loop over the allocation groups, starting from the last
          * inode returned; 0 means start of the allocation group.
          */
-        rval = 0;
-        while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) {
-                cond_resched();
+        while (agno < mp->m_sb.sb_agcount) {
+                struct xfs_inobt_rec_incore     *irbp = irbuf;
+                struct xfs_inobt_rec_incore     *irbufend = irbuf + nirbuf;
+                bool                            end_of_ag = false;
+                int                             icount = 0;
+                int                             stat;
+
                 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
                 if (error)
                         break;
@@ -414,10 +409,6 @@ xfs_bulkstat(
                  */
                 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno,
                                             XFS_BTNUM_INO);
-                irbp = irbuf;
-                irbufend = irbuf + nirbuf;
-                end_of_ag = 0;
-                icount = 0;
                 if (agino > 0) {
                         /*
                          * In the middle of an allocation group, we need to get
@@ -427,22 +418,23 @@ xfs_bulkstat(
 
                         error = xfs_bulkstat_grab_ichunk(cur, agino, &icount, &r);
                         if (error)
-                                break;
+                                goto del_cursor;
                         if (icount) {
                                 irbp->ir_startino = r.ir_startino;
                                 irbp->ir_freecount = r.ir_freecount;
                                 irbp->ir_free = r.ir_free;
                                 irbp++;
-                                agino = r.ir_startino + XFS_INODES_PER_CHUNK;
                         }
                         /* Increment to the next record */
-                        error = xfs_btree_increment(cur, 0, &tmp);
+                        error = xfs_btree_increment(cur, 0, &stat);
                 } else {
                         /* Start of ag.  Lookup the first inode chunk */
-                        error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &tmp);
+                        error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &stat);
+                }
+                if (error || stat == 0) {
+                        end_of_ag = true;
+                        goto del_cursor;
                 }
-                if (error)
-                        break;
 
                 /*
                  * Loop through inode btree records in this ag,
@@ -451,10 +443,10 @@ xfs_bulkstat(
                 while (irbp < irbufend && icount < ubcount) {
                         struct xfs_inobt_rec_incore     r;
 
-                        error = xfs_inobt_get_rec(cur, &r, &i);
-                        if (error || i == 0) {
-                                end_of_ag = 1;
-                                break;
+                        error = xfs_inobt_get_rec(cur, &r, &stat);
+                        if (error || stat == 0) {
+                                end_of_ag = true;
+                                goto del_cursor;
                         }
 
                         /*
@@ -469,77 +461,79 @@ xfs_bulkstat(
                                 irbp++;
                                 icount += XFS_INODES_PER_CHUNK - r.ir_freecount;
                         }
-                        /*
-                         * Set agino to after this chunk and bump the cursor.
-                         */
-                        agino = r.ir_startino + XFS_INODES_PER_CHUNK;
-                        error = xfs_btree_increment(cur, 0, &tmp);
+                        error = xfs_btree_increment(cur, 0, &stat);
+                        if (error || stat == 0) {
+                                end_of_ag = true;
+                                goto del_cursor;
+                        }
                         cond_resched();
                 }
+
                 /*
-                 * Drop the btree buffers and the agi buffer.
-                 * We can't hold any of the locks these represent
-                 * when calling iget.
+                 * Drop the btree buffers and the agi buffer as we can't hold any
+                 * of the locks these represent when calling iget. If there is a
+                 * pending error, then we are done.
                  */
+del_cursor:
                 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
                 xfs_buf_relse(agbp);
+                if (error)
+                        break;
                 /*
-                 * Now format all the good inodes into the user's buffer.
+                 * Now format all the good inodes into the user's buffer. The
+                 * call to xfs_bulkstat_ag_ichunk() sets up the agino pointer
+                 * for the next loop iteration.
                  */
                 irbufend = irbp;
                 for (irbp = irbuf;
-                     irbp < irbufend && XFS_BULKSTAT_UBLEFT(ubleft); irbp++) {
-                        struct xfs_bulkstat_agichunk ac;
-
-                        ac.ac_lastino = lastino;
-                        ac.ac_ubuffer = &ubuffer;
-                        ac.ac_ubleft = ubleft;
-                        ac.ac_ubelem = ubelem;
+                     irbp < irbufend && ac.ac_ubleft >= statstruct_size;
+                     irbp++) {
                         error = xfs_bulkstat_ag_ichunk(mp, agno, irbp,
-                                        formatter, statstruct_size, &ac);
+                                        formatter, statstruct_size, &ac,
+                                        &agino);
                         if (error)
-                                rval = error;
-
-                        lastino = ac.ac_lastino;
-                        ubleft = ac.ac_ubleft;
-                        ubelem = ac.ac_ubelem;
+                                break;
 
                         cond_resched();
                 }
+
                 /*
-                 * Set up for the next loop iteration.
+                 * If we've run out of space or had a formatting error, we
+                 * are now done
                  */
-                if (XFS_BULKSTAT_UBLEFT(ubleft)) {
-                        if (end_of_ag) {
-                                agno++;
-                                agino = 0;
-                        } else
-                                agino = XFS_INO_TO_AGINO(mp, lastino);
-                } else
+                if (ac.ac_ubleft < statstruct_size || error)
                         break;
+
+                if (end_of_ag) {
+                        agno++;
+                        agino = 0;
+                }
         }
         /*
          * Done, we're either out of filesystem or space to put the data.
          */
         kmem_free(irbuf);
-        *ubcountp = ubelem;
+        *ubcountp = ac.ac_ubelem;
+
         /*
-         * Found some inodes, return them now and return the error next time.
+         * We found some inodes, so clear the error status and return them.
+         * The lastino pointer will point directly at the inode that triggered
+         * any error that occurred, so on the next call the error will be
+         * triggered again and propagated to userspace as there will be no
+         * formatted inodes in the buffer.
          */
-        if (ubelem)
-                rval = 0;
-        if (agno >= mp->m_sb.sb_agcount) {
-                /*
-                 * If we ran out of filesystem, mark lastino as off
-                 * the end of the filesystem, so the next call
-                 * will return immediately.
-                 */
-                *lastinop = (xfs_ino_t)XFS_AGINO_TO_INO(mp, agno, 0);
+        if (ac.ac_ubelem)
+                error = 0;
+
+        /*
+         * If we ran out of filesystem, lastino will point off the end of
+         * the filesystem so the next call will return immediately.
+         */
+        *lastinop = XFS_AGINO_TO_INO(mp, agno, agino);
+        if (agno >= mp->m_sb.sb_agcount)
                 *done = 1;
-        } else
-                *lastinop = (xfs_ino_t)lastino;
 
-        return rval;
+        return error;
 }
 
 int
diff --git a/fs/xfs/xfs_itable.h b/fs/xfs/xfs_itable.h
index aaed08022eb9..6ea8b3912fa4 100644
--- a/fs/xfs/xfs_itable.h
+++ b/fs/xfs/xfs_itable.h
@@ -30,22 +30,6 @@ typedef int (*bulkstat_one_pf)(struct xfs_mount	*mp,
                                int              *ubused,
                                int              *stat);
 
-struct xfs_bulkstat_agichunk {
-        xfs_ino_t       ac_lastino;     /* last inode returned */
-        char            __user **ac_ubuffer;/* pointer into user's buffer */
-        int             ac_ubleft;      /* bytes left in user's buffer */
-        int             ac_ubelem;      /* spaces used in user's buffer */
-};
-
-int
-xfs_bulkstat_ag_ichunk(
-        struct xfs_mount                *mp,
-        xfs_agnumber_t                  agno,
-        struct xfs_inobt_rec_incore     *irbp,
-        bulkstat_one_pf                 formatter,
-        size_t                          statstruct_size,
-        struct xfs_bulkstat_agichunk    *acp);
-
 /*
  * Values for stat return value.
  */