263 files changed, 3925 insertions, 3064 deletions
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index e78956cbd702..34c59f14a1c9 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -144,7 +144,7 @@ extern void v9fs_session_close(struct v9fs_session_info *v9ses);
 extern void v9fs_session_cancel(struct v9fs_session_info *v9ses);
 extern void v9fs_session_begin_cancel(struct v9fs_session_info *v9ses);
 extern struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
-                        struct nameidata *nameidata);
+                        unsigned int flags);
 extern int v9fs_vfs_unlink(struct inode *i, struct dentry *d);
 extern int v9fs_vfs_rmdir(struct inode *i, struct dentry *d);
 extern int v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index d529437ff442..64600b5d0522 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -100,13 +100,13 @@ static void v9fs_dentry_release(struct dentry *dentry)
        }
 }
-static int v9fs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int v9fs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct p9_fid *fid;
        struct inode *inode;
        struct v9fs_inode *v9inode;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = dentry->d_inode;
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 57ccb7537dae..cbf9dbb1b2a2 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -712,88 +712,34 @@ error:
 }
 /**
- * v9fs_vfs_create - VFS hook to create files
+ * v9fs_vfs_create - VFS hook to create a regular file
+ *
+ * open(.., O_CREAT) is handled in v9fs_vfs_atomic_open().  This is only called
+ * for mknod(2).
+ *
 * @dir: directory inode that is being created
 * @dentry:  dentry that is being deleted
 * @mode: create permissions
- * @nd: path information
 *
 */
 static int
 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
-        int err;
+        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
-        u32 perm;
+        u32 perm = unixmode2p9mode(v9ses, mode);
-        int flags;
+        struct p9_fid *fid;
-        struct file *filp;
-        struct v9fs_inode *v9inode;
-        struct v9fs_session_info *v9ses;
-        struct p9_fid *fid, *inode_fid;
-        err = 0;
-        fid = NULL;
-        v9ses = v9fs_inode2v9ses(dir);
-        perm = unixmode2p9mode(v9ses, mode);
-        if (nd)
-                flags = nd->intent.open.flags;
-        else
-                flags = O_RDWR;
-        fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
+        /* P9_OEXCL? */
-                                v9fs_uflags2omode(flags,
+        fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_ORDWR);
-                                                v9fs_proto_dotu(v9ses)));
+        if (IS_ERR(fid))
-        if (IS_ERR(fid)) {
+                return PTR_ERR(fid);
-                err = PTR_ERR(fid);
-                fid = NULL;
-                goto error;
-        }
        v9fs_invalidate_inode_attr(dir);
-        /* if we are opening a file, assign the open fid to the file */
+        p9_client_clunk(fid);
-        if (nd) {
-                v9inode = V9FS_I(dentry->d_inode);
-                mutex_lock(&v9inode->v_mutex);
-                if (v9ses->cache && !v9inode->writeback_fid &&
-                    ((flags & O_ACCMODE) != O_RDONLY)) {
-                        /*
-                         * clone a fid and add it to writeback_fid
-                         * we do it during open time instead of
-                         * page dirty time via write_begin/page_mkwrite
-                         * because we want write after unlink usecase
-                         * to work.
-                         */
-                        inode_fid = v9fs_writeback_fid(dentry);
-                        if (IS_ERR(inode_fid)) {
-                                err = PTR_ERR(inode_fid);
-                                mutex_unlock(&v9inode->v_mutex);
-                                goto error;
-                        }
-                        v9inode->writeback_fid = (void *) inode_fid;
-                }
-                mutex_unlock(&v9inode->v_mutex);
-                filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
-                if (IS_ERR(filp)) {
-                        err = PTR_ERR(filp);
-                        goto error;
-                }
-                filp->private_data = fid;
-#ifdef CONFIG_9P_FSCACHE
-                if (v9ses->cache)
-                        v9fs_cache_inode_set_cookie(dentry->d_inode, filp);
-#endif
-        } else
-                p9_client_clunk(fid);
        return 0;
-error:
-        if (fid)
-                p9_client_clunk(fid);
-        return err;
 }
 /**
@@ -839,7 +785,7 @@ static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
 */
 struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
-                                      struct nameidata *nameidata)
+                                      unsigned int flags)
 {
        struct dentry *res;
        struct super_block *sb;
@@ -849,8 +795,8 @@ struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
        char *name;
        int result = 0;
-        p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
+        p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p flags: %x\n",
-                 dir, dentry->d_name.name, dentry, nameidata);
+                 dir, dentry->d_name.name, dentry, flags);
        if (dentry->d_name.len > NAME_MAX)
                return ERR_PTR(-ENAMETOOLONG);
@@ -910,6 +856,86 @@ error:
        return ERR_PTR(result);
 }
+static int
+v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
+                     struct file *file, unsigned flags, umode_t mode,
+                     int *opened)
+{
+        int err;
+        u32 perm;
+        struct v9fs_inode *v9inode;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid, *inode_fid;
+        struct dentry *res = NULL;
+        if (d_unhashed(dentry)) {
+                res = v9fs_vfs_lookup(dir, dentry, 0);
+                if (IS_ERR(res))
+                        return PTR_ERR(res);
+                if (res)
+                        dentry = res;
+        }
+        /* Only creates */
+        if (!(flags & O_CREAT) || dentry->d_inode)
+                return finish_no_open(file, res);
+        err = 0;
+        fid = NULL;
+        v9ses = v9fs_inode2v9ses(dir);
+        perm = unixmode2p9mode(v9ses, mode);
+        fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
+                                v9fs_uflags2omode(flags,
+                                                v9fs_proto_dotu(v9ses)));
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                fid = NULL;
+                goto error;
+        }
+        v9fs_invalidate_inode_attr(dir);
+        v9inode = V9FS_I(dentry->d_inode);
+        mutex_lock(&v9inode->v_mutex);
+        if (v9ses->cache && !v9inode->writeback_fid &&
+            ((flags & O_ACCMODE) != O_RDONLY)) {
+                /*
+                 * clone a fid and add it to writeback_fid
+                 * we do it during open time instead of
+                 * page dirty time via write_begin/page_mkwrite
+                 * because we want write after unlink usecase
+                 * to work.
+                 */
+                inode_fid = v9fs_writeback_fid(dentry);
+                if (IS_ERR(inode_fid)) {
+                        err = PTR_ERR(inode_fid);
+                        mutex_unlock(&v9inode->v_mutex);
+                        goto error;
+                }
+                v9inode->writeback_fid = (void *) inode_fid;
+        }
+        mutex_unlock(&v9inode->v_mutex);
+        err = finish_open(file, dentry, generic_file_open, opened);
+        if (err)
+                goto error;
+        file->private_data = fid;
+#ifdef CONFIG_9P_FSCACHE
+        if (v9ses->cache)
+                v9fs_cache_inode_set_cookie(dentry->d_inode, file);
+#endif
+        *opened |= FILE_CREATED;
+out:
+        dput(res);
+        return err;
+error:
+        if (fid)
+                p9_client_clunk(fid);
+        goto out;
+}
 /**
 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
 * @i:  inode that is being unlinked
@@ -1488,6 +1514,7 @@ out:
 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
        .create = v9fs_vfs_create,
        .lookup = v9fs_vfs_lookup,
+        .atomic_open = v9fs_vfs_atomic_open,
        .symlink = v9fs_vfs_symlink,
        .link = v9fs_vfs_link,
        .unlink = v9fs_vfs_unlink,
@@ -1502,6 +1529,7 @@ static const struct inode_operations v9fs_dir_inode_operations_dotu = {
 static const struct inode_operations v9fs_dir_inode_operations = {
        .create = v9fs_vfs_create,
        .lookup = v9fs_vfs_lookup,
+        .atomic_open = v9fs_vfs_atomic_open,
        .unlink = v9fs_vfs_unlink,
        .mkdir = v9fs_vfs_mkdir,
        .rmdir = v9fs_vfs_rmdir,
diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
index e3dd2a1e2bfc..40895546e103 100644
--- a/fs/9p/vfs_inode_dotl.c
+++ b/fs/9p/vfs_inode_dotl.c
@@ -230,20 +230,25 @@ int v9fs_open_to_dotl_flags(int flags)
 * @dir: directory inode that is being created
 * @dentry:  dentry that is being deleted
 * @mode: create permissions
- * @nd: path information
 *
 */
 static int
 v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
-                struct nameidata *nd)
+                bool excl)
+{
+        return v9fs_vfs_mknod_dotl(dir, dentry, omode, 0);
+}
+static int
+v9fs_vfs_atomic_open_dotl(struct inode *dir, struct dentry *dentry,
+                          struct file *file, unsigned flags, umode_t omode,
+                          int *opened)
 {
        int err = 0;
        gid_t gid;
-        int flags;
        umode_t mode;
        char *name = NULL;
-        struct file *filp;
        struct p9_qid qid;
        struct inode *inode;
        struct p9_fid *fid = NULL;
@@ -251,19 +256,23 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
        struct p9_fid *dfid, *ofid, *inode_fid;
        struct v9fs_session_info *v9ses;
        struct posix_acl *pacl = NULL, *dacl = NULL;
+        struct dentry *res = NULL;
-        v9ses = v9fs_inode2v9ses(dir);
+        if (d_unhashed(dentry)) {
-        if (nd)
+                res = v9fs_vfs_lookup(dir, dentry, 0);
-                flags = nd->intent.open.flags;
+                if (IS_ERR(res))
-        else {
+                        return PTR_ERR(res);
-                /*
-                 * create call without LOOKUP_OPEN is due
+                if (res)
-                 * to mknod of regular files. So use mknod
+                        dentry = res;
-                 * operation.
-                 */
-                return v9fs_vfs_mknod_dotl(dir, dentry, omode, 0);
        }
+        /* Only creates */
+        if (!(flags & O_CREAT) || dentry->d_inode)
+                return finish_no_open(file, res);
+        v9ses = v9fs_inode2v9ses(dir);
        name = (char *) dentry->d_name.name;
        p9_debug(P9_DEBUG_VFS, "name:%s flags:0x%x mode:0x%hx\n",
                 name, flags, omode);
@@ -272,7 +281,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
        if (IS_ERR(dfid)) {
                err = PTR_ERR(dfid);
                p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
-                return err;
+                goto out;
        }
        /* clone a fid to use for creation */
@@ -280,7 +289,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
        if (IS_ERR(ofid)) {
                err = PTR_ERR(ofid);
                p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
-                return err;
+                goto out;
        }
        gid = v9fs_get_fsgid_for_create(dir);
@@ -345,17 +354,18 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, umode_t omode,
        }
        mutex_unlock(&v9inode->v_mutex);
        /* Since we are opening a file, assign the open fid to the file */
-        filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
+        err = finish_open(file, dentry, generic_file_open, opened);
-        if (IS_ERR(filp)) {
+        if (err)
-                err = PTR_ERR(filp);
                goto err_clunk_old_fid;
-        }
+        file->private_data = ofid;
-        filp->private_data = ofid;
 #ifdef CONFIG_9P_FSCACHE
        if (v9ses->cache)
-                v9fs_cache_inode_set_cookie(inode, filp);
+                v9fs_cache_inode_set_cookie(inode, file);
 #endif
-        return 0;
+        *opened |= FILE_CREATED;
+out:
+        dput(res);
+        return err;
 error:
        if (fid)
@@ -364,7 +374,7 @@ err_clunk_old_fid:
        if (ofid)
                p9_client_clunk(ofid);
        v9fs_set_create_acl(NULL, &dacl, &pacl);
-        return err;
+        goto out;
 }
 /**
@@ -982,6 +992,7 @@ out:
 const struct inode_operations v9fs_dir_inode_operations_dotl = {
        .create = v9fs_vfs_create_dotl,
+        .atomic_open = v9fs_vfs_atomic_open_dotl,
        .lookup = v9fs_vfs_lookup,
        .link = v9fs_vfs_link_dotl,
        .symlink = v9fs_vfs_symlink_dotl,
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 8c92a9ba8330..137d50396898 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -89,7 +89,7 @@ v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,
        if (v9ses->cache)
                sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_CACHE_SIZE;
-        sb->s_flags = flags | MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;
+        sb->s_flags |= MS_ACTIVE | MS_DIRSYNC | MS_NOATIME;
        if (!v9ses->cache)
                sb->s_flags |= MS_SYNCHRONOUS;
@@ -137,7 +137,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
                goto close_session;
        }
-        sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
+        sb = sget(fs_type, NULL, v9fs_set_super, flags, v9ses);
        if (IS_ERR(sb)) {
                retval = PTR_ERR(sb);
                goto clunk_fid;
diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index 3d83075aaa2e..b3be2e7c5643 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -266,7 +266,7 @@ const struct dentry_operations adfs_dentry_operations = {
 };
 static struct dentry *
-adfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+adfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode = NULL;
        struct object_info obj;
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 06fdcc9382c4..bdaec92353c2 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -246,7 +246,6 @@ static struct inode *adfs_alloc_inode(struct super_block *sb)
 static void adfs_i_callback(struct rcu_head *head)
 {
        struct inode *inode = container_of(head, struct inode, i_rcu);
-        INIT_LIST_HEAD(&inode->i_dentry);
        kmem_cache_free(adfs_inode_cachep, ADFS_I(inode));
 }
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index 1fceb320d2f2..6e216419f340 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -3,6 +3,7 @@
 #include <linux/buffer_head.h>
 #include <linux/amigaffs.h>
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
 /* AmigaOS allows file names with up to 30 characters length.
 * Names longer than that will be silently truncated. If you
@@ -100,6 +101,10 @@ struct affs_sb_info {
        char *s_prefix;                 /* Prefix for volumes and assigns. */
        char s_volume[32];              /* Volume prefix for absolute symlinks. */
        spinlock_t symlink_lock;        /* protects the previous two */
+        struct super_block *sb;         /* the VFS superblock object */
+        int work_queued;                /* non-zero delayed work is queued */
+        struct delayed_work sb_work;    /* superblock flush delayed work */
+        spinlock_t work_lock;           /* protects sb_work and work_queued */
 };
 #define SF_INTL         0x0001          /* International filesystem. */
@@ -120,6 +125,8 @@ static inline struct affs_sb_info *AFFS_SB(struct super_block *sb)
        return sb->s_fs_info;
 }
+void affs_mark_sb_dirty(struct super_block *sb);
 /* amigaffs.c */
 extern int      affs_insert_hash(struct inode *inode, struct buffer_head *bh);
@@ -146,9 +153,9 @@ extern void	affs_free_bitmap(struct super_block *sb);
 /* namei.c */
 extern int      affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len);
-extern struct dentry *affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *);
+extern struct dentry *affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int);
 extern int      affs_unlink(struct inode *dir, struct dentry *dentry);
-extern int      affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *);
+extern int      affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool);
 extern int      affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
 extern int      affs_rmdir(struct inode *dir, struct dentry *dentry);
 extern int      affs_link(struct dentry *olddentry, struct inode *dir,
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 52a6407682e6..eb82ee53ee0b 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -122,22 +122,16 @@ affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
 }
 static void
-affs_fix_dcache(struct dentry *dentry, u32 entry_ino)
+affs_fix_dcache(struct inode *inode, u32 entry_ino)
 {
-        struct inode *inode = dentry->d_inode;
+        struct dentry *dentry;
-        void *data = dentry->d_fsdata;
+        struct hlist_node *p;
-        struct list_head *head, *next;
        spin_lock(&inode->i_lock);
-        head = &inode->i_dentry;
+        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
-        next = head->next;
-        while (next != head) {
-                dentry = list_entry(next, struct dentry, d_alias);
                if (entry_ino == (u32)(long)dentry->d_fsdata) {
-                        dentry->d_fsdata = data;
+                        dentry->d_fsdata = (void *)inode->i_ino;
                        break;
                }
-                next = next->next;
        }
        spin_unlock(&inode->i_lock);
 }
@@ -177,7 +171,11 @@ affs_remove_link(struct dentry *dentry)
                }
                affs_lock_dir(dir);
-                affs_fix_dcache(dentry, link_ino);
+                /*
+                 * if there's a dentry for that block, make it
+                 * refer to inode itself.
+                 */
+                affs_fix_dcache(inode, link_ino);
                retval = affs_remove_hash(dir, link_bh);
                if (retval) {
                        affs_unlock_dir(dir);
diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
index 3e262711ae06..6e0be43ef6ef 100644
--- a/fs/affs/bitmap.c
+++ b/fs/affs/bitmap.c
@@ -103,7 +103,7 @@ affs_free_block(struct super_block *sb, u32 block)
        *(__be32 *)bh->b_data = cpu_to_be32(tmp - mask);
        mark_buffer_dirty(bh);
-        sb->s_dirt = 1;
+        affs_mark_sb_dirty(sb);
        bm->bm_free++;
        mutex_unlock(&sbi->s_bmlock);
@@ -248,7 +248,7 @@ find_bit:
        *(__be32 *)bh->b_data = cpu_to_be32(tmp + mask);
        mark_buffer_dirty(bh);
-        sb->s_dirt = 1;
+        affs_mark_sb_dirty(sb);
        mutex_unlock(&sbi->s_bmlock);
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 47806940aac0..ff65884a7839 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -211,7 +211,7 @@ affs_find_entry(struct inode *dir, struct dentry *dentry)
 }
 struct dentry *
-affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct super_block *sb = dir->i_sb;
        struct buffer_head *bh;
@@ -255,7 +255,7 @@ affs_unlink(struct inode *dir, struct dentry *dentry)
 }
 int
-affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
+affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
 {
        struct super_block *sb = dir->i_sb;
        struct inode    *inode;
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 0782653a05a2..c70f1e5fc024 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -17,6 +17,7 @@
 #include <linux/magic.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/writeback.h>
 #include "affs.h"
 extern struct timezone sys_tz;
@@ -25,15 +26,17 @@ static int affs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int affs_remount (struct super_block *sb, int *flags, char *data);
 static void
-affs_commit_super(struct super_block *sb, int wait, int clean)
+affs_commit_super(struct super_block *sb, int wait)
 {
        struct affs_sb_info *sbi = AFFS_SB(sb);
        struct buffer_head *bh = sbi->s_root_bh;
        struct affs_root_tail *tail = AFFS_ROOT_TAIL(sb, bh);
-        tail->bm_flag = cpu_to_be32(clean);
+        lock_buffer(bh);
        secs_to_datestamp(get_seconds(), &tail->disk_change);
        affs_fix_checksum(sb, bh);
+        unlock_buffer(bh);
        mark_buffer_dirty(bh);
        if (wait)
                sync_dirty_buffer(bh);
@@ -45,9 +48,7 @@ affs_put_super(struct super_block *sb)
        struct affs_sb_info *sbi = AFFS_SB(sb);
        pr_debug("AFFS: put_super()\n");
-        if (!(sb->s_flags & MS_RDONLY) && sb->s_dirt)
+        cancel_delayed_work_sync(&sbi->sb_work);
-                affs_commit_super(sb, 1, 1);
        kfree(sbi->s_prefix);
        affs_free_bitmap(sb);
        affs_brelse(sbi->s_root_bh);
@@ -55,26 +56,43 @@ affs_put_super(struct super_block *sb)
        sb->s_fs_info = NULL;
 }
-static void
+static int
-affs_write_super(struct super_block *sb)
+affs_sync_fs(struct super_block *sb, int wait)
 {
-        lock_super(sb);
+        affs_commit_super(sb, wait);
-        if (!(sb->s_flags & MS_RDONLY))
+        return 0;
-                affs_commit_super(sb, 1, 2);
+}
-        sb->s_dirt = 0;
-        unlock_super(sb);
+static void flush_superblock(struct work_struct *work)
+{
+        struct affs_sb_info *sbi;
+        struct super_block *sb;
+        sbi = container_of(work, struct affs_sb_info, sb_work.work);
+        sb = sbi->sb;
-        pr_debug("AFFS: write_super() at %lu, clean=2\n", get_seconds());
+        spin_lock(&sbi->work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->work_lock);
+        affs_commit_super(sb, 1);
 }
-static int
+void affs_mark_sb_dirty(struct super_block *sb)
-affs_sync_fs(struct super_block *sb, int wait)
 {
-        lock_super(sb);
+        struct affs_sb_info *sbi = AFFS_SB(sb);
-        affs_commit_super(sb, wait, 2);
+        unsigned long delay;
-        sb->s_dirt = 0;
-        unlock_super(sb);
+        if (sb->s_flags & MS_RDONLY)
-        return 0;
+               return;
+        spin_lock(&sbi->work_lock);
+        if (!sbi->work_queued) {
+               delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+               queue_delayed_work(system_long_wq, &sbi->sb_work, delay);
+               sbi->work_queued = 1;
+        }
+        spin_unlock(&sbi->work_lock);
 }
 static struct kmem_cache * affs_inode_cachep;
@@ -138,7 +156,6 @@ static const struct super_operations affs_sops = {
        .write_inode    = affs_write_inode,
        .evict_inode    = affs_evict_inode,
        .put_super      = affs_put_super,
-        .write_super    = affs_write_super,
        .sync_fs        = affs_sync_fs,
        .statfs         = affs_statfs,
        .remount_fs     = affs_remount,
@@ -305,8 +322,11 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                return -ENOMEM;
        sb->s_fs_info = sbi;
+        sbi->sb = sb;
        mutex_init(&sbi->s_bmlock);
        spin_lock_init(&sbi->symlink_lock);
+        spin_lock_init(&sbi->work_lock);
+        INIT_DELAYED_WORK(&sbi->sb_work, flush_superblock);
        if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
                                &blocksize,&sbi->s_prefix,
@@ -531,6 +551,7 @@ affs_remount(struct super_block *sb, int *flags, char *data)
                return -EINVAL;
        }
+        flush_delayed_work_sync(&sbi->sb_work);
        replace_mount_options(sb, new_opts);
        sbi->s_flags = mount_flags;
@@ -549,10 +570,9 @@ affs_remount(struct super_block *sb, int *flags, char *data)
        if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
                return 0;
-        if (*flags & MS_RDONLY) {
+        if (*flags & MS_RDONLY)
-                affs_write_super(sb);
                affs_free_bitmap(sb);
-        } else
+        else
                res = affs_init_bitmap(sb, flags);
        return res;
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index e22dc4b4a503..db477906ba4f 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -20,16 +20,16 @@
 #include "internal.h"
 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
-                                 struct nameidata *nd);
+                                 unsigned int flags);
 static int afs_dir_open(struct inode *inode, struct file *file);
 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir);
-static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
+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,
                                  loff_t fpos, u64 ino, unsigned dtype);
 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                      struct nameidata *nd);
+                      bool excl);
 static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
 static int afs_unlink(struct inode *dir, struct dentry *dentry);
@@ -516,7 +516,7 @@ out:
 * look up an entry in a directory
 */
 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
-                                 struct nameidata *nd)
+                                 unsigned int flags)
 {
        struct afs_vnode *vnode;
        struct afs_fid fid;
@@ -598,7 +598,7 @@ success:
 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
 *   inode
 */
-static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct afs_vnode *vnode, *dir;
        struct afs_fid uninitialized_var(fid);
@@ -607,7 +607,7 @@ static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
        void *dir_version;
        int ret;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        vnode = AFS_FS_I(dentry->d_inode);
@@ -949,7 +949,7 @@ error:
 * create a regular file on an AFS filesystem
 */
 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                      struct nameidata *nd)
+                      bool excl)
 {
        struct afs_file_status status;
        struct afs_callback cb;
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index 298cf8919ec7..9682c33d5daf 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -22,7 +22,7 @@
 static struct dentry *afs_mntpt_lookup(struct inode *dir,
                                       struct dentry *dentry,
-                                       struct nameidata *nd);
+                                       unsigned int flags);
 static int afs_mntpt_open(struct inode *inode, struct file *file);
 static void afs_mntpt_expiry_timed_out(struct work_struct *work);
@@ -104,7 +104,7 @@ out:
 */
 static struct dentry *afs_mntpt_lookup(struct inode *dir,
                                       struct dentry *dentry,
-                                       struct nameidata *nd)
+                                       unsigned int flags)
 {
        _enter("%p,%p{%p{%s},%s}",
               dir,
diff --git a/fs/afs/super.c b/fs/afs/super.c
index f02b31e7e648..df8c6047c2a1 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -395,7 +395,7 @@ static struct dentry *afs_mount(struct file_system_type *fs_type,
        as->volume = vol;
        /* allocate a deviceless superblock */
-        sb = sget(fs_type, afs_test_super, afs_set_super, as);
+        sb = sget(fs_type, afs_test_super, afs_set_super, flags, as);
        if (IS_ERR(sb)) {
                ret = PTR_ERR(sb);
                afs_put_volume(vol);
@@ -406,7 +406,6 @@ static struct dentry *afs_mount(struct file_system_type *fs_type,
        if (!sb->s_root) {
                /* initial superblock/root creation */
                _debug("create");
-                sb->s_flags = flags;
                ret = afs_fill_super(sb, &params);
                if (ret < 0) {
                        deactivate_locked_super(sb);
diff --git a/fs/aio.c b/fs/aio.c
index 55c4c7656053..71f613cf4a85 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -56,13 +56,6 @@ static struct kmem_cache	*kioctx_cachep;
 static struct workqueue_struct *aio_wq;
-/* Used for rare fput completion. */
-static void aio_fput_routine(struct work_struct *);
-static DECLARE_WORK(fput_work, aio_fput_routine);
-static DEFINE_SPINLOCK(fput_lock);
-static LIST_HEAD(fput_head);
 static void aio_kick_handler(struct work_struct *);
 static void aio_queue_work(struct kioctx *);
@@ -479,7 +472,6 @@ static int kiocb_batch_refill(struct kioctx *ctx, struct kiocb_batch *batch)
 {
        unsigned short allocated, to_alloc;
        long avail;
-        bool called_fput = false;
        struct kiocb *req, *n;
        struct aio_ring *ring;
@@ -495,28 +487,11 @@ static int kiocb_batch_refill(struct kioctx *ctx, struct kiocb_batch *batch)
        if (allocated == 0)
                goto out;
-retry:
        spin_lock_irq(&ctx->ctx_lock);
        ring = kmap_atomic(ctx->ring_info.ring_pages[0]);
        avail = aio_ring_avail(&ctx->ring_info, ring) - ctx->reqs_active;
        BUG_ON(avail < 0);
-        if (avail == 0 && !called_fput) {
-                /*
-                 * Handle a potential starvation case.  It is possible that
-                 * we hold the last reference on a struct file, causing us
-                 * to delay the final fput to non-irq context.  In this case,
-                 * ctx->reqs_active is artificially high.  Calling the fput
-                 * routine here may free up a slot in the event completion
-                 * ring, allowing this allocation to succeed.
-                 */
-                kunmap_atomic(ring);
-                spin_unlock_irq(&ctx->ctx_lock);
-                aio_fput_routine(NULL);
-                called_fput = true;
-                goto retry;
-        }
        if (avail < allocated) {
                /* Trim back the number of requests. */
                list_for_each_entry_safe(req, n, &batch->head, ki_batch) {
@@ -570,36 +545,6 @@ static inline void really_put_req(struct kioctx *ctx, struct kiocb *req)
                wake_up_all(&ctx->wait);
 }
-static void aio_fput_routine(struct work_struct *data)
-{
-        spin_lock_irq(&fput_lock);
-        while (likely(!list_empty(&fput_head))) {
-                struct kiocb *req = list_kiocb(fput_head.next);
-                struct kioctx *ctx = req->ki_ctx;
-                list_del(&req->ki_list);
-                spin_unlock_irq(&fput_lock);
-                /* Complete the fput(s) */
-                if (req->ki_filp != NULL)
-                        fput(req->ki_filp);
-                /* Link the iocb into the context's free list */
-                rcu_read_lock();
-                spin_lock_irq(&ctx->ctx_lock);
-                really_put_req(ctx, req);
-                /*
-                 * at that point ctx might've been killed, but actual
-                 * freeing is RCU'd
-                 */
-                spin_unlock_irq(&ctx->ctx_lock);
-                rcu_read_unlock();
-                spin_lock_irq(&fput_lock);
-        }
-        spin_unlock_irq(&fput_lock);
-}
 /* __aio_put_req
 *      Returns true if this put was the last user of the request.
 */
@@ -618,21 +563,9 @@ static int __aio_put_req(struct kioctx *ctx, struct kiocb *req)
        req->ki_cancel = NULL;
        req->ki_retry = NULL;
-        /*
+        fput(req->ki_filp);
-         * Try to optimize the aio and eventfd file* puts, by avoiding to
+        req->ki_filp = NULL;
-         * schedule work in case it is not final fput() time. In normal cases,
+        really_put_req(ctx, req);
-         * we would not be holding the last reference to the file*, so
-         * this function will be executed w/out any aio kthread wakeup.
-         */
-        if (unlikely(!fput_atomic(req->ki_filp))) {
-                spin_lock(&fput_lock);
-                list_add(&req->ki_list, &fput_head);
-                spin_unlock(&fput_lock);
-                schedule_work(&fput_work);
-        } else {
-                req->ki_filp = NULL;
-                really_put_req(ctx, req);
-        }
        return 1;
 }
diff --git a/fs/attr.c b/fs/attr.c
index 0da90951d277..29e38a1f7f77 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -171,6 +171,8 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
        struct timespec now;
        unsigned int ia_valid = attr->ia_valid;
+        WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
        if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_TIMES_SET)) {
                if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                        return -EPERM;
@@ -250,5 +252,4 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
        return error;
 }
 EXPORT_SYMBOL(notify_change);
diff --git a/fs/autofs4/dev-ioctl.c b/fs/autofs4/dev-ioctl.c
index aa9103f8f01b..abf645c1703b 100644
--- a/fs/autofs4/dev-ioctl.c
+++ b/fs/autofs4/dev-ioctl.c
@@ -257,8 +257,8 @@ static int autofs_dev_ioctl_open_mountpoint(const char *name, dev_t devid)
                 * corresponding to the autofs fs we want to open.
                 */
-                filp = dentry_open(path.dentry, path.mnt, O_RDONLY,
+                filp = dentry_open(&path, O_RDONLY, current_cred());
-                                   current_cred());
+                path_put(&path);
                if (IS_ERR(filp)) {
                        err = PTR_ERR(filp);
                        goto out;
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 75e5f1c8e028..e7396cfdb109 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -32,7 +32,7 @@ static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long);
 static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long);
 #endif
 static int autofs4_dir_open(struct inode *inode, struct file *file);
-static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *);
+static struct dentry *autofs4_lookup(struct inode *,struct dentry *, unsigned int);
 static struct vfsmount *autofs4_d_automount(struct path *);
 static int autofs4_d_manage(struct dentry *, bool);
 static void autofs4_dentry_release(struct dentry *);
@@ -458,7 +458,7 @@ int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
 }
 /* Lookups in the root directory */
-static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct autofs_sb_info *sbi;
        struct autofs_info *ino;
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 1b35d6bd06b0..b1342ffb3cf6 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -173,13 +173,13 @@ static const struct file_operations bad_file_ops =
 };
 static int bad_inode_create (struct inode *dir, struct dentry *dentry,
-                umode_t mode, struct nameidata *nd)
+                umode_t mode, bool excl)
 {
        return -EIO;
 }
 static struct dentry *bad_inode_lookup(struct inode *dir,
-                        struct dentry *dentry, struct nameidata *nd)
+                        struct dentry *dentry, unsigned int flags)
 {
        return ERR_PTR(-EIO);
 }
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index e18da23d42b5..cf7f3c67c8b7 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -34,7 +34,7 @@ static int befs_readdir(struct file *, void *, filldir_t);
 static int befs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 static int befs_readpage(struct file *file, struct page *page);
 static sector_t befs_bmap(struct address_space *mapping, sector_t block);
-static struct dentry *befs_lookup(struct inode *, struct dentry *, struct nameidata *);
+static struct dentry *befs_lookup(struct inode *, struct dentry *, unsigned int);
 static struct inode *befs_iget(struct super_block *, unsigned long);
 static struct inode *befs_alloc_inode(struct super_block *sb);
 static void befs_destroy_inode(struct inode *inode);
@@ -159,7 +159,7 @@ befs_get_block(struct inode *inode, sector_t block,
 }
 static struct dentry *
-befs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode = NULL;
        struct super_block *sb = dir->i_sb;
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index d12c7966db27..2785ef91191a 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -85,7 +85,7 @@ const struct file_operations bfs_dir_operations = {
 extern void dump_imap(const char *, struct super_block *);
 static int bfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                                                struct nameidata *nd)
+                                                bool excl)
 {
        int err;
        struct inode *inode;
@@ -133,7 +133,7 @@ static int bfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 }
 static struct dentry *bfs_lookup(struct inode *dir, struct dentry *dentry,
-                                                struct nameidata *nd)
+                                                unsigned int flags)
 {
        struct inode *inode = NULL;
        struct buffer_head *bh;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index c2bbe1fb1326..1e519195d45b 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1710,3 +1710,39 @@ int __invalidate_device(struct block_device *bdev, bool kill_dirty)
        return res;
 }
 EXPORT_SYMBOL(__invalidate_device);
+void iterate_bdevs(void (*func)(struct block_device *, void *), void *arg)
+{
+        struct inode *inode, *old_inode = NULL;
+        spin_lock(&inode_sb_list_lock);
+        list_for_each_entry(inode, &blockdev_superblock->s_inodes, i_sb_list) {
+                struct address_space *mapping = inode->i_mapping;
+                spin_lock(&inode->i_lock);
+                if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW) ||
+                    mapping->nrpages == 0) {
+                        spin_unlock(&inode->i_lock);
+                        continue;
+                }
+                __iget(inode);
+                spin_unlock(&inode->i_lock);
+                spin_unlock(&inode_sb_list_lock);
+                /*
+                 * We hold a reference to 'inode' so it couldn't have been
+                 * removed from s_inodes list while we dropped the
+                 * inode_sb_list_lock.  We cannot iput the inode now as we can
+                 * be holding the last reference and we cannot iput it under
+                 * inode_sb_list_lock. So we keep the reference and iput it
+                 * later.
+                 */
+                iput(old_inode);
+                old_inode = inode;
+                func(I_BDEV(inode), arg);
+                spin_lock(&inode_sb_list_lock);
+        }
+        spin_unlock(&inode_sb_list_lock);
+        iput(old_inode);
+}
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 3f75895c919b..a383c18e74e8 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -179,60 +179,74 @@ static int __add_prelim_ref(struct list_head *head, u64 root_id,
 static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
                                struct ulist *parents, int level,
-                                struct btrfs_key *key, u64 wanted_disk_byte,
+                                struct btrfs_key *key_for_search, u64 time_seq,
+                                u64 wanted_disk_byte,
                                const u64 *extent_item_pos)
 {
-        int ret;
+        int ret = 0;
-        int slot = path->slots[level];
+        int slot;
-        struct extent_buffer *eb = path->nodes[level];
+        struct extent_buffer *eb;
+        struct btrfs_key key;
        struct btrfs_file_extent_item *fi;
        struct extent_inode_elem *eie = NULL;
        u64 disk_byte;
-        u64 wanted_objectid = key->objectid;
-add_parent:
+        if (level != 0) {
-        if (level == 0 && extent_item_pos) {
+                eb = path->nodes[level];
-                fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
+                ret = ulist_add(parents, eb->start, 0, GFP_NOFS);
-                ret = check_extent_in_eb(key, eb, fi, *extent_item_pos, &eie);
                if (ret < 0)
                        return ret;
-        }
-        ret = ulist_add(parents, eb->start, (unsigned long)eie, GFP_NOFS);
-        if (ret < 0)
-                return ret;
-        if (level != 0)
                return 0;
+        }
        /*
-         * if the current leaf is full with EXTENT_DATA items, we must
+         * We normally enter this function with the path already pointing to
-         * check the next one if that holds a reference as well.
+         * the first item to check. But sometimes, we may enter it with
-         * ref->count cannot be used to skip this check.
+         * slot==nritems. In that case, go to the next leaf before we continue.
-         * repeat this until we don't find any additional EXTENT_DATA items.
         */
-        while (1) {
+        if (path->slots[0] >= btrfs_header_nritems(path->nodes[0]))
-                eie = NULL;
+                ret = btrfs_next_old_leaf(root, path, time_seq);
-                ret = btrfs_next_leaf(root, path);
-                if (ret < 0)
-                        return ret;
-                if (ret)
-                        return 0;
+        while (!ret) {
                eb = path->nodes[0];
-                for (slot = 0; slot < btrfs_header_nritems(eb); ++slot) {
+                slot = path->slots[0];
-                        btrfs_item_key_to_cpu(eb, key, slot);
-                        if (key->objectid != wanted_objectid ||
+                btrfs_item_key_to_cpu(eb, &key, slot);
-                            key->type != BTRFS_EXTENT_DATA_KEY)
-                                return 0;
+                if (key.objectid != key_for_search->objectid ||
-                        fi = btrfs_item_ptr(eb, slot,
+                    key.type != BTRFS_EXTENT_DATA_KEY)
-                                                struct btrfs_file_extent_item);
+                        break;
-                        disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
-                        if (disk_byte == wanted_disk_byte)
+                fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-                                goto add_parent;
+                disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+                if (disk_byte == wanted_disk_byte) {
+                        eie = NULL;
+                        if (extent_item_pos) {
+                                ret = check_extent_in_eb(&key, eb, fi,
+                                                *extent_item_pos,
+                                                &eie);
+                                if (ret < 0)
+                                        break;
+                        }
+                        if (!ret) {
+                                ret = ulist_add(parents, eb->start,
+                                                (unsigned long)eie, GFP_NOFS);
+                                if (ret < 0)
+                                        break;
+                                if (!extent_item_pos) {
+                                        ret = btrfs_next_old_leaf(root, path,
+                                                        time_seq);
+                                        continue;
+                                }
+                        }
                }
+                ret = btrfs_next_old_item(root, path, time_seq);
        }
-        return 0;
+        if (ret > 0)
+                ret = 0;
+        return ret;
 }
 /*
@@ -249,7 +263,6 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
        struct btrfs_path *path;
        struct btrfs_root *root;
        struct btrfs_key root_key;
-        struct btrfs_key key = {0};
        struct extent_buffer *eb;
        int ret = 0;
        int root_level;
@@ -288,25 +301,19 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
                goto out;
        eb = path->nodes[level];
-        if (!eb) {
+        while (!eb) {
-                WARN_ON(1);
+                if (!level) {
-                ret = 1;
+                        WARN_ON(1);
-                goto out;
+                        ret = 1;
-        }
+                        goto out;
-        if (level == 0) {
-                if (ret == 1 && path->slots[0] >= btrfs_header_nritems(eb)) {
-                        ret = btrfs_next_leaf(root, path);
-                        if (ret)
-                                goto out;
-                        eb = path->nodes[0];
                }
+                level--;
-                btrfs_item_key_to_cpu(eb, &key, path->slots[0]);
+                eb = path->nodes[level];
        }
-        ret = add_all_parents(root, path, parents, level, &key,
+        ret = add_all_parents(root, path, parents, level, &ref->key_for_search,
-                                ref->wanted_disk_byte, extent_item_pos);
+                                time_seq, ref->wanted_disk_byte,
+                                extent_item_pos);
 out:
        btrfs_free_path(path);
        return ret;
@@ -832,6 +839,7 @@ again:
                        }
                        ret = __add_delayed_refs(head, delayed_ref_seq,
                                                 &prefs_delayed);
+                        mutex_unlock(&head->mutex);
                        if (ret) {
                                spin_unlock(&delayed_refs->lock);
                                goto out;
@@ -925,8 +933,6 @@ again:
        }
 out:
-        if (head)
-                mutex_unlock(&head->mutex);
        btrfs_free_path(path);
        while (!list_empty(&prefs)) {
                ref = list_first_entry(&prefs, struct __prelim_ref, list);
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index e616f8872e69..12394a90d60f 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -37,6 +37,7 @@
 #define BTRFS_INODE_IN_DEFRAG                   3
 #define BTRFS_INODE_DELALLOC_META_RESERVED      4
 #define BTRFS_INODE_HAS_ORPHAN_ITEM             5
+#define BTRFS_INODE_HAS_ASYNC_EXTENT            6
 /* in memory btrfs inode */
 struct btrfs_inode {
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 9cebb1fd6a3c..da6e9364a5e3 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -93,6 +93,7 @@
 #include "print-tree.h"
 #include "locking.h"
 #include "check-integrity.h"
+#include "rcu-string.h"
 #define BTRFSIC_BLOCK_HASHTABLE_SIZE 0x10000
 #define BTRFSIC_BLOCK_LINK_HASHTABLE_SIZE 0x10000
@@ -843,13 +844,14 @@ static int btrfsic_process_superblock_dev_mirror(
                superblock_tmp->never_written = 0;
                superblock_tmp->mirror_num = 1 + superblock_mirror_num;
                if (state->print_mask & BTRFSIC_PRINT_MASK_SUPERBLOCK_WRITE)
-                        printk(KERN_INFO "New initial S-block (bdev %p, %s)"
+                        printk_in_rcu(KERN_INFO "New initial S-block (bdev %p, %s)"
-                               " @%llu (%s/%llu/%d)\n",
+                                     " @%llu (%s/%llu/%d)\n",
-                               superblock_bdev, device->name,
+                                     superblock_bdev,
-                               (unsigned long long)dev_bytenr,
+                                     rcu_str_deref(device->name),
-                               dev_state->name,
+                                     (unsigned long long)dev_bytenr,
-                               (unsigned long long)dev_bytenr,
+                                     dev_state->name,
-                               superblock_mirror_num);
+                                     (unsigned long long)dev_bytenr,
+                                     superblock_mirror_num);
                list_add(&superblock_tmp->all_blocks_node,
                         &state->all_blocks_list);
                btrfsic_block_hashtable_add(superblock_tmp,
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index d7a96cfdc50a..8206b3900587 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -467,6 +467,15 @@ static inline int tree_mod_dont_log(struct btrfs_fs_info *fs_info,
        return 0;
 }
+/*
+ * This allocates memory and gets a tree modification sequence number when
+ * needed.
+ *
+ * Returns 0 when no sequence number is needed, < 0 on error.
+ * Returns 1 when a sequence number was added. In this case,
+ * fs_info->tree_mod_seq_lock was acquired and must be released by the caller
+ * after inserting into the rb tree.
+ */
 static inline int tree_mod_alloc(struct btrfs_fs_info *fs_info, gfp_t flags,
                                 struct tree_mod_elem **tm_ret)
 {
@@ -491,11 +500,11 @@ static inline int tree_mod_alloc(struct btrfs_fs_info *fs_info, gfp_t flags,
                 */
                kfree(tm);
                seq = 0;
+                spin_unlock(&fs_info->tree_mod_seq_lock);
        } else {
                __get_tree_mod_seq(fs_info, &tm->elem);
                seq = tm->elem.seq;
        }
-        spin_unlock(&fs_info->tree_mod_seq_lock);
        return seq;
 }
@@ -521,7 +530,9 @@ tree_mod_log_insert_key_mask(struct btrfs_fs_info *fs_info,
        tm->slot = slot;
        tm->generation = btrfs_node_ptr_generation(eb, slot);
-        return __tree_mod_log_insert(fs_info, tm);
+        ret = __tree_mod_log_insert(fs_info, tm);
+        spin_unlock(&fs_info->tree_mod_seq_lock);
+        return ret;
 }
 static noinline int
@@ -559,7 +570,9 @@ tree_mod_log_insert_move(struct btrfs_fs_info *fs_info,
        tm->move.nr_items = nr_items;
        tm->op = MOD_LOG_MOVE_KEYS;
-        return __tree_mod_log_insert(fs_info, tm);
+        ret = __tree_mod_log_insert(fs_info, tm);
+        spin_unlock(&fs_info->tree_mod_seq_lock);
+        return ret;
 }
 static noinline int
@@ -580,7 +593,9 @@ tree_mod_log_insert_root(struct btrfs_fs_info *fs_info,
        tm->generation = btrfs_header_generation(old_root);
        tm->op = MOD_LOG_ROOT_REPLACE;
-        return __tree_mod_log_insert(fs_info, tm);
+        ret = __tree_mod_log_insert(fs_info, tm);
+        spin_unlock(&fs_info->tree_mod_seq_lock);
+        return ret;
 }
 static struct tree_mod_elem *
@@ -1009,11 +1024,18 @@ __tree_mod_log_oldest_root(struct btrfs_fs_info *fs_info,
                if (!looped && !tm)
                        return 0;
                /*
-                 * we must have key remove operations in the log before the
+                 * if there are no tree operation for the oldest root, we simply
-                 * replace operation.
+                 * return it. this should only happen if that (old) root is at
+                 * level 0.
                 */
-                BUG_ON(!tm);
+                if (!tm)
+                        break;
+                /*
+                 * if there's an operation that's not a root replacement, we
+                 * found the oldest version of our root. normally, we'll find a
+                 * MOD_LOG_KEY_REMOVE_WHILE_FREEING operation here.
+                 */
                if (tm->op != MOD_LOG_ROOT_REPLACE)
                        break;
@@ -1023,6 +1045,10 @@ __tree_mod_log_oldest_root(struct btrfs_fs_info *fs_info,
                looped = 1;
        }
+        /* if there's no old root to return, return what we found instead */
+        if (!found)
+                found = tm;
        return found;
 }
@@ -1068,11 +1094,7 @@ __tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
                                                      tm->generation);
                        break;
                case MOD_LOG_KEY_ADD:
-                        if (tm->slot != n - 1) {
+                        /* if a move operation is needed it's in the log */
-                                o_dst = btrfs_node_key_ptr_offset(tm->slot);
-                                o_src = btrfs_node_key_ptr_offset(tm->slot + 1);
-                                memmove_extent_buffer(eb, o_dst, o_src, p_size);
-                        }
                        n--;
                        break;
                case MOD_LOG_MOVE_KEYS:
@@ -1143,45 +1165,57 @@ tree_mod_log_rewind(struct btrfs_fs_info *fs_info, struct extent_buffer *eb,
        return eb_rewin;
 }
+/*
+ * get_old_root() rewinds the state of @root's root node to the given @time_seq
+ * value. If there are no changes, the current root->root_node is returned. If
+ * anything changed in between, there's a fresh buffer allocated on which the
+ * rewind operations are done. In any case, the returned buffer is read locked.
+ * Returns NULL on error (with no locks held).
+ */
 static inline struct extent_buffer *
 get_old_root(struct btrfs_root *root, u64 time_seq)
 {
        struct tree_mod_elem *tm;
        struct extent_buffer *eb;
-        struct tree_mod_root *old_root;
+        struct tree_mod_root *old_root = NULL;
-        u64 old_generation;
+        u64 old_generation = 0;
+        u64 logical;
+        eb = btrfs_read_lock_root_node(root);
        tm = __tree_mod_log_oldest_root(root->fs_info, root, time_seq);
        if (!tm)
                return root->node;
-        old_root = &tm->old_root;
+        if (tm->op == MOD_LOG_ROOT_REPLACE) {
-        old_generation = tm->generation;
+                old_root = &tm->old_root;
+                old_generation = tm->generation;
-        tm = tree_mod_log_search(root->fs_info, old_root->logical, time_seq);
+                logical = old_root->logical;
-        /*
+        } else {
-         * there was an item in the log when __tree_mod_log_oldest_root
+                logical = root->node->start;
-         * returned. this one must not go away, because the time_seq passed to
+        }
-         * us must be blocking its removal.
-         */
-        BUG_ON(!tm);
-        if (old_root->logical == root->node->start) {
+        tm = tree_mod_log_search(root->fs_info, logical, time_seq);
-                /* there are logged operations for the current root */
+        if (old_root)
+                eb = alloc_dummy_extent_buffer(logical, root->nodesize);
+        else
                eb = btrfs_clone_extent_buffer(root->node);
-        } else {
+        btrfs_tree_read_unlock(root->node);
-                /* there's a root replace operation for the current root */
+        free_extent_buffer(root->node);
-                eb = alloc_dummy_extent_buffer(tm->index << PAGE_CACHE_SHIFT,
+        if (!eb)
-                                               root->nodesize);
+                return NULL;
+        btrfs_tree_read_lock(eb);
+        if (old_root) {
                btrfs_set_header_bytenr(eb, eb->start);
                btrfs_set_header_backref_rev(eb, BTRFS_MIXED_BACKREF_REV);
                btrfs_set_header_owner(eb, root->root_key.objectid);
+                btrfs_set_header_level(eb, old_root->level);
+                btrfs_set_header_generation(eb, old_generation);
        }
-        if (!eb)
+        if (tm)
-                return NULL;
+                __tree_mod_log_rewind(eb, time_seq, tm);
-        btrfs_set_header_level(eb, old_root->level);
+        else
-        btrfs_set_header_generation(eb, old_generation);
+                WARN_ON(btrfs_header_level(eb) != 0);
-        __tree_mod_log_rewind(eb, time_seq, tm);
+        extent_buffer_get(eb);
        return eb;
 }
@@ -1650,8 +1684,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
            BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
                return 0;
-        btrfs_header_nritems(mid);
        left = read_node_slot(root, parent, pslot - 1);
        if (left) {
                btrfs_tree_lock(left);
@@ -1681,7 +1713,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                wret = push_node_left(trans, root, left, mid, 1);
                if (wret < 0)
                        ret = wret;
-                btrfs_header_nritems(mid);
        }
        /*
@@ -2615,9 +2646,7 @@ int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
 again:
        b = get_old_root(root, time_seq);
-        extent_buffer_get(b);
        level = btrfs_header_level(b);
-        btrfs_tree_read_lock(b);
        p->locks[level] = BTRFS_READ_LOCK;
        while (b) {
@@ -2964,7 +2993,7 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
 static void insert_ptr(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root, struct btrfs_path *path,
                       struct btrfs_disk_key *key, u64 bytenr,
-                       int slot, int level, int tree_mod_log)
+                       int slot, int level)
 {
        struct extent_buffer *lower;
        int nritems;
@@ -2977,7 +3006,7 @@ static void insert_ptr(struct btrfs_trans_handle *trans,
        BUG_ON(slot > nritems);
        BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(root));
        if (slot != nritems) {
-                if (tree_mod_log && level)
+                if (level)
                        tree_mod_log_eb_move(root->fs_info, lower, slot + 1,
                                             slot, nritems - slot);
                memmove_extent_buffer(lower,
@@ -2985,7 +3014,7 @@ static void insert_ptr(struct btrfs_trans_handle *trans,
                              btrfs_node_key_ptr_offset(slot),
                              (nritems - slot) * sizeof(struct btrfs_key_ptr));
        }
-        if (tree_mod_log && level) {
+        if (level) {
                ret = tree_mod_log_insert_key(root->fs_info, lower, slot,
                                              MOD_LOG_KEY_ADD);
                BUG_ON(ret < 0);
@@ -3073,7 +3102,7 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
        btrfs_mark_buffer_dirty(split);
        insert_ptr(trans, root, path, &disk_key, split->start,
-                   path->slots[level + 1] + 1, level + 1, 1);
+                   path->slots[level + 1] + 1, level + 1);
        if (path->slots[level] >= mid) {
                path->slots[level] -= mid;
@@ -3610,7 +3639,7 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans,
        btrfs_set_header_nritems(l, mid);
        btrfs_item_key(right, &disk_key, 0);
        insert_ptr(trans, root, path, &disk_key, right->start,
-                   path->slots[1] + 1, 1, 0);
+                   path->slots[1] + 1, 1);
        btrfs_mark_buffer_dirty(right);
        btrfs_mark_buffer_dirty(l);
@@ -3817,7 +3846,7 @@ again:
                if (mid <= slot) {
                        btrfs_set_header_nritems(right, 0);
                        insert_ptr(trans, root, path, &disk_key, right->start,
-                                   path->slots[1] + 1, 1, 0);
+                                   path->slots[1] + 1, 1);
                        btrfs_tree_unlock(path->nodes[0]);
                        free_extent_buffer(path->nodes[0]);
                        path->nodes[0] = right;
@@ -3826,7 +3855,7 @@ again:
                } else {
                        btrfs_set_header_nritems(right, 0);
                        insert_ptr(trans, root, path, &disk_key, right->start,
-                                          path->slots[1], 1, 0);
+                                          path->slots[1], 1);
                        btrfs_tree_unlock(path->nodes[0]);
                        free_extent_buffer(path->nodes[0]);
                        path->nodes[0] = right;
@@ -5001,6 +5030,12 @@ next:
 */
 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
 {
+        return btrfs_next_old_leaf(root, path, 0);
+}
+int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
+                        u64 time_seq)
+{
        int slot;
        int level;
        struct extent_buffer *c;
@@ -5025,7 +5060,10 @@ again:
        path->keep_locks = 1;
        path->leave_spinning = 1;
-        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+        if (time_seq)
+                ret = btrfs_search_old_slot(root, &key, path, time_seq);
+        else
+                ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
        path->keep_locks = 0;
        if (ret < 0)
@@ -5081,6 +5119,18 @@ again:
                if (!path->skip_locking) {
                        ret = btrfs_try_tree_read_lock(next);
+                        if (!ret && time_seq) {
+                                /*
+                                 * If we don't get the lock, we may be racing
+                                 * with push_leaf_left, holding that lock while
+                                 * itself waiting for the leaf we've currently
+                                 * locked. To solve this situation, we give up
+                                 * on our lock and cycle.
+                                 */
+                                btrfs_release_path(path);
+                                cond_resched();
+                                goto again;
+                        }
                        if (!ret) {
                                btrfs_set_path_blocking(path);
                                btrfs_tree_read_lock(next);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 0236d03c6732..fa5c45b39075 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2753,13 +2753,20 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
 }
 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
-static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
+int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
+                        u64 time_seq);
+static inline int btrfs_next_old_item(struct btrfs_root *root,
+                                      struct btrfs_path *p, u64 time_seq)
 {
        ++p->slots[0];
        if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
-                return btrfs_next_leaf(root, p);
+                return btrfs_next_old_leaf(root, p, time_seq);
        return 0;
 }
+static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
+{
+        return btrfs_next_old_item(root, p, 0);
+}
 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
 int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index c18d0442ae6d..2399f4086915 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1879,3 +1879,21 @@ void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)
                }
        }
 }
+void btrfs_destroy_delayed_inodes(struct btrfs_root *root)
+{
+        struct btrfs_delayed_root *delayed_root;
+        struct btrfs_delayed_node *curr_node, *prev_node;
+        delayed_root = btrfs_get_delayed_root(root);
+        curr_node = btrfs_first_delayed_node(delayed_root);
+        while (curr_node) {
+                __btrfs_kill_delayed_node(curr_node);
+                prev_node = curr_node;
+                curr_node = btrfs_next_delayed_node(curr_node);
+                btrfs_release_delayed_node(prev_node);
+        }
+}
diff --git a/fs/btrfs/delayed-inode.h b/fs/btrfs/delayed-inode.h
index 7083d08b2a21..f5aa4023d3e1 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -124,6 +124,9 @@ int btrfs_fill_inode(struct inode *inode, u32 *rdev);
 /* Used for drop dead root */
 void btrfs_kill_all_delayed_nodes(struct btrfs_root *root);
+/* Used for clean the transaction */
+void btrfs_destroy_delayed_inodes(struct btrfs_root *root);
 /* Used for readdir() */
 void btrfs_get_delayed_items(struct inode *inode, struct list_head *ins_list,
                             struct list_head *del_list);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 7ae51decf6d3..2936ca49b3b4 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -44,6 +44,7 @@
 #include "free-space-cache.h"
 #include "inode-map.h"
 #include "check-integrity.h"
+#include "rcu-string.h"
 static struct extent_io_ops btree_extent_io_ops;
 static void end_workqueue_fn(struct btrfs_work *work);
@@ -2118,7 +2119,7 @@ int open_ctree(struct super_block *sb,
        features = btrfs_super_incompat_flags(disk_super);
        features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
-        if (tree_root->fs_info->compress_type & BTRFS_COMPRESS_LZO)
+        if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
                features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
        /*
@@ -2353,12 +2354,17 @@ retry_root_backup:
                                  BTRFS_CSUM_TREE_OBJECTID, csum_root);
        if (ret)
                goto recovery_tree_root;
        csum_root->track_dirty = 1;
        fs_info->generation = generation;
        fs_info->last_trans_committed = generation;
+        ret = btrfs_recover_balance(fs_info);
+        if (ret) {
+                printk(KERN_WARNING "btrfs: failed to recover balance\n");
+                goto fail_block_groups;
+        }
        ret = btrfs_init_dev_stats(fs_info);
        if (ret) {
                printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
@@ -2484,20 +2490,23 @@ retry_root_backup:
                goto fail_trans_kthread;
        }
-        if (!(sb->s_flags & MS_RDONLY)) {
+        if (sb->s_flags & MS_RDONLY)
-                down_read(&fs_info->cleanup_work_sem);
+                return 0;
-                err = btrfs_orphan_cleanup(fs_info->fs_root);
-                if (!err)
-                        err = btrfs_orphan_cleanup(fs_info->tree_root);
-                up_read(&fs_info->cleanup_work_sem);
-                if (!err)
+        down_read(&fs_info->cleanup_work_sem);
-                        err = btrfs_recover_balance(fs_info->tree_root);
+        if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
+            (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
+                up_read(&fs_info->cleanup_work_sem);
+                close_ctree(tree_root);
+                return ret;
+        }
+        up_read(&fs_info->cleanup_work_sem);
-                if (err) {
+        ret = btrfs_resume_balance_async(fs_info);
-                        close_ctree(tree_root);
+        if (ret) {
-                        return err;
+                printk(KERN_WARNING "btrfs: failed to resume balance\n");
-                }
+                close_ctree(tree_root);
+                return ret;
        }
        return 0;
@@ -2575,8 +2584,9 @@ static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
                struct btrfs_device *device = (struct btrfs_device *)
                        bh->b_private;
-                printk_ratelimited(KERN_WARNING "lost page write due to "
+                printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
-                                   "I/O error on %s\n", device->name);
+                                          "I/O error on %s\n",
+                                          rcu_str_deref(device->name));
                /* note, we dont' set_buffer_write_io_error because we have
                 * our own ways of dealing with the IO errors
                 */
@@ -2749,8 +2759,8 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
                wait_for_completion(&device->flush_wait);
                if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
-                        printk("btrfs: disabling barriers on dev %s\n",
+                        printk_in_rcu("btrfs: disabling barriers on dev %s\n",
-                               device->name);
+                                      rcu_str_deref(device->name));
                        device->nobarriers = 1;
                }
                if (!bio_flagged(bio, BIO_UPTODATE)) {
@@ -3400,7 +3410,6 @@ int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
        delayed_refs = &trans->delayed_refs;
-again:
        spin_lock(&delayed_refs->lock);
        if (delayed_refs->num_entries == 0) {
                spin_unlock(&delayed_refs->lock);
@@ -3408,31 +3417,37 @@ again:
                return ret;
        }
-        node = rb_first(&delayed_refs->root);
+        while ((node = rb_first(&delayed_refs->root)) != NULL) {
-        while (node) {
                ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
-                node = rb_next(node);
-                ref->in_tree = 0;
-                rb_erase(&ref->rb_node, &delayed_refs->root);
-                delayed_refs->num_entries--;
                atomic_set(&ref->refs, 1);
                if (btrfs_delayed_ref_is_head(ref)) {
                        struct btrfs_delayed_ref_head *head;
                        head = btrfs_delayed_node_to_head(ref);
-                        spin_unlock(&delayed_refs->lock);
+                        if (!mutex_trylock(&head->mutex)) {
-                        mutex_lock(&head->mutex);
+                                atomic_inc(&ref->refs);
+                                spin_unlock(&delayed_refs->lock);
+                                /* Need to wait for the delayed ref to run */
+                                mutex_lock(&head->mutex);
+                                mutex_unlock(&head->mutex);
+                                btrfs_put_delayed_ref(ref);
+                                spin_lock(&delayed_refs->lock);
+                                continue;
+                        }
                        kfree(head->extent_op);
                        delayed_refs->num_heads--;
                        if (list_empty(&head->cluster))
                                delayed_refs->num_heads_ready--;
                        list_del_init(&head->cluster);
-                        mutex_unlock(&head->mutex);
-                        btrfs_put_delayed_ref(ref);
-                        goto again;
                }
+                ref->in_tree = 0;
+                rb_erase(&ref->rb_node, &delayed_refs->root);
+                delayed_refs->num_entries--;
                spin_unlock(&delayed_refs->lock);
                btrfs_put_delayed_ref(ref);
@@ -3520,11 +3535,9 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
                             &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
                                               offset >> PAGE_CACHE_SHIFT);
                        spin_unlock(&dirty_pages->buffer_lock);
-                        if (eb) {
+                        if (eb)
                                ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
                                                         &eb->bflags);
-                                atomic_set(&eb->refs, 1);
-                        }
                        if (PageWriteback(page))
                                end_page_writeback(page);
@@ -3538,8 +3551,8 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
                                spin_unlock_irq(&page->mapping->tree_lock);
                        }
-                        page->mapping->a_ops->invalidatepage(page, 0);
                        unlock_page(page);
+                        page_cache_release(page);
                }
        }
@@ -3553,8 +3566,10 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
        u64 start;
        u64 end;
        int ret;
+        bool loop = true;
        unpin = pinned_extents;
+again:
        while (1) {
                ret = find_first_extent_bit(unpin, 0, &start, &end,
                                            EXTENT_DIRTY);
@@ -3572,6 +3587,15 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
                cond_resched();
        }
+        if (loop) {
+                if (unpin == &root->fs_info->freed_extents[0])
+                        unpin = &root->fs_info->freed_extents[1];
+                else
+                        unpin = &root->fs_info->freed_extents[0];
+                loop = false;
+                goto again;
+        }
        return 0;
 }
@@ -3585,21 +3609,23 @@ void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
        /* FIXME: cleanup wait for commit */
        cur_trans->in_commit = 1;
        cur_trans->blocked = 1;
-        if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
+        wake_up(&root->fs_info->transaction_blocked_wait);
-                wake_up(&root->fs_info->transaction_blocked_wait);
        cur_trans->blocked = 0;
-        if (waitqueue_active(&root->fs_info->transaction_wait))
+        wake_up(&root->fs_info->transaction_wait);
-                wake_up(&root->fs_info->transaction_wait);
        cur_trans->commit_done = 1;
-        if (waitqueue_active(&cur_trans->commit_wait))
+        wake_up(&cur_trans->commit_wait);
-                wake_up(&cur_trans->commit_wait);
+        btrfs_destroy_delayed_inodes(root);
+        btrfs_assert_delayed_root_empty(root);
        btrfs_destroy_pending_snapshots(cur_trans);
        btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
                                     EXTENT_DIRTY);
+        btrfs_destroy_pinned_extent(root,
+                                    root->fs_info->pinned_extents);
        /*
        memset(cur_trans, 0, sizeof(*cur_trans));
@@ -3648,6 +3674,9 @@ int btrfs_cleanup_transaction(struct btrfs_root *root)
                if (waitqueue_active(&t->commit_wait))
                        wake_up(&t->commit_wait);
+                btrfs_destroy_delayed_inodes(root);
+                btrfs_assert_delayed_root_empty(root);
                btrfs_destroy_pending_snapshots(t);
                btrfs_destroy_delalloc_inodes(root);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 4b5a1e1bdefb..6e1d36702ff7 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2347,12 +2347,10 @@ next:
        return count;
 }
 static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs,
-                        unsigned long num_refs)
+                               unsigned long num_refs,
+                               struct list_head *first_seq)
 {
-        struct list_head *first_seq = delayed_refs->seq_head.next;
        spin_unlock(&delayed_refs->lock);
        pr_debug("waiting for more refs (num %ld, first %p)\n",
                 num_refs, first_seq);
@@ -2381,6 +2379,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
        struct btrfs_delayed_ref_root *delayed_refs;
        struct btrfs_delayed_ref_node *ref;
        struct list_head cluster;
+        struct list_head *first_seq = NULL;
        int ret;
        u64 delayed_start;
        int run_all = count == (unsigned long)-1;
@@ -2436,8 +2435,10 @@ again:
                                 */
                                consider_waiting = 1;
                                num_refs = delayed_refs->num_entries;
+                                first_seq = root->fs_info->tree_mod_seq_list.next;
                        } else {
-                                wait_for_more_refs(delayed_refs, num_refs);
+                                wait_for_more_refs(delayed_refs,
+                                                   num_refs, first_seq);
                                /*
                                 * after waiting, things have changed. we
                                 * dropped the lock and someone else might have
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 2c8f7b204617..deafe19c34b5 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -20,6 +20,7 @@
 #include "volumes.h"
 #include "check-integrity.h"
 #include "locking.h"
+#include "rcu-string.h"
 static struct kmem_cache *extent_state_cache;
 static struct kmem_cache *extent_buffer_cache;
@@ -928,7 +929,8 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
 /**
- * convert_extent - convert all bits in a given range from one bit to another
+ * convert_extent_bit - convert all bits in a given range from one bit to
+ *                      another
 * @tree:       the io tree to search
 * @start:      the start offset in bytes
 * @end:        the end offset in bytes (inclusive)
@@ -1917,9 +1919,9 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
                return -EIO;
        }
-        printk(KERN_INFO "btrfs read error corrected: ino %lu off %llu (dev %s "
+        printk_in_rcu(KERN_INFO "btrfs read error corrected: ino %lu off %llu "
-                        "sector %llu)\n", page->mapping->host->i_ino, start,
+                      "(dev %s sector %llu)\n", page->mapping->host->i_ino,
-                        dev->name, sector);
+                      start, rcu_str_deref(dev->name), sector);
        bio_put(bio);
        return 0;
@@ -3323,6 +3325,7 @@ static int extent_write_cache_pages(struct extent_io_tree *tree,
                             writepage_t writepage, void *data,
                             void (*flush_fn)(void *))
 {
+        struct inode *inode = mapping->host;
        int ret = 0;
        int done = 0;
        int nr_to_write_done = 0;
@@ -3333,6 +3336,18 @@ static int extent_write_cache_pages(struct extent_io_tree *tree,
        int scanned = 0;
        int tag;
+        /*
+         * We have to hold onto the inode so that ordered extents can do their
+         * work when the IO finishes.  The alternative to this is failing to add
+         * an ordered extent if the igrab() fails there and that is a huge pain
+         * to deal with, so instead just hold onto the inode throughout the
+         * writepages operation.  If it fails here we are freeing up the inode
+         * anyway and we'd rather not waste our time writing out stuff that is
+         * going to be truncated anyway.
+         */
+        if (!igrab(inode))
+                return 0;
        pagevec_init(&pvec, 0);
        if (wbc->range_cyclic) {
                index = mapping->writeback_index; /* Start from prev offset */
@@ -3427,6 +3442,7 @@ retry:
                index = 0;
                goto retry;
        }
+        btrfs_add_delayed_iput(inode);
        return ret;
 }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 70dc8ca73e25..9aa01ec2138d 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1334,7 +1334,6 @@ static ssize_t __btrfs_direct_write(struct kiocb *iocb,
                                    loff_t *ppos, size_t count, size_t ocount)
 {
        struct file *file = iocb->ki_filp;
-        struct inode *inode = fdentry(file)->d_inode;
        struct iov_iter i;
        ssize_t written;
        ssize_t written_buffered;
@@ -1344,18 +1343,6 @@ static ssize_t __btrfs_direct_write(struct kiocb *iocb,
        written = generic_file_direct_write(iocb, iov, &nr_segs, pos, ppos,
                                            count, ocount);
-        /*
-         * the generic O_DIRECT will update in-memory i_size after the
-         * DIOs are done.  But our endio handlers that update the on
-         * disk i_size never update past the in memory i_size.  So we
-         * need one more update here to catch any additions to the
-         * file
-         */
-        if (inode->i_size != BTRFS_I(inode)->disk_i_size) {
-                btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
-                mark_inode_dirty(inode);
-        }
        if (written < 0 || written == count)
                return written;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 81296c57405a..6c4e2baa9290 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -1543,29 +1543,26 @@ again:
        end = bitmap_info->offset + (u64)(BITS_PER_BITMAP * ctl->unit) - 1;
        /*
-         * XXX - this can go away after a few releases.
+         * We need to search for bits in this bitmap.  We could only cover some
-         *
+         * of the extent in this bitmap thanks to how we add space, so we need
-         * since the only user of btrfs_remove_free_space is the tree logging
+         * to search for as much as it as we can and clear that amount, and then
-         * stuff, and the only way to test that is under crash conditions, we
+         * go searching for the next bit.
-         * want to have this debug stuff here just in case somethings not
-         * working.  Search the bitmap for the space we are trying to use to
-         * make sure its actually there.  If its not there then we need to stop
-         * because something has gone wrong.
         */
        search_start = *offset;
-        search_bytes = *bytes;
+        search_bytes = ctl->unit;
        search_bytes = min(search_bytes, end - search_start + 1);
        ret = search_bitmap(ctl, bitmap_info, &search_start, &search_bytes);
        BUG_ON(ret < 0 || search_start != *offset);
-        if (*offset > bitmap_info->offset && *offset + *bytes > end) {
+        /* We may have found more bits than what we need */
-                bitmap_clear_bits(ctl, bitmap_info, *offset, end - *offset + 1);
+        search_bytes = min(search_bytes, *bytes);
-                *bytes -= end - *offset + 1;
-                *offset = end + 1;
+        /* Cannot clear past the end of the bitmap */
-        } else if (*offset >= bitmap_info->offset && *offset + *bytes <= end) {
+        search_bytes = min(search_bytes, end - search_start + 1);
-                bitmap_clear_bits(ctl, bitmap_info, *offset, *bytes);
-                *bytes = 0;
+        bitmap_clear_bits(ctl, bitmap_info, search_start, search_bytes);
-        }
+        *offset += search_bytes;
+        *bytes -= search_bytes;
        if (*bytes) {
                struct rb_node *next = rb_next(&bitmap_info->offset_index);
@@ -1596,7 +1593,7 @@ again:
                 * everything over again.
                 */
                search_start = *offset;
-                search_bytes = *bytes;
+                search_bytes = ctl->unit;
                ret = search_bitmap(ctl, bitmap_info, &search_start,
                                    &search_bytes);
                if (ret < 0 || search_start != *offset)
@@ -1879,12 +1876,14 @@ int btrfs_remove_free_space(struct btrfs_block_group_cache *block_group,
 {
        struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
        struct btrfs_free_space *info;
-        struct btrfs_free_space *next_info = NULL;
        int ret = 0;
        spin_lock(&ctl->tree_lock);
 again:
+        if (!bytes)
+                goto out_lock;
        info = tree_search_offset(ctl, offset, 0, 0);
        if (!info) {
                /*
@@ -1905,88 +1904,48 @@ again:
                }
        }
-        if (info->bytes < bytes && rb_next(&info->offset_index)) {
+        if (!info->bitmap) {
-                u64 end;
-                next_info = rb_entry(rb_next(&info->offset_index),
-                                             struct btrfs_free_space,
-                                             offset_index);
-                if (next_info->bitmap)
-                        end = next_info->offset +
-                              BITS_PER_BITMAP * ctl->unit - 1;
-                else
-                        end = next_info->offset + next_info->bytes;
-                if (next_info->bytes < bytes ||
-                    next_info->offset > offset || offset > end) {
-                        printk(KERN_CRIT "Found free space at %llu, size %llu,"
-                              " trying to use %llu\n",
-                              (unsigned long long)info->offset,
-                              (unsigned long long)info->bytes,
-                              (unsigned long long)bytes);
-                        WARN_ON(1);
-                        ret = -EINVAL;
-                        goto out_lock;
-                }
-                info = next_info;
-        }
-        if (info->bytes == bytes) {
                unlink_free_space(ctl, info);
-                if (info->bitmap) {
+                if (offset == info->offset) {
-                        kfree(info->bitmap);
+                        u64 to_free = min(bytes, info->bytes);
-                        ctl->total_bitmaps--;
-                }
+                        info->bytes -= to_free;
-                kmem_cache_free(btrfs_free_space_cachep, info);
+                        info->offset += to_free;
-                ret = 0;
+                        if (info->bytes) {
-                goto out_lock;
+                                ret = link_free_space(ctl, info);
-        }
+                                WARN_ON(ret);
+                        } else {
-        if (!info->bitmap && info->offset == offset) {
+                                kmem_cache_free(btrfs_free_space_cachep, info);
-                unlink_free_space(ctl, info);
+                        }
-                info->offset += bytes;
-                info->bytes -= bytes;
-                ret = link_free_space(ctl, info);
-                WARN_ON(ret);
-                goto out_lock;
-        }
-        if (!info->bitmap && info->offset <= offset &&
+                        offset += to_free;
-            info->offset + info->bytes >= offset + bytes) {
+                        bytes -= to_free;
-                u64 old_start = info->offset;
+                        goto again;
-                /*
+                } else {
-                 * we're freeing space in the middle of the info,
+                        u64 old_end = info->bytes + info->offset;
-                 * this can happen during tree log replay
-                 *
-                 * first unlink the old info and then
-                 * insert it again after the hole we're creating
-                 */
-                unlink_free_space(ctl, info);
-                if (offset + bytes < info->offset + info->bytes) {
-                        u64 old_end = info->offset + info->bytes;
-                        info->offset = offset + bytes;
+                        info->bytes = offset - info->offset;
-                        info->bytes = old_end - info->offset;
                        ret = link_free_space(ctl, info);
                        WARN_ON(ret);
                        if (ret)
                                goto out_lock;
-                } else {
-                        /* the hole we're creating ends at the end
-                         * of the info struct, just free the info
-                         */
-                        kmem_cache_free(btrfs_free_space_cachep, info);
-                }
-                spin_unlock(&ctl->tree_lock);
-                /* step two, insert a new info struct to cover
+                        /* Not enough bytes in this entry to satisfy us */
-                 * anything before the hole
+                        if (old_end < offset + bytes) {
-                 */
+                                bytes -= old_end - offset;
-                ret = btrfs_add_free_space(block_group, old_start,
+                                offset = old_end;
-                                           offset - old_start);
+                                goto again;
-                WARN_ON(ret); /* -ENOMEM */
+                        } else if (old_end == offset + bytes) {
-                goto out;
+                                /* all done */
+                                goto out_lock;
+                        }
+                        spin_unlock(&ctl->tree_lock);
+                        ret = btrfs_add_free_space(block_group, offset + bytes,
+                                                   old_end - (offset + bytes));
+                        WARN_ON(ret);
+                        goto out;
+                }
        }
        ret = remove_from_bitmap(ctl, info, &offset, &bytes);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index f6ab6f5e635a..fb8d671d00e6 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -830,7 +830,7 @@ static noinline int cow_file_range(struct inode *inode,
        if (IS_ERR(trans)) {
                extent_clear_unlock_delalloc(inode,
                             &BTRFS_I(inode)->io_tree,
-                             start, end, NULL,
+                             start, end, locked_page,
                             EXTENT_CLEAR_UNLOCK_PAGE |
                             EXTENT_CLEAR_UNLOCK |
                             EXTENT_CLEAR_DELALLOC |
@@ -963,7 +963,7 @@ out:
 out_unlock:
        extent_clear_unlock_delalloc(inode,
                     &BTRFS_I(inode)->io_tree,
-                     start, end, NULL,
+                     start, end, locked_page,
                     EXTENT_CLEAR_UNLOCK_PAGE |
                     EXTENT_CLEAR_UNLOCK |
                     EXTENT_CLEAR_DELALLOC |
@@ -986,8 +986,10 @@ static noinline void async_cow_start(struct btrfs_work *work)
        compress_file_range(async_cow->inode, async_cow->locked_page,
                            async_cow->start, async_cow->end, async_cow,
                            &num_added);
-        if (num_added == 0)
+        if (num_added == 0) {
+                btrfs_add_delayed_iput(async_cow->inode);
                async_cow->inode = NULL;
+        }
 }
 /*
@@ -1020,6 +1022,8 @@ static noinline void async_cow_free(struct btrfs_work *work)
 {
        struct async_cow *async_cow;
        async_cow = container_of(work, struct async_cow, work);
+        if (async_cow->inode)
+                btrfs_add_delayed_iput(async_cow->inode);
        kfree(async_cow);
 }
@@ -1038,7 +1042,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
        while (start < end) {
                async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
                BUG_ON(!async_cow); /* -ENOMEM */
-                async_cow->inode = inode;
+                async_cow->inode = igrab(inode);
                async_cow->root = root;
                async_cow->locked_page = locked_page;
                async_cow->start = start;
@@ -1136,8 +1140,18 @@ static noinline int run_delalloc_nocow(struct inode *inode,
        u64 ino = btrfs_ino(inode);
        path = btrfs_alloc_path();
-        if (!path)
+        if (!path) {
+                extent_clear_unlock_delalloc(inode,
+                             &BTRFS_I(inode)->io_tree,
+                             start, end, locked_page,
+                             EXTENT_CLEAR_UNLOCK_PAGE |
+                             EXTENT_CLEAR_UNLOCK |
+                             EXTENT_CLEAR_DELALLOC |
+                             EXTENT_CLEAR_DIRTY |
+                             EXTENT_SET_WRITEBACK |
+                             EXTENT_END_WRITEBACK);
                return -ENOMEM;
+        }
        nolock = btrfs_is_free_space_inode(root, inode);
@@ -1147,6 +1161,15 @@ static noinline int run_delalloc_nocow(struct inode *inode,
                trans = btrfs_join_transaction(root);
        if (IS_ERR(trans)) {
+                extent_clear_unlock_delalloc(inode,
+                             &BTRFS_I(inode)->io_tree,
+                             start, end, locked_page,
+                             EXTENT_CLEAR_UNLOCK_PAGE |
+                             EXTENT_CLEAR_UNLOCK |
+                             EXTENT_CLEAR_DELALLOC |
+                             EXTENT_CLEAR_DIRTY |
+                             EXTENT_SET_WRITEBACK |
+                             EXTENT_END_WRITEBACK);
                btrfs_free_path(path);
                return PTR_ERR(trans);
        }
@@ -1327,8 +1350,11 @@ out_check:
        }
        btrfs_release_path(path);
-        if (cur_offset <= end && cow_start == (u64)-1)
+        if (cur_offset <= end && cow_start == (u64)-1) {
                cow_start = cur_offset;
+                cur_offset = end;
+        }
        if (cow_start != (u64)-1) {
                ret = cow_file_range(inode, locked_page, cow_start, end,
                                     page_started, nr_written, 1);
@@ -1347,6 +1373,17 @@ error:
        if (!ret)
                ret = err;
+        if (ret && cur_offset < end)
+                extent_clear_unlock_delalloc(inode,
+                             &BTRFS_I(inode)->io_tree,
+                             cur_offset, end, locked_page,
+                             EXTENT_CLEAR_UNLOCK_PAGE |
+                             EXTENT_CLEAR_UNLOCK |
+                             EXTENT_CLEAR_DELALLOC |
+                             EXTENT_CLEAR_DIRTY |
+                             EXTENT_SET_WRITEBACK |
+                             EXTENT_END_WRITEBACK);
        btrfs_free_path(path);
        return ret;
 }
@@ -1361,20 +1398,23 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
        int ret;
        struct btrfs_root *root = BTRFS_I(inode)->root;
-        if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)
+        if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
                ret = run_delalloc_nocow(inode, locked_page, start, end,
                                         page_started, 1, nr_written);
-        else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)
+        } else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
                ret = run_delalloc_nocow(inode, locked_page, start, end,
                                         page_started, 0, nr_written);
-        else if (!btrfs_test_opt(root, COMPRESS) &&
+        } else if (!btrfs_test_opt(root, COMPRESS) &&
-                 !(BTRFS_I(inode)->force_compress) &&
+                   !(BTRFS_I(inode)->force_compress) &&
-                 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
+                   !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
                ret = cow_file_range(inode, locked_page, start, end,
                                      page_started, nr_written, 1);
-        else
+        } else {
+                set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
+                        &BTRFS_I(inode)->runtime_flags);
                ret = cow_file_range_async(inode, locked_page, start, end,
                                           page_started, nr_written);
+        }
        return ret;
 }
@@ -3714,7 +3754,7 @@ void btrfs_evict_inode(struct inode *inode)
        btrfs_wait_ordered_range(inode, 0, (u64)-1);
        if (root->fs_info->log_root_recovering) {
-                BUG_ON(!test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
                                 &BTRFS_I(inode)->runtime_flags));
                goto no_delete;
        }
@@ -4207,7 +4247,7 @@ static void btrfs_dentry_release(struct dentry *dentry)
 }
 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        struct dentry *ret;
@@ -4853,7 +4893,7 @@ out_unlock:
 }
 static int btrfs_create(struct inode *dir, struct dentry *dentry,
-                        umode_t mode, struct nameidata *nd)
+                        umode_t mode, bool excl)
 {
        struct btrfs_trans_handle *trans;
        struct btrfs_root *root = BTRFS_I(dir)->root;
@@ -5836,8 +5876,17 @@ map:
        bh_result->b_size = len;
        bh_result->b_bdev = em->bdev;
        set_buffer_mapped(bh_result);
-        if (create && !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
+        if (create) {
-                set_buffer_new(bh_result);
+                if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
+                        set_buffer_new(bh_result);
+                /*
+                 * Need to update the i_size under the extent lock so buffered
+                 * readers will get the updated i_size when we unlock.
+                 */
+                if (start + len > i_size_read(inode))
+                        i_size_write(inode, start + len);
+        }
        free_extent_map(em);
@@ -6320,12 +6369,48 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
                 */
                ordered = btrfs_lookup_ordered_range(inode, lockstart,
                                                     lockend - lockstart + 1);
-                if (!ordered)
+                /*
+                 * We need to make sure there are no buffered pages in this
+                 * range either, we could have raced between the invalidate in
+                 * generic_file_direct_write and locking the extent.  The
+                 * invalidate needs to happen so that reads after a write do not
+                 * get stale data.
+                 */
+                if (!ordered && (!writing ||
+                    !test_range_bit(&BTRFS_I(inode)->io_tree,
+                                    lockstart, lockend, EXTENT_UPTODATE, 0,
+                                    cached_state)))
                        break;
                unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
                                     &cached_state, GFP_NOFS);
-                btrfs_start_ordered_extent(inode, ordered, 1);
-                btrfs_put_ordered_extent(ordered);
+                if (ordered) {
+                        btrfs_start_ordered_extent(inode, ordered, 1);
+                        btrfs_put_ordered_extent(ordered);
+                } else {
+                        /* Screw you mmap */
+                        ret = filemap_write_and_wait_range(file->f_mapping,
+                                                           lockstart,
+                                                           lockend);
+                        if (ret)
+                                goto out;
+                        /*
+                         * If we found a page that couldn't be invalidated just
+                         * fall back to buffered.
+                         */
+                        ret = invalidate_inode_pages2_range(file->f_mapping,
+                                        lockstart >> PAGE_CACHE_SHIFT,
+                                        lockend >> PAGE_CACHE_SHIFT);
+                        if (ret) {
+                                if (ret == -EBUSY)
+                                        ret = 0;
+                                goto out;
+                        }
+                }
                cond_resched();
        }
@@ -6902,7 +6987,7 @@ void btrfs_destroy_inode(struct inode *inode)
        struct btrfs_ordered_extent *ordered;
        struct btrfs_root *root = BTRFS_I(inode)->root;
-        WARN_ON(!list_empty(&inode->i_dentry));
+        WARN_ON(!hlist_empty(&inode->i_dentry));
        WARN_ON(inode->i_data.nrpages);
        WARN_ON(BTRFS_I(inode)->outstanding_extents);
        WARN_ON(BTRFS_I(inode)->reserved_extents);
@@ -7054,10 +7139,13 @@ static void fixup_inode_flags(struct inode *dir, struct inode *inode)
        else
                b_inode->flags &= ~BTRFS_INODE_NODATACOW;
-        if (b_dir->flags & BTRFS_INODE_COMPRESS)
+        if (b_dir->flags & BTRFS_INODE_COMPRESS) {
                b_inode->flags |= BTRFS_INODE_COMPRESS;
-        else
+                b_inode->flags &= ~BTRFS_INODE_NOCOMPRESS;
-                b_inode->flags &= ~BTRFS_INODE_COMPRESS;
+        } else {
+                b_inode->flags &= ~(BTRFS_INODE_COMPRESS |
+                                    BTRFS_INODE_NOCOMPRESS);
+        }
 }
 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 24b776c08d99..1e9f6c019ad0 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -52,6 +52,7 @@
 #include "locking.h"
 #include "inode-map.h"
 #include "backref.h"
+#include "rcu-string.h"
 /* Mask out flags that are inappropriate for the given type of inode. */
 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
@@ -785,39 +786,57 @@ none:
        return -ENOENT;
 }
-/*
+static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start)
- * Validaty check of prev em and next em:
- * 1) no prev/next em
- * 2) prev/next em is an hole/inline extent
- */
-static int check_adjacent_extents(struct inode *inode, struct extent_map *em)
 {
        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
-        struct extent_map *prev = NULL, *next = NULL;
+        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
-        int ret = 0;
+        struct extent_map *em;
+        u64 len = PAGE_CACHE_SIZE;
+        /*
+         * hopefully we have this extent in the tree already, try without
+         * the full extent lock
+         */
        read_lock(&em_tree->lock);
-        prev = lookup_extent_mapping(em_tree, em->start - 1, (u64)-1);
+        em = lookup_extent_mapping(em_tree, start, len);
-        next = lookup_extent_mapping(em_tree, em->start + em->len, (u64)-1);
        read_unlock(&em_tree->lock);
-        if ((!prev || prev->block_start >= EXTENT_MAP_LAST_BYTE) &&
+        if (!em) {
-            (!next || next->block_start >= EXTENT_MAP_LAST_BYTE))
+                /* get the big lock and read metadata off disk */
-                ret = 1;
+                lock_extent(io_tree, start, start + len - 1);
-        free_extent_map(prev);
+                em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
-        free_extent_map(next);
+                unlock_extent(io_tree, start, start + len - 1);
+                if (IS_ERR(em))
+                        return NULL;
+        }
+        return em;
+}
+static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em)
+{
+        struct extent_map *next;
+        bool ret = true;
+        /* this is the last extent */
+        if (em->start + em->len >= i_size_read(inode))
+                return false;
+        next = defrag_lookup_extent(inode, em->start + em->len);
+        if (!next || next->block_start >= EXTENT_MAP_LAST_BYTE)
+                ret = false;
+        free_extent_map(next);
        return ret;
 }
-static int should_defrag_range(struct inode *inode, u64 start, u64 len,
+static int should_defrag_range(struct inode *inode, u64 start, int thresh,
-                               int thresh, u64 *last_len, u64 *skip,
+                               u64 *last_len, u64 *skip, u64 *defrag_end)
-                               u64 *defrag_end)
 {
-        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
+        struct extent_map *em;
-        struct extent_map *em = NULL;
-        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
        int ret = 1;
+        bool next_mergeable = true;
        /*
         * make sure that once we start defragging an extent, we keep on
@@ -828,23 +847,9 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
        *skip = 0;
-        /*
+        em = defrag_lookup_extent(inode, start);
-         * hopefully we have this extent in the tree already, try without
+        if (!em)
-         * the full extent lock
+                return 0;
-         */
-        read_lock(&em_tree->lock);
-        em = lookup_extent_mapping(em_tree, start, len);
-        read_unlock(&em_tree->lock);
-        if (!em) {
-                /* get the big lock and read metadata off disk */
-                lock_extent(io_tree, start, start + len - 1);
-                em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
-                unlock_extent(io_tree, start, start + len - 1);
-                if (IS_ERR(em))
-                        return 0;
-        }
        /* this will cover holes, and inline extents */
        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
@@ -852,18 +857,15 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
                goto out;
        }
-        /* If we have nothing to merge with us, just skip. */
+        next_mergeable = defrag_check_next_extent(inode, em);
-        if (check_adjacent_extents(inode, em)) {
-                ret = 0;
-                goto out;
-        }
        /*
-         * we hit a real extent, if it is big don't bother defragging it again
+         * we hit a real extent, if it is big or the next extent is not a
+         * real extent, don't bother defragging it
         */
-        if ((*last_len == 0 || *last_len >= thresh) && em->len >= thresh)
+        if ((*last_len == 0 || *last_len >= thresh) &&
+            (em->len >= thresh || !next_mergeable))
                ret = 0;
 out:
        /*
         * last_len ends up being a counter of how many bytes we've defragged.
@@ -1142,8 +1144,8 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                        break;
                if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
-                                         PAGE_CACHE_SIZE, extent_thresh,
+                                         extent_thresh, &last_len, &skip,
-                                         &last_len, &skip, &defrag_end)) {
+                                         &defrag_end)) {
                        unsigned long next;
                        /*
                         * the should_defrag function tells us how much to skip
@@ -1304,6 +1306,14 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
                ret = -EINVAL;
                goto out_free;
        }
+        if (device->fs_devices && device->fs_devices->seeding) {
+                printk(KERN_INFO "btrfs: resizer unable to apply on "
+                       "seeding device %llu\n",
+                       (unsigned long long)devid);
+                ret = -EINVAL;
+                goto out_free;
+        }
        if (!strcmp(sizestr, "max"))
                new_size = device->bdev->bd_inode->i_size;
        else {
@@ -1345,8 +1355,9 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
        do_div(new_size, root->sectorsize);
        new_size *= root->sectorsize;
-        printk(KERN_INFO "btrfs: new size for %s is %llu\n",
+        printk_in_rcu(KERN_INFO "btrfs: new size for %s is %llu\n",
-                device->name, (unsigned long long)new_size);
+                      rcu_str_deref(device->name),
+                      (unsigned long long)new_size);
        if (new_size > old_size) {
                trans = btrfs_start_transaction(root, 0);
@@ -2264,7 +2275,12 @@ static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
        di_args->total_bytes = dev->total_bytes;
        memcpy(di_args->uuid, dev->uuid, sizeof(di_args->uuid));
        if (dev->name) {
-                strncpy(di_args->path, dev->name, sizeof(di_args->path));
+                struct rcu_string *name;
+                rcu_read_lock();
+                name = rcu_dereference(dev->name);
+                strncpy(di_args->path, name->str, sizeof(di_args->path));
+                rcu_read_unlock();
                di_args->path[sizeof(di_args->path) - 1] = 0;
        } else {
                di_args->path[0] = '\0';
@@ -3252,7 +3268,7 @@ static long btrfs_ioctl_balance(struct file *file, void __user *arg)
        if (fs_info->sb->s_flags & MS_RDONLY)
                return -EROFS;
-        ret = mnt_want_write(file->f_path.mnt);
+        ret = mnt_want_write_file(file);
        if (ret)
                return ret;
@@ -3322,7 +3338,7 @@ out_bargs:
 out:
        mutex_unlock(&fs_info->balance_mutex);
        mutex_unlock(&fs_info->volume_mutex);
-        mnt_drop_write(file->f_path.mnt);
+        mnt_drop_write_file(file);
        return ret;
 }
diff --git a/fs/btrfs/ioctl.h b/fs/btrfs/ioctl.h
index 497c530724cf..e440aa653c30 100644
--- a/fs/btrfs/ioctl.h
+++ b/fs/btrfs/ioctl.h
@@ -339,7 +339,7 @@ struct btrfs_ioctl_get_dev_stats {
 #define BTRFS_IOC_WAIT_SYNC  _IOW(BTRFS_IOCTL_MAGIC, 22, __u64)
 #define BTRFS_IOC_SNAP_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 23, \
                                   struct btrfs_ioctl_vol_args_v2)
-#define BTRFS_IOC_SUBVOL_GETFLAGS _IOW(BTRFS_IOCTL_MAGIC, 25, __u64)
+#define BTRFS_IOC_SUBVOL_GETFLAGS _IOR(BTRFS_IOCTL_MAGIC, 25, __u64)
 #define BTRFS_IOC_SUBVOL_SETFLAGS _IOW(BTRFS_IOCTL_MAGIC, 26, __u64)
 #define BTRFS_IOC_SCRUB _IOWR(BTRFS_IOCTL_MAGIC, 27, \
                              struct btrfs_ioctl_scrub_args)
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 9e138cdc36c5..643335a4fe3c 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -627,7 +627,27 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
        /* start IO across the range first to instantiate any delalloc
         * extents
         */
-        filemap_write_and_wait_range(inode->i_mapping, start, orig_end);
+        filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
+        /*
+         * So with compression we will find and lock a dirty page and clear the
+         * first one as dirty, setup an async extent, and immediately return
+         * with the entire range locked but with nobody actually marked with
+         * writeback.  So we can't just filemap_write_and_wait_range() and
+         * expect it to work since it will just kick off a thread to do the
+         * actual work.  So we need to call filemap_fdatawrite_range _again_
+         * since it will wait on the page lock, which won't be unlocked until
+         * after the pages have been marked as writeback and so we're good to go
+         * from there.  We have to do this otherwise we'll miss the ordered
+         * extents and that results in badness.  Please Josef, do not think you
+         * know better and pull this out at some point in the future, it is
+         * right and you are wrong.
+         */
+        if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
+                     &BTRFS_I(inode)->runtime_flags))
+                filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
+        filemap_fdatawait_range(inode->i_mapping, start, orig_end);
        end = orig_end;
        found = 0;
diff --git a/fs/btrfs/rcu-string.h b/fs/btrfs/rcu-string.h
new file mode 100644
index 000000000000..9e111e4576d4
--- /dev/null
+++ b/fs/btrfs/rcu-string.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2012 Red Hat.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+struct rcu_string {
+        struct rcu_head rcu;
+        char str[0];
+};
+static inline struct rcu_string *rcu_string_strdup(const char *src, gfp_t mask)
+{
+        size_t len = strlen(src) + 1;
+        struct rcu_string *ret = kzalloc(sizeof(struct rcu_string) +
+                                         (len * sizeof(char)), mask);
+        if (!ret)
+                return ret;
+        strncpy(ret->str, src, len);
+        return ret;
+}
+static inline void rcu_string_free(struct rcu_string *str)
+{
+        if (str)
+                kfree_rcu(str, rcu);
+}
+#define printk_in_rcu(fmt, ...) do {    \
+        rcu_read_lock();                \
+        printk(fmt, __VA_ARGS__);       \
+        rcu_read_unlock();              \
+} while (0)
+#define printk_ratelimited_in_rcu(fmt, ...) do {        \
+        rcu_read_lock();                                \
+        printk_ratelimited(fmt, __VA_ARGS__);           \
+        rcu_read_unlock();                              \
+} while (0)
+#define rcu_str_deref(rcu_str) ({                               \
+        struct rcu_string *__str = rcu_dereference(rcu_str);    \
+        __str->str;                                             \
+})
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index a38cfa4f251e..b223620cd5a6 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -26,6 +26,7 @@
 #include "backref.h"
 #include "extent_io.h"
 #include "check-integrity.h"
+#include "rcu-string.h"
 /*
 * This is only the first step towards a full-features scrub. It reads all
@@ -320,10 +321,10 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, void *ctx)
         * hold all of the paths here
         */
        for (i = 0; i < ipath->fspath->elem_cnt; ++i)
-                printk(KERN_WARNING "btrfs: %s at logical %llu on dev "
+                printk_in_rcu(KERN_WARNING "btrfs: %s at logical %llu on dev "
                        "%s, sector %llu, root %llu, inode %llu, offset %llu, "
                        "length %llu, links %u (path: %s)\n", swarn->errstr,
-                        swarn->logical, swarn->dev->name,
+                        swarn->logical, rcu_str_deref(swarn->dev->name),
                        (unsigned long long)swarn->sector, root, inum, offset,
                        min(isize - offset, (u64)PAGE_SIZE), nlink,
                        (char *)(unsigned long)ipath->fspath->val[i]);
@@ -332,10 +333,10 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, void *ctx)
        return 0;
 err:
-        printk(KERN_WARNING "btrfs: %s at logical %llu on dev "
+        printk_in_rcu(KERN_WARNING "btrfs: %s at logical %llu on dev "
                "%s, sector %llu, root %llu, inode %llu, offset %llu: path "
                "resolving failed with ret=%d\n", swarn->errstr,
-                swarn->logical, swarn->dev->name,
+                swarn->logical, rcu_str_deref(swarn->dev->name),
                (unsigned long long)swarn->sector, root, inum, offset, ret);
        free_ipath(ipath);
@@ -390,10 +391,11 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
                do {
                        ret = tree_backref_for_extent(&ptr, eb, ei, item_size,
                                                        &ref_root, &ref_level);
-                        printk(KERN_WARNING
+                        printk_in_rcu(KERN_WARNING
                                "btrfs: %s at logical %llu on dev %s, "
                                "sector %llu: metadata %s (level %d) in tree "
-                                "%llu\n", errstr, swarn.logical, dev->name,
+                                "%llu\n", errstr, swarn.logical,
+                                rcu_str_deref(dev->name),
                                (unsigned long long)swarn.sector,
                                ref_level ? "node" : "leaf",
                                ret < 0 ? -1 : ref_level,
@@ -580,9 +582,11 @@ out:
                spin_lock(&sdev->stat_lock);
                ++sdev->stat.uncorrectable_errors;
                spin_unlock(&sdev->stat_lock);
-                printk_ratelimited(KERN_ERR
+                printk_ratelimited_in_rcu(KERN_ERR
                        "btrfs: unable to fixup (nodatasum) error at logical %llu on dev %s\n",
-                        (unsigned long long)fixup->logical, sdev->dev->name);
+                        (unsigned long long)fixup->logical,
+                        rcu_str_deref(sdev->dev->name));
        }
        btrfs_free_path(path);
@@ -936,18 +940,20 @@ corrected_error:
                        spin_lock(&sdev->stat_lock);
                        sdev->stat.corrected_errors++;
                        spin_unlock(&sdev->stat_lock);
-                        printk_ratelimited(KERN_ERR
+                        printk_ratelimited_in_rcu(KERN_ERR
                                "btrfs: fixed up error at logical %llu on dev %s\n",
-                                (unsigned long long)logical, sdev->dev->name);
+                                (unsigned long long)logical,
+                                rcu_str_deref(sdev->dev->name));
                }
        } else {
 did_not_correct_error:
                spin_lock(&sdev->stat_lock);
                sdev->stat.uncorrectable_errors++;
                spin_unlock(&sdev->stat_lock);
-                printk_ratelimited(KERN_ERR
+                printk_ratelimited_in_rcu(KERN_ERR
                        "btrfs: unable to fixup (regular) error at logical %llu on dev %s\n",
-                        (unsigned long long)logical, sdev->dev->name);
+                        (unsigned long long)logical,
+                        rcu_str_deref(sdev->dev->name));
        }
 out:
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 96eb9fef7bd2..b19d75567728 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -54,6 +54,7 @@
 #include "version.h"
 #include "export.h"
 #include "compression.h"
+#include "rcu-string.h"
 #define CREATE_TRACE_POINTS
 #include <trace/events/btrfs.h>
@@ -1067,7 +1068,8 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
        }
        bdev = fs_devices->latest_bdev;
-        s = sget(fs_type, btrfs_test_super, btrfs_set_super, fs_info);
+        s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
+                 fs_info);
        if (IS_ERR(s)) {
                error = PTR_ERR(s);
                goto error_close_devices;
@@ -1081,7 +1083,6 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
        } else {
                char b[BDEVNAME_SIZE];
-                s->s_flags = flags | MS_NOSEC;
                strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                btrfs_sb(s)->bdev_holder = fs_type;
                error = btrfs_fill_super(s, fs_devices, data,
@@ -1186,6 +1187,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                if (ret)
                        goto restore;
+                ret = btrfs_resume_balance_async(fs_info);
+                if (ret)
+                        goto restore;
                sb->s_flags &= ~MS_RDONLY;
        }
@@ -1482,12 +1487,44 @@ static void btrfs_fs_dirty_inode(struct inode *inode, int flags)
                                   "error %d\n", btrfs_ino(inode), ret);
 }
+static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
+{
+        struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
+        struct btrfs_fs_devices *cur_devices;
+        struct btrfs_device *dev, *first_dev = NULL;
+        struct list_head *head;
+        struct rcu_string *name;
+        mutex_lock(&fs_info->fs_devices->device_list_mutex);
+        cur_devices = fs_info->fs_devices;
+        while (cur_devices) {
+                head = &cur_devices->devices;
+                list_for_each_entry(dev, head, dev_list) {
+                        if (!first_dev || dev->devid < first_dev->devid)
+                                first_dev = dev;
+                }
+                cur_devices = cur_devices->seed;
+        }
+        if (first_dev) {
+                rcu_read_lock();
+                name = rcu_dereference(first_dev->name);
+                seq_escape(m, name->str, " \t\n\\");
+                rcu_read_unlock();
+        } else {
+                WARN_ON(1);
+        }
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+        return 0;
+}
 static const struct super_operations btrfs_super_ops = {
        .drop_inode     = btrfs_drop_inode,
        .evict_inode    = btrfs_evict_inode,
        .put_super      = btrfs_put_super,
        .sync_fs        = btrfs_sync_fs,
        .show_options   = btrfs_show_options,
+        .show_devname   = btrfs_show_devname,
        .write_inode    = btrfs_write_inode,
        .dirty_inode    = btrfs_fs_dirty_inode,
        .alloc_inode    = btrfs_alloc_inode,
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 1791c6e3d834..b72b068183ec 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -100,6 +100,10 @@ loop:
                kmem_cache_free(btrfs_transaction_cachep, cur_trans);
                cur_trans = fs_info->running_transaction;
                goto loop;
+        } else if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
+                spin_unlock(&root->fs_info->trans_lock);
+                kmem_cache_free(btrfs_transaction_cachep, cur_trans);
+                return -EROFS;
        }
        atomic_set(&cur_trans->num_writers, 1);
@@ -1213,14 +1217,20 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
 static void cleanup_transaction(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root)
+                                struct btrfs_root *root, int err)
 {
        struct btrfs_transaction *cur_trans = trans->transaction;
        WARN_ON(trans->use_count > 1);
+        btrfs_abort_transaction(trans, root, err);
        spin_lock(&root->fs_info->trans_lock);
        list_del_init(&cur_trans->list);
+        if (cur_trans == root->fs_info->running_transaction) {
+                root->fs_info->running_transaction = NULL;
+                root->fs_info->trans_no_join = 0;
+        }
        spin_unlock(&root->fs_info->trans_lock);
        btrfs_cleanup_one_transaction(trans->transaction, root);
@@ -1526,7 +1536,7 @@ cleanup_transaction:
 //      WARN_ON(1);
        if (current->journal_info == trans)
                current->journal_info = NULL;
-        cleanup_transaction(trans, root);
+        cleanup_transaction(trans, root, ret);
        return ret;
 }
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 2017d0ff511c..8abeae4224f9 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -690,6 +690,8 @@ static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
        kfree(name);
        iput(inode);
+        btrfs_run_delayed_items(trans, root);
        return ret;
 }
@@ -895,6 +897,7 @@ again:
                                ret = btrfs_unlink_inode(trans, root, dir,
                                                         inode, victim_name,
                                                         victim_name_len);
+                                btrfs_run_delayed_items(trans, root);
                        }
                        kfree(victim_name);
                        ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
@@ -1475,6 +1478,9 @@ again:
                        ret = btrfs_unlink_inode(trans, root, dir, inode,
                                                 name, name_len);
                        BUG_ON(ret);
+                        btrfs_run_delayed_items(trans, root);
                        kfree(name);
                        iput(inode);
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 7782020996fe..ecaad40e7ef4 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -35,6 +35,7 @@
 #include "volumes.h"
 #include "async-thread.h"
 #include "check-integrity.h"
+#include "rcu-string.h"
 static int init_first_rw_device(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root,
@@ -64,7 +65,7 @@ static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
                device = list_entry(fs_devices->devices.next,
                                    struct btrfs_device, dev_list);
                list_del(&device->dev_list);
-                kfree(device->name);
+                rcu_string_free(device->name);
                kfree(device);
        }
        kfree(fs_devices);
@@ -334,8 +335,8 @@ static noinline int device_list_add(const char *path,
 {
        struct btrfs_device *device;
        struct btrfs_fs_devices *fs_devices;
+        struct rcu_string *name;
        u64 found_transid = btrfs_super_generation(disk_super);
-        char *name;
        fs_devices = find_fsid(disk_super->fsid);
        if (!fs_devices) {
@@ -369,11 +370,13 @@ static noinline int device_list_add(const char *path,
                memcpy(device->uuid, disk_super->dev_item.uuid,
                       BTRFS_UUID_SIZE);
                spin_lock_init(&device->io_lock);
-                device->name = kstrdup(path, GFP_NOFS);
-                if (!device->name) {
+                name = rcu_string_strdup(path, GFP_NOFS);
+                if (!name) {
                        kfree(device);
                        return -ENOMEM;
                }
+                rcu_assign_pointer(device->name, name);
                INIT_LIST_HEAD(&device->dev_alloc_list);
                /* init readahead state */
@@ -390,12 +393,12 @@ static noinline int device_list_add(const char *path,
                device->fs_devices = fs_devices;
                fs_devices->num_devices++;
-        } else if (!device->name || strcmp(device->name, path)) {
+        } else if (!device->name || strcmp(device->name->str, path)) {
-                name = kstrdup(path, GFP_NOFS);
+                name = rcu_string_strdup(path, GFP_NOFS);
                if (!name)
                        return -ENOMEM;
-                kfree(device->name);
+                rcu_string_free(device->name);
-                device->name = name;
+                rcu_assign_pointer(device->name, name);
                if (device->missing) {
                        fs_devices->missing_devices--;
                        device->missing = 0;
@@ -430,15 +433,22 @@ static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
        /* We have held the volume lock, it is safe to get the devices. */
        list_for_each_entry(orig_dev, &orig->devices, dev_list) {
+                struct rcu_string *name;
                device = kzalloc(sizeof(*device), GFP_NOFS);
                if (!device)
                        goto error;
-                device->name = kstrdup(orig_dev->name, GFP_NOFS);
+                /*
-                if (!device->name) {
+                 * This is ok to do without rcu read locked because we hold the
+                 * uuid mutex so nothing we touch in here is going to disappear.
+                 */
+                name = rcu_string_strdup(orig_dev->name->str, GFP_NOFS);
+                if (!name) {
                        kfree(device);
                        goto error;
                }
+                rcu_assign_pointer(device->name, name);
                device->devid = orig_dev->devid;
                device->work.func = pending_bios_fn;
@@ -491,7 +501,7 @@ again:
                }
                list_del_init(&device->dev_list);
                fs_devices->num_devices--;
-                kfree(device->name);
+                rcu_string_free(device->name);
                kfree(device);
        }
@@ -516,7 +526,7 @@ static void __free_device(struct work_struct *work)
        if (device->bdev)
                blkdev_put(device->bdev, device->mode);
-        kfree(device->name);
+        rcu_string_free(device->name);
        kfree(device);
 }
@@ -540,6 +550,7 @@ static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
        mutex_lock(&fs_devices->device_list_mutex);
        list_for_each_entry(device, &fs_devices->devices, dev_list) {
                struct btrfs_device *new_device;
+                struct rcu_string *name;
                if (device->bdev)
                        fs_devices->open_devices--;
@@ -555,8 +566,11 @@ static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
                new_device = kmalloc(sizeof(*new_device), GFP_NOFS);
                BUG_ON(!new_device); /* -ENOMEM */
                memcpy(new_device, device, sizeof(*new_device));
-                new_device->name = kstrdup(device->name, GFP_NOFS);
-                BUG_ON(device->name && !new_device->name); /* -ENOMEM */
+                /* Safe because we are under uuid_mutex */
+                name = rcu_string_strdup(device->name->str, GFP_NOFS);
+                BUG_ON(device->name && !name); /* -ENOMEM */
+                rcu_assign_pointer(new_device->name, name);
                new_device->bdev = NULL;
                new_device->writeable = 0;
                new_device->in_fs_metadata = 0;
@@ -621,9 +635,9 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
                if (!device->name)
                        continue;
-                bdev = blkdev_get_by_path(device->name, flags, holder);
+                bdev = blkdev_get_by_path(device->name->str, flags, holder);
                if (IS_ERR(bdev)) {
-                        printk(KERN_INFO "open %s failed\n", device->name);
+                        printk(KERN_INFO "open %s failed\n", device->name->str);
                        goto error;
                }
                filemap_write_and_wait(bdev->bd_inode->i_mapping);
@@ -1632,6 +1646,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
        struct block_device *bdev;
        struct list_head *devices;
        struct super_block *sb = root->fs_info->sb;
+        struct rcu_string *name;
        u64 total_bytes;
        int seeding_dev = 0;
        int ret = 0;
@@ -1671,23 +1686,24 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
                goto error;
        }
-        device->name = kstrdup(device_path, GFP_NOFS);
+        name = rcu_string_strdup(device_path, GFP_NOFS);
-        if (!device->name) {
+        if (!name) {
                kfree(device);
                ret = -ENOMEM;
                goto error;
        }
+        rcu_assign_pointer(device->name, name);
        ret = find_next_devid(root, &device->devid);
        if (ret) {
-                kfree(device->name);
+                rcu_string_free(device->name);
                kfree(device);
                goto error;
        }
        trans = btrfs_start_transaction(root, 0);
        if (IS_ERR(trans)) {
-                kfree(device->name);
+                rcu_string_free(device->name);
                kfree(device);
                ret = PTR_ERR(trans);
                goto error;
@@ -1796,7 +1812,7 @@ error_trans:
        unlock_chunks(root);
        btrfs_abort_transaction(trans, root, ret);
        btrfs_end_transaction(trans, root);
-        kfree(device->name);
+        rcu_string_free(device->name);
        kfree(device);
 error:
        blkdev_put(bdev, FMODE_EXCL);
@@ -2829,31 +2845,48 @@ out:
 static int balance_kthread(void *data)
 {
-        struct btrfs_balance_control *bctl =
+        struct btrfs_fs_info *fs_info = data;
-                        (struct btrfs_balance_control *)data;
-        struct btrfs_fs_info *fs_info = bctl->fs_info;
        int ret = 0;
        mutex_lock(&fs_info->volume_mutex);
        mutex_lock(&fs_info->balance_mutex);
-        set_balance_control(bctl);
+        if (fs_info->balance_ctl) {
-        if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
-                printk(KERN_INFO "btrfs: force skipping balance\n");
-        } else {
                printk(KERN_INFO "btrfs: continuing balance\n");
-                ret = btrfs_balance(bctl, NULL);
+                ret = btrfs_balance(fs_info->balance_ctl, NULL);
        }
        mutex_unlock(&fs_info->balance_mutex);
        mutex_unlock(&fs_info->volume_mutex);
        return ret;
 }
-int btrfs_recover_balance(struct btrfs_root *tree_root)
+int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
 {
        struct task_struct *tsk;
+        spin_lock(&fs_info->balance_lock);
+        if (!fs_info->balance_ctl) {
+                spin_unlock(&fs_info->balance_lock);
+                return 0;
+        }
+        spin_unlock(&fs_info->balance_lock);
+        if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
+                printk(KERN_INFO "btrfs: force skipping balance\n");
+                return 0;
+        }
+        tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
+        if (IS_ERR(tsk))
+                return PTR_ERR(tsk);
+        return 0;
+}
+int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
+{
        struct btrfs_balance_control *bctl;
        struct btrfs_balance_item *item;
        struct btrfs_disk_balance_args disk_bargs;
@@ -2866,29 +2899,30 @@ int btrfs_recover_balance(struct btrfs_root *tree_root)
        if (!path)
                return -ENOMEM;
-        bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
-        if (!bctl) {
-                ret = -ENOMEM;
-                goto out;
-        }
        key.objectid = BTRFS_BALANCE_OBJECTID;
        key.type = BTRFS_BALANCE_ITEM_KEY;
        key.offset = 0;
-        ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
+        ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
        if (ret < 0)
-                goto out_bctl;
+                goto out;
        if (ret > 0) { /* ret = -ENOENT; */
                ret = 0;
-                goto out_bctl;
+                goto out;
+        }
+        bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
+        if (!bctl) {
+                ret = -ENOMEM;
+                goto out;
        }
        leaf = path->nodes[0];
        item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
-        bctl->fs_info = tree_root->fs_info;
+        bctl->fs_info = fs_info;
-        bctl->flags = btrfs_balance_flags(leaf, item) | BTRFS_BALANCE_RESUME;
+        bctl->flags = btrfs_balance_flags(leaf, item);
+        bctl->flags |= BTRFS_BALANCE_RESUME;
        btrfs_balance_data(leaf, item, &disk_bargs);
        btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
@@ -2897,14 +2931,13 @@ int btrfs_recover_balance(struct btrfs_root *tree_root)
        btrfs_balance_sys(leaf, item, &disk_bargs);
        btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);
-        tsk = kthread_run(balance_kthread, bctl, "btrfs-balance");
+        mutex_lock(&fs_info->volume_mutex);
-        if (IS_ERR(tsk))
+        mutex_lock(&fs_info->balance_mutex);
-                ret = PTR_ERR(tsk);
-        else
-                goto out;
-out_bctl:
+        set_balance_control(bctl);
-        kfree(bctl);
+        mutex_unlock(&fs_info->balance_mutex);
+        mutex_unlock(&fs_info->volume_mutex);
 out:
        btrfs_free_path(path);
        return ret;
@@ -4045,16 +4078,18 @@ static void btrfs_end_bio(struct bio *bio, int err)
                        BUG_ON(stripe_index >= bbio->num_stripes);
                        dev = bbio->stripes[stripe_index].dev;
-                        if (bio->bi_rw & WRITE)
+                        if (dev->bdev) {
-                                btrfs_dev_stat_inc(dev,
+                                if (bio->bi_rw & WRITE)
-                                                   BTRFS_DEV_STAT_WRITE_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        else
+                                                BTRFS_DEV_STAT_WRITE_ERRS);
-                                btrfs_dev_stat_inc(dev,
+                                else
-                                                   BTRFS_DEV_STAT_READ_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
+                                                BTRFS_DEV_STAT_READ_ERRS);
-                                btrfs_dev_stat_inc(dev,
+                                if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
-                                                   BTRFS_DEV_STAT_FLUSH_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        btrfs_dev_stat_print_on_error(dev);
+                                                BTRFS_DEV_STAT_FLUSH_ERRS);
+                                btrfs_dev_stat_print_on_error(dev);
+                        }
                }
        }
@@ -4204,10 +4239,17 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
                bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;
                dev = bbio->stripes[dev_nr].dev;
                if (dev && dev->bdev && (rw != WRITE || dev->writeable)) {
+#ifdef DEBUG
+                        struct rcu_string *name;
+                        rcu_read_lock();
+                        name = rcu_dereference(dev->name);
                        pr_debug("btrfs_map_bio: rw %d, secor=%llu, dev=%lu "
                                 "(%s id %llu), size=%u\n", rw,
                                 (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
-                                 dev->name, dev->devid, bio->bi_size);
+                                 name->str, dev->devid, bio->bi_size);
+                        rcu_read_unlock();
+#endif
                        bio->bi_bdev = dev->bdev;
                        if (async_submit)
                                schedule_bio(root, dev, rw, bio);
@@ -4694,8 +4736,9 @@ int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)
                key.offset = device->devid;
                ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
                if (ret) {
-                        printk(KERN_WARNING "btrfs: no dev_stats entry found for device %s (devid %llu) (OK on first mount after mkfs)\n",
+                        printk_in_rcu(KERN_WARNING "btrfs: no dev_stats entry found for device %s (devid %llu) (OK on first mount after mkfs)\n",
-                               device->name, (unsigned long long)device->devid);
+                                      rcu_str_deref(device->name),
+                                      (unsigned long long)device->devid);
                        __btrfs_reset_dev_stats(device);
                        device->dev_stats_valid = 1;
                        btrfs_release_path(path);
@@ -4747,8 +4790,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
        BUG_ON(!path);
        ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
        if (ret < 0) {
-                printk(KERN_WARNING "btrfs: error %d while searching for dev_stats item for device %s!\n",
+                printk_in_rcu(KERN_WARNING "btrfs: error %d while searching for dev_stats item for device %s!\n",
-                       ret, device->name);
+                              ret, rcu_str_deref(device->name));
                goto out;
        }
@@ -4757,8 +4800,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
                /* need to delete old one and insert a new one */
                ret = btrfs_del_item(trans, dev_root, path);
                if (ret != 0) {
-                        printk(KERN_WARNING "btrfs: delete too small dev_stats item for device %s failed %d!\n",
+                        printk_in_rcu(KERN_WARNING "btrfs: delete too small dev_stats item for device %s failed %d!\n",
-                               device->name, ret);
+                                      rcu_str_deref(device->name), ret);
                        goto out;
                }
                ret = 1;
@@ -4770,8 +4813,8 @@ static int update_dev_stat_item(struct btrfs_trans_handle *trans,
                ret = btrfs_insert_empty_item(trans, dev_root, path,
                                              &key, sizeof(*ptr));
                if (ret < 0) {
-                        printk(KERN_WARNING "btrfs: insert dev_stats item for device %s failed %d!\n",
+                        printk_in_rcu(KERN_WARNING "btrfs: insert dev_stats item for device %s failed %d!\n",
-                               device->name, ret);
+                                      rcu_str_deref(device->name), ret);
                        goto out;
                }
        }
@@ -4823,9 +4866,9 @@ void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
 {
        if (!dev->dev_stats_valid)
                return;
-        printk_ratelimited(KERN_ERR
+        printk_ratelimited_in_rcu(KERN_ERR
                           "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
-                           dev->name,
+                           rcu_str_deref(dev->name),
                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
                           btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
@@ -4837,8 +4880,8 @@ void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
 static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
 {
-        printk(KERN_INFO "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
+        printk_in_rcu(KERN_INFO "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
-               dev->name,
+               rcu_str_deref(dev->name),
               btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
               btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
               btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 3406a88ca83e..95f6637614db 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -58,7 +58,7 @@ struct btrfs_device {
        /* the mode sent to blkdev_get */
        fmode_t mode;
-        char *name;
+        struct rcu_string *name;
        /* the internal btrfs device id */
        u64 devid;
@@ -281,7 +281,8 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
 int btrfs_init_new_device(struct btrfs_root *root, char *path);
 int btrfs_balance(struct btrfs_balance_control *bctl,
                  struct btrfs_ioctl_balance_args *bargs);
-int btrfs_recover_balance(struct btrfs_root *tree_root);
+int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
+int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
diff --git a/fs/buffer.c b/fs/buffer.c
index 838a9cf246bd..c7062c896d7c 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1036,6 +1036,9 @@ grow_buffers(struct block_device *bdev, sector_t block, int size)
 static struct buffer_head *
 __getblk_slow(struct block_device *bdev, sector_t block, int size)
 {
+        int ret;
+        struct buffer_head *bh;
        /* Size must be multiple of hard sectorsize */
        if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
                        (size < 512 || size > PAGE_SIZE))) {
@@ -1048,20 +1051,21 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
                return NULL;
        }
-        for (;;) {
+retry:
-                struct buffer_head * bh;
+        bh = __find_get_block(bdev, block, size);
-                int ret;
+        if (bh)
+                return bh;
+        ret = grow_buffers(bdev, block, size);
+        if (ret == 0) {
+                free_more_memory();
+                goto retry;
+        } else if (ret > 0) {
                bh = __find_get_block(bdev, block, size);
                if (bh)
                        return bh;
-                ret = grow_buffers(bdev, block, size);
-                if (ret < 0)
-                        return NULL;
-                if (ret == 0)
-                        free_more_memory();
        }
+        return NULL;
 }
 /*
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 7f0771d3894e..b0b5f7cdfffa 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -567,7 +567,7 @@ lookup_again:
                        if (ret < 0)
                                goto create_error;
                        start = jiffies;
-                        ret = vfs_create(dir->d_inode, next, S_IFREG, NULL);
+                        ret = vfs_create(dir->d_inode, next, S_IFREG, true);
                        cachefiles_hist(cachefiles_create_histogram, start);
                        if (ret < 0)
                                goto create_error;
diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c
index 0e3c0924cc3a..c0353dfac51f 100644
--- a/fs/cachefiles/rdwr.c
+++ b/fs/cachefiles/rdwr.c
@@ -891,6 +891,7 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page)
        struct cachefiles_cache *cache;
        mm_segment_t old_fs;
        struct file *file;
+        struct path path;
        loff_t pos, eof;
        size_t len;
        void *data;
@@ -916,10 +917,9 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page)
        /* write the page to the backing filesystem and let it store it in its
         * own time */
-        dget(object->backer);
+        path.mnt = cache->mnt;
-        mntget(cache->mnt);
+        path.dentry = object->backer;
-        file = dentry_open(object->backer, cache->mnt, O_RDWR,
+        file = dentry_open(&path, O_RDWR, cache->cache_cred);
-                           cache->cache_cred);
        if (IS_ERR(file)) {
                ret = PTR_ERR(file);
        } else {
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 173b1d22e59b..8b67304e4b80 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -54,7 +54,12 @@
        (CONGESTION_ON_THRESH(congestion_kb) -                          \
         (CONGESTION_ON_THRESH(congestion_kb) >> 2))
+static inline struct ceph_snap_context *page_snap_context(struct page *page)
+{
+        if (PagePrivate(page))
+                return (void *)page->private;
+        return NULL;
+}
 /*
 * Dirty a page.  Optimistically adjust accounting, on the assumption
@@ -142,10 +147,9 @@ static void ceph_invalidatepage(struct page *page, unsigned long offset)
 {
        struct inode *inode;
        struct ceph_inode_info *ci;
-        struct ceph_snap_context *snapc = (void *)page->private;
+        struct ceph_snap_context *snapc = page_snap_context(page);
        BUG_ON(!PageLocked(page));
-        BUG_ON(!page->private);
        BUG_ON(!PagePrivate(page));
        BUG_ON(!page->mapping);
@@ -182,7 +186,6 @@ static int ceph_releasepage(struct page *page, gfp_t g)
        struct inode *inode = page->mapping ? page->mapping->host : NULL;
        dout("%p releasepage %p idx %lu\n", inode, page, page->index);
        WARN_ON(PageDirty(page));
-        WARN_ON(page->private);
        WARN_ON(PagePrivate(page));
        return 0;
 }
@@ -443,7 +446,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
        osdc = &fsc->client->osdc;
        /* verify this is a writeable snap context */
-        snapc = (void *)page->private;
+        snapc = page_snap_context(page);
        if (snapc == NULL) {
                dout("writepage %p page %p not dirty?\n", inode, page);
                goto out;
@@ -451,7 +454,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
        oldest = get_oldest_context(inode, &snap_size);
        if (snapc->seq > oldest->seq) {
                dout("writepage %p page %p snapc %p not writeable - noop\n",
-                     inode, page, (void *)page->private);
+                     inode, page, snapc);
                /* we should only noop if called by kswapd */
                WARN_ON((current->flags & PF_MEMALLOC) == 0);
                ceph_put_snap_context(oldest);
@@ -591,7 +594,7 @@ static void writepages_finish(struct ceph_osd_request *req,
                        clear_bdi_congested(&fsc->backing_dev_info,
                                            BLK_RW_ASYNC);
-                ceph_put_snap_context((void *)page->private);
+                ceph_put_snap_context(page_snap_context(page));
                page->private = 0;
                ClearPagePrivate(page);
                dout("unlocking %d %p\n", i, page);
@@ -795,7 +798,7 @@ get_more_pages:
                        }
                        /* only if matching snap context */
-                        pgsnapc = (void *)page->private;
+                        pgsnapc = page_snap_context(page);
                        if (pgsnapc->seq > snapc->seq) {
                                dout("page snapc %p %lld > oldest %p %lld\n",
                                     pgsnapc, pgsnapc->seq, snapc, snapc->seq);
@@ -984,7 +987,7 @@ retry_locked:
        BUG_ON(!ci->i_snap_realm);
        down_read(&mdsc->snap_rwsem);
        BUG_ON(!ci->i_snap_realm->cached_context);
-        snapc = (void *)page->private;
+        snapc = page_snap_context(page);
        if (snapc && snapc != ci->i_head_snapc) {
                /*
                 * this page is already dirty in another (older) snap
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 3e8094be4604..00894ff9246c 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -576,7 +576,7 @@ static int is_root_ceph_dentry(struct inode *inode, struct dentry *dentry)
 * the MDS so that it gets our 'caps wanted' value in a single op.
 */
 static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
        struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -594,14 +594,6 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
        if (err < 0)
                return ERR_PTR(err);
-        /* open (but not create!) intent? */
-        if (nd &&
-            (nd->flags & LOOKUP_OPEN) &&
-            !(nd->intent.open.flags & O_CREAT)) {
-                int mode = nd->intent.open.create_mode & ~current->fs->umask;
-                return ceph_lookup_open(dir, dentry, nd, mode, 1);
-        }
        /* can we conclude ENOENT locally? */
        if (dentry->d_inode == NULL) {
                struct ceph_inode_info *ci = ceph_inode(dir);
@@ -642,13 +634,51 @@ static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
        return dentry;
 }
+int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
+                     struct file *file, unsigned flags, umode_t mode,
+                     int *opened)
+{
+        int err;
+        struct dentry *res = NULL;
+        if (!(flags & O_CREAT)) {
+                if (dentry->d_name.len > NAME_MAX)
+                        return -ENAMETOOLONG;
+                err = ceph_init_dentry(dentry);
+                if (err < 0)
+                        return err;
+                return ceph_lookup_open(dir, dentry, file, flags, mode, opened);
+        }
+        if (d_unhashed(dentry)) {
+                res = ceph_lookup(dir, dentry, 0);
+                if (IS_ERR(res))
+                        return PTR_ERR(res);
+                if (res)
+                        dentry = res;
+        }
+        /* We don't deal with positive dentries here */
+        if (dentry->d_inode)
+                return finish_no_open(file, res);
+        *opened |= FILE_CREATED;
+        err = ceph_lookup_open(dir, dentry, file, flags, mode, opened);
+        dput(res);
+        return err;
+}
 /*
 * If we do a create but get no trace back from the MDS, follow up with
 * a lookup (the VFS expects us to link up the provided dentry).
 */
 int ceph_handle_notrace_create(struct inode *dir, struct dentry *dentry)
 {
-        struct dentry *result = ceph_lookup(dir, dentry, NULL);
+        struct dentry *result = ceph_lookup(dir, dentry, 0);
        if (result && !IS_ERR(result)) {
                /*
@@ -700,25 +730,9 @@ static int ceph_mknod(struct inode *dir, struct dentry *dentry,
 }
 static int ceph_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                       struct nameidata *nd)
+                       bool excl)
 {
-        dout("create in dir %p dentry %p name '%.*s'\n",
+        return ceph_mknod(dir, dentry, mode, 0);
-             dir, dentry, dentry->d_name.len, dentry->d_name.name);
-        if (ceph_snap(dir) != CEPH_NOSNAP)
-                return -EROFS;
-        if (nd) {
-                BUG_ON((nd->flags & LOOKUP_OPEN) == 0);
-                dentry = ceph_lookup_open(dir, dentry, nd, mode, 0);
-                /* hrm, what should i do here if we get aliased? */
-                if (IS_ERR(dentry))
-                        return PTR_ERR(dentry);
-                return 0;
-        }
-        /* fall back to mknod */
-        return ceph_mknod(dir, dentry, (mode & ~S_IFMT) | S_IFREG, 0);
 }
 static int ceph_symlink(struct inode *dir, struct dentry *dentry,
@@ -1028,12 +1042,12 @@ static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry)
 /*
 * Check if cached dentry can be trusted.
 */
-static int ceph_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags)
 {
        int valid = 0;
        struct inode *dir;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        dout("d_revalidate %p '%.*s' inode %p offset %lld\n", dentry,
@@ -1080,7 +1094,7 @@ static void ceph_d_release(struct dentry *dentry)
 }
 static int ceph_snapdir_d_revalidate(struct dentry *dentry,
-                                          struct nameidata *nd)
+                                          unsigned int flags)
 {
        /*
         * Eventually, we'll want to revalidate snapped metadata
@@ -1357,6 +1371,7 @@ const struct inode_operations ceph_dir_iops = {
        .rmdir = ceph_unlink,
        .rename = ceph_rename,
        .create = ceph_create,
+        .atomic_open = ceph_atomic_open,
 };
 const struct dentry_operations ceph_dentry_ops = {
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 988d4f302e48..1b81d6c31878 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -213,22 +213,15 @@ out:
 * may_open() fails, the struct *file gets cleaned up (i.e.
 * ceph_release gets called).  So fear not!
 */
-/*
+int ceph_lookup_open(struct inode *dir, struct dentry *dentry,
- * flags
+                     struct file *file, unsigned flags, umode_t mode,
- *  path_lookup_open   -> LOOKUP_OPEN
+                     int *opened)
- *  path_lookup_create -> LOOKUP_OPEN|LOOKUP_CREATE
- */
-struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
-                                struct nameidata *nd, int mode,
-                                int locked_dir)
 {
        struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
        struct ceph_mds_client *mdsc = fsc->mdsc;
-        struct file *file;
        struct ceph_mds_request *req;
        struct dentry *ret;
        int err;
-        int flags = nd->intent.open.flags;
        dout("ceph_lookup_open dentry %p '%.*s' flags %d mode 0%o\n",
             dentry, dentry->d_name.len, dentry->d_name.name, flags, mode);
@@ -236,7 +229,7 @@ struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
        /* do the open */
        req = prepare_open_request(dir->i_sb, flags, mode);
        if (IS_ERR(req))
-                return ERR_CAST(req);
+                return PTR_ERR(req);
        req->r_dentry = dget(dentry);
        req->r_num_caps = 2;
        if (flags & O_CREAT) {
@@ -254,14 +247,17 @@ struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
                err = ceph_handle_notrace_create(dir, dentry);
        if (err)
                goto out;
-        file = lookup_instantiate_filp(nd, req->r_dentry, ceph_open);
+        err = finish_open(file, req->r_dentry, ceph_open, opened);
-        if (IS_ERR(file))
-                err = PTR_ERR(file);
 out:
        ret = ceph_finish_lookup(req, dentry, err);
        ceph_mdsc_put_request(req);
        dout("ceph_lookup_open result=%p\n", ret);
-        return ret;
+        if (IS_ERR(ret))
+                return PTR_ERR(ret);
+        dput(ret);
+        return err;
 }
 int ceph_release(struct inode *inode, struct file *file)
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 1e67dd7305a4..7076109f014d 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -871,7 +871,7 @@ static struct dentry *ceph_mount(struct file_system_type *fs_type,
        if (ceph_test_opt(fsc->client, NOSHARE))
                compare_super = NULL;
-        sb = sget(fs_type, compare_super, ceph_set_super, fsc);
+        sb = sget(fs_type, compare_super, ceph_set_super, flags, fsc);
        if (IS_ERR(sb)) {
                res = ERR_CAST(sb);
                goto out;
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index fc35036d258d..f4d5522cb619 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -806,9 +806,9 @@ extern int ceph_copy_from_page_vector(struct page **pages,
                                    loff_t off, size_t len);
 extern struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags);
 extern int ceph_open(struct inode *inode, struct file *file);
-extern struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry,
+extern int ceph_lookup_open(struct inode *dir, struct dentry *dentry,
-                                       struct nameidata *nd, int mode,
+                             struct file *od, unsigned flags,
-                                       int locked_dir);
+                             umode_t mode, int *opened);
 extern int ceph_release(struct inode *inode, struct file *filp);
 /* dir.c */
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8b6e344eb0ba..a7610cfedf0a 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -257,7 +257,6 @@ cifs_alloc_inode(struct super_block *sb)
 static void cifs_i_callback(struct rcu_head *head)
 {
        struct inode *inode = container_of(head, struct inode, i_rcu);
-        INIT_LIST_HEAD(&inode->i_dentry);
        kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 }
@@ -638,7 +637,10 @@ cifs_do_mount(struct file_system_type *fs_type,
        mnt_data.cifs_sb = cifs_sb;
        mnt_data.flags = flags;
-        sb = sget(fs_type, cifs_match_super, cifs_set_super, &mnt_data);
+        /* BB should we make this contingent on mount parm? */
+        flags |= MS_NODIRATIME | MS_NOATIME;
+        sb = sget(fs_type, cifs_match_super, cifs_set_super, flags, &mnt_data);
        if (IS_ERR(sb)) {
                root = ERR_CAST(sb);
                cifs_umount(cifs_sb);
@@ -649,10 +651,6 @@ cifs_do_mount(struct file_system_type *fs_type,
                cFYI(1, "Use existing superblock");
                cifs_umount(cifs_sb);
        } else {
-                sb->s_flags = flags;
-                /* BB should we make this contingent on mount parm? */
-                sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
                rc = cifs_read_super(sb);
                if (rc) {
                        root = ERR_PTR(rc);
@@ -778,6 +776,7 @@ struct file_system_type cifs_fs_type = {
 };
 const struct inode_operations cifs_dir_inode_ops = {
        .create = cifs_create,
+        .atomic_open = cifs_atomic_open,
        .lookup = cifs_lookup,
        .getattr = cifs_getattr,
        .unlink = cifs_unlink,
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 65365358c976..1c49c5a9b27a 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -45,9 +45,12 @@ extern const struct address_space_operations cifs_addr_ops_smallbuf;
 extern const struct inode_operations cifs_dir_inode_ops;
 extern struct inode *cifs_root_iget(struct super_block *);
 extern int cifs_create(struct inode *, struct dentry *, umode_t,
-                       struct nameidata *);
+                       bool excl);
+extern int cifs_atomic_open(struct inode *, struct dentry *,
+                            struct file *, unsigned, umode_t,
+                            int *);
 extern struct dentry *cifs_lookup(struct inode *, struct dentry *,
-                                  struct nameidata *);
+                                  unsigned int);
 extern int cifs_unlink(struct inode *dir, struct dentry *dentry);
 extern int cifs_hardlink(struct dentry *, struct inode *, struct dentry *);
 extern int cifs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 5b400730c213..4ee522b3f66f 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -86,7 +86,31 @@ static struct {
 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
 #endif /* CIFS_POSIX */
-/* Forward declarations */
+#ifdef CONFIG_HIGHMEM
+/*
+ * On arches that have high memory, kmap address space is limited. By
+ * serializing the kmap operations on those arches, we ensure that we don't
+ * end up with a bunch of threads in writeback with partially mapped page
+ * arrays, stuck waiting for kmap to come back. That situation prevents
+ * progress and can deadlock.
+ */
+static DEFINE_MUTEX(cifs_kmap_mutex);
+static inline void
+cifs_kmap_lock(void)
+{
+        mutex_lock(&cifs_kmap_mutex);
+}
+static inline void
+cifs_kmap_unlock(void)
+{
+        mutex_unlock(&cifs_kmap_mutex);
+}
+#else /* !CONFIG_HIGHMEM */
+#define cifs_kmap_lock() do { ; } while(0)
+#define cifs_kmap_unlock() do { ; } while(0)
+#endif /* CONFIG_HIGHMEM */
 /* Mark as invalid, all open files on tree connections since they
   were closed when session to server was lost */
@@ -1503,7 +1527,9 @@ cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
        }
        /* marshal up the page array */
+        cifs_kmap_lock();
        len = rdata->marshal_iov(rdata, data_len);
+        cifs_kmap_unlock();
        data_len -= len;
        /* issue the read if we have any iovecs left to fill */
@@ -2069,7 +2095,9 @@ cifs_async_writev(struct cifs_writedata *wdata)
         * and set the iov_len properly for each one. It may also set
         * wdata->bytes too.
         */
+        cifs_kmap_lock();
        wdata->marshal_iov(iov, wdata);
+        cifs_kmap_unlock();
        cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 78db68a5cf44..94b7788c3189 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1653,24 +1653,26 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         * If yes, we have encountered a double deliminator
                         * reset the NULL character to the deliminator
                         */
-                        if (tmp_end < end && tmp_end[1] == delim)
+                        if (tmp_end < end && tmp_end[1] == delim) {
                                tmp_end[0] = delim;
-                        /* Keep iterating until we get to a single deliminator
+                                /* Keep iterating until we get to a single
-                         * OR the end
+                                 * deliminator OR the end
-                         */
+                                 */
-                        while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
+                                while ((tmp_end = strchr(tmp_end, delim))
-                               (tmp_end[1] == delim)) {
+                                        != NULL && (tmp_end[1] == delim)) {
-                                tmp_end = (char *) &tmp_end[2];
+                                                tmp_end = (char *) &tmp_end[2];
-                        }
+                                }
-                        /* Reset var options to point to next element */
+                                /* Reset var options to point to next element */
-                        if (tmp_end) {
+                                if (tmp_end) {
-                                tmp_end[0] = '\0';
+                                        tmp_end[0] = '\0';
-                                options = (char *) &tmp_end[1];
+                                        options = (char *) &tmp_end[1];
-                        } else
+                                } else
-                                /* Reached the end of the mount option string */
+                                        /* Reached the end of the mount option
-                                options = end;
+                                         * string */
+                                        options = end;
+                        }
                        /* Now build new password string */
                        temp_len = strlen(value);
@@ -3443,6 +3445,18 @@ void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
+/*
+ * On hosts with high memory, we can't currently support wsize/rsize that are
+ * larger than we can kmap at once. Cap the rsize/wsize at
+ * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
+ * larger than that anyway.
+ */
+#ifdef CONFIG_HIGHMEM
+#define CIFS_KMAP_SIZE_LIMIT    (LAST_PKMAP * PAGE_CACHE_SIZE)
+#else /* CONFIG_HIGHMEM */
+#define CIFS_KMAP_SIZE_LIMIT    (1<<24)
+#endif /* CONFIG_HIGHMEM */
 static unsigned int
 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
 {
@@ -3473,6 +3487,9 @@ cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
                wsize = min_t(unsigned int, wsize,
                                server->maxBuf - sizeof(WRITE_REQ) + 4);
+        /* limit to the amount that we can kmap at once */
+        wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
        /* hard limit of CIFS_MAX_WSIZE */
        wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
@@ -3493,18 +3510,15 @@ cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
         * MS-CIFS indicates that servers are only limited by the client's
         * bufsize for reads, testing against win98se shows that it throws
         * INVALID_PARAMETER errors if you try to request too large a read.
+         * OS/2 just sends back short reads.
         *
-         * If the server advertises a MaxBufferSize of less than one page,
+         * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
-         * assume that it also can't satisfy reads larger than that either.
+         * it can't handle a read request larger than its MaxBufferSize either.
-         *
-         * FIXME: Is there a better heuristic for this?
         */
        if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
                defsize = CIFS_DEFAULT_IOSIZE;
        else if (server->capabilities & CAP_LARGE_READ_X)
                defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
-        else if (server->maxBuf >= PAGE_CACHE_SIZE)
-                defsize = CIFSMaxBufSize;
        else
                defsize = server->maxBuf - sizeof(READ_RSP);
@@ -3517,6 +3531,9 @@ cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
        if (!(server->capabilities & CAP_LARGE_READ_X))
                rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
+        /* limit to the amount that we can kmap at once */
+        rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
        /* hard limit of CIFS_MAX_RSIZE */
        rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index ec4e9a2a12f8..a180265a10b5 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -133,108 +133,141 @@ cifs_bp_rename_retry:
        return full_path;
 }
+/*
+ * Don't allow the separator character in a path component.
+ * The VFS will not allow "/", but "\" is allowed by posix.
+ */
+static int
+check_name(struct dentry *direntry)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
+        int i;
+        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
+                for (i = 0; i < direntry->d_name.len; i++) {
+                        if (direntry->d_name.name[i] == '\\') {
+                                cFYI(1, "Invalid file name");
+                                return -EINVAL;
+                        }
+                }
+        }
+        return 0;
+}
 /* Inode operations in similar order to how they appear in Linux file fs.h */
-int
+static int cifs_do_create(struct inode *inode, struct dentry *direntry,
-cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
+                          int xid, struct tcon_link *tlink, unsigned oflags,
-                struct nameidata *nd)
+                          umode_t mode, __u32 *oplock, __u16 *fileHandle,
+                          int *created)
 {
        int rc = -ENOENT;
-        int xid;
        int create_options = CREATE_NOT_DIR;
-        __u32 oplock = 0;
+        int desiredAccess;
-        int oflags;
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
-        /*
+        struct cifs_tcon *tcon = tlink_tcon(tlink);
-         * BB below access is probably too much for mknod to request
-         *    but we have to do query and setpathinfo so requesting
-         *    less could fail (unless we want to request getatr and setatr
-         *    permissions (only).  At least for POSIX we do not have to
-         *    request so much.
-         */
-        int desiredAccess = GENERIC_READ | GENERIC_WRITE;
-        __u16 fileHandle;
-        struct cifs_sb_info *cifs_sb;
-        struct tcon_link *tlink;
-        struct cifs_tcon *tcon;
        char *full_path = NULL;
        FILE_ALL_INFO *buf = NULL;
        struct inode *newinode = NULL;
-        int disposition = FILE_OVERWRITE_IF;
+        int disposition;
-        xid = GetXid();
-        cifs_sb = CIFS_SB(inode->i_sb);
-        tlink = cifs_sb_tlink(cifs_sb);
-        if (IS_ERR(tlink)) {
-                FreeXid(xid);
-                return PTR_ERR(tlink);
-        }
-        tcon = tlink_tcon(tlink);
+        *oplock = 0;
        if (tcon->ses->server->oplocks)
-                oplock = REQ_OPLOCK;
+                *oplock = REQ_OPLOCK;
-        if (nd)
-                oflags = nd->intent.open.file->f_flags;
-        else
-                oflags = O_RDONLY | O_CREAT;
        full_path = build_path_from_dentry(direntry);
        if (full_path == NULL) {
                rc = -ENOMEM;
-                goto cifs_create_out;
+                goto out;
        }
        if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
+            !tcon->broken_posix_open &&
            (CIFS_UNIX_POSIX_PATH_OPS_CAP &
                        le64_to_cpu(tcon->fsUnixInfo.Capability))) {
                rc = cifs_posix_open(full_path, &newinode,
-                        inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
+                        inode->i_sb, mode, oflags, oplock, fileHandle, xid);
-                /* EIO could indicate that (posix open) operation is not
+                switch (rc) {
-                   supported, despite what server claimed in capability
+                case 0:
-                   negotiation.  EREMOTE indicates DFS junction, which is not
+                        if (newinode == NULL) {
-                   handled in posix open */
+                                /* query inode info */
-                if (rc == 0) {
-                        if (newinode == NULL) /* query inode info */
                                goto cifs_create_get_file_info;
-                        else /* success, no need to query */
+                        }
-                                goto cifs_create_set_dentry;
-                } else if ((rc != -EIO) && (rc != -EREMOTE) &&
+                        if (!S_ISREG(newinode->i_mode)) {
-                         (rc != -EOPNOTSUPP) && (rc != -EINVAL))
+                                /*
-                        goto cifs_create_out;
+                                 * The server may allow us to open things like
-                /* else fallthrough to retry, using older open call, this is
+                                 * FIFOs, but the client isn't set up to deal
-                   case where server does not support this SMB level, and
+                                 * with that. If it's not a regular file, just
-                   falsely claims capability (also get here for DFS case
+                                 * close it and proceed as if it were a normal
-                   which should be rare for path not covered on files) */
+                                 * lookup.
-        }
+                                 */
+                                CIFSSMBClose(xid, tcon, *fileHandle);
+                                goto cifs_create_get_file_info;
+                        }
+                        /* success, no need to query */
+                        goto cifs_create_set_dentry;
+                case -ENOENT:
+                        goto cifs_create_get_file_info;
+                case -EIO:
+                case -EINVAL:
+                        /*
+                         * EIO could indicate that (posix open) operation is not
+                         * supported, despite what server claimed in capability
+                         * negotiation.
+                         *
+                         * POSIX open in samba versions 3.3.1 and earlier could
+                         * incorrectly fail with invalid parameter.
+                         */
+                        tcon->broken_posix_open = true;
+                        break;
+                case -EREMOTE:
+                case -EOPNOTSUPP:
+                        /*
+                         * EREMOTE indicates DFS junction, which is not handled
+                         * in posix open.  If either that or op not supported
+                         * returned, follow the normal lookup.
+                         */
+                        break;
-        if (nd) {
+                default:
-                /* if the file is going to stay open, then we
+                        goto out;
-                   need to set the desired access properly */
+                }
-                desiredAccess = 0;
+                /*
-                if (OPEN_FMODE(oflags) & FMODE_READ)
+                 * fallthrough to retry, using older open call, this is case
-                        desiredAccess |= GENERIC_READ; /* is this too little? */
+                 * where server does not support this SMB level, and falsely
-                if (OPEN_FMODE(oflags) & FMODE_WRITE)
+                 * claims capability (also get here for DFS case which should be
-                        desiredAccess |= GENERIC_WRITE;
+                 * rare for path not covered on files)
+                 */
-                if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
-                        disposition = FILE_CREATE;
-                else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
-                        disposition = FILE_OVERWRITE_IF;
-                else if ((oflags & O_CREAT) == O_CREAT)
-                        disposition = FILE_OPEN_IF;
-                else
-                        cFYI(1, "Create flag not set in create function");
        }
+        desiredAccess = 0;
+        if (OPEN_FMODE(oflags) & FMODE_READ)
+                desiredAccess |= GENERIC_READ; /* is this too little? */
+        if (OPEN_FMODE(oflags) & FMODE_WRITE)
+                desiredAccess |= GENERIC_WRITE;
+        disposition = FILE_OVERWRITE_IF;
+        if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
+                disposition = FILE_CREATE;
+        else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
+                disposition = FILE_OVERWRITE_IF;
+        else if ((oflags & O_CREAT) == O_CREAT)
+                disposition = FILE_OPEN_IF;
+        else
+                cFYI(1, "Create flag not set in create function");
        /* BB add processing to set equivalent of mode - e.g. via CreateX with
           ACLs */
        buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
        if (buf == NULL) {
                rc = -ENOMEM;
-                goto cifs_create_out;
+                goto out;
        }
        /*
@@ -250,7 +283,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
        if (tcon->ses->capabilities & CAP_NT_SMBS)
                rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
                         desiredAccess, create_options,
-                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
+                         fileHandle, oplock, buf, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        else
                rc = -EIO; /* no NT SMB support fall into legacy open below */
@@ -259,17 +292,17 @@ cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
                /* old server, retry the open legacy style */
                rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
                        desiredAccess, create_options,
-                        &fileHandle, &oplock, buf, cifs_sb->local_nls,
+                        fileHandle, oplock, buf, cifs_sb->local_nls,
                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        }
        if (rc) {
                cFYI(1, "cifs_create returned 0x%x", rc);
-                goto cifs_create_out;
+                goto out;
        }
        /* If Open reported that we actually created a file
           then we now have to set the mode if possible */
-        if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
+        if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {
                struct cifs_unix_set_info_args args = {
                                .mode   = mode,
                                .ctime  = NO_CHANGE_64,
@@ -278,6 +311,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
                                .device = 0,
                };
+                *created |= FILE_CREATED;
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                        args.uid = (__u64) current_fsuid();
                        if (inode->i_mode & S_ISGID)
@@ -288,7 +322,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
                        args.uid = NO_CHANGE_64;
                        args.gid = NO_CHANGE_64;
                }
-                CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
+                CIFSSMBUnixSetFileInfo(xid, tcon, &args, *fileHandle,
                                        current->tgid);
        } else {
                /* BB implement mode setting via Windows security
@@ -305,11 +339,11 @@ cifs_create_get_file_info:
                                              inode->i_sb, xid);
        else {
                rc = cifs_get_inode_info(&newinode, full_path, buf,
-                                         inode->i_sb, xid, &fileHandle);
+                                         inode->i_sb, xid, fileHandle);
                if (newinode) {
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
                                newinode->i_mode = mode;
-                        if ((oplock & CIFS_CREATE_ACTION) &&
+                        if ((*oplock & CIFS_CREATE_ACTION) &&
                            (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
                                newinode->i_uid = current_fsuid();
                                if (inode->i_mode & S_ISGID)
@@ -321,40 +355,139 @@ cifs_create_get_file_info:
        }
 cifs_create_set_dentry:
-        if (rc == 0)
+        if (rc != 0) {
-                d_instantiate(direntry, newinode);
-        else
                cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
+                goto out;
+        }
+        d_drop(direntry);
+        d_add(direntry, newinode);
-        if (newinode && nd) {
+        /* ENOENT for create?  How weird... */
-                struct cifsFileInfo *pfile_info;
+        rc = -ENOENT;
-                struct file *filp;
+        if (!newinode) {
+                CIFSSMBClose(xid, tcon, *fileHandle);
+                goto out;
+        }
+        rc = 0;
-                filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
+out:
-                if (IS_ERR(filp)) {
+        kfree(buf);
-                        rc = PTR_ERR(filp);
+        kfree(full_path);
-                        CIFSSMBClose(xid, tcon, fileHandle);
+        return rc;
-                        goto cifs_create_out;
+}
-                }
-                pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
+int
-                if (pfile_info == NULL) {
+cifs_atomic_open(struct inode *inode, struct dentry *direntry,
-                        fput(filp);
+                 struct file *file, unsigned oflags, umode_t mode,
-                        CIFSSMBClose(xid, tcon, fileHandle);
+                 int *opened)
-                        rc = -ENOMEM;
+{
-                }
+        int rc;
-        } else {
+        int xid;
+        struct tcon_link *tlink;
+        struct cifs_tcon *tcon;
+        __u16 fileHandle;
+        __u32 oplock;
+        struct file *filp;
+        struct cifsFileInfo *pfile_info;
+        /* Posix open is only called (at lookup time) for file create now.  For
+         * opens (rather than creates), because we do not know if it is a file
+         * or directory yet, and current Samba no longer allows us to do posix
+         * open on dirs, we could end up wasting an open call on what turns out
+         * to be a dir. For file opens, we wait to call posix open till
+         * cifs_open.  It could be added to atomic_open in the future but the
+         * performance tradeoff of the extra network request when EISDIR or
+         * EACCES is returned would have to be weighed against the 50% reduction
+         * in network traffic in the other paths.
+         */
+        if (!(oflags & O_CREAT)) {
+                struct dentry *res = cifs_lookup(inode, direntry, 0);
+                if (IS_ERR(res))
+                        return PTR_ERR(res);
+                return finish_no_open(file, res);
+        }
+        rc = check_name(direntry);
+        if (rc)
+                return rc;
+        xid = GetXid();
+        cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
+             inode, direntry->d_name.name, direntry);
+        tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
+        filp = ERR_CAST(tlink);
+        if (IS_ERR(tlink))
+                goto free_xid;
+        tcon = tlink_tcon(tlink);
+        rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
+                            &oplock, &fileHandle, opened);
+        if (rc)
+                goto out;
+        rc = finish_open(file, direntry, generic_file_open, opened);
+        if (rc) {
                CIFSSMBClose(xid, tcon, fileHandle);
+                goto out;
        }
-cifs_create_out:
+        pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
-        kfree(buf);
+        if (pfile_info == NULL) {
-        kfree(full_path);
+                CIFSSMBClose(xid, tcon, fileHandle);
+                fput(filp);
+                rc = -ENOMEM;
+        }
+out:
        cifs_put_tlink(tlink);
+free_xid:
        FreeXid(xid);
        return rc;
 }
+int cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
+                bool excl)
+{
+        int rc;
+        int xid = GetXid();
+        /*
+         * BB below access is probably too much for mknod to request
+         *    but we have to do query and setpathinfo so requesting
+         *    less could fail (unless we want to request getatr and setatr
+         *    permissions (only).  At least for POSIX we do not have to
+         *    request so much.
+         */
+        unsigned oflags = O_EXCL | O_CREAT | O_RDWR;
+        struct tcon_link *tlink;
+        __u16 fileHandle;
+        __u32 oplock;
+        int created = FILE_CREATED;
+        cFYI(1, "cifs_create parent inode = 0x%p name is: %s and dentry = 0x%p",
+             inode, direntry->d_name.name, direntry);
+        tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
+        rc = PTR_ERR(tlink);
+        if (IS_ERR(tlink))
+                goto free_xid;
+        rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
+                            &oplock, &fileHandle, &created);
+        if (!rc)
+                CIFSSMBClose(xid, tlink_tcon(tlink), fileHandle);
+        cifs_put_tlink(tlink);
+free_xid:
+        FreeXid(xid);
+        return rc;
+}
 int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
                dev_t device_number)
 {
@@ -488,20 +621,15 @@ mknod_out:
 struct dentry *
 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
-            struct nameidata *nd)
+            unsigned int flags)
 {
        int xid;
        int rc = 0; /* to get around spurious gcc warning, set to zero here */
-        __u32 oplock;
-        __u16 fileHandle = 0;
-        bool posix_open = false;
        struct cifs_sb_info *cifs_sb;
        struct tcon_link *tlink;
        struct cifs_tcon *pTcon;
-        struct cifsFileInfo *cfile;
        struct inode *newInode = NULL;
        char *full_path = NULL;
-        struct file *filp;
        xid = GetXid();
@@ -518,31 +646,9 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
        }
        pTcon = tlink_tcon(tlink);
-        oplock = pTcon->ses->server->oplocks ? REQ_OPLOCK : 0;
+        rc = check_name(direntry);
+        if (rc)
-        /*
-         * Don't allow the separator character in a path component.
-         * The VFS will not allow "/", but "\" is allowed by posix.
-         */
-        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
-                int i;
-                for (i = 0; i < direntry->d_name.len; i++)
-                        if (direntry->d_name.name[i] == '\\') {
-                                cFYI(1, "Invalid file name");
-                                rc = -EINVAL;
-                                goto lookup_out;
-                        }
-        }
-        /*
-         * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
-         * the VFS handle the create.
-         */
-        if (nd && (nd->flags & LOOKUP_EXCL)) {
-                d_instantiate(direntry, NULL);
-                rc = 0;
                goto lookup_out;
-        }
        /* can not grab the rename sem here since it would
        deadlock in the cases (beginning of sys_rename itself)
@@ -560,80 +666,16 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
        }
        cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
-        /* Posix open is only called (at lookup time) for file create now.
-         * For opens (rather than creates), because we do not know if it
-         * is a file or directory yet, and current Samba no longer allows
-         * us to do posix open on dirs, we could end up wasting an open call
-         * on what turns out to be a dir. For file opens, we wait to call posix
-         * open till cifs_open.  It could be added here (lookup) in the future
-         * but the performance tradeoff of the extra network request when EISDIR
-         * or EACCES is returned would have to be weighed against the 50%
-         * reduction in network traffic in the other paths.
-         */
        if (pTcon->unix_ext) {
-                if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
+                rc = cifs_get_inode_info_unix(&newInode, full_path,
-                     (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
+                                              parent_dir_inode->i_sb, xid);
-                     (nd->intent.open.file->f_flags & O_CREAT)) {
+        } else {
-                        rc = cifs_posix_open(full_path, &newInode,
-                                        parent_dir_inode->i_sb,
-                                        nd->intent.open.create_mode,
-                                        nd->intent.open.file->f_flags, &oplock,
-                                        &fileHandle, xid);
-                        /*
-                         * The check below works around a bug in POSIX
-                         * open in samba versions 3.3.1 and earlier where
-                         * open could incorrectly fail with invalid parameter.
-                         * If either that or op not supported returned, follow
-                         * the normal lookup.
-                         */
-                        switch (rc) {
-                        case 0:
-                                /*
-                                 * The server may allow us to open things like
-                                 * FIFOs, but the client isn't set up to deal
-                                 * with that. If it's not a regular file, just
-                                 * close it and proceed as if it were a normal
-                                 * lookup.
-                                 */
-                                if (newInode && !S_ISREG(newInode->i_mode)) {
-                                        CIFSSMBClose(xid, pTcon, fileHandle);
-                                        break;
-                                }
-                        case -ENOENT:
-                                posix_open = true;
-                        case -EOPNOTSUPP:
-                                break;
-                        default:
-                                pTcon->broken_posix_open = true;
-                        }
-                }
-                if (!posix_open)
-                        rc = cifs_get_inode_info_unix(&newInode, full_path,
-                                                parent_dir_inode->i_sb, xid);
-        } else
                rc = cifs_get_inode_info(&newInode, full_path, NULL,
                                parent_dir_inode->i_sb, xid, NULL);
+        }
        if ((rc == 0) && (newInode != NULL)) {
                d_add(direntry, newInode);
-                if (posix_open) {
-                        filp = lookup_instantiate_filp(nd, direntry,
-                                                       generic_file_open);
-                        if (IS_ERR(filp)) {
-                                rc = PTR_ERR(filp);
-                                CIFSSMBClose(xid, pTcon, fileHandle);
-                                goto lookup_out;
-                        }
-                        cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
-                                                  oplock);
-                        if (cfile == NULL) {
-                                fput(filp);
-                                CIFSSMBClose(xid, pTcon, fileHandle);
-                                rc = -ENOMEM;
-                                goto lookup_out;
-                        }
-                }
                /* since paths are not looked up by component - the parent
                   directories are presumed to be good here */
                renew_parental_timestamps(direntry);
@@ -658,9 +700,9 @@ lookup_out:
 }
 static int
-cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
+cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
 {
-        if (nd && (nd->flags & LOOKUP_RCU))
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        if (direntry->d_inode) {
@@ -689,7 +731,7 @@ cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
         * This may be nfsd (or something), anyway, we can't see the
         * intent of this. So, since this can be for creation, drop it.
         */
-        if (!nd)
+        if (!flags)
                return 0;
        /*
@@ -697,7 +739,7 @@ cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
         * case sensitive name which is specified by user if this is
         * for creation.
         */
-        if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+        if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
                return 0;
        if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 745da3d0653e..8e8bb49112ff 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -800,7 +800,7 @@ cifs_find_inode(struct inode *inode, void *opaque)
                return 0;
        /* if it's not a directory or has no dentries, then flag it */
-        if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))
+        if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
                fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
        return 1;
@@ -825,9 +825,10 @@ static bool
 inode_has_hashed_dentries(struct inode *inode)
 {
        struct dentry *dentry;
+        struct hlist_node *p;
        spin_lock(&inode->i_lock);
-        list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, p, &inode->i_dentry, 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 0a8224d1c4c5..a4217f02fab2 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -86,9 +86,12 @@ cifs_readdir_lookup(struct dentry *parent, struct qstr *name,
        dentry = d_lookup(parent, name);
        if (dentry) {
-                /* FIXME: check for inode number changes? */
+                inode = dentry->d_inode;
-                if (dentry->d_inode != NULL)
+                /* update inode in place if i_ino didn't change */
+                if (inode && CIFS_I(inode)->uniqueid == fattr->cf_uniqueid) {
+                        cifs_fattr_to_inode(inode, fattr);
                        return dentry;
+                }
                d_drop(dentry);
                dput(dentry);
        }
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 3097ee58fd7d..f25d4ea14be4 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -365,16 +365,14 @@ cifs_setup_async_request(struct TCP_Server_Info *server, struct kvec *iov,
        if (mid == NULL)
                return -ENOMEM;
-        /* put it on the pending_mid_q */
-        spin_lock(&GlobalMid_Lock);
-        list_add_tail(&mid->qhead, &server->pending_mid_q);
-        spin_unlock(&GlobalMid_Lock);
        rc = cifs_sign_smb2(iov, nvec, server, &mid->sequence_number);
-        if (rc)
+        if (rc) {
-                delete_mid(mid);
+                DeleteMidQEntry(mid);
+                return rc;
+        }
        *ret_mid = mid;
-        return rc;
+        return 0;
 }
 /*
@@ -407,17 +405,21 @@ cifs_call_async(struct TCP_Server_Info *server, struct kvec *iov,
        mid->callback_data = cbdata;
        mid->mid_state = MID_REQUEST_SUBMITTED;
+        /* put it on the pending_mid_q */
+        spin_lock(&GlobalMid_Lock);
+        list_add_tail(&mid->qhead, &server->pending_mid_q);
+        spin_unlock(&GlobalMid_Lock);
        cifs_in_send_inc(server);
        rc = smb_sendv(server, iov, nvec);
        cifs_in_send_dec(server);
        cifs_save_when_sent(mid);
        mutex_unlock(&server->srv_mutex);
-        if (rc)
+        if (rc == 0)
-                goto out_err;
+                return 0;
-        return rc;
-out_err:
        delete_mid(mid);
        add_credits(server, 1);
        wake_up(&server->request_q);
diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 690157876184..958ae0e0ff8c 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -89,17 +89,13 @@ int coda_cache_check(struct inode *inode, int mask)
 /* this won't do any harm: just flag all children */
 static void coda_flag_children(struct dentry *parent, int flag)
 {
-        struct list_head *child;
        struct dentry *de;
        spin_lock(&parent->d_lock);
-        list_for_each(child, &parent->d_subdirs)
+        list_for_each_entry(de, &parent->d_subdirs, d_u.d_child) {
-        {
-                de = list_entry(child, struct dentry, d_u.d_child);
                /* don't know what to do with negative dentries */
-                if ( ! de->d_inode ) 
+                if (de->d_inode ) 
-                        continue;
+                        coda_flag_inode(de->d_inode, flag);
-                coda_flag_inode(de->d_inode, flag);
        }
        spin_unlock(&parent->d_lock);
        return; 
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 177515829062..49fe52d25600 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -30,8 +30,8 @@
 #include "coda_int.h"
 /* dir inode-ops */
-static int coda_create(struct inode *dir, struct dentry *new, umode_t mode, struct nameidata *nd);
+static int coda_create(struct inode *dir, struct dentry *new, umode_t mode, bool excl);
-static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd);
+static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, unsigned int flags);
 static int coda_link(struct dentry *old_dentry, struct inode *dir_inode, 
                     struct dentry *entry);
 static int coda_unlink(struct inode *dir_inode, struct dentry *entry);
@@ -46,7 +46,7 @@ static int coda_rename(struct inode *old_inode, struct dentry *old_dentry,
 static int coda_readdir(struct file *file, void *buf, filldir_t filldir);
 /* dentry ops */
-static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd);
+static int coda_dentry_revalidate(struct dentry *de, unsigned int flags);
 static int coda_dentry_delete(const struct dentry *);
 /* support routines */
@@ -94,7 +94,7 @@ const struct file_operations coda_dir_operations = {
 /* inode operations for directories */
 /* access routines: lookup, readlink, permission */
-static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struct nameidata *nd)
+static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, unsigned int flags)
 {
        struct super_block *sb = dir->i_sb;
        const char *name = entry->d_name.name;
@@ -188,7 +188,7 @@ static inline void coda_dir_drop_nlink(struct inode *dir)
 }
 /* creation routines: create, mknod, mkdir, link, symlink */
-static int coda_create(struct inode *dir, struct dentry *de, umode_t mode, struct nameidata *nd)
+static int coda_create(struct inode *dir, struct dentry *de, umode_t mode, bool excl)
 {
        int error;
        const char *name=de->d_name.name;
@@ -536,12 +536,12 @@ out:
 }
 /* called when a cache lookup succeeds */
-static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd)
+static int coda_dentry_revalidate(struct dentry *de, unsigned int flags)
 {
        struct inode *inode;
        struct coda_inode_info *cii;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = de->d_inode;
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 7e6c52d8a207..7414ae24a79b 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -442,7 +442,7 @@ static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * den
 static struct dentry * configfs_lookup(struct inode *dir,
                                       struct dentry *dentry,
-                                       struct nameidata *nd)
+                                       unsigned int flags)
 {
        struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
        struct configfs_dirent * sd;
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index d013c46402ed..28cca01ca9c9 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -417,7 +417,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 /*
 * Lookup and fill in the inode data..
 */
-static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        unsigned int offset = 0;
        struct inode *inode = NULL;
diff --git a/fs/dcache.c b/fs/dcache.c
index 85c9e2bff8e6..8086636bf796 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -218,7 +218,7 @@ static void __d_free(struct rcu_head *head)
 {
        struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
-        WARN_ON(!list_empty(&dentry->d_alias));
+        WARN_ON(!hlist_unhashed(&dentry->d_alias));
        if (dname_external(dentry))
                kfree(dentry->d_name.name);
        kmem_cache_free(dentry_cache, dentry); 
@@ -267,7 +267,7 @@ static void dentry_iput(struct dentry * dentry)
        struct inode *inode = dentry->d_inode;
        if (inode) {
                dentry->d_inode = NULL;
-                list_del_init(&dentry->d_alias);
+                hlist_del_init(&dentry->d_alias);
                spin_unlock(&dentry->d_lock);
                spin_unlock(&inode->i_lock);
                if (!inode->i_nlink)
@@ -291,7 +291,7 @@ static void dentry_unlink_inode(struct dentry * dentry)
 {
        struct inode *inode = dentry->d_inode;
        dentry->d_inode = NULL;
-        list_del_init(&dentry->d_alias);
+        hlist_del_init(&dentry->d_alias);
        dentry_rcuwalk_barrier(dentry);
        spin_unlock(&dentry->d_lock);
        spin_unlock(&inode->i_lock);
@@ -683,6 +683,8 @@ EXPORT_SYMBOL(dget_parent);
 /**
 * d_find_alias - grab a hashed alias of inode
 * @inode: inode in question
+ * @want_discon:  flag, used by d_splice_alias, to request
+ *          that only a DISCONNECTED alias be returned.
 *
 * If inode has a hashed alias, or is a directory and has any alias,
 * acquire the reference to alias and return it. Otherwise return NULL.
@@ -691,21 +693,23 @@ EXPORT_SYMBOL(dget_parent);
 * of a filesystem.
 *
 * If the inode has an IS_ROOT, DCACHE_DISCONNECTED alias, then prefer
- * any other hashed alias over that.
+ * any other hashed alias over that one unless @want_discon is set,
+ * in which case only return an IS_ROOT, DCACHE_DISCONNECTED alias.
 */
-static struct dentry *__d_find_alias(struct inode *inode)
+static struct dentry *__d_find_alias(struct inode *inode, int want_discon)
 {
        struct dentry *alias, *discon_alias;
+        struct hlist_node *p;
 again:
        discon_alias = NULL;
-        list_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, p, &inode->i_dentry, d_alias) {
                spin_lock(&alias->d_lock);
                if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
                        if (IS_ROOT(alias) &&
                            (alias->d_flags & DCACHE_DISCONNECTED)) {
                                discon_alias = alias;
-                        } else {
+                        } else if (!want_discon) {
                                __dget_dlock(alias);
                                spin_unlock(&alias->d_lock);
                                return alias;
@@ -734,9 +738,9 @@ struct dentry *d_find_alias(struct inode *inode)
 {
        struct dentry *de = NULL;
-        if (!list_empty(&inode->i_dentry)) {
+        if (!hlist_empty(&inode->i_dentry)) {
                spin_lock(&inode->i_lock);
-                de = __d_find_alias(inode);
+                de = __d_find_alias(inode, 0);
                spin_unlock(&inode->i_lock);
        }
        return de;
@@ -750,9 +754,10 @@ EXPORT_SYMBOL(d_find_alias);
 void d_prune_aliases(struct inode *inode)
 {
        struct dentry *dentry;
+        struct hlist_node *p;
 restart:
        spin_lock(&inode->i_lock);
-        list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
                spin_lock(&dentry->d_lock);
                if (!dentry->d_count) {
                        __dget_dlock(dentry);
@@ -974,7 +979,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
                        inode = dentry->d_inode;
                        if (inode) {
                                dentry->d_inode = NULL;
-                                list_del_init(&dentry->d_alias);
+                                hlist_del_init(&dentry->d_alias);
                                if (dentry->d_op && dentry->d_op->d_iput)
                                        dentry->d_op->d_iput(dentry, inode);
                                else
@@ -1309,7 +1314,7 @@ 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_LIST_HEAD(&dentry->d_alias);
+        INIT_HLIST_NODE(&dentry->d_alias);
        INIT_LIST_HEAD(&dentry->d_u.d_child);
        d_set_d_op(dentry, dentry->d_sb->s_d_op);
@@ -1397,7 +1402,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
        if (inode) {
                if (unlikely(IS_AUTOMOUNT(inode)))
                        dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
-                list_add(&dentry->d_alias, &inode->i_dentry);
+                hlist_add_head(&dentry->d_alias, &inode->i_dentry);
        }
        dentry->d_inode = inode;
        dentry_rcuwalk_barrier(dentry);
@@ -1422,7 +1427,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
 
 void d_instantiate(struct dentry *entry, struct inode * inode)
 {
-        BUG_ON(!list_empty(&entry->d_alias));
+        BUG_ON(!hlist_unhashed(&entry->d_alias));
        if (inode)
                spin_lock(&inode->i_lock);
        __d_instantiate(entry, inode);
@@ -1455,13 +1460,14 @@ static struct dentry *__d_instantiate_unique(struct dentry *entry,
        int len = entry->d_name.len;
        const char *name = entry->d_name.name;
        unsigned int hash = entry->d_name.hash;
+        struct hlist_node *p;
        if (!inode) {
                __d_instantiate(entry, NULL);
                return NULL;
        }
-        list_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, p, &inode->i_dentry, d_alias) {
                /*
                 * Don't need alias->d_lock here, because aliases with
                 * d_parent == entry->d_parent are not subject to name or
@@ -1487,7 +1493,7 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
 {
        struct dentry *result;
-        BUG_ON(!list_empty(&entry->d_alias));
+        BUG_ON(!hlist_unhashed(&entry->d_alias));
        if (inode)
                spin_lock(&inode->i_lock);
@@ -1528,9 +1534,9 @@ static struct dentry * __d_find_any_alias(struct inode *inode)
 {
        struct dentry *alias;
-        if (list_empty(&inode->i_dentry))
+        if (hlist_empty(&inode->i_dentry))
                return NULL;
-        alias = list_first_entry(&inode->i_dentry, struct dentry, d_alias);
+        alias = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
        __dget(alias);
        return alias;
 }
@@ -1604,7 +1610,7 @@ struct dentry *d_obtain_alias(struct inode *inode)
        spin_lock(&tmp->d_lock);
        tmp->d_inode = inode;
        tmp->d_flags |= DCACHE_DISCONNECTED;
-        list_add(&tmp->d_alias, &inode->i_dentry);
+        hlist_add_head(&tmp->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);
@@ -1647,8 +1653,9 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
        if (inode && S_ISDIR(inode->i_mode)) {
                spin_lock(&inode->i_lock);
-                new = __d_find_any_alias(inode);
+                new = __d_find_alias(inode, 1);
                if (new) {
+                        BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED));
                        spin_unlock(&inode->i_lock);
                        security_d_instantiate(new, inode);
                        d_move(new, dentry);
@@ -2380,14 +2387,13 @@ static struct dentry *__d_unalias(struct inode *inode,
                struct dentry *dentry, struct dentry *alias)
 {
        struct mutex *m1 = NULL, *m2 = NULL;
-        struct dentry *ret;
+        struct dentry *ret = ERR_PTR(-EBUSY);
        /* If alias and dentry share a parent, then no extra locks required */
        if (alias->d_parent == dentry->d_parent)
                goto out_unalias;
        /* See lock_rename() */
-        ret = ERR_PTR(-EBUSY);
        if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex))
                goto out_err;
        m1 = &dentry->d_sb->s_vfs_rename_mutex;
@@ -2395,8 +2401,10 @@ static struct dentry *__d_unalias(struct inode *inode,
                goto out_err;
        m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
-        __d_move(alias, dentry);
+        if (likely(!d_mountpoint(alias))) {
-        ret = alias;
+                __d_move(alias, dentry);
+                ret = alias;
+        }
 out_err:
        spin_unlock(&inode->i_lock);
        if (m2)
@@ -2478,7 +2486,7 @@ struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
                struct dentry *alias;
                /* Does an aliased dentry already exist? */
-                alias = __d_find_alias(inode);
+                alias = __d_find_alias(inode, 0);
                if (alias) {
                        actual = alias;
                        write_seqlock(&rename_lock);
@@ -2618,7 +2626,7 @@ global_root:
        if (!slash)
                error = prepend(buffer, buflen, "/", 1);
        if (!error)
-                error = real_mount(vfsmnt)->mnt_ns ? 1 : 2;
+                error = is_mounted(vfsmnt) ? 1 : 2;
        goto out;
 }
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index b80bc846a15a..d17c20fd74e6 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -54,13 +54,12 @@ static struct inode *debugfs_get_inode(struct super_block *sb, umode_t mode, dev
                        break;
                case S_IFLNK:
                        inode->i_op = &debugfs_link_operations;
-                        inode->i_fop = fops;
                        inode->i_private = data;
                        break;
                case S_IFDIR:
                        inode->i_op = &simple_dir_inode_operations;
-                        inode->i_fop = fops ? fops : &simple_dir_operations;
+                        inode->i_fop = &simple_dir_operations;
-                        inode->i_private = data;
+                        inode->i_private = NULL;
                        /* directory inodes start off with i_nlink == 2
                         * (for "." entry) */
@@ -91,13 +90,12 @@ static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
        return error;
 }
-static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode,
+static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
-                         void *data, const struct file_operations *fops)
 {
        int res;
        mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
-        res = debugfs_mknod(dir, dentry, mode, 0, data, fops);
+        res = debugfs_mknod(dir, dentry, mode, 0, NULL, NULL);
        if (!res) {
                inc_nlink(dir);
                fsnotify_mkdir(dir, dentry);
@@ -106,10 +104,10 @@ static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode,
 }
 static int debugfs_link(struct inode *dir, struct dentry *dentry, umode_t mode,
-                        void *data, const struct file_operations *fops)
+                        void *data)
 {
        mode = (mode & S_IALLUGO) | S_IFLNK;
-        return debugfs_mknod(dir, dentry, mode, 0, data, fops);
+        return debugfs_mknod(dir, dentry, mode, 0, data, NULL);
 }
 static int debugfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
@@ -293,13 +291,19 @@ static struct file_system_type debug_fs_type = {
        .kill_sb =      kill_litter_super,
 };
-static int debugfs_create_by_name(const char *name, umode_t mode,
+struct dentry *__create_file(const char *name, umode_t mode,
-                                  struct dentry *parent,
+                                   struct dentry *parent, void *data,
-                                  struct dentry **dentry,
+                                   const struct file_operations *fops)
-                                  void *data,
-                                  const struct file_operations *fops)
 {
-        int error = 0;
+        struct dentry *dentry = NULL;
+        int error;
+        pr_debug("debugfs: creating file '%s'\n",name);
+        error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
+                              &debugfs_mount_count);
+        if (error)
+                goto exit;
        /* If the parent is not specified, we create it in the root.
         * We need the root dentry to do this, which is in the super 
@@ -309,30 +313,35 @@ static int debugfs_create_by_name(const char *name, umode_t mode,
        if (!parent)
                parent = debugfs_mount->mnt_root;
-        *dentry = NULL;
+        dentry = NULL;
        mutex_lock(&parent->d_inode->i_mutex);
-        *dentry = lookup_one_len(name, parent, strlen(name));
+        dentry = lookup_one_len(name, parent, strlen(name));
-        if (!IS_ERR(*dentry)) {
+        if (!IS_ERR(dentry)) {
                switch (mode & S_IFMT) {
                case S_IFDIR:
-                        error = debugfs_mkdir(parent->d_inode, *dentry, mode,
+                        error = debugfs_mkdir(parent->d_inode, dentry, mode);
-                                              data, fops);
+                                              
                        break;
                case S_IFLNK:
-                        error = debugfs_link(parent->d_inode, *dentry, mode,
+                        error = debugfs_link(parent->d_inode, dentry, mode,
-                                             data, fops);
+                                             data);
                        break;
                default:
-                        error = debugfs_create(parent->d_inode, *dentry, mode,
+                        error = debugfs_create(parent->d_inode, dentry, mode,
                                               data, fops);
                        break;
                }
-                dput(*dentry);
+                dput(dentry);
        } else
-                error = PTR_ERR(*dentry);
+                error = PTR_ERR(dentry);
        mutex_unlock(&parent->d_inode->i_mutex);
-        return error;
+        if (error) {
+                dentry = NULL;
+                simple_release_fs(&debugfs_mount, &debugfs_mount_count);
+        }
+exit:
+        return dentry;
 }
 /**
@@ -365,25 +374,15 @@ struct dentry *debugfs_create_file(const char *name, umode_t mode,
                                   struct dentry *parent, void *data,
                                   const struct file_operations *fops)
 {
-        struct dentry *dentry = NULL;
+        switch (mode & S_IFMT) {
-        int error;
+        case S_IFREG:
+        case 0:
-        pr_debug("debugfs: creating file '%s'\n",name);
+                break;
+        default:
-        error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
+                BUG();
-                              &debugfs_mount_count);
-        if (error)
-                goto exit;
-        error = debugfs_create_by_name(name, mode, parent, &dentry,
-                                       data, fops);
-        if (error) {
-                dentry = NULL;
-                simple_release_fs(&debugfs_mount, &debugfs_mount_count);
-                goto exit;
        }
-exit:
-        return dentry;
+        return __create_file(name, mode, parent, data, fops);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_file);
@@ -407,8 +406,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_file);
 */
 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
 {
-        return debugfs_create_file(name, 
+        return __create_file(name, S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
-                                   S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
                                   parent, NULL, NULL);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_dir);
@@ -446,8 +444,7 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
        if (!link)
                return NULL;
-        result = debugfs_create_file(name, S_IFLNK | S_IRWXUGO, parent, link,
+        result = __create_file(name, S_IFLNK | S_IRWXUGO, parent, link, NULL);
-                                     NULL);
        if (!result)
                kfree(link);
        return result;
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 979c1e309c73..14afbabe6546 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -439,15 +439,15 @@ static struct dentry *devpts_mount(struct file_system_type *fs_type,
                return ERR_PTR(error);
        if (opts.newinstance)
-                s = sget(fs_type, NULL, set_anon_super, NULL);
+                s = sget(fs_type, NULL, set_anon_super, flags, NULL);
        else
-                s = sget(fs_type, compare_init_pts_sb, set_anon_super, NULL);
+                s = sget(fs_type, compare_init_pts_sb, set_anon_super, flags,
+                         NULL);
        if (IS_ERR(s))
                return ERR_CAST(s);
        if (!s->s_root) {
-                s->s_flags = flags;
                error = devpts_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
                if (error)
                        goto out_undo_sget;
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 0c85fae37666..1faf4cb56f39 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1258,7 +1258,7 @@ do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         */
        BUG_ON(retval == -EIOCBQUEUED);
        if (dio->is_async && retval == 0 && dio->result &&
-            ((rw & READ) || (dio->result == sdio.size)))
+            ((rw == READ) || (dio->result == sdio.size)))
                retval = -EIOCBQUEUED;
        if (retval != -EIOCBQUEUED)
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index 534c1d46e69e..1b5d9af937df 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -32,7 +32,7 @@
 /**
 * ecryptfs_d_revalidate - revalidate an ecryptfs dentry
 * @dentry: The ecryptfs dentry
- * @nd: The associated nameidata
+ * @flags: lookup flags
 *
 * Called when the VFS needs to revalidate a dentry. This
 * is called whenever a name lookup finds a dentry in the
@@ -42,32 +42,20 @@
 * Returns 1 if valid, 0 otherwise.
 *
 */
-static int ecryptfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int ecryptfs_d_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct dentry *lower_dentry;
        struct vfsmount *lower_mnt;
-        struct dentry *dentry_save = NULL;
-        struct vfsmount *vfsmount_save = NULL;
        int rc = 1;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        lower_dentry = ecryptfs_dentry_to_lower(dentry);
        lower_mnt = ecryptfs_dentry_to_lower_mnt(dentry);
        if (!lower_dentry->d_op || !lower_dentry->d_op->d_revalidate)
                goto out;
-        if (nd) {
+        rc = lower_dentry->d_op->d_revalidate(lower_dentry, flags);
-                dentry_save = nd->path.dentry;
-                vfsmount_save = nd->path.mnt;
-                nd->path.dentry = lower_dentry;
-                nd->path.mnt = lower_mnt;
-        }
-        rc = lower_dentry->d_op->d_revalidate(lower_dentry, nd);
-        if (nd) {
-                nd->path.dentry = dentry_save;
-                nd->path.mnt = vfsmount_save;
-        }
        if (dentry->d_inode) {
                struct inode *lower_inode =
                        ecryptfs_inode_to_lower(dentry->d_inode);
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 867b64c5d84f..989e034f02bd 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -550,20 +550,6 @@ extern struct kmem_cache *ecryptfs_key_record_cache;
 extern struct kmem_cache *ecryptfs_key_sig_cache;
 extern struct kmem_cache *ecryptfs_global_auth_tok_cache;
 extern struct kmem_cache *ecryptfs_key_tfm_cache;
-extern struct kmem_cache *ecryptfs_open_req_cache;
-struct ecryptfs_open_req {
-#define ECRYPTFS_REQ_PROCESSED 0x00000001
-#define ECRYPTFS_REQ_DROPPED   0x00000002
-#define ECRYPTFS_REQ_ZOMBIE    0x00000004
-        u32 flags;
-        struct file **lower_file;
-        struct dentry *lower_dentry;
-        struct vfsmount *lower_mnt;
-        wait_queue_head_t wait;
-        struct mutex mux;
-        struct list_head kthread_ctl_list;
-};
 struct inode *ecryptfs_get_inode(struct inode *lower_inode,
                                 struct super_block *sb);
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index a07441a0a878..ffa2be57804d 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -173,7 +173,7 @@ ecryptfs_do_create(struct inode *directory_inode,
                inode = ERR_CAST(lower_dir_dentry);
                goto out;
        }
-        rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, NULL);
+        rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true);
        if (rc) {
                printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
                       "rc = [%d]\n", __func__, rc);
@@ -240,7 +240,6 @@ out:
 * @dir: The inode of the directory in which to create the file.
 * @dentry: The eCryptfs dentry
 * @mode: The mode of the new file.
- * @nd: nameidata
 *
 * Creates a new file.
 *
@@ -248,7 +247,7 @@ out:
 */
 static int
 ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry,
-                umode_t mode, struct nameidata *nd)
+                umode_t mode, bool excl)
 {
        struct inode *ecryptfs_inode;
        int rc;
@@ -270,8 +269,8 @@ ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry,
                iput(ecryptfs_inode);
                goto out;
        }
-        d_instantiate(ecryptfs_dentry, ecryptfs_inode);
        unlock_new_inode(ecryptfs_inode);
+        d_instantiate(ecryptfs_dentry, ecryptfs_inode);
 out:
        return rc;
 }
@@ -374,7 +373,7 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
 */
 static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                                      struct dentry *ecryptfs_dentry,
-                                      struct nameidata *ecryptfs_nd)
+                                      unsigned int flags)
 {
        char *encrypted_and_encoded_name = NULL;
        size_t encrypted_and_encoded_name_size;
diff --git a/fs/ecryptfs/kthread.c b/fs/ecryptfs/kthread.c
index 69f994a7d524..809e67d05ca3 100644
--- a/fs/ecryptfs/kthread.c
+++ b/fs/ecryptfs/kthread.c
@@ -27,7 +27,12 @@
 #include <linux/mount.h>
 #include "ecryptfs_kernel.h"
-struct kmem_cache *ecryptfs_open_req_cache;
+struct ecryptfs_open_req {
+        struct file **lower_file;
+        struct path path;
+        struct completion done;
+        struct list_head kthread_ctl_list;
+};
 static struct ecryptfs_kthread_ctl {
 #define ECRYPTFS_KTHREAD_ZOMBIE 0x00000001
@@ -67,18 +72,10 @@ static int ecryptfs_threadfn(void *ignored)
                        req = list_first_entry(&ecryptfs_kthread_ctl.req_list,
                                               struct ecryptfs_open_req,
                                               kthread_ctl_list);
-                        mutex_lock(&req->mux);
                        list_del(&req->kthread_ctl_list);
-                        if (!(req->flags & ECRYPTFS_REQ_ZOMBIE)) {
+                        *req->lower_file = dentry_open(&req->path,
-                                dget(req->lower_dentry);
+                                (O_RDWR | O_LARGEFILE), current_cred());
-                                mntget(req->lower_mnt);
+                        complete(&req->done);
-                                (*req->lower_file) = dentry_open(
-                                        req->lower_dentry, req->lower_mnt,
-                                        (O_RDWR | O_LARGEFILE), current_cred());
-                                req->flags |= ECRYPTFS_REQ_PROCESSED;
-                        }
-                        wake_up(&req->wait);
-                        mutex_unlock(&req->mux);
                }
                mutex_unlock(&ecryptfs_kthread_ctl.mux);
        }
@@ -111,10 +108,9 @@ void ecryptfs_destroy_kthread(void)
        ecryptfs_kthread_ctl.flags |= ECRYPTFS_KTHREAD_ZOMBIE;
        list_for_each_entry(req, &ecryptfs_kthread_ctl.req_list,
                            kthread_ctl_list) {
-                mutex_lock(&req->mux);
+                list_del(&req->kthread_ctl_list);
-                req->flags |= ECRYPTFS_REQ_ZOMBIE;
+                *req->lower_file = ERR_PTR(-EIO);
-                wake_up(&req->wait);
+                complete(&req->done);
-                mutex_unlock(&req->mux);
        }
        mutex_unlock(&ecryptfs_kthread_ctl.mux);
        kthread_stop(ecryptfs_kthread);
@@ -136,34 +132,26 @@ int ecryptfs_privileged_open(struct file **lower_file,
                             struct vfsmount *lower_mnt,
                             const struct cred *cred)
 {
-        struct ecryptfs_open_req *req;
+        struct ecryptfs_open_req req;
        int flags = O_LARGEFILE;
        int rc = 0;
+        init_completion(&req.done);
+        req.lower_file = lower_file;
+        req.path.dentry = lower_dentry;
+        req.path.mnt = lower_mnt;
        /* Corresponding dput() and mntput() are done when the
         * lower file is fput() when all eCryptfs files for the inode are
         * released. */
-        dget(lower_dentry);
-        mntget(lower_mnt);
        flags |= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR;
-        (*lower_file) = dentry_open(lower_dentry, lower_mnt, flags, cred);
+        (*lower_file) = dentry_open(&req.path, flags, cred);
        if (!IS_ERR(*lower_file))
                goto out;
-        if (flags & O_RDONLY) {
+        if ((flags & O_ACCMODE) == O_RDONLY) {
                rc = PTR_ERR((*lower_file));
                goto out;
        }
-        req = kmem_cache_alloc(ecryptfs_open_req_cache, GFP_KERNEL);
-        if (!req) {
-                rc = -ENOMEM;
-                goto out;
-        }
-        mutex_init(&req->mux);
-        req->lower_file = lower_file;
-        req->lower_dentry = lower_dentry;
-        req->lower_mnt = lower_mnt;
-        init_waitqueue_head(&req->wait);
-        req->flags = 0;
        mutex_lock(&ecryptfs_kthread_ctl.mux);
        if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
                rc = -EIO;
@@ -171,27 +159,14 @@ int ecryptfs_privileged_open(struct file **lower_file,
                printk(KERN_ERR "%s: We are in the middle of shutting down; "
                       "aborting privileged request to open lower file\n",
                        __func__);
-                goto out_free;
+                goto out;
        }
-        list_add_tail(&req->kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
+        list_add_tail(&req.kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
        mutex_unlock(&ecryptfs_kthread_ctl.mux);
        wake_up(&ecryptfs_kthread_ctl.wait);
-        wait_event(req->wait, (req->flags != 0));
+        wait_for_completion(&req.done);
-        mutex_lock(&req->mux);
+        if (IS_ERR(*lower_file))
-        BUG_ON(req->flags == 0);
+                rc = PTR_ERR(*lower_file);
-        if (req->flags & ECRYPTFS_REQ_DROPPED
-            || req->flags & ECRYPTFS_REQ_ZOMBIE) {
-                rc = -EIO;
-                printk(KERN_WARNING "%s: Privileged open request dropped\n",
-                       __func__);
-                goto out_unlock;
-        }
-        if (IS_ERR(*req->lower_file))
-                rc = PTR_ERR(*req->lower_file);
-out_unlock:
-        mutex_unlock(&req->mux);
-out_free:
-        kmem_cache_free(ecryptfs_open_req_cache, req);
 out:
        return rc;
 }
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 68954937a071..1c0b3b6b75c6 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -499,13 +499,12 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                goto out;
        }
-        s = sget(fs_type, NULL, set_anon_super, NULL);
+        s = sget(fs_type, NULL, set_anon_super, flags, NULL);
        if (IS_ERR(s)) {
                rc = PTR_ERR(s);
                goto out;
        }
-        s->s_flags = flags;
        rc = bdi_setup_and_register(&sbi->bdi, "ecryptfs", BDI_CAP_MAP_COPY);
        if (rc)
                goto out1;
@@ -682,11 +681,6 @@ static struct ecryptfs_cache_info {
                .name = "ecryptfs_key_tfm_cache",
                .size = sizeof(struct ecryptfs_key_tfm),
        },
-        {
-                .cache = &ecryptfs_open_req_cache,
-                .name = "ecryptfs_open_req_cache",
-                .size = sizeof(struct ecryptfs_open_req),
-        },
 };
 static void ecryptfs_free_kmem_caches(void)
diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 3a06f4043df4..c0038f6566d4 100644
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -49,7 +49,10 @@ ecryptfs_miscdev_poll(struct file *file, poll_table *pt)
        mutex_lock(&ecryptfs_daemon_hash_mux);
        /* TODO: Just use file->private_data? */
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon) {
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EINVAL;
+        }
        mutex_lock(&daemon->mux);
        mutex_unlock(&ecryptfs_daemon_hash_mux);
        if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
@@ -122,6 +125,7 @@ ecryptfs_miscdev_open(struct inode *inode, struct file *file)
                goto out_unlock_daemon;
        }
        daemon->flags |= ECRYPTFS_DAEMON_MISCDEV_OPEN;
+        file->private_data = daemon;
        atomic_inc(&ecryptfs_num_miscdev_opens);
 out_unlock_daemon:
        mutex_unlock(&daemon->mux);
@@ -152,9 +156,9 @@ ecryptfs_miscdev_release(struct inode *inode, struct file *file)
        mutex_lock(&ecryptfs_daemon_hash_mux);
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon)
+                daemon = file->private_data;
        mutex_lock(&daemon->mux);
-        BUG_ON(daemon->pid != task_pid(current));
        BUG_ON(!(daemon->flags & ECRYPTFS_DAEMON_MISCDEV_OPEN));
        daemon->flags &= ~ECRYPTFS_DAEMON_MISCDEV_OPEN;
        atomic_dec(&ecryptfs_num_miscdev_opens);
@@ -191,31 +195,32 @@ int ecryptfs_send_miscdev(char *data, size_t data_size,
                          struct ecryptfs_msg_ctx *msg_ctx, u8 msg_type,
                          u16 msg_flags, struct ecryptfs_daemon *daemon)
 {
-        int rc = 0;
+        struct ecryptfs_message *msg;
-        mutex_lock(&msg_ctx->mux);
+        msg = kmalloc((sizeof(*msg) + data_size), GFP_KERNEL);
-        msg_ctx->msg = kmalloc((sizeof(*msg_ctx->msg) + data_size),
+        if (!msg) {
-                               GFP_KERNEL);
-        if (!msg_ctx->msg) {
-                rc = -ENOMEM;
                printk(KERN_ERR "%s: Out of memory whilst attempting "
                       "to kmalloc(%zd, GFP_KERNEL)\n", __func__,
-                       (sizeof(*msg_ctx->msg) + data_size));
+                       (sizeof(*msg) + data_size));
-                goto out_unlock;
+                return -ENOMEM;
        }
+        mutex_lock(&msg_ctx->mux);
+        msg_ctx->msg = msg;
        msg_ctx->msg->index = msg_ctx->index;
        msg_ctx->msg->data_len = data_size;
        msg_ctx->type = msg_type;
        memcpy(msg_ctx->msg->data, data, data_size);
        msg_ctx->msg_size = (sizeof(*msg_ctx->msg) + data_size);
-        mutex_lock(&daemon->mux);
        list_add_tail(&msg_ctx->daemon_out_list, &daemon->msg_ctx_out_queue);
+        mutex_unlock(&msg_ctx->mux);
+        mutex_lock(&daemon->mux);
        daemon->num_queued_msg_ctx++;
        wake_up_interruptible(&daemon->wait);
        mutex_unlock(&daemon->mux);
-out_unlock:
-        mutex_unlock(&msg_ctx->mux);
+        return 0;
-        return rc;
 }
 /*
@@ -269,8 +274,16 @@ ecryptfs_miscdev_read(struct file *file, char __user *buf, size_t count,
        mutex_lock(&ecryptfs_daemon_hash_mux);
        /* TODO: Just use file->private_data? */
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon) {
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EINVAL;
+        }
        mutex_lock(&daemon->mux);
+        if (task_pid(current) != daemon->pid) {
+                mutex_unlock(&daemon->mux);
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EPERM;
+        }
        if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
                rc = 0;
                mutex_unlock(&ecryptfs_daemon_hash_mux);
@@ -307,9 +320,6 @@ check_list:
                 * message from the queue; try again */
                goto check_list;
        }
-        BUG_ON(euid != daemon->euid);
-        BUG_ON(current_user_ns() != daemon->user_ns);
-        BUG_ON(task_pid(current) != daemon->pid);
        msg_ctx = list_first_entry(&daemon->msg_ctx_out_queue,
                                   struct ecryptfs_msg_ctx, daemon_out_list);
        BUG_ON(!msg_ctx);
diff --git a/fs/efs/efs.h b/fs/efs/efs.h
index d8305b582ab0..5528926ac7f6 100644
--- a/fs/efs/efs.h
+++ b/fs/efs/efs.h
@@ -129,7 +129,7 @@ extern struct inode *efs_iget(struct super_block *, unsigned long);
 extern efs_block_t efs_map_block(struct inode *, efs_block_t);
 extern int efs_get_block(struct inode *, sector_t, struct buffer_head *, int);
-extern struct dentry *efs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *efs_lookup(struct inode *, struct dentry *, unsigned int);
 extern struct dentry *efs_fh_to_dentry(struct super_block *sb, struct fid *fid,
                int fh_len, int fh_type);
 extern struct dentry *efs_fh_to_parent(struct super_block *sb, struct fid *fid,
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index 832b10ded82f..96f66d213a19 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -58,7 +58,8 @@ static efs_ino_t efs_find_entry(struct inode *inode, const char *name, int len)
        return(0);
 }
-struct dentry *efs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) {
+struct dentry *efs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
+{
        efs_ino_t inodenum;
        struct inode *inode = NULL;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 74598f67efeb..1c8b55670804 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -1710,7 +1710,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
                goto error_tgt_fput;
        /* Check if EPOLLWAKEUP is allowed */
-        if ((epds.events & EPOLLWAKEUP) && !capable(CAP_EPOLLWAKEUP))
+        if ((epds.events & EPOLLWAKEUP) && !capable(CAP_BLOCK_SUSPEND))
                epds.events &= ~EPOLLWAKEUP;
        /*
diff --git a/fs/exec.c b/fs/exec.c
index a79786a8d2c8..da27b91ff1e8 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -819,10 +819,10 @@ static int exec_mmap(struct mm_struct *mm)
        /* Notify parent that we're no longer interested in the old VM */
        tsk = current;
        old_mm = current->mm;
-        sync_mm_rss(old_mm);
        mm_release(tsk, old_mm);
        if (old_mm) {
+                sync_mm_rss(old_mm);
                /*
                 * Make sure that if there is a core dump in progress
                 * for the old mm, we get out and die instead of going
diff --git a/fs/exofs/namei.c b/fs/exofs/namei.c
index fc7161d6bf6b..4731fd991efe 100644
--- a/fs/exofs/namei.c
+++ b/fs/exofs/namei.c
@@ -46,7 +46,7 @@ static inline int exofs_add_nondir(struct dentry *dentry, struct inode *inode)
 }
 static struct dentry *exofs_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        struct inode *inode;
        ino_t ino;
@@ -60,7 +60,7 @@ static struct dentry *exofs_lookup(struct inode *dir, struct dentry *dentry,
 }
 static int exofs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                         struct nameidata *nd)
+                         bool excl)
 {
        struct inode *inode = exofs_new_inode(dir, mode);
        int err = PTR_ERR(inode);
diff --git a/fs/exofs/ore.c b/fs/exofs/ore.c
index 49cf230554a2..24a49d47e935 100644
--- a/fs/exofs/ore.c
+++ b/fs/exofs/ore.c
@@ -735,13 +735,7 @@ static int _prepare_for_striping(struct ore_io_state *ios)
 out:
        ios->numdevs = devs_in_group;
        ios->pages_consumed = cur_pg;
-        if (unlikely(ret)) {
+        return ret;
-                if (length == ios->length)
-                        return ret;
-                else
-                        ios->length -= length;
-        }
-        return 0;
 }
 int ore_create(struct ore_io_state *ios)
diff --git a/fs/exofs/ore_raid.c b/fs/exofs/ore_raid.c
index d222c77cfa1b..5f376d14fdcc 100644
--- a/fs/exofs/ore_raid.c
+++ b/fs/exofs/ore_raid.c
@@ -144,26 +144,26 @@ static void _sp2d_reset(struct __stripe_pages_2d *sp2d,
 {
        unsigned data_devs = sp2d->data_devs;
        unsigned group_width = data_devs + sp2d->parity;
-        unsigned p;
+        int p, c;
        if (!sp2d->needed)
                return;
-        for (p = 0; p < sp2d->pages_in_unit; p++) {
+        for (c = data_devs - 1; c >= 0; --c)
-                struct __1_page_stripe *_1ps = &sp2d->_1p_stripes[p];
+                for (p = sp2d->pages_in_unit - 1; p >= 0; --p) {
+                        struct __1_page_stripe *_1ps = &sp2d->_1p_stripes[p];
-                if (_1ps->write_count < group_width) {
-                        unsigned c;
-                        for (c = 0; c < data_devs; c++)
+                        if (_1ps->page_is_read[c]) {
-                                if (_1ps->page_is_read[c]) {
+                                struct page *page = _1ps->pages[c];
-                                        struct page *page = _1ps->pages[c];
-                                        r4w->put_page(priv, page);
+                                r4w->put_page(priv, page);
-                                        _1ps->page_is_read[c] = false;
+                                _1ps->page_is_read[c] = false;
-                                }
+                        }
                }
+        for (p = 0; p < sp2d->pages_in_unit; p++) {
+                struct __1_page_stripe *_1ps = &sp2d->_1p_stripes[p];
                memset(_1ps->pages, 0, group_width * sizeof(*_1ps->pages));
                _1ps->write_count = 0;
                _1ps->tx = NULL;
@@ -461,16 +461,12 @@ static void _mark_read4write_pages_uptodate(struct ore_io_state *ios, int ret)
 * ios->sp2d[p][*], xor is calculated the same way. These pages are
 * allocated/freed and don't go through cache
 */
-static int _read_4_write(struct ore_io_state *ios)
+static int _read_4_write_first_stripe(struct ore_io_state *ios)
 {
-        struct ore_io_state *ios_read;
        struct ore_striping_info read_si;
        struct __stripe_pages_2d *sp2d = ios->sp2d;
        u64 offset = ios->si.first_stripe_start;
-        u64 last_stripe_end;
+        unsigned c, p, min_p = sp2d->pages_in_unit, max_p = -1;
-        unsigned bytes_in_stripe = ios->si.bytes_in_stripe;
-        unsigned i, c, p, min_p = sp2d->pages_in_unit, max_p = -1;
-        int ret;
        if (offset == ios->offset) /* Go to start collect $200 */
                goto read_last_stripe;
@@ -478,6 +474,9 @@ static int _read_4_write(struct ore_io_state *ios)
        min_p = _sp2d_min_pg(sp2d);
        max_p = _sp2d_max_pg(sp2d);
+        ORE_DBGMSG("stripe_start=0x%llx ios->offset=0x%llx min_p=%d max_p=%d\n",
+                   offset, ios->offset, min_p, max_p);
        for (c = 0; ; c++) {
                ore_calc_stripe_info(ios->layout, offset, 0, &read_si);
                read_si.obj_offset += min_p * PAGE_SIZE;
@@ -512,6 +511,18 @@ static int _read_4_write(struct ore_io_state *ios)
        }
 read_last_stripe:
+        return 0;
+}
+static int _read_4_write_last_stripe(struct ore_io_state *ios)
+{
+        struct ore_striping_info read_si;
+        struct __stripe_pages_2d *sp2d = ios->sp2d;
+        u64 offset;
+        u64 last_stripe_end;
+        unsigned bytes_in_stripe = ios->si.bytes_in_stripe;
+        unsigned c, p, min_p = sp2d->pages_in_unit, max_p = -1;
        offset = ios->offset + ios->length;
        if (offset % PAGE_SIZE)
                _add_to_r4w_last_page(ios, &offset);
@@ -527,15 +538,15 @@ read_last_stripe:
        c = _dev_order(ios->layout->group_width * ios->layout->mirrors_p1,
                       ios->layout->mirrors_p1, read_si.par_dev, read_si.dev);
-        BUG_ON(ios->si.first_stripe_start + bytes_in_stripe != last_stripe_end);
-        /* unaligned IO must be within a single stripe */
        if (min_p == sp2d->pages_in_unit) {
                /* Didn't do it yet */
                min_p = _sp2d_min_pg(sp2d);
                max_p = _sp2d_max_pg(sp2d);
        }
+        ORE_DBGMSG("offset=0x%llx stripe_end=0x%llx min_p=%d max_p=%d\n",
+                   offset, last_stripe_end, min_p, max_p);
        while (offset < last_stripe_end) {
                struct __1_page_stripe *_1ps = &sp2d->_1p_stripes[p];
@@ -568,6 +579,15 @@ read_last_stripe:
        }
 read_it:
+        return 0;
+}
+static int _read_4_write_execute(struct ore_io_state *ios)
+{
+        struct ore_io_state *ios_read;
+        unsigned i;
+        int ret;
        ios_read = ios->ios_read_4_write;
        if (!ios_read)
                return 0;
@@ -591,6 +611,8 @@ read_it:
        }
        _mark_read4write_pages_uptodate(ios_read, ret);
+        ore_put_io_state(ios_read);
+        ios->ios_read_4_write = NULL; /* Might need a reuse at last stripe */
        return 0;
 }
@@ -626,8 +648,11 @@ int _ore_add_parity_unit(struct ore_io_state *ios,
                        /* If first stripe, Read in all read4write pages
                         * (if needed) before we calculate the first parity.
                         */
-                        _read_4_write(ios);
+                        _read_4_write_first_stripe(ios);
                }
+                if (!cur_len) /* If last stripe r4w pages of last stripe */
+                        _read_4_write_last_stripe(ios);
+                _read_4_write_execute(ios);
                for (i = 0; i < num_pages; i++) {
                        pages[i] = _raid_page_alloc();
@@ -654,34 +679,14 @@ int _ore_add_parity_unit(struct ore_io_state *ios,
 int _ore_post_alloc_raid_stuff(struct ore_io_state *ios)
 {
-        struct ore_layout *layout = ios->layout;
        if (ios->parity_pages) {
+                struct ore_layout *layout = ios->layout;
                unsigned pages_in_unit = layout->stripe_unit / PAGE_SIZE;
-                unsigned stripe_size = ios->si.bytes_in_stripe;
-                u64 last_stripe, first_stripe;
                if (_sp2d_alloc(pages_in_unit, layout->group_width,
                                layout->parity, &ios->sp2d)) {
                        return -ENOMEM;
                }
-                /* Round io down to last full strip */
-                first_stripe = div_u64(ios->offset, stripe_size);
-                last_stripe = div_u64(ios->offset + ios->length, stripe_size);
-                /* If an IO spans more then a single stripe it must end at
-                 * a stripe boundary. The reminder at the end is pushed into the
-                 * next IO.
-                 */
-                if (last_stripe != first_stripe) {
-                        ios->length = last_stripe * stripe_size - ios->offset;
-                        BUG_ON(!ios->length);
-                        ios->nr_pages = (ios->length + PAGE_SIZE - 1) /
-                                        PAGE_SIZE;
-                        ios->si.length = ios->length; /*make it consistent */
-                }
        }
        return 0;
 }
diff --git a/fs/exofs/sys.c b/fs/exofs/sys.c
index e32bc919e4e3..5a7b691e748b 100644
--- a/fs/exofs/sys.c
+++ b/fs/exofs/sys.c
@@ -109,7 +109,7 @@ static struct kobj_type odev_ktype = {
 static struct kobj_type uuid_ktype = {
 };
-void exofs_sysfs_dbg_print()
+void exofs_sysfs_dbg_print(void)
 {
 #ifdef CONFIG_EXOFS_DEBUG
        struct kobject *k_name, *k_tmp;
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index b0201ca6e9c6..29ab099e3e08 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -19,19 +19,19 @@
 #define dprintk(fmt, args...) do{}while(0)
-static int get_name(struct vfsmount *mnt, struct dentry *dentry, char *name,
+static int get_name(const struct path *path, char *name, struct dentry *child);
-                struct dentry *child);
 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
                char *name, struct dentry *child)
 {
        const struct export_operations *nop = dir->d_sb->s_export_op;
+        struct path path = {.mnt = mnt, .dentry = dir};
        if (nop->get_name)
                return nop->get_name(dir, name, child);
        else
-                return get_name(mnt, dir, name, child);
+                return get_name(&path, name, child);
 }
 /*
@@ -44,13 +44,14 @@ find_acceptable_alias(struct dentry *result,
 {
        struct dentry *dentry, *toput = NULL;
        struct inode *inode;
+        struct hlist_node *p;
        if (acceptable(context, result))
                return result;
        inode = result->d_inode;
        spin_lock(&inode->i_lock);
-        list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
                dget(dentry);
                spin_unlock(&inode->i_lock);
                if (toput)
@@ -248,11 +249,10 @@ static int filldir_one(void * __buf, const char * name, int len,
 * calls readdir on the parent until it finds an entry with
 * the same inode number as the child, and returns that.
 */
-static int get_name(struct vfsmount *mnt, struct dentry *dentry,
+static int get_name(const struct path *path, char *name, struct dentry *child)
-                char *name, struct dentry *child)
 {
        const struct cred *cred = current_cred();
-        struct inode *dir = dentry->d_inode;
+        struct inode *dir = path->dentry->d_inode;
        int error;
        struct file *file;
        struct getdents_callback buffer;
@@ -266,7 +266,7 @@ static int get_name(struct vfsmount *mnt, struct dentry *dentry,
        /*
         * Open the directory ...
         */
-        file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY, cred);
+        file = dentry_open(path, O_RDONLY, cred);
        error = PTR_ERR(file);
        if (IS_ERR(file))
                goto out;
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index f663a67d7bf0..73b0d9519836 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -41,8 +41,8 @@ static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
 {
        int err = ext2_add_link(dentry, inode);
        if (!err) {
-                d_instantiate(dentry, inode);
                unlock_new_inode(inode);
+                d_instantiate(dentry, inode);
                return 0;
        }
        inode_dec_link_count(inode);
@@ -55,7 +55,7 @@ static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
 * Methods themselves.
 */
-static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode * inode;
        ino_t ino;
@@ -94,7 +94,7 @@ struct dentry *ext2_get_parent(struct dentry *child)
 * If the create succeeds, we fill in the inode information
 * with d_instantiate(). 
 */
-static int ext2_create (struct inode * dir, struct dentry * dentry, umode_t mode, struct nameidata *nd)
+static int ext2_create (struct inode * dir, struct dentry * dentry, umode_t mode, bool excl)
 {
        struct inode *inode;
@@ -242,8 +242,8 @@ static int ext2_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
        if (err)
                goto out_fail;
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
 out:
        return err;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index b3621cb7ea31..9f311d27b16f 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -771,13 +771,13 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        err = -ENOMEM;
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
        if (!sbi)
-                goto failed_unlock;
+                goto failed;
        sbi->s_blockgroup_lock =
                kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
        if (!sbi->s_blockgroup_lock) {
                kfree(sbi);
-                goto failed_unlock;
+                goto failed;
        }
        sb->s_fs_info = sbi;
        sbi->s_sb_block = sb_block;
@@ -1130,7 +1130,7 @@ failed_sbi:
        sb->s_fs_info = NULL;
        kfree(sbi->s_blockgroup_lock);
        kfree(sbi);
-failed_unlock:
+failed:
        return ret;
 }
@@ -1184,6 +1184,12 @@ static int ext2_sync_fs(struct super_block *sb, int wait)
        struct ext2_sb_info *sbi = EXT2_SB(sb);
        struct ext2_super_block *es = EXT2_SB(sb)->s_es;
+        /*
+         * Write quota structures to quota file, sync_blockdev() will write
+         * them to disk later
+         */
+        dquot_writeback_dquots(sb, -1);
        spin_lock(&sbi->s_lock);
        if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
                ext2_debug("setting valid to 0\n");
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 92490e9f85ca..c8fff930790d 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -300,10 +300,11 @@ loff_t ext3_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        struct inode *inode = file->f_mapping->host;
        int dx_dir = is_dx_dir(inode);
+        loff_t htree_max = ext3_get_htree_eof(file);
        if (likely(dx_dir))
                return generic_file_llseek_size(file, offset, origin,
-                                                ext3_get_htree_eof(file));
+                                                htree_max, htree_max);
        else
                return generic_file_llseek(file, offset, origin);
 }
diff --git a/fs/ext3/fsync.c b/fs/ext3/fsync.c
index d4dff278cbd8..b31dbd4c46ad 100644
--- a/fs/ext3/fsync.c
+++ b/fs/ext3/fsync.c
@@ -92,8 +92,13 @@ int ext3_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         * disk caches manually so that data really is on persistent
         * storage
         */
-        if (needs_barrier)
+        if (needs_barrier) {
-                blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
+                int err;
+                err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
+                if (!ret)
+                        ret = err;
+        }
 out:
        trace_ext3_sync_file_exit(inode, ret);
        return ret;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index eeb63dfc5d20..8f4fddac01a6 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1011,7 +1011,7 @@ errout:
        return NULL;
 }
-static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode * inode;
        struct ext3_dir_entry_2 * de;
@@ -1671,8 +1671,8 @@ static int ext3_add_nondir(handle_t *handle,
        int err = ext3_add_entry(handle, dentry, inode);
        if (!err) {
                ext3_mark_inode_dirty(handle, inode);
-                d_instantiate(dentry, inode);
                unlock_new_inode(inode);
+                d_instantiate(dentry, inode);
                return 0;
        }
        drop_nlink(inode);
@@ -1690,7 +1690,7 @@ static int ext3_add_nondir(handle_t *handle,
 * with d_instantiate().
 */
 static int ext3_create (struct inode * dir, struct dentry * dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        handle_t *handle;
        struct inode * inode;
@@ -1836,8 +1836,8 @@ out_clear_inode:
        if (err)
                goto out_clear_inode;
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
 out_stop:
        brelse(dir_block);
        ext3_journal_stop(handle);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 8c3a44b7c375..ff9bcdc5b0d5 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -2058,7 +2058,8 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                goto failed_mount3;
        }
-        ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
+        if (ext3_setup_super(sb, es, sb->s_flags & MS_RDONLY))
+                sb->s_flags |= MS_RDONLY;
        EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
        ext3_orphan_cleanup(sb, es);
@@ -2526,6 +2527,11 @@ static int ext3_sync_fs(struct super_block *sb, int wait)
        tid_t target;
        trace_ext3_sync_fs(sb, wait);
+        /*
+         * Writeback quota in non-journalled quota case - journalled quota has
+         * no dirty dquots
+         */
+        dquot_writeback_dquots(sb, -1);
        if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
                if (wait)
                        log_wait_commit(EXT3_SB(sb)->s_journal, target);
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 99b6324290db..cee7812cc3cf 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -90,8 +90,8 @@ unsigned ext4_num_overhead_clusters(struct super_block *sb,
         * unusual file system layouts.
         */
        if (ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp), block_group)) {
-                block_cluster = EXT4_B2C(sbi, (start -
+                block_cluster = EXT4_B2C(sbi,
-                                               ext4_block_bitmap(sb, gdp)));
+                                         ext4_block_bitmap(sb, gdp) - start);
                if (block_cluster < num_clusters)
                        block_cluster = -1;
                else if (block_cluster == num_clusters) {
@@ -102,7 +102,7 @@ unsigned ext4_num_overhead_clusters(struct super_block *sb,
        if (ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp), block_group)) {
                inode_cluster = EXT4_B2C(sbi,
-                                         start - ext4_inode_bitmap(sb, gdp));
+                                         ext4_inode_bitmap(sb, gdp) - start);
                if (inode_cluster < num_clusters)
                        inode_cluster = -1;
                else if (inode_cluster == num_clusters) {
@@ -114,7 +114,7 @@ unsigned ext4_num_overhead_clusters(struct super_block *sb,
        itbl_blk = ext4_inode_table(sb, gdp);
        for (i = 0; i < sbi->s_itb_per_group; i++) {
                if (ext4_block_in_group(sb, itbl_blk + i, block_group)) {
-                        c = EXT4_B2C(sbi, start - itbl_blk + i);
+                        c = EXT4_B2C(sbi, itbl_blk + i - start);
                        if ((c < num_clusters) || (c == inode_cluster) ||
                            (c == block_cluster) || (c == itbl_cluster))
                                continue;
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index aa39e600d159..8e07d2a5a139 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -324,74 +324,27 @@ static inline loff_t ext4_get_htree_eof(struct file *filp)
 /*
- * ext4_dir_llseek() based on generic_file_llseek() to handle both
+ * ext4_dir_llseek() calls generic_file_llseek_size to handle htree
- * non-htree and htree directories, where the "offset" is in terms
+ * directories, where the "offset" is in terms of the filename hash
- * of the filename hash value instead of the byte offset.
+ * value instead of the byte offset.
 *
- * NOTE: offsets obtained *before* ext4_set_inode_flag(dir, EXT4_INODE_INDEX)
+ * Because we may return a 64-bit hash that is well beyond offset limits,
- *       will be invalid once the directory was converted into a dx directory
+ * we need to pass the max hash as the maximum allowable offset in
+ * the htree directory case.
+ *
+ * For non-htree, ext4_llseek already chooses the proper max offset.
 */
 loff_t ext4_dir_llseek(struct file *file, loff_t offset, int origin)
 {
        struct inode *inode = file->f_mapping->host;
-        loff_t ret = -EINVAL;
        int dx_dir = is_dx_dir(inode);
+        loff_t htree_max = ext4_get_htree_eof(file);
-        mutex_lock(&inode->i_mutex);
+        if (likely(dx_dir))
+                return generic_file_llseek_size(file, offset, origin,
-        /* NOTE: relative offsets with dx directories might not work
+                                                    htree_max, htree_max);
-         *       as expected, as it is difficult to figure out the
+        else
-         *       correct offset between dx hashes */
+                return ext4_llseek(file, offset, origin);
-        switch (origin) {
-        case SEEK_END:
-                if (unlikely(offset > 0))
-                        goto out_err; /* not supported for directories */
-                /* so only negative offsets are left, does that have a
-                 * meaning for directories at all? */
-                if (dx_dir)
-                        offset += ext4_get_htree_eof(file);
-                else
-                        offset += inode->i_size;
-                break;
-        case SEEK_CUR:
-                /*
-                 * Here we special-case the lseek(fd, 0, SEEK_CUR)
-                 * position-querying operation.  Avoid rewriting the "same"
-                 * f_pos value back to the file because a concurrent read(),
-                 * write() or lseek() might have altered it
-                 */
-                if (offset == 0) {
-                        offset = file->f_pos;
-                        goto out_ok;
-                }
-                offset += file->f_pos;
-                break;
-        }
-        if (unlikely(offset < 0))
-                goto out_err;
-        if (!dx_dir) {
-                if (offset > inode->i_sb->s_maxbytes)
-                        goto out_err;
-        } else if (offset > ext4_get_htree_eof(file))
-                goto out_err;
-        /* Special lock needed here? */
-        if (offset != file->f_pos) {
-                file->f_pos = offset;
-                file->f_version = 0;
-        }
-out_ok:
-        ret = offset;
-out_err:
-        mutex_unlock(&inode->i_mutex);
-        return ret;
 }
 /*
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 8c7642a00054..782eecb57e43 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -211,9 +211,9 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
 }
 /*
- * ext4_llseek() copied from generic_file_llseek() to handle both
+ * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
- * block-mapped and extent-mapped maxbytes values. This should
+ * by calling generic_file_llseek_size() with the appropriate maxbytes
- * otherwise be identical with generic_file_llseek().
+ * value for each.
 */
 loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
 {
@@ -225,7 +225,8 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
        else
                maxbytes = inode->i_sb->s_maxbytes;
-        return generic_file_llseek_size(file, offset, origin, maxbytes);
+        return generic_file_llseek_size(file, offset, origin,
+                                        maxbytes, i_size_read(inode));
 }
 const struct file_operations ext4_file_operations = {
diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
index bb6c7d811313..2a1dcea4f12e 100644
--- a/fs/ext4/fsync.c
+++ b/fs/ext4/fsync.c
@@ -135,14 +135,7 @@ static int ext4_sync_parent(struct inode *inode)
        inode = igrab(inode);
        while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) {
                ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY);
-                dentry = NULL;
+                dentry = d_find_any_alias(inode);
-                spin_lock(&inode->i_lock);
-                if (!list_empty(&inode->i_dentry)) {
-                        dentry = list_first_entry(&inode->i_dentry,
-                                                  struct dentry, d_alias);
-                        dget(dentry);
-                }
-                spin_unlock(&inode->i_lock);
                if (!dentry)
                        break;
                next = igrab(dentry->d_parent->d_inode);
@@ -232,7 +225,7 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        if (!journal) {
                ret = __sync_inode(inode, datasync);
-                if (!ret && !list_empty(&inode->i_dentry))
+                if (!ret && !hlist_empty(&inode->i_dentry))
                        ret = ext4_sync_parent(inode);
                goto out;
        }
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 8ad112ae0ade..7f7dad787603 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -123,7 +123,6 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                        else
                                ext4_clear_inode_flag(inode, i);
                }
-                ei->i_flags = flags;
                ext4_set_inode_flags(inode);
                inode->i_ctime = ext4_current_time(inode);
@@ -269,7 +268,6 @@ group_extend_out:
                err = ext4_move_extents(filp, donor_filp, me.orig_start,
                                        me.donor_start, me.len, &me.moved_len);
                mnt_drop_write_file(filp);
-                mnt_drop_write(filp->f_path.mnt);
                if (copy_to_user((struct move_extent __user *)arg,
                                 &me, sizeof(me)))
@@ -391,7 +389,7 @@ group_add_out:
                if (err)
                        return err;
-                err = mnt_want_write(filp->f_path.mnt);
+                err = mnt_want_write_file(filp);
                if (err)
                        goto resizefs_out;
@@ -403,7 +401,7 @@ group_add_out:
                }
                if (err == 0)
                        err = err2;
-                mnt_drop_write(filp->f_path.mnt);
+                mnt_drop_write_file(filp);
 resizefs_out:
                ext4_resize_end(sb);
                return err;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 5845cd97bf8b..d0d3f0e87f99 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1312,7 +1312,7 @@ errout:
        return NULL;
 }
-static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode;
        struct ext4_dir_entry_2 *de;
@@ -2072,8 +2072,8 @@ static int ext4_add_nondir(handle_t *handle,
        int err = ext4_add_entry(handle, dentry, inode);
        if (!err) {
                ext4_mark_inode_dirty(handle, inode);
-                d_instantiate(dentry, inode);
                unlock_new_inode(inode);
+                d_instantiate(dentry, inode);
                return 0;
        }
        drop_nlink(inode);
@@ -2091,7 +2091,7 @@ static int ext4_add_nondir(handle_t *handle,
 * with d_instantiate().
 */
 static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                       struct nameidata *nd)
+                       bool excl)
 {
        handle_t *handle;
        struct inode *inode;
@@ -2249,8 +2249,8 @@ out_clear_inode:
        err = ext4_mark_inode_dirty(handle, dir);
        if (err)
                goto out_clear_inode;
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
 out_stop:
        brelse(dir_block);
        ext4_journal_stop(handle);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index eb7aa3e4ef05..d8759401ecae 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4325,6 +4325,11 @@ static int ext4_sync_fs(struct super_block *sb, int wait)
        trace_ext4_sync_fs(sb, wait);
        flush_workqueue(sbi->dio_unwritten_wq);
+        /*
+         * Writeback quota in non-journalled quota case - journalled quota has
+         * no dirty dquots
+         */
+        dquot_writeback_dquots(sb, -1);
        if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
                if (wait)
                        jbd2_log_wait_commit(sbi->s_journal, target);
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index a3d81ebf6d86..0038b32cb362 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -738,22 +738,21 @@ static int
 fat_encode_fh(struct inode *inode, __u32 *fh, int *lenp, struct inode *parent)
 {
        int len = *lenp;
-        u32 ipos_h, ipos_m, ipos_l;
+        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
+        loff_t i_pos;
        if (len < 5) {
                *lenp = 5;
                return 255; /* no room */
        }
-        ipos_h = MSDOS_I(inode)->i_pos >> 8;
+        i_pos = fat_i_pos_read(sbi, inode);
-        ipos_m = (MSDOS_I(inode)->i_pos & 0xf0) << 24;
-        ipos_l = (MSDOS_I(inode)->i_pos & 0x0f) << 28;
        *lenp = 5;
        fh[0] = inode->i_ino;
        fh[1] = inode->i_generation;
-        fh[2] = ipos_h;
+        fh[2] = i_pos >> 8;
-        fh[3] = ipos_m | MSDOS_I(inode)->i_logstart;
+        fh[3] = ((i_pos & 0xf0) << 24) | MSDOS_I(inode)->i_logstart;
-        fh[4] = ipos_l;
+        fh[4] = (i_pos & 0x0f) << 28;
        if (parent)
                fh[4] |= MSDOS_I(parent)->i_logstart;
        return 3;
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index c5938c9084b9..70d993a93805 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -201,7 +201,7 @@ static const struct dentry_operations msdos_dentry_operations = {
 /***** Get inode using directory and name */
 static struct dentry *msdos_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        struct super_block *sb = dir->i_sb;
        struct fat_slot_info sinfo;
@@ -265,7 +265,7 @@ static int msdos_add_entry(struct inode *dir, const unsigned char *name,
 /***** Create a file */
 static int msdos_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                        struct nameidata *nd)
+                        bool excl)
 {
        struct super_block *sb = dir->i_sb;
        struct inode *inode = NULL;
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 98ae804f5273..6cc480652433 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -41,9 +41,9 @@ static int vfat_revalidate_shortname(struct dentry *dentry)
        return ret;
 }
-static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int vfat_revalidate(struct dentry *dentry, unsigned int flags)
 {
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        /* This is not negative dentry. Always valid. */
@@ -52,9 +52,9 @@ static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
        return vfat_revalidate_shortname(dentry);
 }
-static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
+static int vfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
 {
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        /*
@@ -74,7 +74,7 @@ static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
         * This may be nfsd (or something), anyway, we can't see the
         * intent of this. So, since this can be for creation, drop it.
         */
-        if (!nd)
+        if (!flags)
                return 0;
        /*
@@ -82,7 +82,7 @@ static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
         * case sensitive name which is specified by user if this is
         * for creation.
         */
-        if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+        if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
                return 0;
        return vfat_revalidate_shortname(dentry);
@@ -714,7 +714,7 @@ static int vfat_d_anon_disconn(struct dentry *dentry)
 }
 static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        struct super_block *sb = dir->i_sb;
        struct fat_slot_info sinfo;
@@ -772,7 +772,7 @@ error:
 }
 static int vfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                       struct nameidata *nd)
+                       bool excl)
 {
        struct super_block *sb = dir->i_sb;
        struct inode *inode;
diff --git a/fs/fifo.c b/fs/fifo.c
index b1a524d798e7..cf6f4345ceb0 100644
--- a/fs/fifo.c
+++ b/fs/fifo.c
@@ -14,7 +14,7 @@
 #include <linux/sched.h>
 #include <linux/pipe_fs_i.h>
-static void wait_for_partner(struct inode* inode, unsigned int *cnt)
+static int wait_for_partner(struct inode* inode, unsigned int *cnt)
 {
        int cur = *cnt; 
@@ -23,6 +23,7 @@ static void wait_for_partner(struct inode* inode, unsigned int *cnt)
                if (signal_pending(current))
                        break;
        }
+        return cur == *cnt ? -ERESTARTSYS : 0;
 }
 static void wake_up_partner(struct inode* inode)
@@ -67,8 +68,7 @@ static int fifo_open(struct inode *inode, struct file *filp)
                                 * seen a writer */
                                filp->f_version = pipe->w_counter;
                        } else {
-                                wait_for_partner(inode, &pipe->w_counter);
+                                if (wait_for_partner(inode, &pipe->w_counter))
-                                if(signal_pending(current))
                                        goto err_rd;
                        }
                }
@@ -90,8 +90,7 @@ static int fifo_open(struct inode *inode, struct file *filp)
                        wake_up_partner(inode);
                if (!pipe->readers) {
-                        wait_for_partner(inode, &pipe->r_counter);
+                        if (wait_for_partner(inode, &pipe->r_counter))
-                        if (signal_pending(current))
                                goto err_wr;
                }
                break;
diff --git a/fs/file_table.c b/fs/file_table.c
index a305d9e2d1b2..b3fc4d67a26b 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -23,6 +23,8 @@
 #include <linux/lglock.h>
 #include <linux/percpu_counter.h>
 #include <linux/percpu.h>
+#include <linux/hardirq.h>
+#include <linux/task_work.h>
 #include <linux/ima.h>
 #include <linux/atomic.h>
@@ -251,7 +253,6 @@ static void __fput(struct file *file)
        }
        fops_put(file->f_op);
        put_pid(file->f_owner.pid);
-        file_sb_list_del(file);
        if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
                i_readcount_dec(inode);
        if (file->f_mode & FMODE_WRITE)
@@ -263,10 +264,77 @@ static void __fput(struct file *file)
        mntput(mnt);
 }
+static DEFINE_SPINLOCK(delayed_fput_lock);
+static LIST_HEAD(delayed_fput_list);
+static void delayed_fput(struct work_struct *unused)
+{
+        LIST_HEAD(head);
+        spin_lock_irq(&delayed_fput_lock);
+        list_splice_init(&delayed_fput_list, &head);
+        spin_unlock_irq(&delayed_fput_lock);
+        while (!list_empty(&head)) {
+                struct file *f = list_first_entry(&head, struct file, f_u.fu_list);
+                list_del_init(&f->f_u.fu_list);
+                __fput(f);
+        }
+}
+static void ____fput(struct callback_head *work)
+{
+        __fput(container_of(work, struct file, f_u.fu_rcuhead));
+}
+/*
+ * If kernel thread really needs to have the final fput() it has done
+ * to complete, call this.  The only user right now is the boot - we
+ * *do* need to make sure our writes to binaries on initramfs has
+ * not left us with opened struct file waiting for __fput() - execve()
+ * won't work without that.  Please, don't add more callers without
+ * very good reasons; in particular, never call that with locks
+ * held and never call that from a thread that might need to do
+ * some work on any kind of umount.
+ */
+void flush_delayed_fput(void)
+{
+        delayed_fput(NULL);
+}
+static DECLARE_WORK(delayed_fput_work, delayed_fput);
 void fput(struct file *file)
 {
-        if (atomic_long_dec_and_test(&file->f_count))
+        if (atomic_long_dec_and_test(&file->f_count)) {
+                struct task_struct *task = current;
+                file_sb_list_del(file);
+                if (unlikely(in_interrupt() || task->flags & PF_KTHREAD)) {
+                        unsigned long flags;
+                        spin_lock_irqsave(&delayed_fput_lock, flags);
+                        list_add(&file->f_u.fu_list, &delayed_fput_list);
+                        schedule_work(&delayed_fput_work);
+                        spin_unlock_irqrestore(&delayed_fput_lock, flags);
+                        return;
+                }
+                init_task_work(&file->f_u.fu_rcuhead, ____fput);
+                task_work_add(task, &file->f_u.fu_rcuhead, true);
+        }
+}
+/*
+ * synchronous analog of fput(); for kernel threads that might be needed
+ * in some umount() (and thus can't use flush_delayed_fput() without
+ * risking deadlocks), need to wait for completion of __fput() and know
+ * for this specific struct file it won't involve anything that would
+ * need them.  Use only if you really need it - at the very least,
+ * don't blindly convert fput() by kernel thread to that.
+ */
+void __fput_sync(struct file *file)
+{
+        if (atomic_long_dec_and_test(&file->f_count)) {
+                struct task_struct *task = current;
+                file_sb_list_del(file);
+                BUG_ON(!(task->flags & PF_KTHREAD));
                __fput(file);
+        }
 }
 EXPORT_SYMBOL(fput);
@@ -483,10 +551,8 @@ void mark_files_ro(struct super_block *sb)
 {
        struct file *f;
-retry:
        lg_global_lock(&files_lglock);
        do_file_list_for_each_entry(sb, f) {
-                struct vfsmount *mnt;
                if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
                       continue;
                if (!file_count(f))
@@ -499,12 +565,7 @@ retry:
                if (file_check_writeable(f) != 0)
                        continue;
                file_release_write(f);
-                mnt = mntget(f->f_path.mnt);
+                mnt_drop_write_file(f);
-                /* This can sleep, so we can't hold the spinlock. */
-                lg_global_unlock(&files_lglock);
-                mnt_drop_write(mnt);
-                mntput(mnt);
-                goto retry;
        } while_file_list_for_each_entry;
        lg_global_unlock(&files_lglock);
 }
diff --git a/fs/freevxfs/vxfs_lookup.c b/fs/freevxfs/vxfs_lookup.c
index 3360f1e678ad..bd447e88f208 100644
--- a/fs/freevxfs/vxfs_lookup.c
+++ b/fs/freevxfs/vxfs_lookup.c
@@ -48,7 +48,7 @@
 #define VXFS_BLOCK_PER_PAGE(sbp)  ((PAGE_CACHE_SIZE / (sbp)->s_blocksize))
-static struct dentry *  vxfs_lookup(struct inode *, struct dentry *, struct nameidata *);
+static struct dentry *  vxfs_lookup(struct inode *, struct dentry *, unsigned int);
 static int              vxfs_readdir(struct file *, void *, filldir_t);
 const struct inode_operations vxfs_dir_inode_ops = {
@@ -203,7 +203,7 @@ vxfs_inode_by_name(struct inode *dip, struct dentry *dp)
 *   in the return pointer.
 */
 static struct dentry *
-vxfs_lookup(struct inode *dip, struct dentry *dp, struct nameidata *nd)
+vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags)
 {
        struct inode            *ip = NULL;
        ino_t                   ino;
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 8d2fb8c88cf3..8f660dd6137a 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -664,6 +664,7 @@ static long writeback_sb_inodes(struct super_block *sb,
                        /* Wait for I_SYNC. This function drops i_lock... */
                        inode_sleep_on_writeback(inode);
                        /* Inode may be gone, start again */
+                        spin_lock(&wb->list_lock);
                        continue;
                }
                inode->i_state |= I_SYNC;
@@ -1314,6 +1315,8 @@ void writeback_inodes_sb_nr(struct super_block *sb,
                .reason                 = reason,
        };
+        if (sb->s_bdi == &noop_backing_dev_info)
+                return;
        WARN_ON(!rwsem_is_locked(&sb->s_umount));
        bdi_queue_work(sb->s_bdi, &work);
        wait_for_completion(&done);
@@ -1397,6 +1400,9 @@ void sync_inodes_sb(struct super_block *sb)
                .reason         = WB_REASON_SYNC,
        };
+        /* Nothing to do? */
+        if (sb->s_bdi == &noop_backing_dev_info)
+                return;
        WARN_ON(!rwsem_is_locked(&sb->s_umount));
        bdi_queue_work(sb->s_bdi, &work);
diff --git a/fs/fs_struct.c b/fs/fs_struct.c
index e159e682ad4c..5df4775fea03 100644
--- a/fs/fs_struct.c
+++ b/fs/fs_struct.c
@@ -6,18 +6,6 @@
 #include <linux/fs_struct.h>
 #include "internal.h"
-static inline void path_get_longterm(struct path *path)
-{
-        path_get(path);
-        mnt_make_longterm(path->mnt);
-}
-static inline void path_put_longterm(struct path *path)
-{
-        mnt_make_shortterm(path->mnt);
-        path_put(path);
-}
 /*
 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
 * It can block.
@@ -26,7 +14,7 @@ void set_fs_root(struct fs_struct *fs, struct path *path)
 {
        struct path old_root;
-        path_get_longterm(path);
+        path_get(path);
        spin_lock(&fs->lock);
        write_seqcount_begin(&fs->seq);
        old_root = fs->root;
@@ -34,7 +22,7 @@ void set_fs_root(struct fs_struct *fs, struct path *path)
        write_seqcount_end(&fs->seq);
        spin_unlock(&fs->lock);
        if (old_root.dentry)
-                path_put_longterm(&old_root);
+                path_put(&old_root);
 }
 /*
@@ -45,7 +33,7 @@ void set_fs_pwd(struct fs_struct *fs, struct path *path)
 {
        struct path old_pwd;
-        path_get_longterm(path);
+        path_get(path);
        spin_lock(&fs->lock);
        write_seqcount_begin(&fs->seq);
        old_pwd = fs->pwd;
@@ -54,7 +42,7 @@ void set_fs_pwd(struct fs_struct *fs, struct path *path)
        spin_unlock(&fs->lock);
        if (old_pwd.dentry)
-                path_put_longterm(&old_pwd);
+                path_put(&old_pwd);
 }
 static inline int replace_path(struct path *p, const struct path *old, const struct path *new)
@@ -84,7 +72,7 @@ void chroot_fs_refs(struct path *old_root, struct path *new_root)
                        write_seqcount_end(&fs->seq);
                        while (hits--) {
                                count++;
-                                path_get_longterm(new_root);
+                                path_get(new_root);
                        }
                        spin_unlock(&fs->lock);
                }
@@ -92,13 +80,13 @@ void chroot_fs_refs(struct path *old_root, struct path *new_root)
        } while_each_thread(g, p);
        read_unlock(&tasklist_lock);
        while (count--)
-                path_put_longterm(old_root);
+                path_put(old_root);
 }
 void free_fs_struct(struct fs_struct *fs)
 {
-        path_put_longterm(&fs->root);
+        path_put(&fs->root);
-        path_put_longterm(&fs->pwd);
+        path_put(&fs->pwd);
        kmem_cache_free(fs_cachep, fs);
 }
@@ -132,9 +120,9 @@ struct fs_struct *copy_fs_struct(struct fs_struct *old)
                spin_lock(&old->lock);
                fs->root = old->root;
-                path_get_longterm(&fs->root);
+                path_get(&fs->root);
                fs->pwd = old->pwd;
-                path_get_longterm(&fs->pwd);
+                path_get(&fs->pwd);
                spin_unlock(&old->lock);
        }
        return fs;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 334e0b18a014..8964cf3999b2 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -154,7 +154,7 @@ u64 fuse_get_attr_version(struct fuse_conn *fc)
 * the lookup once more.  If the lookup results in the same inode,
 * then refresh the attributes, timeouts and mark the dentry valid.
 */
-static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
+static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
 {
        struct inode *inode;
@@ -174,7 +174,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
                if (!inode)
                        return 0;
-                if (nd && (nd->flags & LOOKUP_RCU))
+                if (flags & LOOKUP_RCU)
                        return -ECHILD;
                fc = get_fuse_conn(inode);
@@ -249,7 +249,7 @@ static struct dentry *fuse_d_add_directory(struct dentry *entry,
                /* This tries to shrink the subtree below alias */
                fuse_invalidate_entry(alias);
                dput(alias);
-                if (!list_empty(&inode->i_dentry))
+                if (!hlist_empty(&inode->i_dentry))
                        return ERR_PTR(-EBUSY);
        } else {
                dput(alias);
@@ -316,7 +316,7 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
 }
 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        int err;
        struct fuse_entry_out outarg;
@@ -370,7 +370,8 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 * 'mknod' + 'open' requests.
 */
 static int fuse_create_open(struct inode *dir, struct dentry *entry,
-                            umode_t mode, struct nameidata *nd)
+                            struct file *file, unsigned flags,
+                            umode_t mode, int *opened)
 {
        int err;
        struct inode *inode;
@@ -381,15 +382,11 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
        struct fuse_open_out outopen;
        struct fuse_entry_out outentry;
        struct fuse_file *ff;
-        struct file *file;
-        int flags = nd->intent.open.flags;
-        if (fc->no_create)
-                return -ENOSYS;
        forget = fuse_alloc_forget();
+        err = -ENOMEM;
        if (!forget)
-                return -ENOMEM;
+                goto out_err;
        req = fuse_get_req(fc);
        err = PTR_ERR(req);
@@ -428,11 +425,8 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
        req->out.args[1].value = &outopen;
        fuse_request_send(fc, req);
        err = req->out.h.error;
-        if (err) {
+        if (err)
-                if (err == -ENOSYS)
-                        fc->no_create = 1;
                goto out_free_ff;
-        }
        err = -EIO;
        if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
@@ -448,28 +442,74 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry,
                flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
                fuse_sync_release(ff, flags);
                fuse_queue_forget(fc, forget, outentry.nodeid, 1);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto out_err;
        }
        kfree(forget);
        d_instantiate(entry, inode);
        fuse_change_entry_timeout(entry, &outentry);
        fuse_invalidate_attr(dir);
-        file = lookup_instantiate_filp(nd, entry, generic_file_open);
+        err = finish_open(file, entry, generic_file_open, opened);
-        if (IS_ERR(file)) {
+        if (err) {
                fuse_sync_release(ff, flags);
-                return PTR_ERR(file);
+        } else {
+                file->private_data = fuse_file_get(ff);
+                fuse_finish_open(inode, file);
        }
-        file->private_data = fuse_file_get(ff);
+        return err;
-        fuse_finish_open(inode, file);
-        return 0;
- out_free_ff:
+out_free_ff:
        fuse_file_free(ff);
- out_put_request:
+out_put_request:
        fuse_put_request(fc, req);
- out_put_forget_req:
+out_put_forget_req:
        kfree(forget);
+out_err:
+        return err;
+}
+static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
+static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
+                            struct file *file, unsigned flags,
+                            umode_t mode, int *opened)
+{
+        int err;
+        struct fuse_conn *fc = get_fuse_conn(dir);
+        struct dentry *res = NULL;
+        if (d_unhashed(entry)) {
+                res = fuse_lookup(dir, entry, 0);
+                if (IS_ERR(res))
+                        return PTR_ERR(res);
+                if (res)
+                        entry = res;
+        }
+        if (!(flags & O_CREAT) || entry->d_inode)
+                goto no_open;
+        /* Only creates */
+        *opened |= FILE_CREATED;
+        if (fc->no_create)
+                goto mknod;
+        err = fuse_create_open(dir, entry, file, flags, mode, opened);
+        if (err == -ENOSYS) {
+                fc->no_create = 1;
+                goto mknod;
+        }
+out_dput:
+        dput(res);
        return err;
+mknod:
+        err = fuse_mknod(dir, entry, mode, 0);
+        if (err)
+                goto out_dput;
+no_open:
+        return finish_no_open(file, res);
 }
 /*
@@ -571,14 +611,8 @@ static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
 }
 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
-                       struct nameidata *nd)
+                       bool excl)
 {
-        if (nd) {
-                int err = fuse_create_open(dir, entry, mode, nd);
-                if (err != -ENOSYS)
-                        return err;
-                /* Fall back on mknod */
-        }
        return fuse_mknod(dir, entry, mode, 0);
 }
@@ -1646,6 +1680,7 @@ static const struct inode_operations fuse_dir_inode_operations = {
        .link           = fuse_link,
        .setattr        = fuse_setattr,
        .create         = fuse_create,
+        .atomic_open    = fuse_atomic_open,
        .mknod          = fuse_mknod,
        .permission     = fuse_permission,
        .getattr        = fuse_getattr,
diff --git a/fs/gfs2/dentry.c b/fs/gfs2/dentry.c
index 0da8da2c991d..4fddb3c22d25 100644
--- a/fs/gfs2/dentry.c
+++ b/fs/gfs2/dentry.c
@@ -25,7 +25,7 @@
 /**
 * gfs2_drevalidate - Check directory lookup consistency
 * @dentry: the mapping to check
- * @nd:
+ * @flags: lookup flags
 *
 * Check to make sure the lookup necessary to arrive at this inode from its
 * parent is still good.
@@ -33,7 +33,7 @@
 * Returns: 1 if the dentry is ok, 0 if it isn't
 */
-static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
+static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
 {
        struct dentry *parent;
        struct gfs2_sbd *sdp;
@@ -44,7 +44,7 @@ static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
        int error;
        int had_lock = 0;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        parent = dget_parent(dentry);
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index c53c67e30bd4..4ce22e547308 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -772,11 +772,8 @@ fail:
 */
 static int gfs2_create(struct inode *dir, struct dentry *dentry,
-                       umode_t mode, struct nameidata *nd)
+                       umode_t mode, bool excl)
 {
-        int excl = 0;
-        if (nd && (nd->flags & LOOKUP_EXCL))
-                excl = 1;
        return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
 }
@@ -792,7 +789,7 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
 */
 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
        if (inode && !IS_ERR(inode)) {
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 9b2389756acd..e5af9dc420ef 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1299,7 +1299,7 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
                error = -EBUSY;
                goto error_bdev;
        }
-        s = sget(fs_type, test_gfs2_super, set_gfs2_super, bdev);
+        s = sget(fs_type, test_gfs2_super, set_gfs2_super, flags, bdev);
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        error = PTR_ERR(s);
        if (IS_ERR(s))
@@ -1329,7 +1329,6 @@ static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
        } else {
                char b[BDEVNAME_SIZE];
-                s->s_flags = flags;
                s->s_mode = mode;
                strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                sb_set_blocksize(s, block_size(bdev));
@@ -1373,7 +1372,7 @@ static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
                       dev_name, error);
                return ERR_PTR(error);
        }
-        s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super,
+        s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
                 path.dentry->d_inode->i_sb->s_bdev);
        path_put(&path);
        if (IS_ERR(s)) {
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 7d1ede7b66fc..a3bde91645c2 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -1113,7 +1113,7 @@ void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
        }
 }
-int gfs2_quota_sync(struct super_block *sb, int type, int wait)
+int gfs2_quota_sync(struct super_block *sb, int type)
 {
        struct gfs2_sbd *sdp = sb->s_fs_info;
        struct gfs2_quota_data **qda;
@@ -1159,7 +1159,7 @@ int gfs2_quota_sync(struct super_block *sb, int type, int wait)
 static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
 {
-        return gfs2_quota_sync(sb, type, 0);
+        return gfs2_quota_sync(sb, type);
 }
 int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)
diff --git a/fs/gfs2/quota.h b/fs/gfs2/quota.h
index 90bf1c302a98..f25d98b87904 100644
--- a/fs/gfs2/quota.h
+++ b/fs/gfs2/quota.h
@@ -26,7 +26,7 @@ extern int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid);
 extern void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
                              u32 uid, u32 gid);
-extern int gfs2_quota_sync(struct super_block *sb, int type, int wait);
+extern int gfs2_quota_sync(struct super_block *sb, int type);
 extern int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id);
 extern int gfs2_quota_init(struct gfs2_sbd *sdp);
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index b1502c4bc60d..fc3168f47a14 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -848,7 +848,7 @@ static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
        int error;
        flush_workqueue(gfs2_delete_workqueue);
-        gfs2_quota_sync(sdp->sd_vfs, 0, 1);
+        gfs2_quota_sync(sdp->sd_vfs, 0);
        gfs2_statfs_sync(sdp->sd_vfs, 0);
        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
@@ -962,6 +962,8 @@ restart:
 static int gfs2_sync_fs(struct super_block *sb, int wait)
 {
        struct gfs2_sbd *sdp = sb->s_fs_info;
+        gfs2_quota_sync(sb, -1);
        if (wait && sdp)
                gfs2_log_flush(sdp, NULL);
        return 0;
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index e4bee4bebbf6..8056b7b7238e 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -168,7 +168,7 @@ static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
        if (simple_strtol(buf, NULL, 0) != 1)
                return -EINVAL;
-        gfs2_quota_sync(sdp->sd_vfs, 0, 1);
+        gfs2_quota_sync(sdp->sd_vfs, 0);
        return len;
 }
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 62fc14ea4b73..422dde2ec0a1 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -18,7 +18,7 @@
 * hfs_lookup()
 */
 static struct dentry *hfs_lookup(struct inode *dir, struct dentry *dentry,
-                                 struct nameidata *nd)
+                                 unsigned int flags)
 {
        hfs_cat_rec rec;
        struct hfs_find_data fd;
@@ -187,7 +187,7 @@ static int hfs_dir_release(struct inode *inode, struct file *file)
 * the directory and the name (and its length) of the new file.
 */
 static int hfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                      struct nameidata *nd)
+                      bool excl)
 {
        struct inode *inode;
        int res;
diff --git a/fs/hfs/extent.c b/fs/hfs/extent.c
index 2c16316d2917..a67955a0c36f 100644
--- a/fs/hfs/extent.c
+++ b/fs/hfs/extent.c
@@ -432,7 +432,7 @@ out:
                if (inode->i_ino < HFS_FIRSTUSER_CNID)
                        set_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags);
                set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-                sb->s_dirt = 1;
+                hfs_mark_mdb_dirty(sb);
        }
        return res;
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 1bf967c6bfdc..8275175acf6e 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -14,6 +14,7 @@
 #include <linux/mutex.h>
 #include <linux/buffer_head.h>
 #include <linux/fs.h>
+#include <linux/workqueue.h>
 #include <asm/byteorder.h>
 #include <asm/uaccess.h>
@@ -137,16 +138,15 @@ struct hfs_sb_info {
        gid_t s_gid;                            /* The gid of all files */
        int session, part;
        struct nls_table *nls_io, *nls_disk;
        struct mutex bitmap_lock;
        unsigned long flags;
        u16 blockoffset;
        int fs_div;
+        struct super_block *sb;
+        int work_queued;                /* non-zero delayed work is queued */
+        struct delayed_work mdb_work;   /* MDB flush delayed work */
+        spinlock_t work_lock;           /* protects mdb_work and work_queued */
 };
 #define HFS_FLG_BITMAP_DIRTY    0
@@ -226,6 +226,9 @@ extern int hfs_compare_dentry(const struct dentry *parent,
 extern void hfs_asc2mac(struct super_block *, struct hfs_name *, struct qstr *);
 extern int hfs_mac2asc(struct super_block *, char *, const struct hfs_name *);
+/* super.c */
+extern void hfs_mark_mdb_dirty(struct super_block *sb);
 extern struct timezone sys_tz;
 /*
@@ -253,7 +256,7 @@ static inline const char *hfs_mdb_name(struct super_block *sb)
 static inline void hfs_bitmap_dirty(struct super_block *sb)
 {
        set_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags);
-        sb->s_dirt = 1;
+        hfs_mark_mdb_dirty(sb);
 }
 #define sb_bread512(sb, sec, data) ({                   \
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 761ec06354b4..ee1bc55677f1 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -220,7 +220,7 @@ struct inode *hfs_new_inode(struct inode *dir, struct qstr *name, umode_t mode)
        insert_inode_hash(inode);
        mark_inode_dirty(inode);
        set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-        sb->s_dirt = 1;
+        hfs_mark_mdb_dirty(sb);
        return inode;
 }
@@ -235,7 +235,7 @@ void hfs_delete_inode(struct inode *inode)
                if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
                        HFS_SB(sb)->root_dirs--;
                set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-                sb->s_dirt = 1;
+                hfs_mark_mdb_dirty(sb);
                return;
        }
        HFS_SB(sb)->file_count--;
@@ -248,7 +248,7 @@ void hfs_delete_inode(struct inode *inode)
                }
        }
        set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
-        sb->s_dirt = 1;
+        hfs_mark_mdb_dirty(sb);
 }
 void hfs_inode_read_fork(struct inode *inode, struct hfs_extent *ext,
@@ -489,7 +489,7 @@ out:
 }
 static struct dentry *hfs_file_lookup(struct inode *dir, struct dentry *dentry,
-                                      struct nameidata *nd)
+                                      unsigned int flags)
 {
        struct inode *inode = NULL;
        hfs_cat_rec rec;
@@ -644,13 +644,7 @@ static int hfs_file_fsync(struct file *filp, loff_t start, loff_t end,
        /* sync the superblock to buffers */
        sb = inode->i_sb;
-        if (sb->s_dirt) {
+        flush_delayed_work_sync(&HFS_SB(sb)->mdb_work);
-                lock_super(sb);
-                sb->s_dirt = 0;
-                if (!(sb->s_flags & MS_RDONLY))
-                        hfs_mdb_commit(sb);
-                unlock_super(sb);
-        }
        /* .. finally sync the buffers to disk */
        err = sync_blockdev(sb->s_bdev);
        if (!ret)
diff --git a/fs/hfs/mdb.c b/fs/hfs/mdb.c
index 1563d5ce5764..5fd51a5833ff 100644
--- a/fs/hfs/mdb.c
+++ b/fs/hfs/mdb.c
@@ -260,6 +260,10 @@ void hfs_mdb_commit(struct super_block *sb)
 {
        struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
+        if (sb->s_flags & MS_RDONLY)
+                return;
+        lock_buffer(HFS_SB(sb)->mdb_bh);
        if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
                /* These parameters may have been modified, so write them back */
                mdb->drLsMod = hfs_mtime();
@@ -283,9 +287,13 @@ void hfs_mdb_commit(struct super_block *sb)
                                     &mdb->drXTFlSize, NULL);
                hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
                                     &mdb->drCTFlSize, NULL);
+                lock_buffer(HFS_SB(sb)->alt_mdb_bh);
                memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
                HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
                HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
+                unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
                mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
                sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
        }
@@ -308,7 +316,11 @@ void hfs_mdb_commit(struct super_block *sb)
                                break;
                        }
                        len = min((int)sb->s_blocksize - off, size);
+                        lock_buffer(bh);
                        memcpy(bh->b_data + off, ptr, len);
+                        unlock_buffer(bh);
                        mark_buffer_dirty(bh);
                        brelse(bh);
                        block++;
@@ -317,6 +329,7 @@ void hfs_mdb_commit(struct super_block *sb)
                        size -= len;
                }
        }
+        unlock_buffer(HFS_SB(sb)->mdb_bh);
 }
 void hfs_mdb_close(struct super_block *sb)
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 7b4c537d6e13..4eb873e0c07b 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -29,43 +29,9 @@ static struct kmem_cache *hfs_inode_cachep;
 MODULE_LICENSE("GPL");
-/*
- * hfs_write_super()
- *
- * Description:
- *   This function is called by the VFS only. When the filesystem
- *   is mounted r/w it updates the MDB on disk.
- * Input Variable(s):
- *   struct super_block *sb: Pointer to the hfs superblock
- * Output Variable(s):
- *   NONE
- * Returns:
- *   void
- * Preconditions:
- *   'sb' points to a "valid" (struct super_block).
- * Postconditions:
- *   The MDB is marked 'unsuccessfully unmounted' by clearing bit 8 of drAtrb
- *   (hfs_put_super() must set this flag!). Some MDB fields are updated
- *   and the MDB buffer is written to disk by calling hfs_mdb_commit().
- */
-static void hfs_write_super(struct super_block *sb)
-{
-        lock_super(sb);
-        sb->s_dirt = 0;
-        /* sync everything to the buffers */
-        if (!(sb->s_flags & MS_RDONLY))
-                hfs_mdb_commit(sb);
-        unlock_super(sb);
-}
 static int hfs_sync_fs(struct super_block *sb, int wait)
 {
-        lock_super(sb);
        hfs_mdb_commit(sb);
-        sb->s_dirt = 0;
-        unlock_super(sb);
        return 0;
 }
@@ -78,13 +44,44 @@ static int hfs_sync_fs(struct super_block *sb, int wait)
 */
 static void hfs_put_super(struct super_block *sb)
 {
-        if (sb->s_dirt)
+        cancel_delayed_work_sync(&HFS_SB(sb)->mdb_work);
-                hfs_write_super(sb);
        hfs_mdb_close(sb);
        /* release the MDB's resources */
        hfs_mdb_put(sb);
 }
+static void flush_mdb(struct work_struct *work)
+{
+        struct hfs_sb_info *sbi;
+        struct super_block *sb;
+        sbi = container_of(work, struct hfs_sb_info, mdb_work.work);
+        sb = sbi->sb;
+        spin_lock(&sbi->work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->work_lock);
+        hfs_mdb_commit(sb);
+}
+void hfs_mark_mdb_dirty(struct super_block *sb)
+{
+        struct hfs_sb_info *sbi = HFS_SB(sb);
+        unsigned long delay;
+        if (sb->s_flags & MS_RDONLY)
+                return;
+        spin_lock(&sbi->work_lock);
+        if (!sbi->work_queued) {
+                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+                queue_delayed_work(system_long_wq, &sbi->mdb_work, delay);
+                sbi->work_queued = 1;
+        }
+        spin_unlock(&sbi->work_lock);
+}
 /*
 * hfs_statfs()
 *
@@ -184,7 +181,6 @@ static const struct super_operations hfs_super_operations = {
        .write_inode    = hfs_write_inode,
        .evict_inode    = hfs_evict_inode,
        .put_super      = hfs_put_super,
-        .write_super    = hfs_write_super,
        .sync_fs        = hfs_sync_fs,
        .statfs         = hfs_statfs,
        .remount_fs     = hfs_remount,
@@ -387,7 +383,10 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
        if (!sbi)
                return -ENOMEM;
+        sbi->sb = sb;
        sb->s_fs_info = sbi;
+        spin_lock_init(&sbi->work_lock);
+        INIT_DELAYED_WORK(&sbi->mdb_work, flush_mdb);
        res = -EINVAL;
        if (!parse_options((char *)data, sbi)) {
diff --git a/fs/hfs/sysdep.c b/fs/hfs/sysdep.c
index 19cf291eb91f..91b91fd3a901 100644
--- a/fs/hfs/sysdep.c
+++ b/fs/hfs/sysdep.c
@@ -13,12 +13,12 @@
 /* dentry case-handling: just lowercase everything */
-static int hfs_revalidate_dentry(struct dentry *dentry, struct nameidata *nd)
+static int hfs_revalidate_dentry(struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode;
        int diff;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = dentry->d_inode;
diff --git a/fs/hfsplus/bitmap.c b/fs/hfsplus/bitmap.c
index 1cad80c789cb..4cfbe2edd296 100644
--- a/fs/hfsplus/bitmap.c
+++ b/fs/hfsplus/bitmap.c
@@ -153,7 +153,7 @@ done:
        kunmap(page);
        *max = offset + (curr - pptr) * 32 + i - start;
        sbi->free_blocks -= *max;
-        sb->s_dirt = 1;
+        hfsplus_mark_mdb_dirty(sb);
        dprint(DBG_BITMAP, "-> %u,%u\n", start, *max);
 out:
        mutex_unlock(&sbi->alloc_mutex);
@@ -228,7 +228,7 @@ out:
        set_page_dirty(page);
        kunmap(page);
        sbi->free_blocks += len;
-        sb->s_dirt = 1;
+        hfsplus_mark_mdb_dirty(sb);
        mutex_unlock(&sbi->alloc_mutex);
        return 0;
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 26b53fb09f68..6b9f921ef2fa 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -25,7 +25,7 @@ static inline void hfsplus_instantiate(struct dentry *dentry,
 /* Find the entry inside dir named dentry->d_name */
 static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
-                                     struct nameidata *nd)
+                                     unsigned int flags)
 {
        struct inode *inode = NULL;
        struct hfs_find_data fd;
@@ -316,7 +316,7 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
        inode->i_ctime = CURRENT_TIME_SEC;
        mark_inode_dirty(inode);
        sbi->file_count++;
-        dst_dir->i_sb->s_dirt = 1;
+        hfsplus_mark_mdb_dirty(dst_dir->i_sb);
 out:
        mutex_unlock(&sbi->vh_mutex);
        return res;
@@ -465,7 +465,7 @@ out:
 }
 static int hfsplus_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                          struct nameidata *nd)
+                          bool excl)
 {
        return hfsplus_mknod(dir, dentry, mode, 0);
 }
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 4e75ac646fea..558dbb463a4e 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -153,8 +153,11 @@ struct hfsplus_sb_info {
        gid_t gid;
        int part, session;
        unsigned long flags;
+        int work_queued;               /* non-zero delayed work is queued */
+        struct delayed_work sync_work; /* FS sync delayed work */
+        spinlock_t work_lock;          /* protects sync_work and work_queued */
 };
 #define HFSPLUS_SB_WRITEBACKUP  0
@@ -428,7 +431,7 @@ int hfsplus_show_options(struct seq_file *, struct dentry *);
 /* super.c */
 struct inode *hfsplus_iget(struct super_block *, unsigned long);
-int hfsplus_sync_fs(struct super_block *sb, int wait);
+void hfsplus_mark_mdb_dirty(struct super_block *sb);
 /* tables.c */
 extern u16 hfsplus_case_fold_table[];
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 82b69ee4dacc..3d8b4a675ba0 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -168,7 +168,7 @@ const struct dentry_operations hfsplus_dentry_operations = {
 };
 static struct dentry *hfsplus_file_lookup(struct inode *dir,
-                struct dentry *dentry, struct nameidata *nd)
+                struct dentry *dentry, unsigned int flags)
 {
        struct hfs_find_data fd;
        struct super_block *sb = dir->i_sb;
@@ -431,7 +431,7 @@ struct inode *hfsplus_new_inode(struct super_block *sb, umode_t mode)
                sbi->file_count++;
        insert_inode_hash(inode);
        mark_inode_dirty(inode);
-        sb->s_dirt = 1;
+        hfsplus_mark_mdb_dirty(sb);
        return inode;
 }
@@ -442,7 +442,7 @@ void hfsplus_delete_inode(struct inode *inode)
        if (S_ISDIR(inode->i_mode)) {
                HFSPLUS_SB(sb)->folder_count--;
-                sb->s_dirt = 1;
+                hfsplus_mark_mdb_dirty(sb);
                return;
        }
        HFSPLUS_SB(sb)->file_count--;
@@ -455,7 +455,7 @@ void hfsplus_delete_inode(struct inode *inode)
                inode->i_size = 0;
                hfsplus_file_truncate(inode);
        }
-        sb->s_dirt = 1;
+        hfsplus_mark_mdb_dirty(sb);
 }
 void hfsplus_inode_read_fork(struct inode *inode, struct hfsplus_fork_raw *fork)
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index c640ba57074b..09addc8615fa 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -31,6 +31,7 @@ static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
        struct hfsplus_vh *vh = sbi->s_vhdr;
        struct hfsplus_vh *bvh = sbi->s_backup_vhdr;
+        u32 cnid = (unsigned long)dentry->d_fsdata;
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
@@ -41,8 +42,12 @@ static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
        vh->finder_info[0] = bvh->finder_info[0] =
                cpu_to_be32(parent_ino(dentry));
-        /* Bootloader */
+        /*
-        vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(inode->i_ino);
+         * Bootloader. Just using the inode here breaks in the case of
+         * hard links - the firmware wants the ID of the hard link file,
+         * but the inode points at the indirect inode
+         */
+        vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid);
        /* Per spec, the OS X system folder - same as finder_info[0] here */
        vh->finder_info[5] = bvh->finder_info[5] =
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index a9bca4b8768b..473332098013 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -124,7 +124,7 @@ static int hfsplus_system_write_inode(struct inode *inode)
        if (fork->total_size != cpu_to_be64(inode->i_size)) {
                set_bit(HFSPLUS_SB_WRITEBACKUP, &sbi->flags);
-                inode->i_sb->s_dirt = 1;
+                hfsplus_mark_mdb_dirty(inode->i_sb);
        }
        hfsplus_inode_write_fork(inode, fork);
        if (tree)
@@ -161,7 +161,7 @@ static void hfsplus_evict_inode(struct inode *inode)
        }
 }
-int hfsplus_sync_fs(struct super_block *sb, int wait)
+static int hfsplus_sync_fs(struct super_block *sb, int wait)
 {
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
        struct hfsplus_vh *vhdr = sbi->s_vhdr;
@@ -171,9 +171,7 @@ int hfsplus_sync_fs(struct super_block *sb, int wait)
        if (!wait)
                return 0;
-        dprint(DBG_SUPER, "hfsplus_write_super\n");
+        dprint(DBG_SUPER, "hfsplus_sync_fs\n");
-        sb->s_dirt = 0;
        /*
         * Explicitly write out the special metadata inodes.
@@ -226,12 +224,34 @@ out:
        return error;
 }
-static void hfsplus_write_super(struct super_block *sb)
+static void delayed_sync_fs(struct work_struct *work)
 {
-        if (!(sb->s_flags & MS_RDONLY))
+        struct hfsplus_sb_info *sbi;
-                hfsplus_sync_fs(sb, 1);
-        else
+        sbi = container_of(work, struct hfsplus_sb_info, sync_work.work);
-                sb->s_dirt = 0;
+        spin_lock(&sbi->work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->work_lock);
+        hfsplus_sync_fs(sbi->alloc_file->i_sb, 1);
+}
+void hfsplus_mark_mdb_dirty(struct super_block *sb)
+{
+        struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
+        unsigned long delay;
+        if (sb->s_flags & MS_RDONLY)
+                return;
+        spin_lock(&sbi->work_lock);
+        if (!sbi->work_queued) {
+                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+                queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
+                sbi->work_queued = 1;
+        }
+        spin_unlock(&sbi->work_lock);
 }
 static void hfsplus_put_super(struct super_block *sb)
@@ -240,8 +260,7 @@ static void hfsplus_put_super(struct super_block *sb)
        dprint(DBG_SUPER, "hfsplus_put_super\n");
-        if (!sb->s_fs_info)
+        cancel_delayed_work_sync(&sbi->sync_work);
-                return;
        if (!(sb->s_flags & MS_RDONLY) && sbi->s_vhdr) {
                struct hfsplus_vh *vhdr = sbi->s_vhdr;
@@ -328,7 +347,6 @@ static const struct super_operations hfsplus_sops = {
        .write_inode    = hfsplus_write_inode,
        .evict_inode    = hfsplus_evict_inode,
        .put_super      = hfsplus_put_super,
-        .write_super    = hfsplus_write_super,
        .sync_fs        = hfsplus_sync_fs,
        .statfs         = hfsplus_statfs,
        .remount_fs     = hfsplus_remount,
@@ -355,6 +373,8 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_fs_info = sbi;
        mutex_init(&sbi->alloc_mutex);
        mutex_init(&sbi->vh_mutex);
+        spin_lock_init(&sbi->work_lock);
+        INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
        hfsplus_fill_defaults(sbi);
        err = -EINVAL;
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 7daf4b852d1c..90effcccca9a 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -56,7 +56,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
        DECLARE_COMPLETION_ONSTACK(wait);
        struct bio *bio;
        int ret = 0;
-        unsigned int io_size;
+        u64 io_size;
        loff_t start;
        int offset;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 2afa5bbccf9b..124146543aa7 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -553,7 +553,7 @@ static int read_name(struct inode *ino, char *name)
 }
 int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                  struct nameidata *nd)
+                  bool excl)
 {
        struct inode *inode;
        char *name;
@@ -595,7 +595,7 @@ int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 }
 struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
-                             struct nameidata *nd)
+                             unsigned int flags)
 {
        struct inode *inode;
        char *name;
diff --git a/fs/hpfs/dir.c b/fs/hpfs/dir.c
index b8472f803f4e..78e12b2e0ea2 100644
--- a/fs/hpfs/dir.c
+++ b/fs/hpfs/dir.c
@@ -189,7 +189,7 @@ out:
 *            to tell read_inode to read fnode or not.
 */
-struct dentry *hpfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *hpfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        const unsigned char *name = dentry->d_name.name;
        unsigned len = dentry->d_name.len;
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index c07ef1f1ced6..ac1ead194db5 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -220,7 +220,7 @@ extern const struct dentry_operations hpfs_dentry_operations;
 /* dir.c */
-struct dentry *hpfs_lookup(struct inode *, struct dentry *, struct nameidata *);
+struct dentry *hpfs_lookup(struct inode *, struct dentry *, unsigned int);
 extern const struct file_operations hpfs_dir_ops;
 /* dnode.c */
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index 9083ef8af58c..bc9082482f68 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -115,7 +115,7 @@ bail:
        return err;
 }
-static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
+static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
 {
        const unsigned char *name = dentry->d_name.name;
        unsigned len = dentry->d_name.len;
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index d4f93b52cec5..c1dffe47fde2 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -138,7 +138,7 @@ static int file_removed(struct dentry *dentry, const char *file)
 }
 static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        struct dentry *proc_dentry, *parent;
        struct qstr *name = &dentry->d_name;
@@ -420,8 +420,7 @@ static int hppfs_open(struct inode *inode, struct file *file)
 {
        const struct cred *cred = file->f_cred;
        struct hppfs_private *data;
-        struct vfsmount *proc_mnt;
+        struct path path;
-        struct dentry *proc_dentry;
        char *host_file;
        int err, fd, type, filter;
@@ -434,12 +433,11 @@ static int hppfs_open(struct inode *inode, struct file *file)
        if (host_file == NULL)
                goto out_free2;
-        proc_dentry = HPPFS_I(inode)->proc_dentry;
+        path.mnt = inode->i_sb->s_fs_info;
-        proc_mnt = inode->i_sb->s_fs_info;
+        path.dentry = HPPFS_I(inode)->proc_dentry;
        /* XXX This isn't closed anywhere */
-        data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
+        data->proc_file = dentry_open(&path, file_mode(file->f_mode), cred);
-                                      file_mode(file->f_mode), cred);
        err = PTR_ERR(data->proc_file);
        if (IS_ERR(data->proc_file))
                goto out_free1;
@@ -484,8 +482,7 @@ static int hppfs_dir_open(struct inode *inode, struct file *file)
 {
        const struct cred *cred = file->f_cred;
        struct hppfs_private *data;
-        struct vfsmount *proc_mnt;
+        struct path path;
-        struct dentry *proc_dentry;
        int err;
        err = -ENOMEM;
@@ -493,10 +490,9 @@ static int hppfs_dir_open(struct inode *inode, struct file *file)
        if (data == NULL)
                goto out;
-        proc_dentry = HPPFS_I(inode)->proc_dentry;
+        path.mnt = inode->i_sb->s_fs_info;
-        proc_mnt = inode->i_sb->s_fs_info;
+        path.dentry = HPPFS_I(inode)->proc_dentry;
-        data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
+        data->proc_file = dentry_open(&path, file_mode(file->f_mode), cred);
-                                      file_mode(file->f_mode), cred);
        err = PTR_ERR(data->proc_file);
        if (IS_ERR(data->proc_file))
                goto out_free;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index cc9281b6c628..e13e9bdb0bf5 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -565,7 +565,7 @@ static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mod
        return retval;
 }
-static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
+static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
 {
        return hugetlbfs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
diff --git a/fs/inode.c b/fs/inode.c
index c99163b1b310..775cbabd4fa5 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -182,7 +182,7 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
        }
        inode->i_private = NULL;
        inode->i_mapping = mapping;
-        INIT_LIST_HEAD(&inode->i_dentry);       /* buggered by rcu freeing */
+        INIT_HLIST_HEAD(&inode->i_dentry);      /* buggered by rcu freeing */
 #ifdef CONFIG_FS_POSIX_ACL
        inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
 #endif
diff --git a/fs/internal.h b/fs/internal.h
index 18bc216ea09d..a6fd56c68b11 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -42,6 +42,11 @@ static inline int __sync_blockdev(struct block_device *bdev, int wait)
 extern void __init chrdev_init(void);
 /*
+ * namei.c
+ */
+extern int __inode_permission(struct inode *, int);
+/*
 * namespace.c
 */
 extern int copy_mount_options(const void __user *, unsigned long *);
@@ -50,8 +55,6 @@ extern int copy_mount_string(const void __user *, char **);
 extern struct vfsmount *lookup_mnt(struct path *);
 extern int finish_automount(struct vfsmount *, struct path *);
-extern void mnt_make_longterm(struct vfsmount *);
-extern void mnt_make_shortterm(struct vfsmount *);
 extern int sb_prepare_remount_readonly(struct super_block *);
 extern void __init mnt_init(void);
@@ -84,9 +87,6 @@ extern struct super_block *user_get_super(dev_t);
 /*
 * open.c
 */
-struct nameidata;
-extern struct file *nameidata_to_filp(struct nameidata *);
-extern void release_open_intent(struct nameidata *);
 struct open_flags {
        int open_flag;
        umode_t mode;
diff --git a/fs/isofs/export.c b/fs/isofs/export.c
index aa4356d09eee..1d3804492aa7 100644
--- a/fs/isofs/export.c
+++ b/fs/isofs/export.c
@@ -134,6 +134,7 @@ isofs_export_encode_fh(struct inode *inode,
        len = 3;
        fh32[0] = ei->i_iget5_block;
        fh16[2] = (__u16)ei->i_iget5_offset;  /* fh16 [sic] */
+        fh16[3] = 0;  /* avoid leaking uninitialized data */
        fh32[2] = inode->i_generation;
        if (parent) {
                struct iso_inode_info *eparent;
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index 0e73f63d9274..3620ad1ea9bc 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -114,7 +114,7 @@ extern int isofs_name_translate(struct iso_directory_record *, char *, struct in
 int get_joliet_filename(struct iso_directory_record *, unsigned char *, struct inode *);
 int get_acorn_filename(struct iso_directory_record *, char *, struct inode *);
-extern struct dentry *isofs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *isofs_lookup(struct inode *, struct dentry *, unsigned int flags);
 extern struct buffer_head *isofs_bread(struct inode *, sector_t);
 extern int isofs_get_blocks(struct inode *, sector_t, struct buffer_head **, unsigned long);
diff --git a/fs/isofs/namei.c b/fs/isofs/namei.c
index 1e2946f2a69e..c167028844ed 100644
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
@@ -163,7 +163,7 @@ isofs_find_entry(struct inode *dir, struct dentry *dentry,
        return 0;
 }
-struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        int found;
        unsigned long uninitialized_var(block);
diff --git a/fs/jbd/recovery.c b/fs/jbd/recovery.c
index 008bf062fd26..a748fe21465a 100644
--- a/fs/jbd/recovery.c
+++ b/fs/jbd/recovery.c
@@ -265,8 +265,11 @@ int journal_recover(journal_t *journal)
        if (!err)
                err = err2;
        /* Flush disk caches to get replayed data on the permanent storage */
-        if (journal->j_flags & JFS_BARRIER)
+        if (journal->j_flags & JFS_BARRIER) {
-                blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
+                err2 = blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
+                if (!err)
+                        err = err2;
+        }
        return err;
 }
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index b56018896d5e..ad7774d32095 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -25,9 +25,9 @@
 static int jffs2_readdir (struct file *, void *, filldir_t);
 static int jffs2_create (struct inode *,struct dentry *,umode_t,
-                         struct nameidata *);
+                         bool);
 static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
-                                    struct nameidata *);
+                                    unsigned int);
 static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
 static int jffs2_unlink (struct inode *,struct dentry *);
 static int jffs2_symlink (struct inode *,struct dentry *,const char *);
@@ -74,7 +74,7 @@ const struct inode_operations jffs2_dir_inode_operations =
   nice and simple
 */
 static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        struct jffs2_inode_info *dir_f;
        struct jffs2_full_dirent *fd = NULL, *fd_list;
@@ -175,7 +175,7 @@ static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
 static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
-                        umode_t mode, struct nameidata *nd)
+                        umode_t mode, bool excl)
 {
        struct jffs2_raw_inode *ri;
        struct jffs2_inode_info *f, *dir_f;
@@ -226,8 +226,8 @@ static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
                  __func__, inode->i_ino, inode->i_mode, inode->i_nlink,
                  f->inocache->pino_nlink, inode->i_mapping->nrpages);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        return 0;
 fail:
@@ -446,8 +446,8 @@ static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char
        mutex_unlock(&dir_f->sem);
        jffs2_complete_reservation(c);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        return 0;
 fail:
@@ -591,8 +591,8 @@ static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode
        mutex_unlock(&dir_f->sem);
        jffs2_complete_reservation(c);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        return 0;
 fail:
@@ -766,8 +766,8 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode
        mutex_unlock(&dir_f->sem);
        jffs2_complete_reservation(c);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        return 0;
 fail:
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 07c91ca6017d..3b91a7ad6086 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -73,7 +73,7 @@ static inline void free_ea_wmap(struct inode *inode)
 *
 */
 static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        int rc = 0;
        tid_t tid;              /* transaction id */
@@ -176,8 +176,8 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
                unlock_new_inode(ip);
                iput(ip);
        } else {
-                d_instantiate(dentry, ip);
                unlock_new_inode(ip);
+                d_instantiate(dentry, ip);
        }
      out2:
@@ -309,8 +309,8 @@ static int jfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
                unlock_new_inode(ip);
                iput(ip);
        } else {
-                d_instantiate(dentry, ip);
                unlock_new_inode(ip);
+                d_instantiate(dentry, ip);
        }
      out2:
@@ -1043,8 +1043,8 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
                unlock_new_inode(ip);
                iput(ip);
        } else {
-                d_instantiate(dentry, ip);
                unlock_new_inode(ip);
+                d_instantiate(dentry, ip);
        }
      out2:
@@ -1424,8 +1424,8 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
                unlock_new_inode(ip);
                iput(ip);
        } else {
-                d_instantiate(dentry, ip);
                unlock_new_inode(ip);
+                d_instantiate(dentry, ip);
        }
      out1:
@@ -1436,7 +1436,7 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
        return rc;
 }
-static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, unsigned int flags)
 {
        struct btstack btstack;
        ino_t inum;
@@ -1570,7 +1570,7 @@ out:
        return result;
 }
-static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int jfs_ci_revalidate(struct dentry *dentry, unsigned int flags)
 {
        /*
         * This is not negative dentry. Always valid.
@@ -1589,7 +1589,7 @@ static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
         * This may be nfsd (or something), anyway, we can't see the
         * intent of this. So, since this can be for creation, drop it.
         */
-        if (!nd)
+        if (!flags)
                return 0;
        /*
@@ -1597,7 +1597,7 @@ static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
         * case sensitive name which is specified by user if this is
         * for creation.
         */
-        if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+        if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
                return 0;
        return 1;
 }
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 4a82950f412f..c55c7452d285 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -601,6 +601,11 @@ static int jfs_sync_fs(struct super_block *sb, int wait)
        /* log == NULL indicates read-only mount */
        if (log) {
+                /*
+                 * Write quota structures to quota file, sync_blockdev() will
+                 * write them to disk later
+                 */
+                dquot_writeback_dquots(sb, -1);
                jfs_flush_journal(log, wait);
                jfs_syncpt(log, 0);
        }
diff --git a/fs/libfs.c b/fs/libfs.c
index f86ec27a4230..a74cb1725ac6 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -53,7 +53,7 @@ static int simple_delete_dentry(const struct dentry *dentry)
 * Lookup the data. This is trivial - if the dentry didn't already
 * exist, we know it is negative.  Set d_op to delete negative dentries.
 */
-struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        static const struct dentry_operations simple_dentry_operations = {
                .d_delete = simple_delete_dentry,
@@ -222,15 +222,15 @@ struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
        const struct super_operations *ops,
        const struct dentry_operations *dops, unsigned long magic)
 {
-        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
+        struct super_block *s;
        struct dentry *dentry;
        struct inode *root;
        struct qstr d_name = QSTR_INIT(name, strlen(name));
+        s = sget(fs_type, NULL, set_anon_super, MS_NOUSER, NULL);
        if (IS_ERR(s))
                return ERR_CAST(s);
-        s->s_flags = MS_NOUSER;
        s->s_maxbytes = MAX_LFS_FILESIZE;
        s->s_blocksize = PAGE_SIZE;
        s->s_blocksize_bits = PAGE_SHIFT;
diff --git a/fs/locks.c b/fs/locks.c
index 814c51d0de47..82c353304f9e 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -308,7 +308,7 @@ static int flock_make_lock(struct file *filp, struct file_lock **lock,
        return 0;
 }
-static int assign_type(struct file_lock *fl, int type)
+static int assign_type(struct file_lock *fl, long type)
 {
        switch (type) {
        case F_RDLCK:
@@ -445,7 +445,7 @@ static const struct lock_manager_operations lease_manager_ops = {
 /*
 * Initialize a lease, use the default lock manager operations
 */
-static int lease_init(struct file *filp, int type, struct file_lock *fl)
+static int lease_init(struct file *filp, long type, struct file_lock *fl)
 {
        if (assign_type(fl, type) != 0)
                return -EINVAL;
@@ -463,7 +463,7 @@ static int lease_init(struct file *filp, int type, struct file_lock *fl)
 }
 /* Allocate a file_lock initialised to this type of lease */
-static struct file_lock *lease_alloc(struct file *filp, int type)
+static struct file_lock *lease_alloc(struct file *filp, long type)
 {
        struct file_lock *fl = locks_alloc_lock();
        int error = -ENOMEM;
@@ -1465,7 +1465,7 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
        case F_WRLCK:
                return generic_add_lease(filp, arg, flp);
        default:
-                BUG();
+                return -EINVAL;
        }
 }
 EXPORT_SYMBOL(generic_setlease);
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index bea5d1b9954b..26e4a941532f 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -349,7 +349,7 @@ static void logfs_set_name(struct logfs_disk_dentry *dd, struct qstr *name)
 }
 static struct dentry *logfs_lookup(struct inode *dir, struct dentry *dentry,
-                struct nameidata *nd)
+                unsigned int flags)
 {
        struct page *page;
        struct logfs_disk_dentry *dd;
@@ -502,7 +502,7 @@ static int logfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 }
 static int logfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        struct inode *inode;
diff --git a/fs/logfs/super.c b/fs/logfs/super.c
index 97bca623d893..345c24b8a6f8 100644
--- a/fs/logfs/super.c
+++ b/fs/logfs/super.c
@@ -519,7 +519,7 @@ static struct dentry *logfs_get_sb_device(struct logfs_super *super,
        log_super("LogFS: Start mount %x\n", mount_count++);
        err = -EINVAL;
-        sb = sget(type, logfs_sb_test, logfs_sb_set, super);
+        sb = sget(type, logfs_sb_test, logfs_sb_set, flags | MS_NOATIME, super);
        if (IS_ERR(sb)) {
                super->s_devops->put_device(super);
                kfree(super);
@@ -542,7 +542,6 @@ static struct dentry *logfs_get_sb_device(struct logfs_super *super,
        sb->s_maxbytes  = (1ull << 43) - 1;
        sb->s_max_links = LOGFS_LINK_MAX;
        sb->s_op        = &logfs_super_operations;
-        sb->s_flags     = flags | MS_NOATIME;
        err = logfs_read_sb(sb, sb->s_flags & MS_RDONLY);
        if (err)
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index 2d0ee1786305..0db73d9dd668 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -18,7 +18,7 @@ static int add_nondir(struct dentry *dentry, struct inode *inode)
        return err;
 }
-static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode * inode = NULL;
        ino_t ino;
@@ -55,7 +55,7 @@ static int minix_mknod(struct inode * dir, struct dentry *dentry, umode_t mode,
 }
 static int minix_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        return minix_mknod(dir, dentry, mode, 0);
 }
diff --git a/fs/mount.h b/fs/mount.h
index 4ef36d93e5a2..4f291f9de641 100644
--- a/fs/mount.h
+++ b/fs/mount.h
@@ -22,7 +22,6 @@ struct mount {
        struct vfsmount mnt;
 #ifdef CONFIG_SMP
        struct mnt_pcp __percpu *mnt_pcp;
-        atomic_t mnt_longterm;          /* how many of the refs are longterm */
 #else
        int mnt_count;
        int mnt_writers;
@@ -49,6 +48,8 @@ struct mount {
        int mnt_ghosts;
 };
+#define MNT_NS_INTERNAL ERR_PTR(-EINVAL) /* distinct from any mnt_namespace */
 static inline struct mount *real_mount(struct vfsmount *mnt)
 {
        return container_of(mnt, struct mount, mnt);
@@ -59,6 +60,12 @@ static inline int mnt_has_parent(struct mount *mnt)
        return mnt != mnt->mnt_parent;
 }
+static inline int is_mounted(struct vfsmount *mnt)
+{
+        /* neither detached nor internal? */
+        return !IS_ERR_OR_NULL(real_mount(mnt));
+}
 extern struct mount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
 static inline void get_mnt_ns(struct mnt_namespace *ns)
@@ -67,10 +74,12 @@ static inline void get_mnt_ns(struct mnt_namespace *ns)
 }
 struct proc_mounts {
-        struct seq_file m; /* must be the first element */
+        struct seq_file m;
        struct mnt_namespace *ns;
        struct path root;
        int (*show)(struct seq_file *, struct vfsmount *);
 };
+#define proc_mounts(p) (container_of((p), struct proc_mounts, m))
 extern const struct seq_operations mounts_op;
diff --git a/fs/namei.c b/fs/namei.c
index 7d694194024a..2ccc35c4dc24 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -315,31 +315,22 @@ static inline int do_inode_permission(struct inode *inode, int mask)
 }
 /**
- * inode_permission  -  check for access rights to a given inode
+ * __inode_permission - Check for access rights to a given inode
- * @inode:      inode to check permission on
+ * @inode: Inode to check permission on
- * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 *
- * Used to check for read/write/execute permissions on an inode.
+ * Check for read/write/execute permissions on an inode.
- * We use "fsuid" for this, letting us set arbitrary permissions
- * for filesystem access without changing the "normal" uids which
- * are used for other things.
 *
 * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
+ *
+ * This does not check for a read-only file system.  You probably want
+ * inode_permission().
 */
-int inode_permission(struct inode *inode, int mask)
+int __inode_permission(struct inode *inode, int mask)
 {
        int retval;
        if (unlikely(mask & MAY_WRITE)) {
-                umode_t mode = inode->i_mode;
-                /*
-                 * Nobody gets write access to a read-only fs.
-                 */
-                if (IS_RDONLY(inode) &&
-                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
-                        return -EROFS;
                /*
                 * Nobody gets write access to an immutable file.
                 */
@@ -359,6 +350,47 @@ int inode_permission(struct inode *inode, int mask)
 }
 /**
+ * sb_permission - Check superblock-level permissions
+ * @sb: Superblock of inode to check permission on
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ *
+ * Separate out file-system wide checks from inode-specific permission checks.
+ */
+static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
+{
+        if (unlikely(mask & MAY_WRITE)) {
+                umode_t mode = inode->i_mode;
+                /* Nobody gets write access to a read-only fs. */
+                if ((sb->s_flags & MS_RDONLY) &&
+                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
+                        return -EROFS;
+        }
+        return 0;
+}
+/**
+ * inode_permission - Check for access rights to a given inode
+ * @inode: Inode to check permission on
+ * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
+ *
+ * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
+ * this, letting us set arbitrary permissions for filesystem access without
+ * changing the "normal" UIDs which are used for other things.
+ *
+ * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
+ */
+int inode_permission(struct inode *inode, int mask)
+{
+        int retval;
+        retval = sb_permission(inode->i_sb, inode, mask);
+        if (retval)
+                return retval;
+        return __inode_permission(inode, mask);
+}
+/**
 * path_get - get a reference to a path
 * @path: path to get the reference to
 *
@@ -395,6 +427,18 @@ EXPORT_SYMBOL(path_put);
 * to restart the path walk from the beginning in ref-walk mode.
 */
+static inline void lock_rcu_walk(void)
+{
+        br_read_lock(&vfsmount_lock);
+        rcu_read_lock();
+}
+static inline void unlock_rcu_walk(void)
+{
+        rcu_read_unlock();
+        br_read_unlock(&vfsmount_lock);
+}
 /**
 * unlazy_walk - try to switch to ref-walk mode.
 * @nd: nameidata pathwalk data
@@ -448,8 +492,7 @@ static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
        }
        mntget(nd->path.mnt);
-        rcu_read_unlock();
+        unlock_rcu_walk();
-        br_read_unlock(&vfsmount_lock);
        nd->flags &= ~LOOKUP_RCU;
        return 0;
@@ -463,25 +506,9 @@ err_root:
        return -ECHILD;
 }
-/**
+static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
- * release_open_intent - free up open intent resources
- * @nd: pointer to nameidata
- */
-void release_open_intent(struct nameidata *nd)
 {
-        struct file *file = nd->intent.open.file;
+        return dentry->d_op->d_revalidate(dentry, flags);
-        if (file && !IS_ERR(file)) {
-                if (file->f_path.dentry == NULL)
-                        put_filp(file);
-                else
-                        fput(file);
-        }
-}
-static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
-{
-        return dentry->d_op->d_revalidate(dentry, nd);
 }
 /**
@@ -506,15 +533,13 @@ static int complete_walk(struct nameidata *nd)
                spin_lock(&dentry->d_lock);
                if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
                        spin_unlock(&dentry->d_lock);
-                        rcu_read_unlock();
+                        unlock_rcu_walk();
-                        br_read_unlock(&vfsmount_lock);
                        return -ECHILD;
                }
                BUG_ON(nd->inode != dentry->d_inode);
                spin_unlock(&dentry->d_lock);
                mntget(nd->path.mnt);
-                rcu_read_unlock();
+                unlock_rcu_walk();
-                br_read_unlock(&vfsmount_lock);
        }
        if (likely(!(nd->flags & LOOKUP_JUMPED)))
@@ -527,7 +552,7 @@ static int complete_walk(struct nameidata *nd)
                return 0;
        /* Note: we do not d_invalidate() */
-        status = d_revalidate(dentry, nd);
+        status = d_revalidate(dentry, nd->flags);
        if (status > 0)
                return 0;
@@ -602,10 +627,25 @@ static inline void path_to_nameidata(const struct path *path,
        nd->path.dentry = path->dentry;
 }
+/*
+ * Helper to directly jump to a known parsed path from ->follow_link,
+ * caller must have taken a reference to path beforehand.
+ */
+void nd_jump_link(struct nameidata *nd, struct path *path)
+{
+        path_put(&nd->path);
+        nd->path = *path;
+        nd->inode = nd->path.dentry->d_inode;
+        nd->flags |= LOOKUP_JUMPED;
+        BUG_ON(nd->inode->i_op->follow_link);
+}
 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
 {
        struct inode *inode = link->dentry->d_inode;
-        if (!IS_ERR(cookie) && inode->i_op->put_link)
+        if (inode->i_op->put_link)
                inode->i_op->put_link(link->dentry, nd, cookie);
        path_put(link);
 }
@@ -613,19 +653,19 @@ static inline void put_link(struct nameidata *nd, struct path *link, void *cooki
 static __always_inline int
 follow_link(struct path *link, struct nameidata *nd, void **p)
 {
-        int error;
        struct dentry *dentry = link->dentry;
+        int error;
+        char *s;
        BUG_ON(nd->flags & LOOKUP_RCU);
        if (link->mnt == nd->path.mnt)
                mntget(link->mnt);
-        if (unlikely(current->total_link_count >= 40)) {
+        error = -ELOOP;
-                *p = ERR_PTR(-ELOOP); /* no ->put_link(), please */
+        if (unlikely(current->total_link_count >= 40))
-                path_put(&nd->path);
+                goto out_put_nd_path;
-                return -ELOOP;
-        }
        cond_resched();
        current->total_link_count++;
@@ -633,30 +673,28 @@ follow_link(struct path *link, struct nameidata *nd, void **p)
        nd_set_link(nd, NULL);
        error = security_inode_follow_link(link->dentry, nd);
-        if (error) {
+        if (error)
-                *p = ERR_PTR(error); /* no ->put_link(), please */
+                goto out_put_nd_path;
-                path_put(&nd->path);
-                return error;
-        }
        nd->last_type = LAST_BIND;
        *p = dentry->d_inode->i_op->follow_link(dentry, nd);
        error = PTR_ERR(*p);
-        if (!IS_ERR(*p)) {
+        if (IS_ERR(*p))
-                char *s = nd_get_link(nd);
+                goto out_put_nd_path;
-                error = 0;
-                if (s)
+        error = 0;
-                        error = __vfs_follow_link(nd, s);
+        s = nd_get_link(nd);
-                else if (nd->last_type == LAST_BIND) {
+        if (s) {
-                        nd->flags |= LOOKUP_JUMPED;
+                error = __vfs_follow_link(nd, s);
-                        nd->inode = nd->path.dentry->d_inode;
+                if (unlikely(error))
-                        if (nd->inode->i_op->follow_link) {
+                        put_link(nd, link, *p);
-                                /* stepped on a _really_ weird one */
-                                path_put(&nd->path);
-                                error = -ELOOP;
-                        }
-                }
        }
+        return error;
+out_put_nd_path:
+        path_put(&nd->path);
+        path_put(link);
        return error;
 }
@@ -675,6 +713,16 @@ static int follow_up_rcu(struct path *path)
        return 1;
 }
+/*
+ * follow_up - Find the mountpoint of path's vfsmount
+ *
+ * Given a path, find the mountpoint of its source file system.
+ * Replace @path with the path of the mountpoint in the parent mount.
+ * Up is towards /.
+ *
+ * Return 1 if we went up a level and 0 if we were already at the
+ * root.
+ */
 int follow_up(struct path *path)
 {
        struct mount *mnt = real_mount(path->mnt);
@@ -683,7 +731,7 @@ int follow_up(struct path *path)
        br_read_lock(&vfsmount_lock);
        parent = mnt->mnt_parent;
-        if (&parent->mnt == path->mnt) {
+        if (parent == mnt) {
                br_read_unlock(&vfsmount_lock);
                return 0;
        }
@@ -946,8 +994,7 @@ failed:
        nd->flags &= ~LOOKUP_RCU;
        if (!(nd->flags & LOOKUP_ROOT))
                nd->root.mnt = NULL;
-        rcu_read_unlock();
+        unlock_rcu_walk();
-        br_read_unlock(&vfsmount_lock);
        return -ECHILD;
 }
@@ -1048,7 +1095,7 @@ static void follow_dotdot(struct nameidata *nd)
 * dir->d_inode->i_mutex must be held
 */
 static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
-                                    struct nameidata *nd, bool *need_lookup)
+                                    unsigned int flags, bool *need_lookup)
 {
        struct dentry *dentry;
        int error;
@@ -1059,7 +1106,7 @@ static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
                if (d_need_lookup(dentry)) {
                        *need_lookup = true;
                } else if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
-                        error = d_revalidate(dentry, nd);
+                        error = d_revalidate(dentry, flags);
                        if (unlikely(error <= 0)) {
                                if (error < 0) {
                                        dput(dentry);
@@ -1089,7 +1136,7 @@ static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
 * dir->d_inode->i_mutex must be held
 */
 static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        struct dentry *old;
@@ -1099,7 +1146,7 @@ static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
                return ERR_PTR(-ENOENT);
        }
-        old = dir->i_op->lookup(dir, dentry, nd);
+        old = dir->i_op->lookup(dir, dentry, flags);
        if (unlikely(old)) {
                dput(dentry);
                dentry = old;
@@ -1108,16 +1155,16 @@ static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
 }
 static struct dentry *__lookup_hash(struct qstr *name,
-                struct dentry *base, struct nameidata *nd)
+                struct dentry *base, unsigned int flags)
 {
        bool need_lookup;
        struct dentry *dentry;
-        dentry = lookup_dcache(name, base, nd, &need_lookup);
+        dentry = lookup_dcache(name, base, flags, &need_lookup);
        if (!need_lookup)
                return dentry;
-        return lookup_real(base->d_inode, dentry, nd);
+        return lookup_real(base->d_inode, dentry, flags);
 }
 /*
@@ -1167,7 +1214,7 @@ static int lookup_fast(struct nameidata *nd, struct qstr *name,
                if (unlikely(d_need_lookup(dentry)))
                        goto unlazy;
                if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
-                        status = d_revalidate(dentry, nd);
+                        status = d_revalidate(dentry, nd->flags);
                        if (unlikely(status <= 0)) {
                                if (status != -ECHILD)
                                        need_reval = 0;
@@ -1197,7 +1244,7 @@ unlazy:
        }
        if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
-                status = d_revalidate(dentry, nd);
+                status = d_revalidate(dentry, nd->flags);
        if (unlikely(status <= 0)) {
                if (status < 0) {
                        dput(dentry);
@@ -1236,7 +1283,7 @@ static int lookup_slow(struct nameidata *nd, struct qstr *name,
        BUG_ON(nd->inode != parent->d_inode);
        mutex_lock(&parent->d_inode->i_mutex);
-        dentry = __lookup_hash(name, parent, nd);
+        dentry = __lookup_hash(name, parent, nd->flags);
        mutex_unlock(&parent->d_inode->i_mutex);
        if (IS_ERR(dentry))
                return PTR_ERR(dentry);
@@ -1284,8 +1331,7 @@ static void terminate_walk(struct nameidata *nd)
                nd->flags &= ~LOOKUP_RCU;
                if (!(nd->flags & LOOKUP_ROOT))
                        nd->root.mnt = NULL;
-                rcu_read_unlock();
+                unlock_rcu_walk();
-                br_read_unlock(&vfsmount_lock);
        }
 }
@@ -1383,9 +1429,10 @@ static inline int nested_symlink(struct path *path, struct nameidata *nd)
                void *cookie;
                res = follow_link(&link, nd, &cookie);
-                if (!res)
+                if (res)
-                        res = walk_component(nd, path, &nd->last,
+                        break;
-                                             nd->last_type, LOOKUP_FOLLOW);
+                res = walk_component(nd, path, &nd->last,
+                                     nd->last_type, LOOKUP_FOLLOW);
                put_link(nd, &link, cookie);
        } while (res > 0);
@@ -1651,8 +1698,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                nd->path = nd->root;
                nd->inode = inode;
                if (flags & LOOKUP_RCU) {
-                        br_read_lock(&vfsmount_lock);
+                        lock_rcu_walk();
-                        rcu_read_lock();
                        nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
                } else {
                        path_get(&nd->path);
@@ -1664,8 +1710,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
        if (*name=='/') {
                if (flags & LOOKUP_RCU) {
-                        br_read_lock(&vfsmount_lock);
+                        lock_rcu_walk();
-                        rcu_read_lock();
                        set_root_rcu(nd);
                } else {
                        set_root(nd);
@@ -1677,8 +1722,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                        struct fs_struct *fs = current->fs;
                        unsigned seq;
-                        br_read_lock(&vfsmount_lock);
+                        lock_rcu_walk();
-                        rcu_read_lock();
                        do {
                                seq = read_seqcount_begin(&fs->seq);
@@ -1713,8 +1757,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                        if (fput_needed)
                                *fp = file;
                        nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
-                        br_read_lock(&vfsmount_lock);
+                        lock_rcu_walk();
-                        rcu_read_lock();
                } else {
                        path_get(&file->f_path);
                        fput_light(file, fput_needed);
@@ -1777,8 +1820,9 @@ static int path_lookupat(int dfd, const char *name,
                        struct path link = path;
                        nd->flags |= LOOKUP_PARENT;
                        err = follow_link(&link, nd, &cookie);
-                        if (!err)
+                        if (err)
-                                err = lookup_last(nd, &path);
+                                break;
+                        err = lookup_last(nd, &path);
                        put_link(nd, &link, cookie);
                }
        }
@@ -1821,9 +1865,27 @@ static int do_path_lookup(int dfd, const char *name,
        return retval;
 }
-int kern_path_parent(const char *name, struct nameidata *nd)
+/* does lookup, returns the object with parent locked */
+struct dentry *kern_path_locked(const char *name, struct path *path)
 {
-        return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd);
+        struct nameidata nd;
+        struct dentry *d;
+        int err = do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, &nd);
+        if (err)
+                return ERR_PTR(err);
+        if (nd.last_type != LAST_NORM) {
+                path_put(&nd.path);
+                return ERR_PTR(-EINVAL);
+        }
+        mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
+        d = __lookup_hash(&nd.last, nd.path.dentry, 0);
+        if (IS_ERR(d)) {
+                mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
+                path_put(&nd.path);
+                return d;
+        }
+        *path = nd.path;
+        return d;
 }
 int kern_path(const char *name, unsigned int flags, struct path *path)
@@ -1866,7 +1928,7 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
 */
 static struct dentry *lookup_hash(struct nameidata *nd)
 {
-        return __lookup_hash(&nd->last, nd->path.dentry, nd);
+        return __lookup_hash(&nd->last, nd->path.dentry, nd->flags);
 }
 /**
@@ -1913,7 +1975,7 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
        if (err)
                return ERR_PTR(err);
-        return __lookup_hash(&this, base, NULL);
+        return __lookup_hash(&this, base, 0);
 }
 int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
@@ -2086,10 +2148,9 @@ void unlock_rename(struct dentry *p1, struct dentry *p2)
 }
 int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool want_excl)
 {
        int error = may_create(dir, dentry);
        if (error)
                return error;
@@ -2100,7 +2161,7 @@ int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
        error = security_inode_create(dir, dentry, mode);
        if (error)
                return error;
-        error = dir->i_op->create(dir, dentry, mode, nd);
+        error = dir->i_op->create(dir, dentry, mode, want_excl);
        if (!error)
                fsnotify_create(dir, dentry);
        return error;
@@ -2187,21 +2248,275 @@ static inline int open_to_namei_flags(int flag)
        return flag;
 }
+static int may_o_create(struct path *dir, struct dentry *dentry, umode_t mode)
+{
+        int error = security_path_mknod(dir, dentry, mode, 0);
+        if (error)
+                return error;
+        error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
+        if (error)
+                return error;
+        return security_inode_create(dir->dentry->d_inode, dentry, mode);
+}
 /*
- * Handle the last step of open()
+ * Attempt to atomically look up, create and open a file from a negative
+ * dentry.
+ *
+ * Returns 0 if successful.  The file will have been created and attached to
+ * @file by the filesystem calling finish_open().
+ *
+ * Returns 1 if the file was looked up only or didn't need creating.  The
+ * caller will need to perform the open themselves.  @path will have been
+ * updated to point to the new dentry.  This may be negative.
+ *
+ * Returns an error code otherwise.
+ */
+static int atomic_open(struct nameidata *nd, struct dentry *dentry,
+                        struct path *path, struct file *file,
+                        const struct open_flags *op,
+                        bool *want_write, bool need_lookup,
+                        int *opened)
+{
+        struct inode *dir =  nd->path.dentry->d_inode;
+        unsigned open_flag = open_to_namei_flags(op->open_flag);
+        umode_t mode;
+        int error;
+        int acc_mode;
+        int create_error = 0;
+        struct dentry *const DENTRY_NOT_SET = (void *) -1UL;
+        BUG_ON(dentry->d_inode);
+        /* Don't create child dentry for a dead directory. */
+        if (unlikely(IS_DEADDIR(dir))) {
+                error = -ENOENT;
+                goto out;
+        }
+        mode = op->mode & S_IALLUGO;
+        if ((open_flag & O_CREAT) && !IS_POSIXACL(dir))
+                mode &= ~current_umask();
+        if (open_flag & O_EXCL) {
+                open_flag &= ~O_TRUNC;
+                *opened |= FILE_CREATED;
+        }
+        /*
+         * Checking write permission is tricky, bacuse we don't know if we are
+         * going to actually need it: O_CREAT opens should work as long as the
+         * file exists.  But checking existence breaks atomicity.  The trick is
+         * to check access and if not granted clear O_CREAT from the flags.
+         *
+         * Another problem is returing the "right" error value (e.g. for an
+         * O_EXCL open we want to return EEXIST not EROFS).
+         */
+        if ((open_flag & (O_CREAT | O_TRUNC)) ||
+            (open_flag & O_ACCMODE) != O_RDONLY) {
+                error = mnt_want_write(nd->path.mnt);
+                if (!error) {
+                        *want_write = true;
+                } else if (!(open_flag & O_CREAT)) {
+                        /*
+                         * No O_CREATE -> atomicity not a requirement -> fall
+                         * back to lookup + open
+                         */
+                        goto no_open;
+                } else if (open_flag & (O_EXCL | O_TRUNC)) {
+                        /* Fall back and fail with the right error */
+                        create_error = error;
+                        goto no_open;
+                } else {
+                        /* No side effects, safe to clear O_CREAT */
+                        create_error = error;
+                        open_flag &= ~O_CREAT;
+                }
+        }
+        if (open_flag & O_CREAT) {
+                error = may_o_create(&nd->path, dentry, op->mode);
+                if (error) {
+                        create_error = error;
+                        if (open_flag & O_EXCL)
+                                goto no_open;
+                        open_flag &= ~O_CREAT;
+                }
+        }
+        if (nd->flags & LOOKUP_DIRECTORY)
+                open_flag |= O_DIRECTORY;
+        file->f_path.dentry = DENTRY_NOT_SET;
+        file->f_path.mnt = nd->path.mnt;
+        error = dir->i_op->atomic_open(dir, dentry, file, open_flag, mode,
+                                      opened);
+        if (error < 0) {
+                if (create_error && error == -ENOENT)
+                        error = create_error;
+                goto out;
+        }
+        acc_mode = op->acc_mode;
+        if (*opened & FILE_CREATED) {
+                fsnotify_create(dir, dentry);
+                acc_mode = MAY_OPEN;
+        }
+        if (error) {    /* returned 1, that is */
+                if (WARN_ON(file->f_path.dentry == DENTRY_NOT_SET)) {
+                        error = -EIO;
+                        goto out;
+                }
+                if (file->f_path.dentry) {
+                        dput(dentry);
+                        dentry = file->f_path.dentry;
+                }
+                goto looked_up;
+        }
+        /*
+         * We didn't have the inode before the open, so check open permission
+         * here.
+         */
+        error = may_open(&file->f_path, acc_mode, open_flag);
+        if (error)
+                fput(file);
+out:
+        dput(dentry);
+        return error;
+no_open:
+        if (need_lookup) {
+                dentry = lookup_real(dir, dentry, nd->flags);
+                if (IS_ERR(dentry))
+                        return PTR_ERR(dentry);
+                if (create_error) {
+                        int open_flag = op->open_flag;
+                        error = create_error;
+                        if ((open_flag & O_EXCL)) {
+                                if (!dentry->d_inode)
+                                        goto out;
+                        } else if (!dentry->d_inode) {
+                                goto out;
+                        } else if ((open_flag & O_TRUNC) &&
+                                   S_ISREG(dentry->d_inode->i_mode)) {
+                                goto out;
+                        }
+                        /* will fail later, go on to get the right error */
+                }
+        }
+looked_up:
+        path->dentry = dentry;
+        path->mnt = nd->path.mnt;
+        return 1;
+}
+/*
+ * Look up and maybe create and open the last component.
+ *
+ * Must be called with i_mutex held on parent.
+ *
+ * Returns 0 if the file was successfully atomically created (if necessary) and
+ * opened.  In this case the file will be returned attached to @file.
+ *
+ * Returns 1 if the file was not completely opened at this time, though lookups
+ * and creations will have been performed and the dentry returned in @path will
+ * be positive upon return if O_CREAT was specified.  If O_CREAT wasn't
+ * specified then a negative dentry may be returned.
+ *
+ * An error code is returned otherwise.
+ *
+ * FILE_CREATE will be set in @*opened if the dentry was created and will be
+ * cleared otherwise prior to returning.
 */
-static struct file *do_last(struct nameidata *nd, struct path *path,
+static int lookup_open(struct nameidata *nd, struct path *path,
-                            const struct open_flags *op, const char *pathname)
+                        struct file *file,
+                        const struct open_flags *op,
+                        bool *want_write, int *opened)
 {
        struct dentry *dir = nd->path.dentry;
+        struct inode *dir_inode = dir->d_inode;
        struct dentry *dentry;
+        int error;
+        bool need_lookup;
+        *opened &= ~FILE_CREATED;
+        dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
+        /* Cached positive dentry: will open in f_op->open */
+        if (!need_lookup && dentry->d_inode)
+                goto out_no_open;
+        if ((nd->flags & LOOKUP_OPEN) && dir_inode->i_op->atomic_open) {
+                return atomic_open(nd, dentry, path, file, op, want_write,
+                                   need_lookup, opened);
+        }
+        if (need_lookup) {
+                BUG_ON(dentry->d_inode);
+                dentry = lookup_real(dir_inode, dentry, nd->flags);
+                if (IS_ERR(dentry))
+                        return PTR_ERR(dentry);
+        }
+        /* Negative dentry, just create the file */
+        if (!dentry->d_inode && (op->open_flag & O_CREAT)) {
+                umode_t mode = op->mode;
+                if (!IS_POSIXACL(dir->d_inode))
+                        mode &= ~current_umask();
+                /*
+                 * This write is needed to ensure that a
+                 * rw->ro transition does not occur between
+                 * the time when the file is created and when
+                 * a permanent write count is taken through
+                 * the 'struct file' in finish_open().
+                 */
+                error = mnt_want_write(nd->path.mnt);
+                if (error)
+                        goto out_dput;
+                *want_write = true;
+                *opened |= FILE_CREATED;
+                error = security_path_mknod(&nd->path, dentry, mode, 0);
+                if (error)
+                        goto out_dput;
+                error = vfs_create(dir->d_inode, dentry, mode,
+                                   nd->flags & LOOKUP_EXCL);
+                if (error)
+                        goto out_dput;
+        }
+out_no_open:
+        path->dentry = dentry;
+        path->mnt = nd->path.mnt;
+        return 1;
+out_dput:
+        dput(dentry);
+        return error;
+}
+/*
+ * Handle the last step of open()
+ */
+static int do_last(struct nameidata *nd, struct path *path,
+                   struct file *file, const struct open_flags *op,
+                   int *opened, const char *pathname)
+{
+        struct dentry *dir = nd->path.dentry;
        int open_flag = op->open_flag;
-        int will_truncate = open_flag & O_TRUNC;
+        bool will_truncate = (open_flag & O_TRUNC) != 0;
-        int want_write = 0;
+        bool want_write = false;
        int acc_mode = op->acc_mode;
-        struct file *filp;
        struct inode *inode;
-        int symlink_ok = 0;
+        bool symlink_ok = false;
        struct path save_parent = { .dentry = NULL, .mnt = NULL };
        bool retried = false;
        int error;
@@ -2214,112 +2529,99 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
        case LAST_DOT:
                error = handle_dots(nd, nd->last_type);
                if (error)
-                        return ERR_PTR(error);
+                        return error;
                /* fallthrough */
        case LAST_ROOT:
                error = complete_walk(nd);
                if (error)
-                        return ERR_PTR(error);
+                        return error;
                audit_inode(pathname, nd->path.dentry);
                if (open_flag & O_CREAT) {
                        error = -EISDIR;
-                        goto exit;
+                        goto out;
                }
-                goto ok;
+                goto finish_open;
        case LAST_BIND:
                error = complete_walk(nd);
                if (error)
-                        return ERR_PTR(error);
+                        return error;
                audit_inode(pathname, dir);
-                goto ok;
+                goto finish_open;
        }
        if (!(open_flag & O_CREAT)) {
                if (nd->last.name[nd->last.len])
                        nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
                if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
-                        symlink_ok = 1;
+                        symlink_ok = true;
                /* we _can_ be in RCU mode here */
                error = lookup_fast(nd, &nd->last, path, &inode);
-                if (unlikely(error)) {
+                if (likely(!error))
-                        if (error < 0)
+                        goto finish_lookup;
-                                goto exit;
-                        error = lookup_slow(nd, &nd->last, path);
+                if (error < 0)
-                        if (error < 0)
+                        goto out;
-                                goto exit;
-                        inode = path->dentry->d_inode;
+                BUG_ON(nd->inode != dir->d_inode);
-                }
+        } else {
-                goto finish_lookup;
+                /* create side of things */
-        }
+                /*
+                 * This will *only* deal with leaving RCU mode - LOOKUP_JUMPED
-        /* create side of things */
+                 * has been cleared when we got to the last component we are
-        /*
+                 * about to look up
-         * This will *only* deal with leaving RCU mode - LOOKUP_JUMPED has been
+                 */
-         * cleared when we got to the last component we are about to look up
+                error = complete_walk(nd);
-         */
+                if (error)
-        error = complete_walk(nd);
+                        return error;
-        if (error)
-                return ERR_PTR(error);
-        audit_inode(pathname, dir);
+                audit_inode(pathname, dir);
-        error = -EISDIR;
+                error = -EISDIR;
-        /* trailing slashes? */
+                /* trailing slashes? */
-        if (nd->last.name[nd->last.len])
+                if (nd->last.name[nd->last.len])
-                goto exit;
+                        goto out;
+        }
 retry_lookup:
        mutex_lock(&dir->d_inode->i_mutex);
+        error = lookup_open(nd, path, file, op, &want_write, opened);
+        mutex_unlock(&dir->d_inode->i_mutex);
-        dentry = lookup_hash(nd);
+        if (error <= 0) {
-        error = PTR_ERR(dentry);
+                if (error)
-        if (IS_ERR(dentry)) {
+                        goto out;
-                mutex_unlock(&dir->d_inode->i_mutex);
-                goto exit;
-        }
-        path->dentry = dentry;
+                if ((*opened & FILE_CREATED) ||
-        path->mnt = nd->path.mnt;
+                    !S_ISREG(file->f_path.dentry->d_inode->i_mode))
+                        will_truncate = false;
-        /* Negative dentry, just create the file */
+                audit_inode(pathname, file->f_path.dentry);
-        if (!dentry->d_inode) {
+                goto opened;
-                umode_t mode = op->mode;
+        }
-                if (!IS_POSIXACL(dir->d_inode))
-                        mode &= ~current_umask();
+        if (*opened & FILE_CREATED) {
-                /*
-                 * This write is needed to ensure that a
-                 * rw->ro transition does not occur between
-                 * the time when the file is created and when
-                 * a permanent write count is taken through
-                 * the 'struct file' in nameidata_to_filp().
-                 */
-                error = mnt_want_write(nd->path.mnt);
-                if (error)
-                        goto exit_mutex_unlock;
-                want_write = 1;
                /* Don't check for write permission, don't truncate */
                open_flag &= ~O_TRUNC;
-                will_truncate = 0;
+                will_truncate = false;
                acc_mode = MAY_OPEN;
-                error = security_path_mknod(&nd->path, dentry, mode, 0);
+                path_to_nameidata(path, nd);
-                if (error)
+                goto finish_open_created;
-                        goto exit_mutex_unlock;
-                error = vfs_create(dir->d_inode, dentry, mode, nd);
-                if (error)
-                        goto exit_mutex_unlock;
-                mutex_unlock(&dir->d_inode->i_mutex);
-                dput(nd->path.dentry);
-                nd->path.dentry = dentry;
-                goto common;
        }
        /*
         * It already exists.
         */
-        mutex_unlock(&dir->d_inode->i_mutex);
        audit_inode(pathname, path->dentry);
+        /*
+         * If atomic_open() acquired write access it is dropped now due to
+         * possible mount and symlink following (this might be optimized away if
+         * necessary...)
+         */
+        if (want_write) {
+                mnt_drop_write(nd->path.mnt);
+                want_write = false;
+        }
        error = -EEXIST;
        if (open_flag & O_EXCL)
                goto exit_dput;
@@ -2338,18 +2640,18 @@ finish_lookup:
        error = -ENOENT;
        if (!inode) {
                path_to_nameidata(path, nd);
-                goto exit;
+                goto out;
        }
        if (should_follow_link(inode, !symlink_ok)) {
                if (nd->flags & LOOKUP_RCU) {
                        if (unlikely(unlazy_walk(nd, path->dentry))) {
                                error = -ECHILD;
-                                goto exit;
+                                goto out;
                        }
                }
                BUG_ON(inode != path->dentry->d_inode);
-                return NULL;
+                return 1;
        }
        if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
@@ -2365,119 +2667,122 @@ finish_lookup:
        error = complete_walk(nd);
        if (error) {
                path_put(&save_parent);
-                return ERR_PTR(error);
+                return error;
        }
        error = -EISDIR;
        if ((open_flag & O_CREAT) && S_ISDIR(nd->inode->i_mode))
-                goto exit;
+                goto out;
        error = -ENOTDIR;
        if ((nd->flags & LOOKUP_DIRECTORY) && !nd->inode->i_op->lookup)
-                goto exit;
+                goto out;
        audit_inode(pathname, nd->path.dentry);
-ok:
+finish_open:
        if (!S_ISREG(nd->inode->i_mode))
-                will_truncate = 0;
+                will_truncate = false;
        if (will_truncate) {
                error = mnt_want_write(nd->path.mnt);
                if (error)
-                        goto exit;
+                        goto out;
-                want_write = 1;
+                want_write = true;
        }
-common:
+finish_open_created:
        error = may_open(&nd->path, acc_mode, open_flag);
        if (error)
-                goto exit;
+                goto out;
-        filp = nameidata_to_filp(nd);
+        file->f_path.mnt = nd->path.mnt;
-        if (filp == ERR_PTR(-EOPENSTALE) && save_parent.dentry && !retried) {
+        error = finish_open(file, nd->path.dentry, NULL, opened);
-                BUG_ON(save_parent.dentry != dir);
+        if (error) {
-                path_put(&nd->path);
+                if (error == -EOPENSTALE)
-                nd->path = save_parent;
+                        goto stale_open;
-                nd->inode = dir->d_inode;
+                goto out;
-                save_parent.mnt = NULL;
-                save_parent.dentry = NULL;
-                if (want_write) {
-                        mnt_drop_write(nd->path.mnt);
-                        want_write = 0;
-                }
-                retried = true;
-                goto retry_lookup;
-        }
-        if (!IS_ERR(filp)) {
-                error = ima_file_check(filp, op->acc_mode);
-                if (error) {
-                        fput(filp);
-                        filp = ERR_PTR(error);
-                }
        }
-        if (!IS_ERR(filp)) {
+opened:
-                if (will_truncate) {
+        error = open_check_o_direct(file);
-                        error = handle_truncate(filp);
+        if (error)
-                        if (error) {
+                goto exit_fput;
-                                fput(filp);
+        error = ima_file_check(file, op->acc_mode);
-                                filp = ERR_PTR(error);
+        if (error)
-                        }
+                goto exit_fput;
-                }
+        if (will_truncate) {
+                error = handle_truncate(file);
+                if (error)
+                        goto exit_fput;
        }
 out:
        if (want_write)
                mnt_drop_write(nd->path.mnt);
        path_put(&save_parent);
        terminate_walk(nd);
-        return filp;
+        return error;
-exit_mutex_unlock:
-        mutex_unlock(&dir->d_inode->i_mutex);
 exit_dput:
        path_put_conditional(path, nd);
-exit:
-        filp = ERR_PTR(error);
        goto out;
+exit_fput:
+        fput(file);
+        goto out;
+stale_open:
+        /* If no saved parent or already retried then can't retry */
+        if (!save_parent.dentry || retried)
+                goto out;
+        BUG_ON(save_parent.dentry != dir);
+        path_put(&nd->path);
+        nd->path = save_parent;
+        nd->inode = dir->d_inode;
+        save_parent.mnt = NULL;
+        save_parent.dentry = NULL;
+        if (want_write) {
+                mnt_drop_write(nd->path.mnt);
+                want_write = false;
+        }
+        retried = true;
+        goto retry_lookup;
 }
 static struct file *path_openat(int dfd, const char *pathname,
                struct nameidata *nd, const struct open_flags *op, int flags)
 {
        struct file *base = NULL;
-        struct file *filp;
+        struct file *file;
        struct path path;
+        int opened = 0;
        int error;
-        filp = get_empty_filp();
+        file = get_empty_filp();
-        if (!filp)
+        if (!file)
                return ERR_PTR(-ENFILE);
-        filp->f_flags = op->open_flag;
+        file->f_flags = op->open_flag;
-        nd->intent.open.file = filp;
-        nd->intent.open.flags = open_to_namei_flags(op->open_flag);
-        nd->intent.open.create_mode = op->mode;
        error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base);
        if (unlikely(error))
-                goto out_filp;
+                goto out;
        current->total_link_count = 0;
        error = link_path_walk(pathname, nd);
        if (unlikely(error))
-                goto out_filp;
+                goto out;
-        filp = do_last(nd, &path, op, pathname);
+        error = do_last(nd, &path, file, op, &opened, pathname);
-        while (unlikely(!filp)) { /* trailing symlink */
+        while (unlikely(error > 0)) { /* trailing symlink */
                struct path link = path;
                void *cookie;
                if (!(nd->flags & LOOKUP_FOLLOW)) {
                        path_put_conditional(&path, nd);
                        path_put(&nd->path);
-                        filp = ERR_PTR(-ELOOP);
+                        error = -ELOOP;
                        break;
                }
                nd->flags |= LOOKUP_PARENT;
                nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
                error = follow_link(&link, nd, &cookie);
                if (unlikely(error))
-                        filp = ERR_PTR(error);
+                        break;
-                else
+                error = do_last(nd, &path, file, op, &opened, pathname);
-                        filp = do_last(nd, &path, op, pathname);
                put_link(nd, &link, cookie);
        }
 out:
@@ -2485,18 +2790,20 @@ out:
                path_put(&nd->root);
        if (base)
                fput(base);
-        release_open_intent(nd);
+        if (!(opened & FILE_OPENED)) {
-        if (filp == ERR_PTR(-EOPENSTALE)) {
+                BUG_ON(!error);
-                if (flags & LOOKUP_RCU)
+                put_filp(file);
-                        filp = ERR_PTR(-ECHILD);
-                else
-                        filp = ERR_PTR(-ESTALE);
        }
-        return filp;
+        if (unlikely(error)) {
+                if (error == -EOPENSTALE) {
-out_filp:
+                        if (flags & LOOKUP_RCU)
-        filp = ERR_PTR(error);
+                                error = -ECHILD;
-        goto out;
+                        else
+                                error = -ESTALE;
+                }
+                file = ERR_PTR(error);
+        }
+        return file;
 }
 struct file *do_filp_open(int dfd, const char *pathname,
@@ -2551,7 +2858,6 @@ struct dentry *kern_path_create(int dfd, const char *pathname, struct path *path
                goto out;
        nd.flags &= ~LOOKUP_PARENT;
        nd.flags |= LOOKUP_CREATE | LOOKUP_EXCL;
-        nd.intent.open.flags = O_EXCL;
        /*
         * Do the final lookup.
@@ -2670,7 +2976,7 @@ SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
                goto out_drop_write;
        switch (mode & S_IFMT) {
                case 0: case S_IFREG:
-                        error = vfs_create(path.dentry->d_inode,dentry,mode,NULL);
+                        error = vfs_create(path.dentry->d_inode,dentry,mode,true);
                        break;
                case S_IFCHR: case S_IFBLK:
                        error = vfs_mknod(path.dentry->d_inode,dentry,mode,
diff --git a/fs/namespace.c b/fs/namespace.c
index 1e4a5fe3d7b7..c53d3381b0d0 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -515,8 +515,20 @@ struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry,
 }
 /*
- * lookup_mnt increments the ref count before returning
+ * lookup_mnt - Return the first child mount mounted at path
- * the vfsmount struct.
+ *
+ * "First" means first mounted chronologically.  If you create the
+ * following mounts:
+ *
+ * mount /dev/sda1 /mnt
+ * mount /dev/sda2 /mnt
+ * mount /dev/sda3 /mnt
+ *
+ * Then lookup_mnt() on the base /mnt dentry in the root mount will
+ * return successively the root dentry and vfsmount of /dev/sda1, then
+ * /dev/sda2, then /dev/sda3, then NULL.
+ *
+ * lookup_mnt takes a reference to the found vfsmount.
 */
 struct vfsmount *lookup_mnt(struct path *path)
 {
@@ -621,21 +633,6 @@ static void attach_mnt(struct mount *mnt, struct path *path)
        list_add_tail(&mnt->mnt_child, &real_mount(path->mnt)->mnt_mounts);
 }
-static inline void __mnt_make_longterm(struct mount *mnt)
-{
-#ifdef CONFIG_SMP
-        atomic_inc(&mnt->mnt_longterm);
-#endif
-}
-/* needs vfsmount lock for write */
-static inline void __mnt_make_shortterm(struct mount *mnt)
-{
-#ifdef CONFIG_SMP
-        atomic_dec(&mnt->mnt_longterm);
-#endif
-}
 /*
 * vfsmount lock must be held for write
 */
@@ -649,10 +646,8 @@ static void commit_tree(struct mount *mnt)
        BUG_ON(parent == mnt);
        list_add_tail(&head, &mnt->mnt_list);
-        list_for_each_entry(m, &head, mnt_list) {
+        list_for_each_entry(m, &head, mnt_list)
                m->mnt_ns = n;
-                __mnt_make_longterm(m);
-        }
        list_splice(&head, n->list.prev);
@@ -725,56 +720,60 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root,
                                        int flag)
 {
        struct super_block *sb = old->mnt.mnt_sb;
-        struct mount *mnt = alloc_vfsmnt(old->mnt_devname);
+        struct mount *mnt;
+        int err;
-        if (mnt) {
+        mnt = alloc_vfsmnt(old->mnt_devname);
-                if (flag & (CL_SLAVE | CL_PRIVATE))
+        if (!mnt)
-                        mnt->mnt_group_id = 0; /* not a peer of original */
+                return ERR_PTR(-ENOMEM);
-                else
-                        mnt->mnt_group_id = old->mnt_group_id;
-                if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
-                        int err = mnt_alloc_group_id(mnt);
-                        if (err)
-                                goto out_free;
-                }
-                mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~MNT_WRITE_HOLD;
+        if (flag & (CL_SLAVE | CL_PRIVATE))
-                atomic_inc(&sb->s_active);
+                mnt->mnt_group_id = 0; /* not a peer of original */
-                mnt->mnt.mnt_sb = sb;
+        else
-                mnt->mnt.mnt_root = dget(root);
+                mnt->mnt_group_id = old->mnt_group_id;
-                mnt->mnt_mountpoint = mnt->mnt.mnt_root;
-                mnt->mnt_parent = mnt;
-                br_write_lock(&vfsmount_lock);
-                list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
-                br_write_unlock(&vfsmount_lock);
-                if (flag & CL_SLAVE) {
+        if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) {
-                        list_add(&mnt->mnt_slave, &old->mnt_slave_list);
+                err = mnt_alloc_group_id(mnt);
-                        mnt->mnt_master = old;
+                if (err)
-                        CLEAR_MNT_SHARED(mnt);
+                        goto out_free;
-                } else if (!(flag & CL_PRIVATE)) {
-                        if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
-                                list_add(&mnt->mnt_share, &old->mnt_share);
-                        if (IS_MNT_SLAVE(old))
-                                list_add(&mnt->mnt_slave, &old->mnt_slave);
-                        mnt->mnt_master = old->mnt_master;
-                }
-                if (flag & CL_MAKE_SHARED)
-                        set_mnt_shared(mnt);
-                /* stick the duplicate mount on the same expiry list
-                 * as the original if that was on one */
-                if (flag & CL_EXPIRE) {
-                        if (!list_empty(&old->mnt_expire))
-                                list_add(&mnt->mnt_expire, &old->mnt_expire);
-                }
        }
+        mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~MNT_WRITE_HOLD;
+        atomic_inc(&sb->s_active);
+        mnt->mnt.mnt_sb = sb;
+        mnt->mnt.mnt_root = dget(root);
+        mnt->mnt_mountpoint = mnt->mnt.mnt_root;
+        mnt->mnt_parent = mnt;
+        br_write_lock(&vfsmount_lock);
+        list_add_tail(&mnt->mnt_instance, &sb->s_mounts);
+        br_write_unlock(&vfsmount_lock);
+        if (flag & CL_SLAVE) {
+                list_add(&mnt->mnt_slave, &old->mnt_slave_list);
+                mnt->mnt_master = old;
+                CLEAR_MNT_SHARED(mnt);
+        } else if (!(flag & CL_PRIVATE)) {
+                if ((flag & CL_MAKE_SHARED) || IS_MNT_SHARED(old))
+                        list_add(&mnt->mnt_share, &old->mnt_share);
+                if (IS_MNT_SLAVE(old))
+                        list_add(&mnt->mnt_slave, &old->mnt_slave);
+                mnt->mnt_master = old->mnt_master;
+        }
+        if (flag & CL_MAKE_SHARED)
+                set_mnt_shared(mnt);
+        /* stick the duplicate mount on the same expiry list
+         * as the original if that was on one */
+        if (flag & CL_EXPIRE) {
+                if (!list_empty(&old->mnt_expire))
+                        list_add(&mnt->mnt_expire, &old->mnt_expire);
+        }
        return mnt;
 out_free:
        free_vfsmnt(mnt);
-        return NULL;
+        return ERR_PTR(err);
 }
 static inline void mntfree(struct mount *mnt)
@@ -804,7 +803,8 @@ static void mntput_no_expire(struct mount *mnt)
 put_again:
 #ifdef CONFIG_SMP
        br_read_lock(&vfsmount_lock);
-        if (likely(atomic_read(&mnt->mnt_longterm))) {
+        if (likely(mnt->mnt_ns)) {
+                /* shouldn't be the last one */
                mnt_add_count(mnt, -1);
                br_read_unlock(&vfsmount_lock);
                return;
@@ -939,7 +939,7 @@ EXPORT_SYMBOL(replace_mount_options);
 /* iterator; we want it to have access to namespace_sem, thus here... */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
-        struct proc_mounts *p = container_of(m, struct proc_mounts, m);
+        struct proc_mounts *p = proc_mounts(m);
        down_read(&namespace_sem);
        return seq_list_start(&p->ns->list, *pos);
@@ -947,7 +947,7 @@ static void *m_start(struct seq_file *m, loff_t *pos)
 static void *m_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct proc_mounts *p = container_of(m, struct proc_mounts, m);
+        struct proc_mounts *p = proc_mounts(m);
        return seq_list_next(v, &p->ns->list, pos);
 }
@@ -959,7 +959,7 @@ static void m_stop(struct seq_file *m, void *v)
 static int m_show(struct seq_file *m, void *v)
 {
-        struct proc_mounts *p = container_of(m, struct proc_mounts, m);
+        struct proc_mounts *p = proc_mounts(m);
        struct mount *r = list_entry(v, struct mount, mnt_list);
        return p->show(m, &r->mnt);
 }
@@ -1074,8 +1074,6 @@ void umount_tree(struct mount *mnt, int propagate, struct list_head *kill)
                list_del_init(&p->mnt_expire);
                list_del_init(&p->mnt_list);
                __touch_mnt_namespace(p->mnt_ns);
-                if (p->mnt_ns)
-                        __mnt_make_shortterm(p);
                p->mnt_ns = NULL;
                list_del_init(&p->mnt_child);
                if (mnt_has_parent(p)) {
@@ -1260,11 +1258,12 @@ struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
        struct path path;
        if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
-                return NULL;
+                return ERR_PTR(-EINVAL);
        res = q = clone_mnt(mnt, dentry, flag);
-        if (!q)
+        if (IS_ERR(q))
-                goto Enomem;
+                return q;
        q->mnt_mountpoint = mnt->mnt_mountpoint;
        p = mnt;
@@ -1286,8 +1285,8 @@ struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
                        path.mnt = &q->mnt;
                        path.dentry = p->mnt_mountpoint;
                        q = clone_mnt(p, p->mnt.mnt_root, flag);
-                        if (!q)
+                        if (IS_ERR(q))
-                                goto Enomem;
+                                goto out;
                        br_write_lock(&vfsmount_lock);
                        list_add_tail(&q->mnt_list, &res->mnt_list);
                        attach_mnt(q, &path);
@@ -1295,7 +1294,7 @@ struct mount *copy_tree(struct mount *mnt, struct dentry *dentry,
                }
        }
        return res;
-Enomem:
+out:
        if (res) {
                LIST_HEAD(umount_list);
                br_write_lock(&vfsmount_lock);
@@ -1303,9 +1302,11 @@ Enomem:
                br_write_unlock(&vfsmount_lock);
                release_mounts(&umount_list);
        }
-        return NULL;
+        return q;
 }
+/* Caller should check returned pointer for errors */
 struct vfsmount *collect_mounts(struct path *path)
 {
        struct mount *tree;
@@ -1313,7 +1314,9 @@ struct vfsmount *collect_mounts(struct path *path)
        tree = copy_tree(real_mount(path->mnt), path->dentry,
                         CL_COPY_ALL | CL_PRIVATE);
        up_write(&namespace_sem);
-        return tree ? &tree->mnt : NULL;
+        if (IS_ERR(tree))
+                return NULL;
+        return &tree->mnt;
 }
 void drop_collected_mounts(struct vfsmount *mnt)
@@ -1608,14 +1611,15 @@ static int do_loopback(struct path *path, char *old_name,
        if (!check_mnt(real_mount(path->mnt)) || !check_mnt(old))
                goto out2;
-        err = -ENOMEM;
        if (recurse)
                mnt = copy_tree(old, old_path.dentry, 0);
        else
                mnt = clone_mnt(old, old_path.dentry, 0);
-        if (!mnt)
+        if (IS_ERR(mnt)) {
-                goto out2;
+                err = PTR_ERR(mnt);
+                goto out;
+        }
        err = graft_tree(mnt, path);
        if (err) {
@@ -2209,23 +2213,6 @@ static struct mnt_namespace *alloc_mnt_ns(void)
        return new_ns;
 }
-void mnt_make_longterm(struct vfsmount *mnt)
-{
-        __mnt_make_longterm(real_mount(mnt));
-}
-void mnt_make_shortterm(struct vfsmount *m)
-{
-#ifdef CONFIG_SMP
-        struct mount *mnt = real_mount(m);
-        if (atomic_add_unless(&mnt->mnt_longterm, -1, 1))
-                return;
-        br_write_lock(&vfsmount_lock);
-        atomic_dec(&mnt->mnt_longterm);
-        br_write_unlock(&vfsmount_lock);
-#endif
-}
 /*
 * Allocate a new namespace structure and populate it with contents
 * copied from the namespace of the passed in task structure.
@@ -2246,10 +2233,10 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
        down_write(&namespace_sem);
        /* First pass: copy the tree topology */
        new = copy_tree(old, old->mnt.mnt_root, CL_COPY_ALL | CL_EXPIRE);
-        if (!new) {
+        if (IS_ERR(new)) {
                up_write(&namespace_sem);
                kfree(new_ns);
-                return ERR_PTR(-ENOMEM);
+                return ERR_CAST(new);
        }
        new_ns->root = new;
        br_write_lock(&vfsmount_lock);
@@ -2265,18 +2252,13 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
        q = new;
        while (p) {
                q->mnt_ns = new_ns;
-                __mnt_make_longterm(q);
                if (fs) {
                        if (&p->mnt == fs->root.mnt) {
                                fs->root.mnt = mntget(&q->mnt);
-                                __mnt_make_longterm(q);
-                                mnt_make_shortterm(&p->mnt);
                                rootmnt = &p->mnt;
                        }
                        if (&p->mnt == fs->pwd.mnt) {
                                fs->pwd.mnt = mntget(&q->mnt);
-                                __mnt_make_longterm(q);
-                                mnt_make_shortterm(&p->mnt);
                                pwdmnt = &p->mnt;
                        }
                }
@@ -2320,7 +2302,6 @@ static struct mnt_namespace *create_mnt_ns(struct vfsmount *m)
        if (!IS_ERR(new_ns)) {
                struct mount *mnt = real_mount(m);
                mnt->mnt_ns = new_ns;
-                __mnt_make_longterm(mnt);
                new_ns->root = mnt;
                list_add(&new_ns->list, &mnt->mnt_list);
        } else {
@@ -2615,7 +2596,7 @@ struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
                 * it is a longterm mount, don't release mnt until
                 * we unmount before file sys is unregistered
                */
-                mnt_make_longterm(mnt);
+                real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
        }
        return mnt;
 }
@@ -2625,7 +2606,9 @@ void kern_unmount(struct vfsmount *mnt)
 {
        /* release long term mount so mount point can be released */
        if (!IS_ERR_OR_NULL(mnt)) {
-                mnt_make_shortterm(mnt);
+                br_write_lock(&vfsmount_lock);
+                real_mount(mnt)->mnt_ns = NULL;
+                br_write_unlock(&vfsmount_lock);
                mntput(mnt);
        }
 }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index aeed93a6bde0..4117e7b377bb 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -30,8 +30,8 @@ static void ncp_do_readdir(struct file *, void *, filldir_t,
 static int ncp_readdir(struct file *, void *, filldir_t);
-static int ncp_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
+static int ncp_create(struct inode *, struct dentry *, umode_t, bool);
-static struct dentry *ncp_lookup(struct inode *, struct dentry *, struct nameidata *);
+static struct dentry *ncp_lookup(struct inode *, struct dentry *, unsigned int);
 static int ncp_unlink(struct inode *, struct dentry *);
 static int ncp_mkdir(struct inode *, struct dentry *, umode_t);
 static int ncp_rmdir(struct inode *, struct dentry *);
@@ -72,7 +72,7 @@ const struct inode_operations ncp_dir_inode_operations =
 /*
 * Dentry operations routines
 */
-static int ncp_lookup_validate(struct dentry *, struct nameidata *);
+static int ncp_lookup_validate(struct dentry *, unsigned int);
 static int ncp_hash_dentry(const struct dentry *, const struct inode *,
                struct qstr *);
 static int ncp_compare_dentry(const struct dentry *, const struct inode *,
@@ -290,7 +290,7 @@ leave_me:;
 static int
-ncp_lookup_validate(struct dentry *dentry, struct nameidata *nd)
+ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
 {
        struct ncp_server *server;
        struct dentry *parent;
@@ -302,7 +302,7 @@ ncp_lookup_validate(struct dentry *dentry, struct nameidata *nd)
        if (dentry == dentry->d_sb->s_root)
                return 1;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        parent = dget_parent(dentry);
@@ -836,7 +836,7 @@ out:
        return result;
 }
-static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct ncp_server *server = NCP_SERVER(dir);
        struct inode *inode = NULL;
@@ -980,7 +980,7 @@ out:
 }
 static int ncp_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        return ncp_create_new(dir, dentry, mode, 0, 0);
 }
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 970659daa323..23ff18fe080a 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -17,7 +17,6 @@
 #include <linux/kthread.h>
 #include <linux/sunrpc/svcauth_gss.h>
 #include <linux/sunrpc/bc_xprt.h>
-#include <linux/nsproxy.h>
 #include <net/inet_sock.h>
@@ -107,7 +106,7 @@ nfs4_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
 {
        int ret;
-        ret = svc_create_xprt(serv, "tcp", xprt->xprt_net, PF_INET,
+        ret = svc_create_xprt(serv, "tcp", &init_net, PF_INET,
                                nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
        if (ret <= 0)
                goto out_err;
@@ -115,7 +114,7 @@ nfs4_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
        dprintk("NFS: Callback listener port = %u (af %u)\n",
                        nfs_callback_tcpport, PF_INET);
-        ret = svc_create_xprt(serv, "tcp", xprt->xprt_net, PF_INET6,
+        ret = svc_create_xprt(serv, "tcp", &init_net, PF_INET6,
                                nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
        if (ret > 0) {
                nfs_callback_tcpport6 = ret;
@@ -184,7 +183,7 @@ nfs41_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
         * fore channel connection.
         * Returns the input port (0) and sets the svc_serv bc_xprt on success
         */
-        ret = svc_create_xprt(serv, "tcp-bc", xprt->xprt_net, PF_INET, 0,
+        ret = svc_create_xprt(serv, "tcp-bc", &init_net, PF_INET, 0,
                              SVC_SOCK_ANONYMOUS);
        if (ret < 0) {
                rqstp = ERR_PTR(ret);
@@ -254,7 +253,7 @@ int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
        char svc_name[12];
        int ret = 0;
        int minorversion_setup;
-        struct net *net = current->nsproxy->net_ns;
+        struct net *net = &init_net;
        mutex_lock(&nfs_callback_mutex);
        if (cb_info->users++ || cb_info->task != NULL) {
@@ -330,7 +329,7 @@ void nfs_callback_down(int minorversion)
        cb_info->users--;
        if (cb_info->users == 0 && cb_info->task != NULL) {
                kthread_stop(cb_info->task);
-                svc_shutdown_net(cb_info->serv, current->nsproxy->net_ns);
+                svc_shutdown_net(cb_info->serv, &init_net);
                svc_exit_thread(cb_info->rqst);
                cb_info->serv = NULL;
                cb_info->rqst = NULL;
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index 95bfc243992c..e64b01d2a338 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -455,9 +455,9 @@ static __be32 decode_cb_sequence_args(struct svc_rqst *rqstp,
        args->csa_nrclists = ntohl(*p++);
        args->csa_rclists = NULL;
        if (args->csa_nrclists) {
-                args->csa_rclists = kmalloc(args->csa_nrclists *
+                args->csa_rclists = kmalloc_array(args->csa_nrclists,
-                                            sizeof(*args->csa_rclists),
+                                                  sizeof(*args->csa_rclists),
-                                            GFP_KERNEL);
+                                                  GFP_KERNEL);
                if (unlikely(args->csa_rclists == NULL))
                        goto out;
@@ -696,7 +696,7 @@ static __be32 encode_cb_sequence_res(struct svc_rqst *rqstp,
                                       const struct cb_sequenceres *res)
 {
        __be32 *p;
-        unsigned status = res->csr_status;
+        __be32 status = res->csr_status;
        if (unlikely(status != 0))
                goto out;
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 7d108753af81..f005b5bebdc7 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -207,7 +207,6 @@ error_0:
 static void nfs4_shutdown_session(struct nfs_client *clp)
 {
        if (nfs4_has_session(clp)) {
-                nfs4_deviceid_purge_client(clp);
                nfs4_destroy_session(clp->cl_session);
                nfs4_destroy_clientid(clp);
        }
@@ -544,8 +543,6 @@ nfs_found_client(const struct nfs_client_initdata *cl_init,
        smp_rmb();
-        BUG_ON(clp->cl_cons_state != NFS_CS_READY);
        dprintk("<-- %s found nfs_client %p for %s\n",
                __func__, clp, cl_init->hostname ?: "");
        return clp;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index f430057ff3b3..a6b1c7fb8232 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -46,8 +46,8 @@
 static int nfs_opendir(struct inode *, struct file *);
 static int nfs_closedir(struct inode *, struct file *);
 static int nfs_readdir(struct file *, void *, filldir_t);
-static struct dentry *nfs_lookup(struct inode *, struct dentry *, struct nameidata *);
+static struct dentry *nfs_lookup(struct inode *, struct dentry *, unsigned int);
-static int nfs_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
+static int nfs_create(struct inode *, struct dentry *, umode_t, bool);
 static int nfs_mkdir(struct inode *, struct dentry *, umode_t);
 static int nfs_rmdir(struct inode *, struct dentry *);
 static int nfs_unlink(struct inode *, struct dentry *);
@@ -111,11 +111,13 @@ const struct inode_operations nfs3_dir_inode_operations = {
 #ifdef CONFIG_NFS_V4
-static struct dentry *nfs_atomic_lookup(struct inode *, struct dentry *, struct nameidata *);
+static int nfs_atomic_open(struct inode *, struct dentry *,
-static int nfs_open_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd);
+                           struct file *, unsigned, umode_t,
+                           int *);
 const struct inode_operations nfs4_dir_inode_operations = {
-        .create         = nfs_open_create,
+        .create         = nfs_create,
-        .lookup         = nfs_atomic_lookup,
+        .lookup         = nfs_lookup,
+        .atomic_open    = nfs_atomic_open,
        .link           = nfs_link,
        .unlink         = nfs_unlink,
        .symlink        = nfs_symlink,
@@ -1029,27 +1031,14 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
 }
 /*
- * Return the intent data that applies to this particular path component
- *
- * Note that the current set of intents only apply to the very last
- * component of the path and none of them is set before that last
- * component.
- */
-static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
-                                                unsigned int mask)
-{
-        return nd->flags & mask;
-}
-/*
 * Use intent information to check whether or not we're going to do
 * an O_EXCL create using this path component.
 */
-static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
+static int nfs_is_exclusive_create(struct inode *dir, unsigned int flags)
 {
        if (NFS_PROTO(dir)->version == 2)
                return 0;
-        return nd && nfs_lookup_check_intent(nd, LOOKUP_EXCL);
+        return flags & LOOKUP_EXCL;
 }
 /*
@@ -1061,25 +1050,20 @@ static int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
 *
 */
 static inline
-int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
+int nfs_lookup_verify_inode(struct inode *inode, unsigned int flags)
 {
        struct nfs_server *server = NFS_SERVER(inode);
        if (IS_AUTOMOUNT(inode))
                return 0;
-        if (nd != NULL) {
+        /* VFS wants an on-the-wire revalidation */
-                /* VFS wants an on-the-wire revalidation */
+        if (flags & LOOKUP_REVAL)
-                if (nd->flags & LOOKUP_REVAL)
+                goto out_force;
-                        goto out_force;
+        /* This is an open(2) */
-                /* This is an open(2) */
+        if ((flags & LOOKUP_OPEN) && !(server->flags & NFS_MOUNT_NOCTO) &&
-                if (nfs_lookup_check_intent(nd, LOOKUP_OPEN) != 0 &&
+            (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
-                                !(server->flags & NFS_MOUNT_NOCTO) &&
+                goto out_force;
-                                (S_ISREG(inode->i_mode) ||
+        return 0;
-                                 S_ISDIR(inode->i_mode)))
-                        goto out_force;
-                return 0;
-        }
-        return nfs_revalidate_inode(server, inode);
 out_force:
        return __nfs_revalidate_inode(server, inode);
 }
@@ -1093,10 +1077,10 @@ out_force:
 */
 static inline
 int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
-                       struct nameidata *nd)
+                       unsigned int flags)
 {
        /* Don't revalidate a negative dentry if we're creating a new file */
-        if (nd != NULL && nfs_lookup_check_intent(nd, LOOKUP_CREATE) != 0)
+        if (flags & LOOKUP_CREATE)
                return 0;
        if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)
                return 1;
@@ -1114,7 +1098,7 @@ int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
 * If the parent directory is seen to have changed, we throw out the
 * cached dentry and do a new lookup.
 */
-static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct inode *dir;
        struct inode *inode;
@@ -1123,7 +1107,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
        struct nfs_fattr *fattr = NULL;
        int error;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        parent = dget_parent(dentry);
@@ -1132,7 +1116,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
        inode = dentry->d_inode;
        if (!inode) {
-                if (nfs_neg_need_reval(dir, dentry, nd))
+                if (nfs_neg_need_reval(dir, dentry, flags))
                        goto out_bad;
                goto out_valid_noent;
        }
@@ -1148,8 +1132,8 @@ static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
                goto out_set_verifier;
        /* Force a full look up iff the parent directory has changed */
-        if (!nfs_is_exclusive_create(dir, nd) && nfs_check_verifier(dir, dentry)) {
+        if (!nfs_is_exclusive_create(dir, flags) && nfs_check_verifier(dir, dentry)) {
-                if (nfs_lookup_verify_inode(inode, nd))
+                if (nfs_lookup_verify_inode(inode, flags))
                        goto out_zap_parent;
                goto out_valid;
        }
@@ -1286,7 +1270,7 @@ const struct dentry_operations nfs_dentry_operations = {
        .d_release      = nfs_d_release,
 };
-static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
+static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
 {
        struct dentry *res;
        struct dentry *parent;
@@ -1307,7 +1291,7 @@ static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, stru
         * If we're doing an exclusive create, optimize away the lookup
         * but don't hash the dentry.
         */
-        if (nfs_is_exclusive_create(dir, nd)) {
+        if (nfs_is_exclusive_create(dir, flags)) {
                d_instantiate(dentry, NULL);
                res = NULL;
                goto out;
@@ -1354,7 +1338,7 @@ out:
 }
 #ifdef CONFIG_NFS_V4
-static int nfs4_lookup_revalidate(struct dentry *, struct nameidata *);
+static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
 const struct dentry_operations nfs4_dentry_operations = {
        .d_revalidate   = nfs4_lookup_revalidate,
@@ -1364,24 +1348,6 @@ const struct dentry_operations nfs4_dentry_operations = {
        .d_release      = nfs_d_release,
 };
-/*
- * Use intent information to determine whether we need to substitute
- * the NFSv4-style stateful OPEN for the LOOKUP call
- */
-static int is_atomic_open(struct nameidata *nd)
-{
-        if (nd == NULL || nfs_lookup_check_intent(nd, LOOKUP_OPEN) == 0)
-                return 0;
-        /* NFS does not (yet) have a stateful open for directories */
-        if (nd->flags & LOOKUP_DIRECTORY)
-                return 0;
-        /* Are we trying to write to a read only partition? */
-        if (__mnt_is_readonly(nd->path.mnt) &&
-            (nd->intent.open.flags & (O_CREAT|O_TRUNC|O_ACCMODE)))
-                return 0;
-        return 1;
-}
 static fmode_t flags_to_mode(int flags)
 {
        fmode_t res = (__force fmode_t)flags & FMODE_EXEC;
@@ -1403,136 +1369,143 @@ static int do_open(struct inode *inode, struct file *filp)
        return 0;
 }
-static int nfs_intent_set_file(struct nameidata *nd, struct nfs_open_context *ctx)
+static int nfs_finish_open(struct nfs_open_context *ctx,
+                           struct dentry *dentry,
+                           struct file *file, unsigned open_flags,
+                           int *opened)
 {
-        struct file *filp;
+        int err;
-        int ret = 0;
+        if (ctx->dentry != dentry) {
+                dput(ctx->dentry);
+                ctx->dentry = dget(dentry);
+        }
        /* If the open_intent is for execute, we have an extra check to make */
        if (ctx->mode & FMODE_EXEC) {
-                ret = nfs_may_open(ctx->dentry->d_inode,
+                err = nfs_may_open(dentry->d_inode, ctx->cred, open_flags);
-                                ctx->cred,
+                if (err < 0)
-                                nd->intent.open.flags);
-                if (ret < 0)
                        goto out;
        }
-        filp = lookup_instantiate_filp(nd, ctx->dentry, do_open);
-        if (IS_ERR(filp))
+        err = finish_open(file, dentry, do_open, opened);
-                ret = PTR_ERR(filp);
+        if (err)
-        else
+                goto out;
-                nfs_file_set_open_context(filp, ctx);
+        nfs_file_set_open_context(file, ctx);
 out:
        put_nfs_open_context(ctx);
-        return ret;
+        return err;
 }
-static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
+                            struct file *file, unsigned open_flags,
+                            umode_t mode, int *opened)
 {
        struct nfs_open_context *ctx;
-        struct iattr attr;
+        struct dentry *res;
-        struct dentry *res = NULL;
+        struct iattr attr = { .ia_valid = ATTR_OPEN };
        struct inode *inode;
-        int open_flags;
        int err;
-        dfprintk(VFS, "NFS: atomic_lookup(%s/%ld), %s\n",
+        /* Expect a negative dentry */
+        BUG_ON(dentry->d_inode);
+        dfprintk(VFS, "NFS: atomic_open(%s/%ld), %s\n",
                        dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
-        /* Check that we are indeed trying to open this file */
+        /* NFS only supports OPEN on regular files */
-        if (!is_atomic_open(nd))
+        if ((open_flags & O_DIRECTORY)) {
+                if (!d_unhashed(dentry)) {
+                        /*
+                         * Hashed negative dentry with O_DIRECTORY: dentry was
+                         * revalidated and is fine, no need to perform lookup
+                         * again
+                         */
+                        return -ENOENT;
+                }
                goto no_open;
-        if (dentry->d_name.len > NFS_SERVER(dir)->namelen) {
-                res = ERR_PTR(-ENAMETOOLONG);
-                goto out;
-        }
-        /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
-         * the dentry. */
-        if (nd->flags & LOOKUP_EXCL) {
-                d_instantiate(dentry, NULL);
-                goto out;
        }
-        open_flags = nd->intent.open.flags;
+        if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
-        attr.ia_valid = ATTR_OPEN;
+                return -ENAMETOOLONG;
-        ctx = create_nfs_open_context(dentry, open_flags);
-        res = ERR_CAST(ctx);
-        if (IS_ERR(ctx))
-                goto out;
-        if (nd->flags & LOOKUP_CREATE) {
+        if (open_flags & O_CREAT) {
-                attr.ia_mode = nd->intent.open.create_mode;
                attr.ia_valid |= ATTR_MODE;
-                attr.ia_mode &= ~current_umask();
+                attr.ia_mode = mode & ~current_umask();
-        } else
+        }
-                open_flags &= ~(O_EXCL | O_CREAT);
        if (open_flags & O_TRUNC) {
                attr.ia_valid |= ATTR_SIZE;
                attr.ia_size = 0;
        }
-        /* Open the file on the server */
+        ctx = create_nfs_open_context(dentry, open_flags);
+        err = PTR_ERR(ctx);
+        if (IS_ERR(ctx))
+                goto out;
        nfs_block_sillyrename(dentry->d_parent);
        inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr);
+        d_drop(dentry);
        if (IS_ERR(inode)) {
                nfs_unblock_sillyrename(dentry->d_parent);
                put_nfs_open_context(ctx);
-                switch (PTR_ERR(inode)) {
+                err = PTR_ERR(inode);
-                        /* Make a negative dentry */
+                switch (err) {
-                        case -ENOENT:
+                case -ENOENT:
-                                d_add(dentry, NULL);
+                        d_add(dentry, NULL);
-                                res = NULL;
+                        break;
-                                goto out;
+                case -EISDIR:
-                        /* This turned out not to be a regular file */
+                case -ENOTDIR:
-                        case -EISDIR:
+                        goto no_open;
-                        case -ENOTDIR:
+                case -ELOOP:
+                        if (!(open_flags & O_NOFOLLOW))
                                goto no_open;
-                        case -ELOOP:
+                        break;
-                                if (!(nd->intent.open.flags & O_NOFOLLOW))
-                                        goto no_open;
                        /* case -EINVAL: */
-                        default:
+                default:
-                                res = ERR_CAST(inode);
+                        break;
-                                goto out;
                }
+                goto out;
        }
        res = d_add_unique(dentry, inode);
-        nfs_unblock_sillyrename(dentry->d_parent);
+        if (res != NULL)
-        if (res != NULL) {
-                dput(ctx->dentry);
-                ctx->dentry = dget(res);
                dentry = res;
-        }
-        err = nfs_intent_set_file(nd, ctx);
+        nfs_unblock_sillyrename(dentry->d_parent);
-        if (err < 0) {
-                if (res != NULL)
-                        dput(res);
-                return ERR_PTR(err);
-        }
-out:
        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-        return res;
+        err = nfs_finish_open(ctx, dentry, file, open_flags, opened);
+        dput(res);
+out:
+        return err;
 no_open:
-        return nfs_lookup(dir, dentry, nd);
+        res = nfs_lookup(dir, dentry, 0);
+        err = PTR_ERR(res);
+        if (IS_ERR(res))
+                goto out;
+        return finish_no_open(file, res);
 }
-static int nfs4_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct dentry *parent = NULL;
        struct inode *inode;
        struct inode *dir;
-        int openflags, ret = 0;
+        int ret = 0;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
-        inode = dentry->d_inode;
+        if (!(flags & LOOKUP_OPEN) || (flags & LOOKUP_DIRECTORY))
-        if (!is_atomic_open(nd) || d_mountpoint(dentry))
+                goto no_open;
+        if (d_mountpoint(dentry))
                goto no_open;
+        inode = dentry->d_inode;
        parent = dget_parent(dentry);
        dir = parent->d_inode;
@@ -1540,7 +1513,7 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
         * optimize away revalidation of negative dentries.
         */
        if (inode == NULL) {
-                if (!nfs_neg_need_reval(dir, dentry, nd))
+                if (!nfs_neg_need_reval(dir, dentry, flags))
                        ret = 1;
                goto out;
        }
@@ -1548,9 +1521,8 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
        /* NFS only supports OPEN on regular files */
        if (!S_ISREG(inode->i_mode))
                goto no_open_dput;
-        openflags = nd->intent.open.flags;
        /* We cannot do exclusive creation on a positive dentry */
-        if ((openflags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
+        if (flags & LOOKUP_EXCL)
                goto no_open_dput;
        /* Let f_op->open() actually open (and revalidate) the file */
@@ -1563,48 +1535,7 @@ out:
 no_open_dput:
        dput(parent);
 no_open:
-        return nfs_lookup_revalidate(dentry, nd);
+        return nfs_lookup_revalidate(dentry, flags);
-}
-static int nfs_open_create(struct inode *dir, struct dentry *dentry,
-                umode_t mode, struct nameidata *nd)
-{
-        struct nfs_open_context *ctx = NULL;
-        struct iattr attr;
-        int error;
-        int open_flags = O_CREAT|O_EXCL;
-        dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
-                        dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
-        attr.ia_mode = mode;
-        attr.ia_valid = ATTR_MODE;
-        if (nd)
-                open_flags = nd->intent.open.flags;
-        ctx = create_nfs_open_context(dentry, open_flags);
-        error = PTR_ERR(ctx);
-        if (IS_ERR(ctx))
-                goto out_err_drop;
-        error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, ctx);
-        if (error != 0)
-                goto out_put_ctx;
-        if (nd) {
-                error = nfs_intent_set_file(nd, ctx);
-                if (error < 0)
-                        goto out_err;
-        } else {
-                put_nfs_open_context(ctx);
-        }
-        return 0;
-out_put_ctx:
-        put_nfs_open_context(ctx);
-out_err_drop:
-        d_drop(dentry);
-out_err:
-        return error;
 }
 #endif /* CONFIG_NFSV4 */
@@ -1658,11 +1589,11 @@ out_error:
 * reply path made it appear to have failed.
 */
 static int nfs_create(struct inode *dir, struct dentry *dentry,
-                umode_t mode, struct nameidata *nd)
+                umode_t mode, bool excl)
 {
        struct iattr attr;
+        int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;
        int error;
-        int open_flags = O_CREAT|O_EXCL;
        dfprintk(VFS, "NFS: create(%s/%ld), %s\n",
                        dir->i_sb->s_id, dir->i_ino, dentry->d_name.name);
@@ -1670,10 +1601,7 @@ static int nfs_create(struct inode *dir, struct dentry *dentry,
        attr.ia_mode = mode;
        attr.ia_valid = ATTR_MODE;
-        if (nd)
+        error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags);
-                open_flags = nd->intent.open.flags;
-        error = NFS_PROTO(dir)->create(dir, dentry, &attr, open_flags, NULL);
        if (error != 0)
                goto out_err;
        return 0;
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index ad2775d3e219..48253372ab1d 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -484,17 +484,22 @@ static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
        list_for_each_entry_safe(req, tmp, &reqs, wb_list) {
                if (!nfs_pageio_add_request(&desc, req)) {
+                        nfs_list_remove_request(req);
                        nfs_list_add_request(req, &failed);
                        spin_lock(cinfo.lock);
                        dreq->flags = 0;
                        dreq->error = -EIO;
                        spin_unlock(cinfo.lock);
                }
+                nfs_release_request(req);
        }
        nfs_pageio_complete(&desc);
-        while (!list_empty(&failed))
+        while (!list_empty(&failed)) {
+                req = nfs_list_entry(failed.next);
+                nfs_list_remove_request(req);
                nfs_unlock_and_release_request(req);
+        }
        if (put_dreq(dreq))
                nfs_direct_write_complete(dreq, dreq->inode);
@@ -523,9 +528,9 @@ static void nfs_direct_commit_complete(struct nfs_commit_data *data)
                nfs_list_remove_request(req);
                if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES) {
                        /* Note the rewrite will go through mds */
-                        kref_get(&req->wb_kref);
                        nfs_mark_request_commit(req, NULL, &cinfo);
-                }
+                } else
+                        nfs_release_request(req);
                nfs_unlock_and_release_request(req);
        }
@@ -716,12 +721,12 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr)
                        if (dreq->flags == NFS_ODIRECT_RESCHED_WRITES)
                                bit = NFS_IOHDR_NEED_RESCHED;
                        else if (dreq->flags == 0) {
-                                memcpy(&dreq->verf, &req->wb_verf,
+                                memcpy(&dreq->verf, hdr->verf,
                                       sizeof(dreq->verf));
                                bit = NFS_IOHDR_NEED_COMMIT;
                                dreq->flags = NFS_ODIRECT_DO_COMMIT;
                        } else if (dreq->flags == NFS_ODIRECT_DO_COMMIT) {
-                                if (memcmp(&dreq->verf, &req->wb_verf, sizeof(dreq->verf))) {
+                                if (memcmp(&dreq->verf, hdr->verf, sizeof(dreq->verf))) {
                                        dreq->flags = NFS_ODIRECT_RESCHED_WRITES;
                                        bit = NFS_IOHDR_NEED_RESCHED;
                                } else
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 8abfb19bd3aa..a67990f90bd7 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -62,7 +62,7 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                 */
                spin_lock(&sb->s_root->d_inode->i_lock);
                spin_lock(&sb->s_root->d_lock);
-                list_del_init(&sb->s_root->d_alias);
+                hlist_del_init(&sb->s_root->d_alias);
                spin_unlock(&sb->s_root->d_lock);
                spin_unlock(&sb->s_root->d_inode->i_lock);
        }
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index b5b86a05059c..864c51e4b400 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -57,6 +57,11 @@ unsigned int nfs_idmap_cache_timeout = 600;
 static const struct cred *id_resolver_cache;
 static struct key_type key_type_id_resolver_legacy;
+struct idmap {
+        struct rpc_pipe         *idmap_pipe;
+        struct key_construction *idmap_key_cons;
+        struct mutex            idmap_mutex;
+};
 /**
 * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields
@@ -310,9 +315,11 @@ static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
                                            name, namelen, type, data,
                                            data_size, NULL);
        if (ret < 0) {
+                mutex_lock(&idmap->idmap_mutex);
                ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
                                            name, namelen, type, data,
                                            data_size, idmap);
+                mutex_unlock(&idmap->idmap_mutex);
        }
        return ret;
 }
@@ -354,11 +361,6 @@ static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *typ
 /* idmap classic begins here */
 module_param(nfs_idmap_cache_timeout, int, 0644);
-struct idmap {
-        struct rpc_pipe         *idmap_pipe;
-        struct key_construction *idmap_key_cons;
-};
 enum {
        Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err
 };
@@ -469,6 +471,7 @@ nfs_idmap_new(struct nfs_client *clp)
                return error;
        }
        idmap->idmap_pipe = pipe;
+        mutex_init(&idmap->idmap_mutex);
        clp->cl_idmap = idmap;
        return 0;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index e605d695dbcb..f7296983eba6 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1530,7 +1530,6 @@ static inline void nfs4_init_once(struct nfs_inode *nfsi)
        nfsi->delegation_state = 0;
        init_rwsem(&nfsi->rwsem);
        nfsi->layout = NULL;
-        atomic_set(&nfsi->commit_info.rpcs_out, 0);
 #endif
 }
@@ -1545,6 +1544,7 @@ static void init_once(void *foo)
        INIT_LIST_HEAD(&nfsi->commit_info.list);
        nfsi->npages = 0;
        nfsi->commit_info.ncommit = 0;
+        atomic_set(&nfsi->commit_info.rpcs_out, 0);
        atomic_set(&nfsi->silly_count, 1);
        INIT_HLIST_HEAD(&nfsi->silly_list);
        init_waitqueue_head(&nfsi->waitqueue);
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 2292a0fd2bff..3187e24e8f78 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -314,7 +314,7 @@ static void nfs3_free_createdata(struct nfs3_createdata *data)
 */
 static int
 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
-                 int flags, struct nfs_open_context *ctx)
+                 int flags)
 {
        struct nfs3_createdata *data;
        umode_t mode = sattr->ia_mode;
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index c6827f93ab57..cc5900ac61b5 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -295,7 +295,7 @@ is_ds_client(struct nfs_client *clp)
 extern const struct nfs4_minor_version_ops *nfs_v4_minor_ops[];
-extern const u32 nfs4_fattr_bitmap[2];
+extern const u32 nfs4_fattr_bitmap[3];
 extern const u32 nfs4_statfs_bitmap[2];
 extern const u32 nfs4_pathconf_bitmap[2];
 extern const u32 nfs4_fsinfo_bitmap[3];
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index d48dbefa0e71..c157b2089b47 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -105,6 +105,8 @@ static int nfs4_map_errors(int err)
                return -EINVAL;
        case -NFS4ERR_SHARE_DENIED:
                return -EACCES;
+        case -NFS4ERR_MINOR_VERS_MISMATCH:
+                return -EPROTONOSUPPORT;
        default:
                dprintk("%s could not handle NFSv4 error %d\n",
                                __func__, -err);
@@ -116,7 +118,7 @@ static int nfs4_map_errors(int err)
 /*
 * This is our standard bitmap for GETATTR requests.
 */
-const u32 nfs4_fattr_bitmap[2] = {
+const u32 nfs4_fattr_bitmap[3] = {
        FATTR4_WORD0_TYPE
        | FATTR4_WORD0_CHANGE
        | FATTR4_WORD0_SIZE
@@ -133,6 +135,24 @@ const u32 nfs4_fattr_bitmap[2] = {
        | FATTR4_WORD1_TIME_MODIFY
 };
+static const u32 nfs4_pnfs_open_bitmap[3] = {
+        FATTR4_WORD0_TYPE
+        | FATTR4_WORD0_CHANGE
+        | FATTR4_WORD0_SIZE
+        | FATTR4_WORD0_FSID
+        | FATTR4_WORD0_FILEID,
+        FATTR4_WORD1_MODE
+        | FATTR4_WORD1_NUMLINKS
+        | FATTR4_WORD1_OWNER
+        | FATTR4_WORD1_OWNER_GROUP
+        | FATTR4_WORD1_RAWDEV
+        | FATTR4_WORD1_SPACE_USED
+        | FATTR4_WORD1_TIME_ACCESS
+        | FATTR4_WORD1_TIME_METADATA
+        | FATTR4_WORD1_TIME_MODIFY,
+        FATTR4_WORD2_MDSTHRESHOLD
+};
 const u32 nfs4_statfs_bitmap[2] = {
        FATTR4_WORD0_FILES_AVAIL
        | FATTR4_WORD0_FILES_FREE
@@ -844,6 +864,7 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
        p->o_arg.name = &dentry->d_name;
        p->o_arg.server = server;
        p->o_arg.bitmask = server->attr_bitmask;
+        p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
        p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
        if (attrs != NULL && attrs->ia_valid != 0) {
                __be32 verf[2];
@@ -1820,6 +1841,7 @@ static int _nfs4_do_open(struct inode *dir,
                opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
                if (!opendata->f_attr.mdsthreshold)
                        goto err_opendata_put;
+                opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
        }
        if (dentry->d_inode != NULL)
                opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
@@ -1880,6 +1902,7 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir,
        struct nfs4_state *res;
        int status;
+        fmode &= FMODE_READ|FMODE_WRITE;
        do {
                status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
                                       &res, ctx_th);
@@ -2526,6 +2549,14 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
        nfs_fattr_init(fattr);
        
+        /* Deal with open(O_TRUNC) */
+        if (sattr->ia_valid & ATTR_OPEN)
+                sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
+        /* Optimization: if the end result is no change, don't RPC */
+        if ((sattr->ia_valid & ~(ATTR_FILE)) == 0)
+                return 0;
        /* Search for an existing open(O_WRITE) file */
        if (sattr->ia_valid & ATTR_FILE) {
                struct nfs_open_context *ctx;
@@ -2537,10 +2568,6 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
                }
        }
-        /* Deal with open(O_TRUNC) */
-        if (sattr->ia_valid & ATTR_OPEN)
-                sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
        status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
        if (status == 0)
                nfs_setattr_update_inode(inode, sattr);
@@ -2779,37 +2806,22 @@ static int nfs4_proc_readlink(struct inode *inode, struct page *page,
 }
 /*
- * Got race?
+ * This is just for mknod.  open(O_CREAT) will always do ->open_context().
- * We will need to arrange for the VFS layer to provide an atomic open.
- * Until then, this create/open method is prone to inefficiency and race
- * conditions due to the lookup, create, and open VFS calls from sys_open()
- * placed on the wire.
- *
- * Given the above sorry state of affairs, I'm simply sending an OPEN.
- * The file will be opened again in the subsequent VFS open call
- * (nfs4_proc_file_open).
- *
- * The open for read will just hang around to be used by any process that
- * opens the file O_RDONLY. This will all be resolved with the VFS changes.
 */
 static int
 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
-                 int flags, struct nfs_open_context *ctx)
+                 int flags)
 {
-        struct dentry *de = dentry;
+        struct nfs_open_context *ctx;
        struct nfs4_state *state;
-        struct rpc_cred *cred = NULL;
-        fmode_t fmode = 0;
        int status = 0;
-        if (ctx != NULL) {
+        ctx = alloc_nfs_open_context(dentry, FMODE_READ);
-                cred = ctx->cred;
+        if (IS_ERR(ctx))
-                de = ctx->dentry;
+                return PTR_ERR(ctx);
-                fmode = ctx->mode;
-        }
        sattr->ia_mode &= ~current_umask();
-        state = nfs4_do_open(dir, de, fmode, flags, sattr, cred, NULL);
+        state = nfs4_do_open(dir, dentry, ctx->mode, flags, sattr, ctx->cred, NULL);
        d_drop(dentry);
        if (IS_ERR(state)) {
                status = PTR_ERR(state);
@@ -2817,11 +2829,9 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
        }
        d_add(dentry, igrab(state->inode));
        nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
-        if (ctx != NULL)
+        ctx->state = state;
-                ctx->state = state;
-        else
-                nfs4_close_sync(state, fmode);
 out:
+        put_nfs_open_context(ctx);
        return status;
 }
@@ -5275,7 +5285,7 @@ static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
        status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
        if (status)
-                pr_warn("NFS: Got error %d from the server %s on "
+                dprintk("NFS: Got error %d from the server %s on "
                        "DESTROY_CLIENTID.", status, clp->cl_hostname);
        return status;
 }
@@ -5746,8 +5756,7 @@ int nfs4_proc_destroy_session(struct nfs4_session *session,
        status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
        if (status)
-                printk(KERN_WARNING
+                dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
-                        "NFS: Got error %d from the server on DESTROY_SESSION. "
                        "Session has been destroyed regardless...\n", status);
        dprintk("<-- nfs4_proc_destroy_session\n");
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index c679b9ecef63..f38300e9f171 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -244,6 +244,16 @@ static int nfs4_begin_drain_session(struct nfs_client *clp)
        return nfs4_wait_on_slot_tbl(&ses->fc_slot_table);
 }
+static void nfs41_finish_session_reset(struct nfs_client *clp)
+{
+        clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
+        clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
+        /* create_session negotiated new slot table */
+        clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
+        clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
+        nfs41_setup_state_renewal(clp);
+}
 int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
 {
        int status;
@@ -259,8 +269,7 @@ do_confirm:
        status = nfs4_proc_create_session(clp, cred);
        if (status != 0)
                goto out;
-        clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
+        nfs41_finish_session_reset(clp);
-        nfs41_setup_state_renewal(clp);
        nfs_mark_client_ready(clp, NFS_CS_READY);
 out:
        return status;
@@ -1772,16 +1781,9 @@ static int nfs4_reset_session(struct nfs_client *clp)
                status = nfs4_handle_reclaim_lease_error(clp, status);
                goto out;
        }
-        clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
+        nfs41_finish_session_reset(clp);
-        /* create_session negotiated new slot table */
-        clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
-        clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
        dprintk("%s: session reset was successful for server %s!\n",
                        __func__, clp->cl_hostname);
-         /* Let the state manager reestablish state */
-        if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
-                nfs41_setup_state_renewal(clp);
 out:
        if (cred)
                put_rpccred(cred);
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index ee4a74db95d0..18fae29b0301 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1198,12 +1198,13 @@ static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct c
 }
 static void encode_getfattr_open(struct xdr_stream *xdr, const u32 *bitmask,
+                                 const u32 *open_bitmap,
                                 struct compound_hdr *hdr)
 {
        encode_getattr_three(xdr,
-                             bitmask[0] & nfs4_fattr_bitmap[0],
+                             bitmask[0] & open_bitmap[0],
-                             bitmask[1] & nfs4_fattr_bitmap[1],
+                             bitmask[1] & open_bitmap[1],
-                             bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD,
+                             bitmask[2] & open_bitmap[2],
                             hdr);
 }
@@ -2221,7 +2222,7 @@ static void nfs4_xdr_enc_open(struct rpc_rqst *req, struct xdr_stream *xdr,
        encode_putfh(xdr, args->fh, &hdr);
        encode_open(xdr, args, &hdr);
        encode_getfh(xdr, &hdr);
-        encode_getfattr_open(xdr, args->bitmask, &hdr);
+        encode_getfattr_open(xdr, args->bitmask, args->open_bitmap, &hdr);
        encode_nops(&hdr);
 }
@@ -4359,7 +4360,10 @@ static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
        if (unlikely(bitmap[2] & (FATTR4_WORD2_MDSTHRESHOLD - 1U)))
                return -EIO;
-        if (likely(bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD)) {
+        if (bitmap[2] & FATTR4_WORD2_MDSTHRESHOLD) {
+                /* Did the server return an unrequested attribute? */
+                if (unlikely(res == NULL))
+                        return -EREMOTEIO;
                p = xdr_inline_decode(xdr, 4);
                if (unlikely(!p))
                        goto out_overflow;
@@ -4372,6 +4376,7 @@ static int decode_attr_mdsthreshold(struct xdr_stream *xdr,
                                __func__);
                status = decode_first_threshold_item4(xdr, res);
+                bitmap[2] &= ~FATTR4_WORD2_MDSTHRESHOLD;
        }
        return status;
 out_overflow:
diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
index b47277baebab..f50d3e8d6f22 100644
--- a/fs/nfs/objlayout/objio_osd.c
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -454,7 +454,10 @@ int objio_read_pagelist(struct nfs_read_data *rdata)
        objios->ios->done = _read_done;
        dprintk("%s: offset=0x%llx length=0x%x\n", __func__,
                rdata->args.offset, rdata->args.count);
-        return ore_read(objios->ios);
+        ret = ore_read(objios->ios);
+        if (unlikely(ret))
+                objio_free_result(&objios->oir);
+        return ret;
 }
 /*
@@ -486,8 +489,16 @@ static struct page *__r4w_get_page(void *priv, u64 offset, bool *uptodate)
        struct nfs_write_data *wdata = objios->oir.rpcdata;
        struct address_space *mapping = wdata->header->inode->i_mapping;
        pgoff_t index = offset / PAGE_SIZE;
-        struct page *page = find_get_page(mapping, index);
+        struct page *page;
+        loff_t i_size = i_size_read(wdata->header->inode);
+        if (offset >= i_size) {
+                *uptodate = true;
+                dprintk("%s: g_zero_page index=0x%lx\n", __func__, index);
+                return ZERO_PAGE(0);
+        }
+        page = find_get_page(mapping, index);
        if (!page) {
                page = find_or_create_page(mapping, index, GFP_NOFS);
                if (unlikely(!page)) {
@@ -507,8 +518,10 @@ static struct page *__r4w_get_page(void *priv, u64 offset, bool *uptodate)
 static void __r4w_put_page(void *priv, struct page *page)
 {
-        dprintk("%s: index=0x%lx\n", __func__, page->index);
+        dprintk("%s: index=0x%lx\n", __func__,
-        page_cache_release(page);
+                (page == ZERO_PAGE(0)) ? -1UL : page->index);
+        if (ZERO_PAGE(0) != page)
+                page_cache_release(page);
        return;
 }
@@ -539,8 +552,10 @@ int objio_write_pagelist(struct nfs_write_data *wdata, int how)
        dprintk("%s: offset=0x%llx length=0x%x\n", __func__,
                wdata->args.offset, wdata->args.count);
        ret = ore_write(objios->ios);
-        if (unlikely(ret))
+        if (unlikely(ret)) {
+                objio_free_result(&objios->oir);
                return ret;
+        }
        if (objios->sync)
                _write_done(objios->ios, objios);
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index b8323aa7b543..bbc49caa7a82 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -70,6 +70,10 @@ find_pnfs_driver(u32 id)
        spin_lock(&pnfs_spinlock);
        local = find_pnfs_driver_locked(id);
+        if (local != NULL && !try_module_get(local->owner)) {
+                dprintk("%s: Could not grab reference on module\n", __func__);
+                local = NULL;
+        }
        spin_unlock(&pnfs_spinlock);
        return local;
 }
@@ -80,6 +84,9 @@ unset_pnfs_layoutdriver(struct nfs_server *nfss)
        if (nfss->pnfs_curr_ld) {
                if (nfss->pnfs_curr_ld->clear_layoutdriver)
                        nfss->pnfs_curr_ld->clear_layoutdriver(nfss);
+                /* Decrement the MDS count. Purge the deviceid cache if zero */
+                if (atomic_dec_and_test(&nfss->nfs_client->cl_mds_count))
+                        nfs4_deviceid_purge_client(nfss->nfs_client);
                module_put(nfss->pnfs_curr_ld->owner);
        }
        nfss->pnfs_curr_ld = NULL;
@@ -115,10 +122,6 @@ set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
                        goto out_no_driver;
                }
        }
-        if (!try_module_get(ld_type->owner)) {
-                dprintk("%s: Could not grab reference on module\n", __func__);
-                goto out_no_driver;
-        }
        server->pnfs_curr_ld = ld_type;
        if (ld_type->set_layoutdriver
            && ld_type->set_layoutdriver(server, mntfh)) {
@@ -127,6 +130,8 @@ set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
                module_put(ld_type->owner);
                goto out_no_driver;
        }
+        /* Bump the MDS count */
+        atomic_inc(&server->nfs_client->cl_mds_count);
        dprintk("%s: pNFS module for %u set\n", __func__, id);
        return;
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index 29fd23c0efdc..64f90d845f6a 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -365,7 +365,7 @@ static inline bool
 pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
                   struct nfs_server *nfss)
 {
-        return (dst && src && src->bm != 0 &&
+        return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&
                                        nfss->pnfs_curr_ld->id == src->l_type);
 }
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index a706b6bcc286..4433806e116f 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -259,7 +259,7 @@ static void nfs_free_createdata(const struct nfs_createdata *data)
 static int
 nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
-                int flags, struct nfs_open_context *ctx)
+                int flags)
 {
        struct nfs_createdata *data;
        struct rpc_message msg = {
@@ -651,7 +651,7 @@ static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
                /* Emulate the eof flag, which isn't normally needed in NFSv2
                 * as it is guaranteed to always return the file attributes
                 */
-                if (data->args.offset + data->args.count >= data->res.fattr->size)
+                if (data->args.offset + data->res.count >= data->res.fattr->size)
                        data->res.eof = 1;
        }
        return 0;
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index ff656c022684..8b2a2977b720 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -1867,6 +1867,7 @@ static int nfs23_validate_mount_data(void *options,
        if (data == NULL)
                goto out_no_data;
+        args->version = NFS_DEFAULT_VERSION;
        switch (data->version) {
        case 1:
                data->namlen = 0;
@@ -2418,7 +2419,7 @@ static struct dentry *nfs_fs_mount_common(struct file_system_type *fs_type,
                sb_mntdata.mntflags |= MS_SYNCHRONOUS;
        /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, compare_super, nfs_set_super, &sb_mntdata);
+        s = sget(fs_type, compare_super, nfs_set_super, flags, &sb_mntdata);
        if (IS_ERR(s)) {
                mntroot = ERR_CAST(s);
                goto out_err_nosb;
@@ -2637,6 +2638,8 @@ static int nfs4_validate_mount_data(void *options,
        if (data == NULL)
                goto out_no_data;
+        args->version = 4;
        switch (data->version) {
        case 1:
                if (data->host_addrlen > sizeof(args->nfs_server.address))
@@ -2857,6 +2860,8 @@ static struct dentry *nfs4_try_mount(int flags, const char *dev_name,
        dfprintk(MOUNT, "--> nfs4_try_mount()\n");
+        mount_info->fill_super = nfs4_fill_super;
        export_path = data->nfs_server.export_path;
        data->nfs_server.export_path = "/";
        root_mnt = nfs_do_root_mount(&nfs4_remote_fs_type, flags, mount_info,
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index e6fe3d69d14c..4d6861c0dc14 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -80,6 +80,7 @@ struct nfs_write_header *nfs_writehdr_alloc(void)
                INIT_LIST_HEAD(&hdr->rpc_list);
                spin_lock_init(&hdr->lock);
                atomic_set(&hdr->refcnt, 0);
+                hdr->verf = &p->verf;
        }
        return p;
 }
@@ -619,6 +620,7 @@ static void nfs_write_completion(struct nfs_pgio_header *hdr)
                        goto next;
                }
                if (test_bit(NFS_IOHDR_NEED_COMMIT, &hdr->flags)) {
+                        memcpy(&req->wb_verf, hdr->verf, sizeof(req->wb_verf));
                        nfs_mark_request_commit(req, hdr->lseg, &cinfo);
                        goto next;
                }
@@ -1255,15 +1257,14 @@ static void nfs_writeback_release_common(void *calldata)
        struct nfs_write_data   *data = calldata;
        struct nfs_pgio_header *hdr = data->header;
        int status = data->task.tk_status;
-        struct nfs_page *req = hdr->req;
        if ((status >= 0) && nfs_write_need_commit(data)) {
                spin_lock(&hdr->lock);
                if (test_bit(NFS_IOHDR_NEED_RESCHED, &hdr->flags))
                        ; /* Do nothing */
                else if (!test_and_set_bit(NFS_IOHDR_NEED_COMMIT, &hdr->flags))
-                        memcpy(&req->wb_verf, &data->verf, sizeof(req->wb_verf));
+                        memcpy(hdr->verf, &data->verf, sizeof(*hdr->verf));
-                else if (memcmp(&req->wb_verf, &data->verf, sizeof(req->wb_verf)))
+                else if (memcmp(hdr->verf, &data->verf, sizeof(*hdr->verf)))
                        set_bit(NFS_IOHDR_NEED_RESCHED, &hdr->flags);
                spin_unlock(&hdr->lock);
        }
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 8fdc9ec5c5d3..94effd5bc4a1 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -900,7 +900,7 @@ static void free_session(struct kref *kref)
        struct nfsd4_session *ses;
        int mem;
-        BUG_ON(!spin_is_locked(&client_lock));
+        lockdep_assert_held(&client_lock);
        ses = container_of(kref, struct nfsd4_session, se_ref);
        nfsd4_del_conns(ses);
        spin_lock(&nfsd_drc_lock);
@@ -1080,7 +1080,7 @@ static struct nfs4_client *alloc_client(struct xdr_netobj name)
 static inline void
 free_client(struct nfs4_client *clp)
 {
-        BUG_ON(!spin_is_locked(&client_lock));
+        lockdep_assert_held(&client_lock);
        while (!list_empty(&clp->cl_sessions)) {
                struct nfsd4_session *ses;
                ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index c8bd9c3be7f7..4700a0a929d7 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -745,7 +745,7 @@ __be32
 nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
                        int may_flags, struct file **filp)
 {
-        struct dentry   *dentry;
+        struct path     path;
        struct inode    *inode;
        int             flags = O_RDONLY|O_LARGEFILE;
        __be32          err;
@@ -762,8 +762,9 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
        if (err)
                goto out;
-        dentry = fhp->fh_dentry;
+        path.mnt = fhp->fh_export->ex_path.mnt;
-        inode = dentry->d_inode;
+        path.dentry = fhp->fh_dentry;
+        inode = path.dentry->d_inode;
        /* Disallow write access to files with the append-only bit set
         * or any access when mandatory locking enabled
@@ -792,8 +793,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
                else
                        flags = O_WRONLY|O_LARGEFILE;
        }
-        *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt),
+        *filp = dentry_open(&path, flags, current_cred());
-                            flags, current_cred());
        if (IS_ERR(*filp))
                host_err = PTR_ERR(*filp);
        else {
@@ -1329,7 +1329,7 @@ nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
        err = 0;
        switch (type) {
        case S_IFREG:
-                host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL);
+                host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
                if (!host_err)
                        nfsd_check_ignore_resizing(iap);
                break;
@@ -1492,7 +1492,7 @@ do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                goto out;
        }
-        host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL);
+        host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
        if (host_err < 0) {
                fh_drop_write(fhp);
                goto out_nfserr;
diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
index 08a07a218d26..57ceaf33d177 100644
--- a/fs/nilfs2/gcinode.c
+++ b/fs/nilfs2/gcinode.c
@@ -191,6 +191,8 @@ void nilfs_remove_all_gcinodes(struct the_nilfs *nilfs)
        while (!list_empty(head)) {
                ii = list_first_entry(head, struct nilfs_inode_info, i_dirty);
                list_del_init(&ii->i_dirty);
+                truncate_inode_pages(&ii->vfs_inode.i_data, 0);
+                nilfs_btnode_cache_clear(&ii->i_btnode_cache);
                iput(&ii->vfs_inode);
        }
 }
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index b72847988b78..1d0c0b84c5a3 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -63,7 +63,7 @@ static inline int nilfs_add_nondir(struct dentry *dentry, struct inode *inode)
 */
 static struct dentry *
-nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+nilfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode;
        ino_t ino;
@@ -85,7 +85,7 @@ nilfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 * with d_instantiate().
 */
 static int nilfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                        struct nameidata *nd)
+                        bool excl)
 {
        struct inode *inode;
        struct nilfs_transaction_info ti;
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 0e72ad6f22aa..88e11fb346b6 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -2309,6 +2309,8 @@ nilfs_remove_written_gcinodes(struct the_nilfs *nilfs, struct list_head *head)
                if (!test_bit(NILFS_I_UPDATED, &ii->i_state))
                        continue;
                list_del_init(&ii->i_dirty);
+                truncate_inode_pages(&ii->vfs_inode.i_data, 0);
+                nilfs_btnode_cache_clear(&ii->i_btnode_cache);
                iput(&ii->vfs_inode);
        }
 }
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 1099a76cee59..d57c42f974ea 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -1288,7 +1288,8 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
                err = -EBUSY;
                goto failed;
        }
-        s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, sd.bdev);
+        s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, flags,
+                 sd.bdev);
        mutex_unlock(&sd.bdev->bd_fsfreeze_mutex);
        if (IS_ERR(s)) {
                err = PTR_ERR(s);
@@ -1301,7 +1302,6 @@ nilfs_mount(struct file_system_type *fs_type, int flags,
                s_new = true;
                /* New superblock instance created */
-                s->s_flags = flags;
                s->s_mode = mode;
                strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
                sb_set_blocksize(s, block_size(sd.bdev));
diff --git a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
index 3568c8a8b138..d43803669739 100644
--- a/fs/notify/fanotify/fanotify_user.c
+++ b/fs/notify/fanotify/fanotify_user.c
@@ -61,8 +61,6 @@ static struct fsnotify_event *get_one_event(struct fsnotify_group *group,
 static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event)
 {
        int client_fd;
-        struct dentry *dentry;
-        struct vfsmount *mnt;
        struct file *new_file;
        pr_debug("%s: group=%p event=%p\n", __func__, group, event);
@@ -81,12 +79,10 @@ static int create_fd(struct fsnotify_group *group, struct fsnotify_event *event)
         * we need a new file handle for the userspace program so it can read even if it was
         * originally opened O_WRONLY.
         */
-        dentry = dget(event->path.dentry);
-        mnt = mntget(event->path.mnt);
        /* it's possible this event was an overflow event.  in that case dentry and mnt
         * are NULL;  That's fine, just don't call dentry open */
-        if (dentry && mnt)
+        if (event->path.dentry && event->path.mnt)
-                new_file = dentry_open(dentry, mnt,
+                new_file = dentry_open(&event->path,
                                       group->fanotify_data.f_flags | FMODE_NONOTIFY,
                                       current_cred());
        else
diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
index b39c5c161adb..6baadb5a8430 100644
--- a/fs/notify/fsnotify.c
+++ b/fs/notify/fsnotify.c
@@ -52,6 +52,7 @@ void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
 void __fsnotify_update_child_dentry_flags(struct inode *inode)
 {
        struct dentry *alias;
+        struct hlist_node *p;
        int watched;
        if (!S_ISDIR(inode->i_mode))
@@ -63,7 +64,7 @@ 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 */
-        list_for_each_entry(alias, &inode->i_dentry, d_alias) {
+        hlist_for_each_entry(alias, p, &inode->i_dentry, d_alias) {
                struct dentry *child;
                /* run all of the children of the original inode and fix their
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index 358273e59ade..436f36037e09 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -101,7 +101,7 @@
 * Locking: Caller must hold i_mutex on the directory.
 */
 static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
-                struct nameidata *nd)
+                unsigned int flags)
 {
        ntfs_volume *vol = NTFS_SB(dir_ino->i_sb);
        struct inode *dent_inode;
diff --git a/fs/ocfs2/dcache.c b/fs/ocfs2/dcache.c
index e5ba34818332..8db4b58b2e4b 100644
--- a/fs/ocfs2/dcache.c
+++ b/fs/ocfs2/dcache.c
@@ -49,14 +49,13 @@ void ocfs2_dentry_attach_gen(struct dentry *dentry)
 }
-static int ocfs2_dentry_revalidate(struct dentry *dentry,
+static int ocfs2_dentry_revalidate(struct dentry *dentry, unsigned int flags)
-                                   struct nameidata *nd)
 {
        struct inode *inode;
        int ret = 0;    /* if all else fails, just return false */
        struct ocfs2_super *osb;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = dentry->d_inode;
@@ -170,13 +169,11 @@ struct dentry *ocfs2_find_local_alias(struct inode *inode,
                                      u64 parent_blkno,
                                      int skip_unhashed)
 {
-        struct list_head *p;
+        struct hlist_node *p;
-        struct dentry *dentry = NULL;
+        struct dentry *dentry;
        spin_lock(&inode->i_lock);
-        list_for_each(p, &inode->i_dentry) {
+        hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
-                dentry = list_entry(p, struct dentry, 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,
@@ -184,16 +181,13 @@ struct dentry *ocfs2_find_local_alias(struct inode *inode,
                        dget_dlock(dentry);
                        spin_unlock(&dentry->d_lock);
-                        break;
+                        spin_unlock(&inode->i_lock);
+                        return dentry;
                }
                spin_unlock(&dentry->d_lock);
-                dentry = NULL;
        }
        spin_unlock(&inode->i_lock);
+        return NULL;
-        return dentry;
 }
 DEFINE_SPINLOCK(dentry_attach_lock);
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index e31d6ae013ab..83b6f98e0665 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -526,7 +526,7 @@ bail:
 static int dlmfs_create(struct inode *dir,
                        struct dentry *dentry,
                        umode_t mode,
-                        struct nameidata *nd)
+                        bool excl)
 {
        int status = 0;
        struct inode *inode;
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 81a4cd22f80b..4f7795fb5fc0 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -456,7 +456,7 @@ static void ocfs2_update_lock_stats(struct ocfs2_lock_res *res, int level,
        stats->ls_gets++;
        stats->ls_total += ktime_to_ns(kt);
        /* overflow */
-        if (unlikely(stats->ls_gets) == 0) {
+        if (unlikely(stats->ls_gets == 0)) {
                stats->ls_gets++;
                stats->ls_total = ktime_to_ns(kt);
        }
@@ -3932,6 +3932,8 @@ unqueue:
 static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
                                        struct ocfs2_lock_res *lockres)
 {
+        unsigned long flags;
        assert_spin_locked(&lockres->l_lock);
        if (lockres->l_flags & OCFS2_LOCK_FREEING) {
@@ -3945,21 +3947,22 @@ static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
        lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (list_empty(&lockres->l_blocked_list)) {
                list_add_tail(&lockres->l_blocked_list,
                              &osb->blocked_lock_list);
                osb->blocked_lock_count++;
        }
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
 }
 static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
 {
        unsigned long processed;
+        unsigned long flags;
        struct ocfs2_lock_res *lockres;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        /* grab this early so we know to try again if a state change and
         * wake happens part-way through our work  */
        osb->dc_work_sequence = osb->dc_wake_sequence;
@@ -3972,38 +3975,40 @@ static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
                                     struct ocfs2_lock_res, l_blocked_list);
                list_del_init(&lockres->l_blocked_list);
                osb->blocked_lock_count--;
-                spin_unlock(&osb->dc_task_lock);
+                spin_unlock_irqrestore(&osb->dc_task_lock, flags);
                BUG_ON(!processed);
                processed--;
                ocfs2_process_blocked_lock(osb, lockres);
-                spin_lock(&osb->dc_task_lock);
+                spin_lock_irqsave(&osb->dc_task_lock, flags);
        }
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
 }
 static int ocfs2_downconvert_thread_lists_empty(struct ocfs2_super *osb)
 {
        int empty = 0;
+        unsigned long flags;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (list_empty(&osb->blocked_lock_list))
                empty = 1;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        return empty;
 }
 static int ocfs2_downconvert_thread_should_wake(struct ocfs2_super *osb)
 {
        int should_wake = 0;
+        unsigned long flags;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (osb->dc_work_sequence != osb->dc_wake_sequence)
                should_wake = 1;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        return should_wake;
 }
@@ -4033,10 +4038,12 @@ static int ocfs2_downconvert_thread(void *arg)
 void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb)
 {
-        spin_lock(&osb->dc_task_lock);
+        unsigned long flags;
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        /* make sure the voting thread gets a swipe at whatever changes
         * the caller may have made to the voting state */
        osb->dc_wake_sequence++;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        wake_up(&osb->dc_event);
 }
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index 2f5b92ef0e53..70b5863a2d64 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -923,8 +923,6 @@ out_unlock:
        ocfs2_inode_unlock(inode, 0);
 out:
-        if (ret && ret != -ENXIO)
-                ret = -ENXIO;
        return ret;
 }
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 061591a3ab08..7602783d7f41 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1950,7 +1950,7 @@ static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
        if (ret < 0)
                mlog_errno(ret);
-        if (file->f_flags & O_SYNC)
+        if (file && (file->f_flags & O_SYNC))
                handle->h_sync = 1;
        ocfs2_commit_trans(osb, handle);
@@ -2422,8 +2422,10 @@ out_dio:
                unaligned_dio = 0;
        }
-        if (unaligned_dio)
+        if (unaligned_dio) {
+                ocfs2_iocb_clear_unaligned_aio(iocb);
                atomic_dec(&OCFS2_I(inode)->ip_unaligned_aio);
+        }
 out:
        if (rw_level != -1)
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 9f39c640cddf..f1fd0741162b 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -98,7 +98,7 @@ static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        int status;
        u64 blkno;
@@ -618,7 +618,7 @@ static int ocfs2_mkdir(struct inode *dir,
 static int ocfs2_create(struct inode *dir,
                        struct dentry *dentry,
                        umode_t mode,
-                        struct nameidata *nd)
+                        bool excl)
 {
        int ret;
diff --git a/fs/ocfs2/quota_global.c b/fs/ocfs2/quota_global.c
index 92fcd575775a..0a86e302655f 100644
--- a/fs/ocfs2/quota_global.c
+++ b/fs/ocfs2/quota_global.c
@@ -399,8 +399,6 @@ int ocfs2_global_read_info(struct super_block *sb, int type)
                              msecs_to_jiffies(oinfo->dqi_syncms));
 out_err:
-        if (status)
-                mlog_errno(status);
        return status;
 out_unlock:
        ocfs2_unlock_global_qf(oinfo, 0);
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index f00576ec320f..fb5b3ff79dc6 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -285,13 +285,13 @@ static int omfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 }
 static int omfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        return omfs_add_node(dir, dentry, mode | S_IFREG);
 }
 static struct dentry *omfs_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                  unsigned int flags)
 {
        struct buffer_head *bh;
        struct inode *inode = NULL;
diff --git a/fs/open.c b/fs/open.c
index d6c79a0dffc7..1e914b397e12 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -397,10 +397,10 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 {
        struct file *file;
        struct inode *inode;
-        int error;
+        int error, fput_needed;
        error = -EBADF;
-        file = fget(fd);
+        file = fget_raw_light(fd, &fput_needed);
        if (!file)
                goto out;
@@ -414,7 +414,7 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
        if (!error)
                set_fs_pwd(current->fs, &file->f_path);
 out_putf:
-        fput(file);
+        fput_light(file, fput_needed);
 out:
        return error;
 }
@@ -537,25 +537,6 @@ static int chown_common(struct path *path, uid_t user, gid_t group)
        return error;
 }
-SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
-{
-        struct path path;
-        int error;
-        error = user_path(filename, &path);
-        if (error)
-                goto out;
-        error = mnt_want_write(path.mnt);
-        if (error)
-                goto out_release;
-        error = chown_common(&path, user, group);
-        mnt_drop_write(path.mnt);
-out_release:
-        path_put(&path);
-out:
-        return error;
-}
 SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
                gid_t, group, int, flag)
 {
@@ -583,23 +564,15 @@ out:
        return error;
 }
-SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
+SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
 {
-        struct path path;
+        return sys_fchownat(AT_FDCWD, filename, user, group, 0);
-        int error;
+}
-        error = user_lpath(filename, &path);
+SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
-        if (error)
+{
-                goto out;
+        return sys_fchownat(AT_FDCWD, filename, user, group,
-        error = mnt_want_write(path.mnt);
+                            AT_SYMLINK_NOFOLLOW);
-        if (error)
-                goto out_release;
-        error = chown_common(&path, user, group);
-        mnt_drop_write(path.mnt);
-out_release:
-        path_put(&path);
-out:
-        return error;
 }
 SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
@@ -667,10 +640,9 @@ int open_check_o_direct(struct file *f)
        return 0;
 }
-static struct file *do_dentry_open(struct dentry *dentry, struct vfsmount *mnt,
+static int do_dentry_open(struct file *f,
-                                   struct file *f,
+                          int (*open)(struct inode *, struct file *),
-                                   int (*open)(struct inode *, struct file *),
+                          const struct cred *cred)
-                                   const struct cred *cred)
 {
        static const struct file_operations empty_fops = {};
        struct inode *inode;
@@ -682,9 +654,9 @@ static struct file *do_dentry_open(struct dentry *dentry, struct vfsmount *mnt,
        if (unlikely(f->f_flags & O_PATH))
                f->f_mode = FMODE_PATH;
-        inode = dentry->d_inode;
+        inode = f->f_path.dentry->d_inode;
        if (f->f_mode & FMODE_WRITE) {
-                error = __get_file_write_access(inode, mnt);
+                error = __get_file_write_access(inode, f->f_path.mnt);
                if (error)
                        goto cleanup_file;
                if (!special_file(inode->i_mode))
@@ -692,14 +664,12 @@ static struct file *do_dentry_open(struct dentry *dentry, struct vfsmount *mnt,
        }
        f->f_mapping = inode->i_mapping;
-        f->f_path.dentry = dentry;
-        f->f_path.mnt = mnt;
        f->f_pos = 0;
        file_sb_list_add(f, inode->i_sb);
        if (unlikely(f->f_mode & FMODE_PATH)) {
                f->f_op = &empty_fops;
-                return f;
+                return 0;
        }
        f->f_op = fops_get(inode->i_fop);
@@ -726,10 +696,11 @@ static struct file *do_dentry_open(struct dentry *dentry, struct vfsmount *mnt,
        file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);
-        return f;
+        return 0;
 cleanup_all:
        fops_put(f->f_op);
+        file_sb_list_del(f);
        if (f->f_mode & FMODE_WRITE) {
                put_write_access(inode);
                if (!special_file(inode->i_mode)) {
@@ -740,124 +711,62 @@ cleanup_all:
                         * here, so just reset the state.
                         */
                        file_reset_write(f);
-                        mnt_drop_write(mnt);
+                        mnt_drop_write(f->f_path.mnt);
                }
        }
-        file_sb_list_del(f);
-        f->f_path.dentry = NULL;
-        f->f_path.mnt = NULL;
 cleanup_file:
-        dput(dentry);
+        path_put(&f->f_path);
-        mntput(mnt);
+        f->f_path.mnt = NULL;
-        return ERR_PTR(error);
+        f->f_path.dentry = NULL;
-}
+        return error;
-static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
-                                struct file *f,
-                                int (*open)(struct inode *, struct file *),
-                                const struct cred *cred)
-{
-        struct file *res = do_dentry_open(dentry, mnt, f, open, cred);
-        if (!IS_ERR(res)) {
-                int error = open_check_o_direct(f);
-                if (error) {
-                        fput(res);
-                        res = ERR_PTR(error);
-                }
-        } else {
-                put_filp(f);
-        }
-        return res;
 }
 /**
- * lookup_instantiate_filp - instantiates the open intent filp
+ * finish_open - finish opening a file
- * @nd: pointer to nameidata
+ * @od: opaque open data
 * @dentry: pointer to dentry
 * @open: open callback
 *
- * Helper for filesystems that want to use lookup open intents and pass back
+ * This can be used to finish opening a file passed to i_op->atomic_open().
- * a fully instantiated struct file to the caller.
+ *
- * This function is meant to be called from within a filesystem's
- * lookup method.
- * Beware of calling it for non-regular files! Those ->open methods might block
- * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
- * leading to a deadlock, as nobody can open that fifo anymore, because
- * another process to open fifo will block on locked parent when doing lookup).
- * Note that in case of error, nd->intent.open.file is destroyed, but the
- * path information remains valid.
 * If the open callback is set to NULL, then the standard f_op->open()
 * filesystem callback is substituted.
 */
-struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
+int finish_open(struct file *file, struct dentry *dentry,
-                int (*open)(struct inode *, struct file *))
+                int (*open)(struct inode *, struct file *),
+                int *opened)
 {
-        const struct cred *cred = current_cred();
+        int error;
+        BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
-        if (IS_ERR(nd->intent.open.file))
+        mntget(file->f_path.mnt);
-                goto out;
+        file->f_path.dentry = dget(dentry);
-        if (IS_ERR(dentry))
-                goto out_err;
+        error = do_dentry_open(file, open, current_cred());
-        nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt),
+        if (!error)
-                                             nd->intent.open.file,
+                *opened |= FILE_OPENED;
-                                             open, cred);
-out:
+        return error;
-        return nd->intent.open.file;
-out_err:
-        release_open_intent(nd);
-        nd->intent.open.file = ERR_CAST(dentry);
-        goto out;
 }
-EXPORT_SYMBOL_GPL(lookup_instantiate_filp);
+EXPORT_SYMBOL(finish_open);
 /**
- * nameidata_to_filp - convert a nameidata to an open filp.
+ * finish_no_open - finish ->atomic_open() without opening the file
- * @nd: pointer to nameidata
+ *
- * @flags: open flags
+ * @od: opaque open data
+ * @dentry: dentry or NULL (as returned from ->lookup())
 *
- * Note that this function destroys the original nameidata
+ * This can be used to set the result of a successful lookup in ->atomic_open().
+ * The filesystem's atomic_open() method shall return NULL after calling this.
 */
-struct file *nameidata_to_filp(struct nameidata *nd)
+int finish_no_open(struct file *file, struct dentry *dentry)
 {
-        const struct cred *cred = current_cred();
+        file->f_path.dentry = dentry;
-        struct file *filp;
+        return 1;
-        /* Pick up the filp from the open intent */
-        filp = nd->intent.open.file;
-        /* Has the filesystem initialised the file for us? */
-        if (filp->f_path.dentry != NULL) {
-                nd->intent.open.file = NULL;
-        } else {
-                struct file *res;
-                path_get(&nd->path);
-                res = do_dentry_open(nd->path.dentry, nd->path.mnt,
-                                     filp, NULL, cred);
-                if (!IS_ERR(res)) {
-                        int error;
-                        nd->intent.open.file = NULL;
-                        BUG_ON(res != filp);
-                        error = open_check_o_direct(filp);
-                        if (error) {
-                                fput(filp);
-                                filp = ERR_PTR(error);
-                        }
-                } else {
-                        /* Allow nd->intent.open.file to be recycled */
-                        filp = res;
-                }
-        }
-        return filp;
 }
+EXPORT_SYMBOL(finish_no_open);
-/*
+struct file *dentry_open(const struct path *path, int flags,
- * dentry_open() will have done dput(dentry) and mntput(mnt) if it returns an
- * error.
- */
-struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
                         const struct cred *cred)
 {
        int error;
@@ -866,18 +775,28 @@ struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
        validate_creds(cred);
        /* We must always pass in a valid mount pointer. */
-        BUG_ON(!mnt);
+        BUG_ON(!path->mnt);
        error = -ENFILE;
        f = get_empty_filp();
-        if (f == NULL) {
+        if (f == NULL)
-                dput(dentry);
-                mntput(mnt);
                return ERR_PTR(error);
-        }
        f->f_flags = flags;
-        return __dentry_open(dentry, mnt, f, NULL, cred);
+        f->f_path = *path;
+        path_get(&f->f_path);
+        error = do_dentry_open(f, NULL, cred);
+        if (!error) {
+                error = open_check_o_direct(f);
+                if (error) {
+                        fput(f);
+                        f = ERR_PTR(error);
+                }
+        } else { 
+                put_filp(f);
+                f = ERR_PTR(error);
+        }
+        return f;
 }
 EXPORT_SYMBOL(dentry_open);
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index bc49c975d501..4a3477949bca 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -170,13 +170,13 @@ static const struct file_operations openprom_operations = {
        .llseek         = generic_file_llseek,
 };
-static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, struct nameidata *);
+static struct dentry *openpromfs_lookup(struct inode *, struct dentry *, unsigned int);
 static const struct inode_operations openprom_inode_operations = {
        .lookup         = openpromfs_lookup,
 };
-static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *openpromfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        struct op_inode_info *ent_oi, *oi = OP_I(dir);
        struct device_node *dp, *child;
diff --git a/fs/pnode.c b/fs/pnode.c
index bed378db0758..3e000a51ac0d 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -237,8 +237,9 @@ int propagate_mnt(struct mount *dest_mnt, struct dentry *dest_dentry,
                source =  get_source(m, prev_dest_mnt, prev_src_mnt, &type);
-                if (!(child = copy_tree(source, source->mnt.mnt_root, type))) {
+                child = copy_tree(source, source->mnt.mnt_root, type);
-                        ret = -ENOMEM;
+                if (IS_ERR(child)) {
+                        ret = PTR_ERR(child);
                        list_splice(tree_list, tmp_list.prev);
                        goto out;
                }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 437195f204e1..2772208338f8 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1427,16 +1427,19 @@ static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
        struct inode *inode = dentry->d_inode;
+        struct path path;
        int error = -EACCES;
-        /* We don't need a base pointer in the /proc filesystem */
-        path_put(&nd->path);
        /* Are we allowed to snoop on the tasks file descriptors? */
        if (!proc_fd_access_allowed(inode))
                goto out;
-        error = PROC_I(inode)->op.proc_get_link(dentry, &nd->path);
+        error = PROC_I(inode)->op.proc_get_link(dentry, &path);
+        if (error)
+                goto out;
+        nd_jump_link(nd, &path);
+        return NULL;
 out:
        return ERR_PTR(error);
 }
@@ -1601,13 +1604,13 @@ int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 * made this apply to all per process world readable and executable
 * directories.
 */
-int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
+int pid_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode;
        struct task_struct *task;
        const struct cred *cred;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = dentry->d_inode;
@@ -1781,7 +1784,7 @@ static int proc_fd_link(struct dentry *dentry, struct path *path)
        return proc_fd_info(dentry->d_inode, path, NULL);
 }
-static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct inode *inode;
        struct task_struct *task;
@@ -1789,7 +1792,7 @@ static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
        struct files_struct *files;
        const struct cred *cred;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        inode = dentry->d_inode;
@@ -1868,7 +1871,7 @@ static struct dentry *proc_fd_instantiate(struct inode *dir,
        d_set_d_op(dentry, &tid_fd_dentry_operations);
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (tid_fd_revalidate(dentry, NULL))
+        if (tid_fd_revalidate(dentry, 0))
                error = NULL;
 out:
@@ -1956,7 +1959,7 @@ out_no_task:
 }
 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
-                                    struct nameidata *nd)
+                                    unsigned int flags)
 {
        return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
 }
@@ -2003,7 +2006,7 @@ static int dname_to_vma_addr(struct dentry *dentry,
        return 0;
 }
-static int map_files_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
 {
        unsigned long vm_start, vm_end;
        bool exact_vma_exists = false;
@@ -2013,7 +2016,7 @@ static int map_files_d_revalidate(struct dentry *dentry, struct nameidata *nd)
        struct inode *inode;
        int status = 0;
-        if (nd && nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        if (!capable(CAP_SYS_ADMIN)) {
@@ -2145,7 +2148,7 @@ proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
 }
 static struct dentry *proc_map_files_lookup(struct inode *dir,
-                struct dentry *dentry, struct nameidata *nd)
+                struct dentry *dentry, unsigned int flags)
 {
        unsigned long vm_start, vm_end;
        struct vm_area_struct *vma;
@@ -2371,7 +2374,7 @@ static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
        d_set_d_op(dentry, &tid_fd_dentry_operations);
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (tid_fd_revalidate(dentry, NULL))
+        if (tid_fd_revalidate(dentry, 0))
                error = NULL;
 out:
@@ -2380,7 +2383,7 @@ static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
 static struct dentry *proc_lookupfdinfo(struct inode *dir,
                                        struct dentry *dentry,
-                                        struct nameidata *nd)
+                                        unsigned int flags)
 {
        return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
 }
@@ -2430,7 +2433,7 @@ static struct dentry *proc_pident_instantiate(struct inode *dir,
        d_set_d_op(dentry, &pid_dentry_operations);
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (pid_revalidate(dentry, NULL))
+        if (pid_revalidate(dentry, 0))
                error = NULL;
 out:
        return error;
@@ -2630,7 +2633,7 @@ static const struct file_operations proc_attr_dir_operations = {
 };
 static struct dentry *proc_attr_dir_lookup(struct inode *dir,
-                                struct dentry *dentry, struct nameidata *nd)
+                                struct dentry *dentry, unsigned int flags)
 {
        return proc_pident_lookup(dir, dentry,
                                  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
@@ -3114,7 +3117,8 @@ static const struct file_operations proc_tgid_base_operations = {
        .llseek         = default_llseek,
 };
-static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
+static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
+{
        return proc_pident_lookup(dir, dentry,
                                  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
 }
@@ -3237,13 +3241,13 @@ static struct dentry *proc_pid_instantiate(struct inode *dir,
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (pid_revalidate(dentry, NULL))
+        if (pid_revalidate(dentry, 0))
                error = NULL;
 out:
        return error;
 }
-struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
+struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
 {
        struct dentry *result;
        struct task_struct *task;
@@ -3470,7 +3474,8 @@ static int proc_tid_base_readdir(struct file * filp,
                                   tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
 }
-static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
+static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
+{
        return proc_pident_lookup(dir, dentry,
                                  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
 }
@@ -3508,13 +3513,13 @@ static struct dentry *proc_task_instantiate(struct inode *dir,
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (pid_revalidate(dentry, NULL))
+        if (pid_revalidate(dentry, 0))
                error = NULL;
 out:
        return error;
 }
-static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
+static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
 {
        struct dentry *result = ERR_PTR(-ENOENT);
        struct task_struct *task;
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 2edf34f2eb61..b3647fe6a608 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -446,7 +446,7 @@ out_unlock:
 }
 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
-                struct nameidata *nd)
+                unsigned int flags)
 {
        return proc_lookup_de(PDE(dir), dir, dentry);
 }
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index eca4aca5b6e2..e1167a1c9126 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -106,7 +106,7 @@ void pde_users_dec(struct proc_dir_entry *pde);
 extern spinlock_t proc_subdir_lock;
-struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *);
+struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int);
 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir);
 unsigned long task_vsize(struct mm_struct *);
 unsigned long task_statm(struct mm_struct *,
@@ -132,7 +132,7 @@ int proc_remount(struct super_block *sb, int *flags, char *data);
 * of the /proc/<pid> subdirectories.
 */
 int proc_readdir(struct file *, void *, filldir_t);
-struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);
+struct dentry *proc_lookup(struct inode *, struct dentry *, unsigned int);
@@ -142,7 +142,7 @@ typedef struct dentry *instantiate_t(struct inode *, struct dentry *,
 int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
        const char *name, int len,
        instantiate_t instantiate, struct task_struct *task, const void *ptr);
-int pid_revalidate(struct dentry *dentry, struct nameidata *nd);
+int pid_revalidate(struct dentry *dentry, unsigned int flags);
 struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task);
 extern const struct dentry_operations pid_dentry_operations;
 int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
diff --git a/fs/proc/namespaces.c b/fs/proc/namespaces.c
index 0d9e23a39e49..b178ed733c36 100644
--- a/fs/proc/namespaces.c
+++ b/fs/proc/namespaces.c
@@ -56,7 +56,7 @@ static struct dentry *proc_ns_instantiate(struct inode *dir,
        d_set_d_op(dentry, &pid_dentry_operations);
        d_add(dentry, inode);
        /* Close the race of the process dying before we return the dentry */
-        if (pid_revalidate(dentry, NULL))
+        if (pid_revalidate(dentry, 0))
                error = NULL;
 out:
        return error;
@@ -140,7 +140,7 @@ const struct file_operations proc_ns_dir_operations = {
 };
 static struct dentry *proc_ns_dir_lookup(struct inode *dir,
-                                struct dentry *dentry, struct nameidata *nd)
+                                struct dentry *dentry, unsigned int flags)
 {
        struct dentry *error;
        struct task_struct *task = get_proc_task(dir);
diff --git a/fs/proc/proc_devtree.c b/fs/proc/proc_devtree.c
index 927cbd115e53..df7dd08d4391 100644
--- a/fs/proc/proc_devtree.c
+++ b/fs/proc/proc_devtree.c
@@ -101,6 +101,11 @@ void proc_device_tree_update_prop(struct proc_dir_entry *pde,
 {
        struct proc_dir_entry *ent;
+        if (!oldprop) {
+                proc_device_tree_add_prop(pde, newprop);
+                return;
+        }
        for (ent = pde->subdir; ent != NULL; ent = ent->next)
                if (ent->data == oldprop)
                        break;
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 06e1cc17caf6..fe72cd073dea 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -119,7 +119,7 @@ static struct net *get_proc_task_net(struct inode *dir)
 }
 static struct dentry *proc_tgid_net_lookup(struct inode *dir,
-                struct dentry *dentry, struct nameidata *nd)
+                struct dentry *dentry, unsigned int flags)
 {
        struct dentry *de;
        struct net *net;
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 3476bca8f7af..dfafeb2b05a0 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -433,7 +433,7 @@ static struct ctl_table_header *grab_header(struct inode *inode)
 }
 static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
-                                        struct nameidata *nd)
+                                        unsigned int flags)
 {
        struct ctl_table_header *head = grab_header(dir);
        struct ctl_table_header *h = NULL;
@@ -794,9 +794,9 @@ static const struct inode_operations proc_sys_dir_operations = {
        .getattr        = proc_sys_getattr,
 };
-static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
 {
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        return !PROC_I(dentry->d_inode)->sysctl->unregistering;
 }
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 7c30fce037c0..9a2d9fd7cadd 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -111,7 +111,7 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
                options = data;
        }
-        sb = sget(fs_type, proc_test_super, proc_set_super, ns);
+        sb = sget(fs_type, proc_test_super, proc_set_super, flags, ns);
        if (IS_ERR(sb))
                return ERR_CAST(sb);
@@ -121,7 +121,6 @@ static struct dentry *proc_mount(struct file_system_type *fs_type,
        }
        if (!sb->s_root) {
-                sb->s_flags = flags;
                err = proc_fill_super(sb);
                if (err) {
                        deactivate_locked_super(sb);
@@ -200,13 +199,12 @@ static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct
        return 0;
 }
-static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags)
 {
-        if (!proc_lookup(dir, dentry, nd)) {
+        if (!proc_lookup(dir, dentry, flags))
                return NULL;
-        }
        
-        return proc_pid_lookup(dir, dentry, nd);
+        return proc_pid_lookup(dir, dentry, flags);
 }
 static int proc_root_readdir(struct file * filp,
diff --git a/fs/proc_namespace.c b/fs/proc_namespace.c
index 5e289a7cbad1..5fe34c355e85 100644
--- a/fs/proc_namespace.c
+++ b/fs/proc_namespace.c
@@ -17,7 +17,7 @@
 static unsigned mounts_poll(struct file *file, poll_table *wait)
 {
-        struct proc_mounts *p = file->private_data;
+        struct proc_mounts *p = proc_mounts(file->private_data);
        struct mnt_namespace *ns = p->ns;
        unsigned res = POLLIN | POLLRDNORM;
@@ -121,7 +121,7 @@ out:
 static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt)
 {
-        struct proc_mounts *p = m->private;
+        struct proc_mounts *p = proc_mounts(m);
        struct mount *r = real_mount(mnt);
        struct super_block *sb = mnt->mnt_sb;
        struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt };
@@ -268,7 +268,6 @@ static int mounts_open_common(struct inode *inode, struct file *file,
        if (ret)
                goto err_free;
-        p->m.private = p;
        p->ns = ns;
        p->root = root;
        p->m.poll_event = ns->event;
@@ -288,7 +287,7 @@ static int mounts_open_common(struct inode *inode, struct file *file,
 static int mounts_release(struct inode *inode, struct file *file)
 {
-        struct proc_mounts *p = file->private_data;
+        struct proc_mounts *p = proc_mounts(file->private_data);
        path_put(&p->root);
        put_mnt_ns(p->ns);
        return seq_release(inode, file);
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index aeb19e68e086..11a2aa2a56c4 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -258,7 +258,7 @@ fail:
        return rc;
 }
-int pstore_fill_super(struct super_block *sb, void *data, int silent)
+static int pstore_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct inode *inode;
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 82c585f715e3..03ce7a9b81cc 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -94,20 +94,15 @@ static const char *get_reason_str(enum kmsg_dump_reason reason)
 * as we can from the end of the buffer.
 */
 static void pstore_dump(struct kmsg_dumper *dumper,
-            enum kmsg_dump_reason reason,
+                        enum kmsg_dump_reason reason)
-            const char *s1, unsigned long l1,
-            const char *s2, unsigned long l2)
 {
-        unsigned long   s1_start, s2_start;
+        unsigned long   total = 0;
-        unsigned long   l1_cpy, l2_cpy;
-        unsigned long   size, total = 0;
-        char            *dst;
        const char      *why;
        u64             id;
-        int             hsize, ret;
        unsigned int    part = 1;
        unsigned long   flags = 0;
        int             is_locked = 0;
+        int             ret;
        why = get_reason_str(reason);
@@ -119,30 +114,25 @@ static void pstore_dump(struct kmsg_dumper *dumper,
                spin_lock_irqsave(&psinfo->buf_lock, flags);
        oopscount++;
        while (total < kmsg_bytes) {
+                char *dst;
+                unsigned long size;
+                int hsize;
+                size_t len;
                dst = psinfo->buf;
                hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part);
                size = psinfo->bufsize - hsize;
                dst += hsize;
-                l2_cpy = min(l2, size);
+                if (!kmsg_dump_get_buffer(dumper, true, dst, size, &len))
-                l1_cpy = min(l1, size - l2_cpy);
-                if (l1_cpy + l2_cpy == 0)
                        break;
-                s2_start = l2 - l2_cpy;
-                s1_start = l1 - l1_cpy;
-                memcpy(dst, s1 + s1_start, l1_cpy);
-                memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
                ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part,
-                                   hsize + l1_cpy + l2_cpy, psinfo);
+                                    hsize + len, psinfo);
                if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted())
                        pstore_new_entry = 1;
-                l1 -= l1_cpy;
-                l2 -= l2_cpy;
+                total += hsize + len;
-                total += l1_cpy + l2_cpy;
                part++;
        }
        if (in_nmi()) {
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 9123cce28c1e..453030f9c5bc 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -106,6 +106,8 @@ static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
        time->tv_sec = 0;
        time->tv_nsec = 0;
+        /* Update old/shadowed buffer. */
+        persistent_ram_save_old(prz);
        size = persistent_ram_old_size(prz);
        *buf = kmalloc(size, GFP_KERNEL);
        if (*buf == NULL)
@@ -184,6 +186,7 @@ static int ramoops_pstore_erase(enum pstore_type_id type, u64 id,
                return -EINVAL;
        persistent_ram_free_old(cxt->przs[id]);
+        persistent_ram_zap(cxt->przs[id]);
        return 0;
 }
diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c
index 31f8d184f3a0..c5fbdbbf81ac 100644
--- a/fs/pstore/ram_core.c
+++ b/fs/pstore/ram_core.c
@@ -250,23 +250,24 @@ static void notrace persistent_ram_update(struct persistent_ram_zone *prz,
        persistent_ram_update_ecc(prz, start, count);
 }
-static void __init
+void persistent_ram_save_old(struct persistent_ram_zone *prz)
-persistent_ram_save_old(struct persistent_ram_zone *prz)
 {
        struct persistent_ram_buffer *buffer = prz->buffer;
        size_t size = buffer_size(prz);
        size_t start = buffer_start(prz);
-        char *dest;
-        persistent_ram_ecc_old(prz);
+        if (!size)
+                return;
-        dest = kmalloc(size, GFP_KERNEL);
+        if (!prz->old_log) {
-        if (dest == NULL) {
+                persistent_ram_ecc_old(prz);
+                prz->old_log = kmalloc(size, GFP_KERNEL);
+        }
+        if (!prz->old_log) {
                pr_err("persistent_ram: failed to allocate buffer\n");
                return;
        }
-        prz->old_log = dest;
        prz->old_log_size = size;
        memcpy(prz->old_log, &buffer->data[start], size - start);
        memcpy(prz->old_log + size - start, &buffer->data[0], start);
@@ -319,6 +320,13 @@ void persistent_ram_free_old(struct persistent_ram_zone *prz)
        prz->old_log_size = 0;
 }
+void persistent_ram_zap(struct persistent_ram_zone *prz)
+{
+        atomic_set(&prz->buffer->start, 0);
+        atomic_set(&prz->buffer->size, 0);
+        persistent_ram_update_header_ecc(prz);
+}
 static void *persistent_ram_vmap(phys_addr_t start, size_t size)
 {
        struct page **pages;
@@ -405,6 +413,7 @@ static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool
                                " size %zu, start %zu\n",
                               buffer_size(prz), buffer_start(prz));
                        persistent_ram_save_old(prz);
+                        return 0;
                }
        } else {
                pr_info("persistent_ram: no valid data in buffer"
@@ -412,8 +421,7 @@ static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool
        }
        prz->buffer->sig = PERSISTENT_RAM_SIG;
-        atomic_set(&prz->buffer->start, 0);
+        persistent_ram_zap(prz);
-        atomic_set(&prz->buffer->size, 0);
        return 0;
 }
@@ -448,7 +456,6 @@ struct persistent_ram_zone * __init persistent_ram_new(phys_addr_t start,
                goto err;
        persistent_ram_post_init(prz, ecc);
-        persistent_ram_update_header_ecc(prz);
        return prz;
 err:
diff --git a/fs/qnx4/namei.c b/fs/qnx4/namei.c
index a512c0b30e8e..d024505ba007 100644
--- a/fs/qnx4/namei.c
+++ b/fs/qnx4/namei.c
@@ -95,7 +95,7 @@ static struct buffer_head *qnx4_find_entry(int len, struct inode *dir,
        return NULL;
 }
-struct dentry * qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry * qnx4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
        int ino;
        struct qnx4_inode_entry *de;
diff --git a/fs/qnx4/qnx4.h b/fs/qnx4/qnx4.h
index 244d4620189b..34e2d329c97e 100644
--- a/fs/qnx4/qnx4.h
+++ b/fs/qnx4/qnx4.h
@@ -23,7 +23,7 @@ struct qnx4_inode_info {
 };
 extern struct inode *qnx4_iget(struct super_block *, unsigned long);
-extern struct dentry *qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd);
+extern struct dentry *qnx4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags);
 extern unsigned long qnx4_count_free_blocks(struct super_block *sb);
 extern unsigned long qnx4_block_map(struct inode *inode, long iblock);
diff --git a/fs/qnx6/inode.c b/fs/qnx6/inode.c
index e44012dc5645..2049c814bda4 100644
--- a/fs/qnx6/inode.c
+++ b/fs/qnx6/inode.c
@@ -622,7 +622,6 @@ static struct inode *qnx6_alloc_inode(struct super_block *sb)
 static void qnx6_i_callback(struct rcu_head *head)
 {
        struct inode *inode = container_of(head, struct inode, i_rcu);
-        INIT_LIST_HEAD(&inode->i_dentry);
        kmem_cache_free(qnx6_inode_cachep, QNX6_I(inode));
 }
diff --git a/fs/qnx6/namei.c b/fs/qnx6/namei.c
index 8a97289e04ad..0561326a94f5 100644
--- a/fs/qnx6/namei.c
+++ b/fs/qnx6/namei.c
@@ -13,7 +13,7 @@
 #include "qnx6.h"
 struct dentry *qnx6_lookup(struct inode *dir, struct dentry *dentry,
-                                struct nameidata *nd)
+                                unsigned int flags)
 {
        unsigned ino;
        struct page *page;
diff --git a/fs/qnx6/qnx6.h b/fs/qnx6/qnx6.h
index 6c5e02a0b6a8..b00fcc960d37 100644
--- a/fs/qnx6/qnx6.h
+++ b/fs/qnx6/qnx6.h
@@ -45,7 +45,7 @@ struct qnx6_inode_info {
 extern struct inode *qnx6_iget(struct super_block *sb, unsigned ino);
 extern struct dentry *qnx6_lookup(struct inode *dir, struct dentry *dentry,
-                                        struct nameidata *nd);
+                                        unsigned int flags);
 #ifdef CONFIG_QNX6FS_DEBUG
 extern void qnx6_superblock_debug(struct qnx6_super_block *,
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index 10cbe841cb7e..36a29b753c79 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -78,7 +78,7 @@
 #include <linux/quotaops.h>
 #include "../internal.h" /* ugh */
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 /*
 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
@@ -595,12 +595,14 @@ out:
 }
 EXPORT_SYMBOL(dquot_scan_active);
-int dquot_quota_sync(struct super_block *sb, int type, int wait)
+/* Write all dquot structures to quota files */
+int dquot_writeback_dquots(struct super_block *sb, int type)
 {
        struct list_head *dirty;
        struct dquot *dquot;
        struct quota_info *dqopt = sb_dqopt(sb);
        int cnt;
+        int err, ret = 0;
        mutex_lock(&dqopt->dqonoff_mutex);
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
@@ -624,7 +626,9 @@ int dquot_quota_sync(struct super_block *sb, int type, int wait)
                        atomic_inc(&dquot->dq_count);
                        spin_unlock(&dq_list_lock);
                        dqstats_inc(DQST_LOOKUPS);
-                        sb->dq_op->write_dquot(dquot);
+                        err = sb->dq_op->write_dquot(dquot);
+                        if (!ret && err)
+                                err = ret;
                        dqput(dquot);
                        spin_lock(&dq_list_lock);
                }
@@ -638,7 +642,21 @@ int dquot_quota_sync(struct super_block *sb, int type, int wait)
        dqstats_inc(DQST_SYNCS);
        mutex_unlock(&dqopt->dqonoff_mutex);
-        if (!wait || (dqopt->flags & DQUOT_QUOTA_SYS_FILE))
+        return ret;
+}
+EXPORT_SYMBOL(dquot_writeback_dquots);
+/* Write all dquot structures to disk and make them visible from userspace */
+int dquot_quota_sync(struct super_block *sb, int type)
+{
+        struct quota_info *dqopt = sb_dqopt(sb);
+        int cnt;
+        int ret;
+        ret = dquot_writeback_dquots(sb, type);
+        if (ret)
+                return ret;
+        if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
                return 0;
        /* This is not very clever (and fast) but currently I don't know about
diff --git a/fs/quota/quota.c b/fs/quota/quota.c
index 9a391204ca27..6f155788cbc6 100644
--- a/fs/quota/quota.c
+++ b/fs/quota/quota.c
@@ -9,7 +9,7 @@
 #include <linux/namei.h>
 #include <linux/slab.h>
 #include <asm/current.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/kernel.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
@@ -47,7 +47,7 @@ static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
 static void quota_sync_one(struct super_block *sb, void *arg)
 {
        if (sb->s_qcop && sb->s_qcop->quota_sync)
-                sb->s_qcop->quota_sync(sb, *(int *)arg, 1);
+                sb->s_qcop->quota_sync(sb, *(int *)arg);
 }
 static int quota_sync_all(int type)
@@ -270,7 +270,7 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
        case Q_SYNC:
                if (!sb->s_qcop->quota_sync)
                        return -ENOSYS;
-                return sb->s_qcop->quota_sync(sb, type, 1);
+                return sb->s_qcop->quota_sync(sb, type);
        case Q_XQUOTAON:
        case Q_XQUOTAOFF:
        case Q_XQUOTARM:
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index fbb0b478a346..d5378d028589 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -110,6 +110,7 @@ int ramfs_nommu_expand_for_mapping(struct inode *inode, size_t newsize)
                /* prevent the page from being discarded on memory pressure */
                SetPageDirty(page);
+                SetPageUptodate(page);
                unlock_page(page);
                put_page(page);
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index a1fdabe21dec..eab8c09d3801 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -114,7 +114,7 @@ static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
        return retval;
 }
-static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
+static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
 {
        return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
 }
diff --git a/fs/read_write.c b/fs/read_write.c
index c20614f86c01..1adfb691e4f1 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -55,10 +55,11 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
 * @file:       file structure to seek on
 * @offset:     file offset to seek to
 * @origin:     type of seek
- * @size:       max size of file system
+ * @size:       max size of this file in file system
+ * @eof:        offset used for SEEK_END position
 *
 * This is a variant of generic_file_llseek that allows passing in a custom
- * file size.
+ * maximum file size and a custom EOF position, for e.g. hashed directories
 *
 * Synchronization:
 * SEEK_SET and SEEK_END are unsynchronized (but atomic on 64bit platforms)
@@ -67,13 +68,13 @@ static loff_t lseek_execute(struct file *file, struct inode *inode,
 */
 loff_t
 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
-                loff_t maxsize)
+                loff_t maxsize, loff_t eof)
 {
        struct inode *inode = file->f_mapping->host;
        switch (origin) {
        case SEEK_END:
-                offset += i_size_read(inode);
+                offset += eof;
                break;
        case SEEK_CUR:
                /*
@@ -99,7 +100,7 @@ generic_file_llseek_size(struct file *file, loff_t offset, int origin,
                 * In the generic case the entire file is data, so as long as
                 * offset isn't at the end of the file then the offset is data.
                 */
-                if (offset >= i_size_read(inode))
+                if (offset >= eof)
                        return -ENXIO;
                break;
        case SEEK_HOLE:
@@ -107,9 +108,9 @@ generic_file_llseek_size(struct file *file, loff_t offset, int origin,
                 * There is a virtual hole at the end of the file, so as long as
                 * offset isn't i_size or larger, return i_size.
                 */
-                if (offset >= i_size_read(inode))
+                if (offset >= eof)
                        return -ENXIO;
-                offset = i_size_read(inode);
+                offset = eof;
                break;
        }
@@ -132,7 +133,8 @@ loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
        struct inode *inode = file->f_mapping->host;
        return generic_file_llseek_size(file, offset, origin,
-                                        inode->i_sb->s_maxbytes);
+                                        inode->i_sb->s_maxbytes,
+                                        i_size_read(inode));
 }
 EXPORT_SYMBOL(generic_file_llseek);
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 84e8a69cee9d..8567fb847601 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -322,7 +322,7 @@ static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
 }
 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
-                                      struct nameidata *nd)
+                                      unsigned int flags)
 {
        int retval;
        int lock_depth;
@@ -573,7 +573,7 @@ static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
 }
 static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                           struct nameidata *nd)
+                           bool excl)
 {
        int retval;
        struct inode *inode;
@@ -634,8 +634,8 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mod
        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        retval = journal_end(&th, dir->i_sb, jbegin_count);
      out_failed:
@@ -712,8 +712,8 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode
                goto out_failed;
        }
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        retval = journal_end(&th, dir->i_sb, jbegin_count);
      out_failed:
@@ -800,8 +800,8 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
        // the above add_entry did not update dir's stat data
        reiserfs_update_sd(&th, dir);
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        retval = journal_end(&th, dir->i_sb, jbegin_count);
 out_failed:
        reiserfs_write_unlock_once(dir->i_sb, lock_depth);
@@ -1096,8 +1096,8 @@ static int reiserfs_symlink(struct inode *parent_dir,
                goto out_failed;
        }
-        d_instantiate(dentry, inode);
        unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
        retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
      out_failed:
        reiserfs_write_unlock(parent_dir->i_sb);
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index 2c1ade692cc8..e60e87035bb3 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -403,7 +403,7 @@ static void *r_start(struct seq_file *m, loff_t * pos)
        if (l)
                return NULL;
-        if (IS_ERR(sget(&reiserfs_fs_type, test_sb, set_sb, s)))
+        if (IS_ERR(sget(&reiserfs_fs_type, test_sb, set_sb, 0, s)))
                return NULL;
        up_write(&s->s_umount);
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 651ce767b55d..7a37dabf5a96 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -68,6 +68,11 @@ static int reiserfs_sync_fs(struct super_block *s, int wait)
 {
        struct reiserfs_transaction_handle th;
+        /*
+         * Writeback quota in non-journalled quota case - journalled quota has
+         * no dirty dquots
+         */
+        dquot_writeback_dquots(s, -1);
        reiserfs_write_lock(s);
        if (!journal_begin(&th, s, 1))
                if (!journal_end_sync(&th, s, 1))
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 46fc1c20a6b1..d319963aeb11 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -62,7 +62,7 @@
 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
 {
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
-        return dir->i_op->create(dir, dentry, mode, NULL);
+        return dir->i_op->create(dir, dentry, mode, true);
 }
 #endif
@@ -942,7 +942,7 @@ int reiserfs_permission(struct inode *inode, int mask)
        return generic_permission(inode, mask);
 }
-static int xattr_hide_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int xattr_hide_revalidate(struct dentry *dentry, unsigned int flags)
 {
        return -EPERM;
 }
diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index e64f6b5f7ae5..77c5f2173983 100644
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -210,7 +210,7 @@ out:
 * look up an entry in a directory
 */
 static struct dentry *romfs_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        unsigned long offset, maxoff;
        struct inode *inode;
diff --git a/fs/splice.c b/fs/splice.c
index c9f1318a3b82..7bf08fa22ec9 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -273,13 +273,16 @@ void spd_release_page(struct splice_pipe_desc *spd, unsigned int i)
 * Check if we need to grow the arrays holding pages and partial page
 * descriptions.
 */
-int splice_grow_spd(struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
+int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
 {
-        if (pipe->buffers <= PIPE_DEF_BUFFERS)
+        unsigned int buffers = ACCESS_ONCE(pipe->buffers);
+        spd->nr_pages_max = buffers;
+        if (buffers <= PIPE_DEF_BUFFERS)
                return 0;
-        spd->pages = kmalloc(pipe->buffers * sizeof(struct page *), GFP_KERNEL);
+        spd->pages = kmalloc(buffers * sizeof(struct page *), GFP_KERNEL);
-        spd->partial = kmalloc(pipe->buffers * sizeof(struct partial_page), GFP_KERNEL);
+        spd->partial = kmalloc(buffers * sizeof(struct partial_page), GFP_KERNEL);
        if (spd->pages && spd->partial)
                return 0;
@@ -289,10 +292,9 @@ int splice_grow_spd(struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
        return -ENOMEM;
 }
-void splice_shrink_spd(struct pipe_inode_info *pipe,
+void splice_shrink_spd(struct splice_pipe_desc *spd)
-                       struct splice_pipe_desc *spd)
 {
-        if (pipe->buffers <= PIPE_DEF_BUFFERS)
+        if (spd->nr_pages_max <= PIPE_DEF_BUFFERS)
                return;
        kfree(spd->pages);
@@ -315,6 +317,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &page_cache_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -326,7 +329,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
        index = *ppos >> PAGE_CACHE_SHIFT;
        loff = *ppos & ~PAGE_CACHE_MASK;
        req_pages = (len + loff + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        nr_pages = min(req_pages, pipe->buffers);
+        nr_pages = min(req_pages, spd.nr_pages_max);
        /*
         * Lookup the (hopefully) full range of pages we need.
@@ -497,7 +500,7 @@ fill_it:
        if (spd.nr_pages)
                error = splice_to_pipe(pipe, &spd);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return error;
 }
@@ -598,6 +601,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &default_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -608,8 +612,8 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        res = -ENOMEM;
        vec = __vec;
-        if (pipe->buffers > PIPE_DEF_BUFFERS) {
+        if (spd.nr_pages_max > PIPE_DEF_BUFFERS) {
-                vec = kmalloc(pipe->buffers * sizeof(struct iovec), GFP_KERNEL);
+                vec = kmalloc(spd.nr_pages_max * sizeof(struct iovec), GFP_KERNEL);
                if (!vec)
                        goto shrink_ret;
        }
@@ -617,7 +621,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        offset = *ppos & ~PAGE_CACHE_MASK;
        nr_pages = (len + offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        for (i = 0; i < nr_pages && i < pipe->buffers && len; i++) {
+        for (i = 0; i < nr_pages && i < spd.nr_pages_max && len; i++) {
                struct page *page;
                page = alloc_page(GFP_USER);
@@ -665,7 +669,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
 shrink_ret:
        if (vec != __vec)
                kfree(vec);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return res;
 err:
@@ -1614,6 +1618,7 @@ static long vmsplice_to_pipe(struct file *file, const struct iovec __user *iov,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &user_page_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -1629,13 +1634,13 @@ static long vmsplice_to_pipe(struct file *file, const struct iovec __user *iov,
        spd.nr_pages = get_iovec_page_array(iov, nr_segs, spd.pages,
                                            spd.partial, false,
-                                            pipe->buffers);
+                                            spd.nr_pages_max);
        if (spd.nr_pages <= 0)
                ret = spd.nr_pages;
        else
                ret = splice_to_pipe(pipe, &spd);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return ret;
 }
diff --git a/fs/squashfs/namei.c b/fs/squashfs/namei.c
index abcc58f3c152..7834a517f7f4 100644
--- a/fs/squashfs/namei.c
+++ b/fs/squashfs/namei.c
@@ -134,7 +134,7 @@ out:
 static struct dentry *squashfs_lookup(struct inode *dir, struct dentry *dentry,
-                                 struct nameidata *nd)
+                                 unsigned int flags)
 {
        const unsigned char *name = dentry->d_name.name;
        int len = dentry->d_name.len;
diff --git a/fs/super.c b/fs/super.c
index cf001775617f..c743fb3be4b8 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -105,11 +105,12 @@ static int prune_super(struct shrinker *shrink, struct shrink_control *sc)
 /**
 *      alloc_super     -       create new superblock
 *      @type:  filesystem type superblock should belong to
+ *      @flags: the mount flags
 *
 *      Allocates and initializes a new &struct super_block.  alloc_super()
 *      returns a pointer new superblock or %NULL if allocation had failed.
 */
-static struct super_block *alloc_super(struct file_system_type *type)
+static struct super_block *alloc_super(struct file_system_type *type, int flags)
 {
        struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
        static const struct super_operations default_op;
@@ -136,6 +137,7 @@ static struct super_block *alloc_super(struct file_system_type *type)
 #else
                INIT_LIST_HEAD(&s->s_files);
 #endif
+                s->s_flags = flags;
                s->s_bdi = &default_backing_dev_info;
                INIT_HLIST_NODE(&s->s_instances);
                INIT_HLIST_BL_HEAD(&s->s_anon);
@@ -415,11 +417,13 @@ EXPORT_SYMBOL(generic_shutdown_super);
 *      @type:  filesystem type superblock should belong to
 *      @test:  comparison callback
 *      @set:   setup callback
+ *      @flags: mount flags
 *      @data:  argument to each of them
 */
 struct super_block *sget(struct file_system_type *type,
                        int (*test)(struct super_block *,void *),
                        int (*set)(struct super_block *,void *),
+                        int flags,
                        void *data)
 {
        struct super_block *s = NULL;
@@ -450,7 +454,7 @@ retry:
        }
        if (!s) {
                spin_unlock(&sb_lock);
-                s = alloc_super(type);
+                s = alloc_super(type, flags);
                if (!s)
                        return ERR_PTR(-ENOMEM);
                goto retry;
@@ -925,13 +929,12 @@ struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
 {
        struct super_block *sb;
-        sb = sget(fs_type, ns_test_super, ns_set_super, data);
+        sb = sget(fs_type, ns_test_super, ns_set_super, flags, data);
        if (IS_ERR(sb))
                return ERR_CAST(sb);
        if (!sb->s_root) {
                int err;
-                sb->s_flags = flags;
                err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
                if (err) {
                        deactivate_locked_super(sb);
@@ -992,7 +995,8 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
                error = -EBUSY;
                goto error_bdev;
        }
-        s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
+        s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
+                 bdev);
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        if (IS_ERR(s))
                goto error_s;
@@ -1017,7 +1021,6 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
        } else {
                char b[BDEVNAME_SIZE];
-                s->s_flags = flags | MS_NOSEC;
                s->s_mode = mode;
                strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                sb_set_blocksize(s, block_size(bdev));
@@ -1062,13 +1065,11 @@ struct dentry *mount_nodev(struct file_system_type *fs_type,
        int (*fill_super)(struct super_block *, void *, int))
 {
        int error;
-        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
+        struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
        if (IS_ERR(s))
                return ERR_CAST(s);
-        s->s_flags = flags;
        error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
        if (error) {
                deactivate_locked_super(s);
@@ -1091,11 +1092,10 @@ struct dentry *mount_single(struct file_system_type *fs_type,
        struct super_block *s;
        int error;
-        s = sget(fs_type, compare_single, set_anon_super, NULL);
+        s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
        if (IS_ERR(s))
                return ERR_CAST(s);
        if (!s->s_root) {
-                s->s_flags = flags;
                error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
                if (error) {
                        deactivate_locked_super(s);
diff --git a/fs/sync.c b/fs/sync.c
index 11e3d1c44901..eb8722dc556f 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -29,16 +29,6 @@
 */
 static int __sync_filesystem(struct super_block *sb, int wait)
 {
-        /*
-         * This should be safe, as we require bdi backing to actually
-         * write out data in the first place
-         */
-        if (sb->s_bdi == &noop_backing_dev_info)
-                return 0;
-        if (sb->s_qcop && sb->s_qcop->quota_sync)
-                sb->s_qcop->quota_sync(sb, -1, wait);
        if (wait)
                sync_inodes_sb(sb);
        else
@@ -77,29 +67,48 @@ int sync_filesystem(struct super_block *sb)
 }
 EXPORT_SYMBOL_GPL(sync_filesystem);
-static void sync_one_sb(struct super_block *sb, void *arg)
+static void sync_inodes_one_sb(struct super_block *sb, void *arg)
 {
        if (!(sb->s_flags & MS_RDONLY))
-                __sync_filesystem(sb, *(int *)arg);
+                sync_inodes_sb(sb);
 }
-/*
- * Sync all the data for all the filesystems (called by sys_sync() and
+static void sync_fs_one_sb(struct super_block *sb, void *arg)
- * emergency sync)
- */
-static void sync_filesystems(int wait)
 {
-        iterate_supers(sync_one_sb, &wait);
+        if (!(sb->s_flags & MS_RDONLY) && sb->s_op->sync_fs)
+                sb->s_op->sync_fs(sb, *(int *)arg);
+}
+static void fdatawrite_one_bdev(struct block_device *bdev, void *arg)
+{
+        filemap_fdatawrite(bdev->bd_inode->i_mapping);
+}
+static void fdatawait_one_bdev(struct block_device *bdev, void *arg)
+{
+        filemap_fdatawait(bdev->bd_inode->i_mapping);
 }
 /*
- * sync everything.  Start out by waking pdflush, because that writes back
+ * Sync everything. We start by waking flusher threads so that most of
- * all queues in parallel.
+ * writeback runs on all devices in parallel. Then we sync all inodes reliably
+ * which effectively also waits for all flusher threads to finish doing
+ * writeback. At this point all data is on disk so metadata should be stable
+ * and we tell filesystems to sync their metadata via ->sync_fs() calls.
+ * Finally, we writeout all block devices because some filesystems (e.g. ext2)
+ * just write metadata (such as inodes or bitmaps) to block device page cache
+ * and do not sync it on their own in ->sync_fs().
 */
 SYSCALL_DEFINE0(sync)
 {
+        int nowait = 0, wait = 1;
        wakeup_flusher_threads(0, WB_REASON_SYNC);
-        sync_filesystems(0);
+        iterate_supers(sync_inodes_one_sb, NULL);
-        sync_filesystems(1);
+        iterate_supers(sync_fs_one_sb, &nowait);
+        iterate_supers(sync_fs_one_sb, &wait);
+        iterate_bdevs(fdatawrite_one_bdev, NULL);
+        iterate_bdevs(fdatawait_one_bdev, NULL);
        if (unlikely(laptop_mode))
                laptop_sync_completion();
        return 0;
@@ -107,12 +116,18 @@ SYSCALL_DEFINE0(sync)
 static void do_sync_work(struct work_struct *work)
 {
+        int nowait = 0;
        /*
         * Sync twice to reduce the possibility we skipped some inodes / pages
         * because they were temporarily locked
         */
-        sync_filesystems(0);
+        iterate_supers(sync_inodes_one_sb, &nowait);
-        sync_filesystems(0);
+        iterate_supers(sync_fs_one_sb, &nowait);
+        iterate_bdevs(fdatawrite_one_bdev, NULL);
+        iterate_supers(sync_inodes_one_sb, &nowait);
+        iterate_supers(sync_fs_one_sb, &nowait);
+        iterate_bdevs(fdatawrite_one_bdev, NULL);
        printk("Emergency Sync complete\n");
        kfree(work);
 }
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index e6bb9b2a4cbe..a5cf784f9cc2 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -300,15 +300,15 @@ void release_sysfs_dirent(struct sysfs_dirent * sd)
 static int sysfs_dentry_delete(const struct dentry *dentry)
 {
        struct sysfs_dirent *sd = dentry->d_fsdata;
-        return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
+        return !(sd && !(sd->s_flags & SYSFS_FLAG_REMOVED));
 }
-static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
+static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
 {
        struct sysfs_dirent *sd;
        int is_dir;
-        if (nd->flags & LOOKUP_RCU)
+        if (flags & LOOKUP_RCU)
                return -ECHILD;
        sd = dentry->d_fsdata;
@@ -355,18 +355,15 @@ out_bad:
        return 0;
 }
-static void sysfs_dentry_iput(struct dentry *dentry, struct inode *inode)
+static void sysfs_dentry_release(struct dentry *dentry)
 {
-        struct sysfs_dirent * sd = dentry->d_fsdata;
+        sysfs_put(dentry->d_fsdata);
-        sysfs_put(sd);
-        iput(inode);
 }
-static const struct dentry_operations sysfs_dentry_ops = {
+const struct dentry_operations sysfs_dentry_ops = {
        .d_revalidate   = sysfs_dentry_revalidate,
        .d_delete       = sysfs_dentry_delete,
-        .d_iput         = sysfs_dentry_iput,
+        .d_release      = sysfs_dentry_release,
 };
 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
@@ -764,7 +761,7 @@ int sysfs_create_dir(struct kobject * kobj)
 }
 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
-                                struct nameidata *nd)
+                                unsigned int flags)
 {
        struct dentry *ret = NULL;
        struct dentry *parent = dentry->d_parent;
@@ -786,6 +783,7 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
                ret = ERR_PTR(-ENOENT);
                goto out_unlock;
        }
+        dentry->d_fsdata = sysfs_get(sd);
        /* attach dentry and inode */
        inode = sysfs_get_inode(dir->i_sb, sd);
@@ -795,16 +793,7 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
        }
        /* instantiate and hash dentry */
-        ret = d_find_alias(inode);
+        ret = d_materialise_unique(dentry, inode);
-        if (!ret) {
-                d_set_d_op(dentry, &sysfs_dentry_ops);
-                dentry->d_fsdata = sysfs_get(sd);
-                d_add(dentry, inode);
-        } else {
-                d_move(ret, dentry);
-                iput(inode);
-        }
 out_unlock:
        mutex_unlock(&sysfs_mutex);
        return ret;
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 52c3bdb66a84..71eb7e253927 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -68,6 +68,7 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
        }
        root->d_fsdata = &sysfs_root;
        sb->s_root = root;
+        sb->s_d_op = &sysfs_dentry_ops;
        return 0;
 }
@@ -117,13 +118,12 @@ static struct dentry *sysfs_mount(struct file_system_type *fs_type,
        for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
                info->ns[type] = kobj_ns_grab_current(type);
-        sb = sget(fs_type, sysfs_test_super, sysfs_set_super, info);
+        sb = sget(fs_type, sysfs_test_super, sysfs_set_super, flags, info);
        if (IS_ERR(sb) || sb->s_fs_info != info)
                free_sysfs_super_info(info);
        if (IS_ERR(sb))
                return ERR_CAST(sb);
        if (!sb->s_root) {
-                sb->s_flags = flags;
                error = sysfs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
                if (error) {
                        deactivate_locked_super(sb);
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 661a9639570b..d73c0932bbd6 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -157,6 +157,7 @@ extern struct kmem_cache *sysfs_dir_cachep;
 */
 extern struct mutex sysfs_mutex;
 extern spinlock_t sysfs_assoc_lock;
+extern const struct dentry_operations sysfs_dentry_ops;
 extern const struct file_operations sysfs_dir_operations;
 extern const struct inode_operations sysfs_dir_inode_operations;
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 08d0b2568cd3..80e1e2b18df1 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -43,7 +43,6 @@ static int sysv_sync_fs(struct super_block *sb, int wait)
         * then attach current time stamp.
         * But if the filesystem was marked clean, keep it clean.
         */
-        sb->s_dirt = 0;
        old_time = fs32_to_cpu(sbi, *sbi->s_sb_time);
        if (sbi->s_type == FSTYPE_SYSV4) {
                if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38 - old_time))
@@ -57,23 +56,12 @@ static int sysv_sync_fs(struct super_block *sb, int wait)
        return 0;
 }
-static void sysv_write_super(struct super_block *sb)
-{
-        if (!(sb->s_flags & MS_RDONLY))
-                sysv_sync_fs(sb, 1);
-        else
-                sb->s_dirt = 0;
-}
 static int sysv_remount(struct super_block *sb, int *flags, char *data)
 {
        struct sysv_sb_info *sbi = SYSV_SB(sb);
-        lock_super(sb);
        if (sbi->s_forced_ro)
                *flags |= MS_RDONLY;
-        if (*flags & MS_RDONLY)
-                sysv_write_super(sb);
-        unlock_super(sb);
        return 0;
 }
@@ -81,9 +69,6 @@ static void sysv_put_super(struct super_block *sb)
 {
        struct sysv_sb_info *sbi = SYSV_SB(sb);
-        if (sb->s_dirt)
-                sysv_write_super(sb);
        if (!(sb->s_flags & MS_RDONLY)) {
                /* XXX ext2 also updates the state here */
                mark_buffer_dirty(sbi->s_bh1);
@@ -357,7 +342,6 @@ const struct super_operations sysv_sops = {
        .write_inode    = sysv_write_inode,
        .evict_inode    = sysv_evict_inode,
        .put_super      = sysv_put_super,
-        .write_super    = sysv_write_super,
        .sync_fs        = sysv_sync_fs,
        .remount_fs     = sysv_remount,
        .statfs         = sysv_statfs,
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index d7466e293614..1c0d5f264767 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -43,7 +43,7 @@ const struct dentry_operations sysv_dentry_operations = {
        .d_hash         = sysv_hash,
 };
-static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags)
 {
        struct inode * inode = NULL;
        ino_t ino;
@@ -80,7 +80,7 @@ static int sysv_mknod(struct inode * dir, struct dentry * dentry, umode_t mode,
        return err;
 }
-static int sysv_create(struct inode * dir, struct dentry * dentry, umode_t mode, struct nameidata *nd)
+static int sysv_create(struct inode * dir, struct dentry * dentry, umode_t mode, bool excl)
 {
        return sysv_mknod(dir, dentry, mode, 0);
 }
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index 11b07672f6c5..0bc35fdc58e2 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -117,7 +117,6 @@ static inline void dirty_sb(struct super_block *sb)
        mark_buffer_dirty(sbi->s_bh1);
        if (sbi->s_bh1 != sbi->s_bh2)
                mark_buffer_dirty(sbi->s_bh2);
-        sb->s_dirt = 1;
 }
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 685a83756b2b..bb3167257aab 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -2802,6 +2802,8 @@ static ssize_t dfs_file_read(struct file *file, char __user *u, size_t count,
                val = d->chk_fs;
        else if (dent == d->dfs_tst_rcvry)
                val = d->tst_rcvry;
+        else if (dent == d->dfs_ro_error)
+                val = c->ro_error;
        else
                return -EINVAL;
@@ -2885,6 +2887,8 @@ static ssize_t dfs_file_write(struct file *file, const char __user *u,
                d->chk_fs = val;
        else if (dent == d->dfs_tst_rcvry)
                d->tst_rcvry = val;
+        else if (dent == d->dfs_ro_error)
+                c->ro_error = !!val;
        else
                return -EINVAL;
@@ -2918,6 +2922,9 @@ int dbg_debugfs_init_fs(struct ubifs_info *c)
        struct dentry *dent;
        struct ubifs_debug_info *d = c->dbg;
+        if (!IS_ENABLED(CONFIG_DEBUG_FS))
+                return 0;
        n = snprintf(d->dfs_dir_name, UBIFS_DFS_DIR_LEN + 1, UBIFS_DFS_DIR_NAME,
                     c->vi.ubi_num, c->vi.vol_id);
        if (n == UBIFS_DFS_DIR_LEN) {
@@ -2993,6 +3000,13 @@ int dbg_debugfs_init_fs(struct ubifs_info *c)
                goto out_remove;
        d->dfs_tst_rcvry = dent;
+        fname = "ro_error";
+        dent = debugfs_create_file(fname, S_IRUSR | S_IWUSR, d->dfs_dir, c,
+                                   &dfs_fops);
+        if (IS_ERR_OR_NULL(dent))
+                goto out_remove;
+        d->dfs_ro_error = dent;
        return 0;
 out_remove:
@@ -3010,7 +3024,8 @@ out:
 */
 void dbg_debugfs_exit_fs(struct ubifs_info *c)
 {
-        debugfs_remove_recursive(c->dbg->dfs_dir);
+        if (IS_ENABLED(CONFIG_DEBUG_FS))
+                debugfs_remove_recursive(c->dbg->dfs_dir);
 }
 struct ubifs_global_debug_info ubifs_dbg;
@@ -3095,6 +3110,9 @@ int dbg_debugfs_init(void)
        const char *fname;
        struct dentry *dent;
+        if (!IS_ENABLED(CONFIG_DEBUG_FS))
+                return 0;
        fname = "ubifs";
        dent = debugfs_create_dir(fname, NULL);
        if (IS_ERR_OR_NULL(dent))
@@ -3159,7 +3177,8 @@ out:
 */
 void dbg_debugfs_exit(void)
 {
-        debugfs_remove_recursive(dfs_rootdir);
+        if (IS_ENABLED(CONFIG_DEBUG_FS))
+                debugfs_remove_recursive(dfs_rootdir);
 }
 /**
diff --git a/fs/ubifs/debug.h b/fs/ubifs/debug.h
index 486a8e024fb6..8b8cc4e945f4 100644
--- a/fs/ubifs/debug.h
+++ b/fs/ubifs/debug.h
@@ -79,6 +79,10 @@ typedef int (*dbg_znode_callback)(struct ubifs_info *c,
 * @dfs_chk_lprops: debugfs knob to enable UBIFS LEP properties extra checks
 * @dfs_chk_fs: debugfs knob to enable UBIFS contents extra checks
 * @dfs_tst_rcvry: debugfs knob to enable UBIFS recovery testing
+ * @dfs_ro_error: debugfs knob to switch UBIFS to R/O mode (different to
+ *                re-mounting to R/O mode because it does not flush any buffers
+ *                and UBIFS just starts returning -EROFS on all write
+ *               operations)
 */
 struct ubifs_debug_info {
        struct ubifs_zbranch old_zroot;
@@ -122,6 +126,7 @@ struct ubifs_debug_info {
        struct dentry *dfs_chk_lprops;
        struct dentry *dfs_chk_fs;
        struct dentry *dfs_tst_rcvry;
+        struct dentry *dfs_ro_error;
 };
 /**
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index a6d42efc76d2..c95681cf1b71 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -184,7 +184,7 @@ static int dbg_check_name(const struct ubifs_info *c,
 }
 static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
        int err;
        union ubifs_key key;
@@ -246,7 +246,7 @@ out:
 }
 static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                        struct nameidata *nd)
+                        bool excl)
 {
        struct inode *inode;
        struct ubifs_info *c = dir->i_sb->s_fs_info;
@@ -969,7 +969,7 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
                        .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
        struct timespec time;
-        unsigned int saved_nlink;
+        unsigned int uninitialized_var(saved_nlink);
        /*
         * Budget request settings: deletion direntry, new direntry, removing
diff --git a/fs/ubifs/find.c b/fs/ubifs/find.c
index 2559d174e004..28ec13af28d9 100644
--- a/fs/ubifs/find.c
+++ b/fs/ubifs/find.c
@@ -939,8 +939,8 @@ static int find_dirtiest_idx_leb(struct ubifs_info *c)
        }
        dbg_find("LEB %d, dirty %d and free %d flags %#x", lp->lnum, lp->dirty,
                 lp->free, lp->flags);
-        ubifs_assert(lp->flags | LPROPS_TAKEN);
+        ubifs_assert(lp->flags & LPROPS_TAKEN);
-        ubifs_assert(lp->flags | LPROPS_INDEX);
+        ubifs_assert(lp->flags & LPROPS_INDEX);
        return lnum;
 }
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index b02734db187c..cebf17ea0458 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -176,7 +176,7 @@ int ubifs_orphan_start_commit(struct ubifs_info *c)
                *last = orphan;
                last = &orphan->cnext;
        }
-        *last = orphan->cnext;
+        *last = NULL;
        c->cmt_orphans = c->new_orphans;
        c->new_orphans = 0;
        dbg_cmt("%d orphans to commit", c->cmt_orphans);
@@ -382,7 +382,7 @@ static int consolidate(struct ubifs_info *c)
                        last = &orphan->cnext;
                        cnt += 1;
                }
-                *last = orphan->cnext;
+                *last = NULL;
                ubifs_assert(cnt == c->tot_orphans - c->new_orphans);
                c->cmt_orphans = cnt;
                c->ohead_lnum = c->orph_first;
diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c
index 3a2da7e476e5..eba46d4a7619 100644
--- a/fs/ubifs/replay.c
+++ b/fs/ubifs/replay.c
@@ -1007,7 +1007,7 @@ out:
 */
 int ubifs_replay_journal(struct ubifs_info *c)
 {
-        int err, i, lnum, offs, free;
+        int err, lnum, free;
        BUILD_BUG_ON(UBIFS_TRUN_KEY > 5);
@@ -1025,25 +1025,17 @@ int ubifs_replay_journal(struct ubifs_info *c)
        dbg_mnt("start replaying the journal");
        c->replaying = 1;
        lnum = c->ltail_lnum = c->lhead_lnum;
-        offs = c->lhead_offs;
-        for (i = 0; i < c->log_lebs; i++, lnum++) {
+        lnum = UBIFS_LOG_LNUM;
-                if (lnum >= UBIFS_LOG_LNUM + c->log_lebs) {
+        do {
-                        /*
+                err = replay_log_leb(c, lnum, 0, c->sbuf);
-                         * The log is logically circular, we reached the last
-                         * LEB, switch to the first one.
-                         */
-                        lnum = UBIFS_LOG_LNUM;
-                        offs = 0;
-                }
-                err = replay_log_leb(c, lnum, offs, c->sbuf);
                if (err == 1)
                        /* We hit the end of the log */
                        break;
                if (err)
                        goto out;
-                offs = 0;
+                lnum = ubifs_next_log_lnum(c, lnum);
-        }
+        } while (lnum != UBIFS_LOG_LNUM);
        err = replay_buds(c);
        if (err)
diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
index ef3d1ba6d992..15e2fc5aa60b 100644
--- a/fs/ubifs/sb.c
+++ b/fs/ubifs/sb.c
@@ -718,8 +718,12 @@ static int fixup_free_space(struct ubifs_info *c)
                lnum = ubifs_next_log_lnum(c, lnum);
        }
-        /* Fixup the current log head */
+        /*
-        err = fixup_leb(c, c->lhead_lnum, c->lhead_offs);
+         * Fixup the log head which contains the only a CS node at the
+         * beginning.
+         */
+        err = fixup_leb(c, c->lhead_lnum,
+                        ALIGN(UBIFS_CS_NODE_SZ, c->min_io_size));
        if (err)
                goto out;
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 5862dd9d2784..1c766c39c038 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -2136,7 +2136,7 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
        dbg_gen("opened ubi%d_%d", c->vi.ubi_num, c->vi.vol_id);
-        sb = sget(fs_type, sb_test, sb_set, c);
+        sb = sget(fs_type, sb_test, sb_set, flags, c);
        if (IS_ERR(sb)) {
                err = PTR_ERR(sb);
                kfree(c);
@@ -2153,7 +2153,6 @@ static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
                        goto out_deact;
                }
        } else {
-                sb->s_flags = flags;
                err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
                if (err)
                        goto out_deact;
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 873e1bab9c4c..fafaad795cd6 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -1247,7 +1247,6 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
 {
        struct fileEntry *fe;
        struct extendedFileEntry *efe;
-        int offset;
        struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
        struct udf_inode_info *iinfo = UDF_I(inode);
        unsigned int link_count;
@@ -1359,7 +1358,6 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
                iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
                iinfo->i_checkpoint = le32_to_cpu(fe->checkpoint);
-                offset = sizeof(struct fileEntry) + iinfo->i_lenEAttr;
        } else {
                inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
                    (inode->i_sb->s_blocksize_bits - 9);
@@ -1381,8 +1379,6 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
                iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
                iinfo->i_checkpoint = le32_to_cpu(efe->checkpoint);
-                offset = sizeof(struct extendedFileEntry) +
-                                                        iinfo->i_lenEAttr;
        }
        switch (fe->icbTag.fileType) {
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 18024178ac4c..95fee278ab9d 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -251,7 +251,7 @@ out_ok:
 }
 static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
-                                 struct nameidata *nd)
+                                 unsigned int flags)
 {
        struct inode *inode = NULL;
        struct fileIdentDesc cfi;
@@ -551,7 +551,7 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
 }
 static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                      struct nameidata *nd)
+                      bool excl)
 {
        struct udf_fileident_bh fibh;
        struct inode *inode;
@@ -1279,6 +1279,7 @@ static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
        *lenp = 3;
        fid->udf.block = location.logicalBlockNum;
        fid->udf.partref = location.partitionReferenceNum;
+        fid->udf.parent_partref = 0;
        fid->udf.generation = inode->i_generation;
        if (parent) {
diff --git a/fs/udf/super.c b/fs/udf/super.c
index ac8a348dcb69..dcbf98722afc 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -56,6 +56,7 @@
 #include <linux/seq_file.h>
 #include <linux/bitmap.h>
 #include <linux/crc-itu-t.h>
+#include <linux/log2.h>
 #include <asm/byteorder.h>
 #include "udf_sb.h"
@@ -251,6 +252,63 @@ static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
        return 0;
 }
+static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
+{
+        int i;
+        int nr_groups = bitmap->s_nr_groups;
+        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
+                                                nr_groups);
+        for (i = 0; i < nr_groups; i++)
+                if (bitmap->s_block_bitmap[i])
+                        brelse(bitmap->s_block_bitmap[i]);
+        if (size <= PAGE_SIZE)
+                kfree(bitmap);
+        else
+                vfree(bitmap);
+}
+static void udf_free_partition(struct udf_part_map *map)
+{
+        int i;
+        struct udf_meta_data *mdata;
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
+                iput(map->s_uspace.s_table);
+        if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
+                iput(map->s_fspace.s_table);
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
+                udf_sb_free_bitmap(map->s_uspace.s_bitmap);
+        if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
+                udf_sb_free_bitmap(map->s_fspace.s_bitmap);
+        if (map->s_partition_type == UDF_SPARABLE_MAP15)
+                for (i = 0; i < 4; i++)
+                        brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
+        else if (map->s_partition_type == UDF_METADATA_MAP25) {
+                mdata = &map->s_type_specific.s_metadata;
+                iput(mdata->s_metadata_fe);
+                mdata->s_metadata_fe = NULL;
+                iput(mdata->s_mirror_fe);
+                mdata->s_mirror_fe = NULL;
+                iput(mdata->s_bitmap_fe);
+                mdata->s_bitmap_fe = NULL;
+        }
+}
+static void udf_sb_free_partitions(struct super_block *sb)
+{
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        int i;
+        for (i = 0; i < sbi->s_partitions; i++)
+                udf_free_partition(&sbi->s_partmaps[i]);
+        kfree(sbi->s_partmaps);
+        sbi->s_partmaps = NULL;
+}
 static int udf_show_options(struct seq_file *seq, struct dentry *root)
 {
        struct super_block *sb = root->d_sb;
@@ -1215,16 +1273,65 @@ out_bh:
        return ret;
 }
+static int udf_load_sparable_map(struct super_block *sb,
+                                 struct udf_part_map *map,
+                                 struct sparablePartitionMap *spm)
+{
+        uint32_t loc;
+        uint16_t ident;
+        struct sparingTable *st;
+        struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing;
+        int i;
+        struct buffer_head *bh;
+        map->s_partition_type = UDF_SPARABLE_MAP15;
+        sdata->s_packet_len = le16_to_cpu(spm->packetLength);
+        if (!is_power_of_2(sdata->s_packet_len)) {
+                udf_err(sb, "error loading logical volume descriptor: "
+                        "Invalid packet length %u\n",
+                        (unsigned)sdata->s_packet_len);
+                return -EIO;
+        }
+        if (spm->numSparingTables > 4) {
+                udf_err(sb, "error loading logical volume descriptor: "
+                        "Too many sparing tables (%d)\n",
+                        (int)spm->numSparingTables);
+                return -EIO;
+        }
+        for (i = 0; i < spm->numSparingTables; i++) {
+                loc = le32_to_cpu(spm->locSparingTable[i]);
+                bh = udf_read_tagged(sb, loc, loc, &ident);
+                if (!bh)
+                        continue;
+                st = (struct sparingTable *)bh->b_data;
+                if (ident != 0 ||
+                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING,
+                            strlen(UDF_ID_SPARING)) ||
+                    sizeof(*st) + le16_to_cpu(st->reallocationTableLen) >
+                                                        sb->s_blocksize) {
+                        brelse(bh);
+                        continue;
+                }
+                sdata->s_spar_map[i] = bh;
+        }
+        map->s_partition_func = udf_get_pblock_spar15;
+        return 0;
+}
 static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                               struct kernel_lb_addr *fileset)
 {
        struct logicalVolDesc *lvd;
-        int i, j, offset;
+        int i, offset;
        uint8_t type;
        struct udf_sb_info *sbi = UDF_SB(sb);
        struct genericPartitionMap *gpm;
        uint16_t ident;
        struct buffer_head *bh;
+        unsigned int table_len;
        int ret = 0;
        bh = udf_read_tagged(sb, block, block, &ident);
@@ -1232,15 +1339,20 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                return 1;
        BUG_ON(ident != TAG_IDENT_LVD);
        lvd = (struct logicalVolDesc *)bh->b_data;
+        table_len = le32_to_cpu(lvd->mapTableLength);
-        i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
+        if (table_len > sb->s_blocksize - sizeof(*lvd)) {
-        if (i != 0) {
+                udf_err(sb, "error loading logical volume descriptor: "
-                ret = i;
+                        "Partition table too long (%u > %lu)\n", table_len,
+                        sb->s_blocksize - sizeof(*lvd));
                goto out_bh;
        }
+        ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
+        if (ret)
+                goto out_bh;
        for (i = 0, offset = 0;
-             i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
+             i < sbi->s_partitions && offset < table_len;
             i++, offset += gpm->partitionMapLength) {
                struct udf_part_map *map = &sbi->s_partmaps[i];
                gpm = (struct genericPartitionMap *)
@@ -1275,38 +1387,9 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                        } else if (!strncmp(upm2->partIdent.ident,
                                                UDF_ID_SPARABLE,
                                                strlen(UDF_ID_SPARABLE))) {
-                                uint32_t loc;
+                                if (udf_load_sparable_map(sb, map,
-                                struct sparingTable *st;
+                                    (struct sparablePartitionMap *)gpm) < 0)
-                                struct sparablePartitionMap *spm =
+                                        goto out_bh;
-                                        (struct sparablePartitionMap *)gpm;
-                                map->s_partition_type = UDF_SPARABLE_MAP15;
-                                map->s_type_specific.s_sparing.s_packet_len =
-                                                le16_to_cpu(spm->packetLength);
-                                for (j = 0; j < spm->numSparingTables; j++) {
-                                        struct buffer_head *bh2;
-                                        loc = le32_to_cpu(
-                                                spm->locSparingTable[j]);
-                                        bh2 = udf_read_tagged(sb, loc, loc,
-                                                             &ident);
-                                        map->s_type_specific.s_sparing.
-                                                        s_spar_map[j] = bh2;
-                                        if (bh2 == NULL)
-                                                continue;
-                                        st = (struct sparingTable *)bh2->b_data;
-                                        if (ident != 0 || strncmp(
-                                                st->sparingIdent.ident,
-                                                UDF_ID_SPARING,
-                                                strlen(UDF_ID_SPARING))) {
-                                                brelse(bh2);
-                                                map->s_type_specific.s_sparing.
-                                                        s_spar_map[j] = NULL;
-                                        }
-                                }
-                                map->s_partition_func = udf_get_pblock_spar15;
                        } else if (!strncmp(upm2->partIdent.ident,
                                                UDF_ID_METADATA,
                                                strlen(UDF_ID_METADATA))) {
@@ -1570,7 +1653,11 @@ static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
        /* responsible for finding the PartitionDesc(s) */
        if (!udf_process_sequence(sb, main_s, main_e, fileset))
                return 1;
-        return !udf_process_sequence(sb, reserve_s, reserve_e, fileset);
+        udf_sb_free_partitions(sb);
+        if (!udf_process_sequence(sb, reserve_s, reserve_e, fileset))
+                return 1;
+        udf_sb_free_partitions(sb);
+        return 0;
 }
 /*
@@ -1835,55 +1922,8 @@ u64 lvid_get_unique_id(struct super_block *sb)
        return ret;
 }
-static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
-{
-        int i;
-        int nr_groups = bitmap->s_nr_groups;
-        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
-                                                nr_groups);
-        for (i = 0; i < nr_groups; i++)
-                if (bitmap->s_block_bitmap[i])
-                        brelse(bitmap->s_block_bitmap[i]);
-        if (size <= PAGE_SIZE)
-                kfree(bitmap);
-        else
-                vfree(bitmap);
-}
-static void udf_free_partition(struct udf_part_map *map)
-{
-        int i;
-        struct udf_meta_data *mdata;
-        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
-                iput(map->s_uspace.s_table);
-        if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
-                iput(map->s_fspace.s_table);
-        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
-                udf_sb_free_bitmap(map->s_uspace.s_bitmap);
-        if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
-                udf_sb_free_bitmap(map->s_fspace.s_bitmap);
-        if (map->s_partition_type == UDF_SPARABLE_MAP15)
-                for (i = 0; i < 4; i++)
-                        brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
-        else if (map->s_partition_type == UDF_METADATA_MAP25) {
-                mdata = &map->s_type_specific.s_metadata;
-                iput(mdata->s_metadata_fe);
-                mdata->s_metadata_fe = NULL;
-                iput(mdata->s_mirror_fe);
-                mdata->s_mirror_fe = NULL;
-                iput(mdata->s_bitmap_fe);
-                mdata->s_bitmap_fe = NULL;
-        }
-}
 static int udf_fill_super(struct super_block *sb, void *options, int silent)
 {
-        int i;
        int ret;
        struct inode *inode = NULL;
        struct udf_options uopt;
@@ -1948,7 +1988,6 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
        sb->s_op = &udf_sb_ops;
        sb->s_export_op = &udf_export_ops;
-        sb->s_dirt = 0;
        sb->s_magic = UDF_SUPER_MAGIC;
        sb->s_time_gran = 1000;
@@ -2046,9 +2085,6 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
 error_out:
        if (sbi->s_vat_inode)
                iput(sbi->s_vat_inode);
-        if (sbi->s_partitions)
-                for (i = 0; i < sbi->s_partitions; i++)
-                        udf_free_partition(&sbi->s_partmaps[i]);
 #ifdef CONFIG_UDF_NLS
        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
                unload_nls(sbi->s_nls_map);
@@ -2056,8 +2092,7 @@ error_out:
        if (!(sb->s_flags & MS_RDONLY))
                udf_close_lvid(sb);
        brelse(sbi->s_lvid_bh);
+        udf_sb_free_partitions(sb);
-        kfree(sbi->s_partmaps);
        kfree(sbi);
        sb->s_fs_info = NULL;
@@ -2070,10 +2105,6 @@ void _udf_err(struct super_block *sb, const char *function,
        struct va_format vaf;
        va_list args;
-        /* mark sb error */
-        if (!(sb->s_flags & MS_RDONLY))
-                sb->s_dirt = 1;
        va_start(args, fmt);
        vaf.fmt = fmt;
@@ -2102,16 +2133,12 @@ void _udf_warn(struct super_block *sb, const char *function,
 static void udf_put_super(struct super_block *sb)
 {
-        int i;
        struct udf_sb_info *sbi;
        sbi = UDF_SB(sb);
        if (sbi->s_vat_inode)
                iput(sbi->s_vat_inode);
-        if (sbi->s_partitions)
-                for (i = 0; i < sbi->s_partitions; i++)
-                        udf_free_partition(&sbi->s_partmaps[i]);
 #ifdef CONFIG_UDF_NLS
        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
                unload_nls(sbi->s_nls_map);
@@ -2119,7 +2146,7 @@ static void udf_put_super(struct super_block *sb)
        if (!(sb->s_flags & MS_RDONLY))
                udf_close_lvid(sb);
        brelse(sbi->s_lvid_bh);
-        kfree(sbi->s_partmaps);
+        udf_sb_free_partitions(sb);
        kfree(sb->s_fs_info);
        sb->s_fs_info = NULL;
 }
@@ -2135,7 +2162,6 @@ static int udf_sync_fs(struct super_block *sb, int wait)
                 * the buffer for IO
                 */
                mark_buffer_dirty(sbi->s_lvid_bh);
-                sb->s_dirt = 0;
                sbi->s_lvid_dirty = 0;
        }
        mutex_unlock(&sbi->s_alloc_mutex);
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
index 4b98fee8e161..8a9657d7f7c6 100644
--- a/fs/udf/truncate.c
+++ b/fs/udf/truncate.c
@@ -248,7 +248,7 @@ void udf_truncate_extents(struct inode *inode)
                                /* We managed to free all extents in the
                                 * indirect extent - free it too */
                                BUG_ON(!epos.bh);
-                                udf_free_blocks(sb, inode, &epos.block,
+                                udf_free_blocks(sb, NULL, &epos.block,
                                                0, indirect_ext_len);
                        } else if (!epos.bh) {
                                iinfo->i_lenAlloc = lenalloc;
@@ -275,7 +275,7 @@ void udf_truncate_extents(struct inode *inode)
        if (indirect_ext_len) {
                BUG_ON(!epos.bh);
-                udf_free_blocks(sb, inode, &epos.block, 0, indirect_ext_len);
+                udf_free_blocks(sb, NULL, &epos.block, 0, indirect_ext_len);
        } else if (!epos.bh) {
                iinfo->i_lenAlloc = lenalloc;
                mark_inode_dirty(inode);
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index ebe10314e512..de038da6f6bd 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -129,7 +129,6 @@ static inline void udf_updated_lvid(struct super_block *sb)
        WARN_ON_ONCE(((struct logicalVolIntegrityDesc *)
                     bh->b_data)->integrityType !=
                     cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN));
-        sb->s_dirt = 1;
        UDF_SB(sb)->s_lvid_dirty = 1;
 }
 extern u64 lvid_get_unique_id(struct super_block *sb);
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 42694e11c23d..1b3e410bf334 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -116,7 +116,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS)
                ubh_sync_block(UCPI_UBH(ucpi));
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        
        unlock_super (sb);
        UFSD("EXIT\n");
@@ -214,7 +214,7 @@ do_more:
                goto do_more;
        }
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        unlock_super (sb);
        UFSD("EXIT\n");
        return;
@@ -557,7 +557,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS)
                ubh_sync_block(UCPI_UBH(ucpi));
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        UFSD("EXIT, fragment %llu\n", (unsigned long long)fragment);
        
@@ -677,7 +677,7 @@ succed:
        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS)
                ubh_sync_block(UCPI_UBH(ucpi));
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        result += cgno * uspi->s_fpg;
        UFSD("EXIT3, result %llu\n", (unsigned long long)result);
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 4ec5c1085a87..e84cbe21b986 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -116,7 +116,7 @@ void ufs_free_inode (struct inode * inode)
        if (sb->s_flags & MS_SYNCHRONOUS)
                ubh_sync_block(UCPI_UBH(ucpi));
        
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        unlock_super (sb);
        UFSD("EXIT\n");
 }
@@ -288,7 +288,7 @@ cg_found:
        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
        if (sb->s_flags & MS_SYNCHRONOUS)
                ubh_sync_block(UCPI_UBH(ucpi));
-        sb->s_dirt = 1;
+        ufs_mark_sb_dirty(sb);
        inode->i_ino = cg * uspi->s_ipg + bit;
        inode_init_owner(inode, dir, mode);
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index a2281cadefa1..90d74b8f8eba 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -46,7 +46,7 @@ static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
        return err;
 }
-static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
 {
        struct inode * inode = NULL;
        ino_t ino;
@@ -71,7 +71,7 @@ static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, stru
 * with d_instantiate(). 
 */
 static int ufs_create (struct inode * dir, struct dentry * dentry, umode_t mode,
-                struct nameidata *nd)
+                bool excl)
 {
        struct inode *inode;
        int err;
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 302f340d0071..444927e5706b 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -302,7 +302,7 @@ void ufs_error (struct super_block * sb, const char * function,
        if (!(sb->s_flags & MS_RDONLY)) {
                usb1->fs_clean = UFS_FSBAD;
                ubh_mark_buffer_dirty(USPI_UBH(uspi));
-                sb->s_dirt = 1;
+                ufs_mark_sb_dirty(sb);
                sb->s_flags |= MS_RDONLY;
        }
        va_start (args, fmt);
@@ -334,7 +334,7 @@ void ufs_panic (struct super_block * sb, const char * function,
        if (!(sb->s_flags & MS_RDONLY)) {
                usb1->fs_clean = UFS_FSBAD;
                ubh_mark_buffer_dirty(USPI_UBH(uspi));
-                sb->s_dirt = 1;
+                ufs_mark_sb_dirty(sb);
        }
        va_start (args, fmt);
        vsnprintf (error_buf, sizeof(error_buf), fmt, args);
@@ -691,6 +691,83 @@ static void ufs_put_super_internal(struct super_block *sb)
        UFSD("EXIT\n");
 }
+static int ufs_sync_fs(struct super_block *sb, int wait)
+{
+        struct ufs_sb_private_info * uspi;
+        struct ufs_super_block_first * usb1;
+        struct ufs_super_block_third * usb3;
+        unsigned flags;
+        lock_ufs(sb);
+        lock_super(sb);
+        UFSD("ENTER\n");
+        flags = UFS_SB(sb)->s_flags;
+        uspi = UFS_SB(sb)->s_uspi;
+        usb1 = ubh_get_usb_first(uspi);
+        usb3 = ubh_get_usb_third(uspi);
+        usb1->fs_time = cpu_to_fs32(sb, get_seconds());
+        if ((flags & UFS_ST_MASK) == UFS_ST_SUN  ||
+            (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
+            (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
+                ufs_set_fs_state(sb, usb1, usb3,
+                                UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
+        ufs_put_cstotal(sb);
+        UFSD("EXIT\n");
+        unlock_super(sb);
+        unlock_ufs(sb);
+        return 0;
+}
+static void delayed_sync_fs(struct work_struct *work)
+{
+        struct ufs_sb_info *sbi;
+        sbi = container_of(work, struct ufs_sb_info, sync_work.work);
+        spin_lock(&sbi->work_lock);
+        sbi->work_queued = 0;
+        spin_unlock(&sbi->work_lock);
+        ufs_sync_fs(sbi->sb, 1);
+}
+void ufs_mark_sb_dirty(struct super_block *sb)
+{
+        struct ufs_sb_info *sbi = UFS_SB(sb);
+        unsigned long delay;
+        spin_lock(&sbi->work_lock);
+        if (!sbi->work_queued) {
+                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+                queue_delayed_work(system_long_wq, &sbi->sync_work, delay);
+                sbi->work_queued = 1;
+        }
+        spin_unlock(&sbi->work_lock);
+}
+static void ufs_put_super(struct super_block *sb)
+{
+        struct ufs_sb_info * sbi = UFS_SB(sb);
+        UFSD("ENTER\n");
+        if (!(sb->s_flags & MS_RDONLY))
+                ufs_put_super_internal(sb);
+        cancel_delayed_work_sync(&sbi->sync_work);
+        ubh_brelse_uspi (sbi->s_uspi);
+        kfree (sbi->s_uspi);
+        kfree (sbi);
+        sb->s_fs_info = NULL;
+        UFSD("EXIT\n");
+        return;
+}
 static int ufs_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct ufs_sb_info * sbi;
@@ -716,6 +793,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        if (!sbi)
                goto failed_nomem;
        sb->s_fs_info = sbi;
+        sbi->sb = sb;
        UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
        
@@ -727,6 +805,8 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        }
 #endif
        mutex_init(&sbi->mutex);
+        spin_lock_init(&sbi->work_lock);
+        INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
        /*
         * Set default mount options
         * Parse mount options
@@ -1191,68 +1271,6 @@ failed_nomem:
        return -ENOMEM;
 }
-static int ufs_sync_fs(struct super_block *sb, int wait)
-{
-        struct ufs_sb_private_info * uspi;
-        struct ufs_super_block_first * usb1;
-        struct ufs_super_block_third * usb3;
-        unsigned flags;
-        lock_ufs(sb);
-        lock_super(sb);
-        UFSD("ENTER\n");
-        flags = UFS_SB(sb)->s_flags;
-        uspi = UFS_SB(sb)->s_uspi;
-        usb1 = ubh_get_usb_first(uspi);
-        usb3 = ubh_get_usb_third(uspi);
-        usb1->fs_time = cpu_to_fs32(sb, get_seconds());
-        if ((flags & UFS_ST_MASK) == UFS_ST_SUN  ||
-            (flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
-            (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
-                ufs_set_fs_state(sb, usb1, usb3,
-                                UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
-        ufs_put_cstotal(sb);
-        sb->s_dirt = 0;
-        UFSD("EXIT\n");
-        unlock_super(sb);
-        unlock_ufs(sb);
-        return 0;
-}
-static void ufs_write_super(struct super_block *sb)
-{
-        if (!(sb->s_flags & MS_RDONLY))
-                ufs_sync_fs(sb, 1);
-        else
-                sb->s_dirt = 0;
-}
-static void ufs_put_super(struct super_block *sb)
-{
-        struct ufs_sb_info * sbi = UFS_SB(sb);
-                
-        UFSD("ENTER\n");
-        if (sb->s_dirt)
-                ufs_write_super(sb);
-        if (!(sb->s_flags & MS_RDONLY))
-                ufs_put_super_internal(sb);
-        
-        ubh_brelse_uspi (sbi->s_uspi);
-        kfree (sbi->s_uspi);
-        kfree (sbi);
-        sb->s_fs_info = NULL;
-        UFSD("EXIT\n");
-        return;
-}
 static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
 {
        struct ufs_sb_private_info * uspi;
@@ -1308,7 +1326,6 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                        ufs_set_fs_state(sb, usb1, usb3,
                                UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
                ubh_mark_buffer_dirty (USPI_UBH(uspi));
-                sb->s_dirt = 0;
                sb->s_flags |= MS_RDONLY;
        } else {
        /*
@@ -1458,7 +1475,6 @@ static const struct super_operations ufs_super_ops = {
        .write_inode    = ufs_write_inode,
        .evict_inode    = ufs_evict_inode,
        .put_super      = ufs_put_super,
-        .write_super    = ufs_write_super,
        .sync_fs        = ufs_sync_fs,
        .statfs         = ufs_statfs,
        .remount_fs     = ufs_remount,
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index 528750b7e701..343e6fc571e5 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -20,6 +20,10 @@ struct ufs_sb_info {
        unsigned s_mount_opt;
        struct mutex mutex;
        struct task_struct *mutex_owner;
+        struct super_block *sb;
+        int work_queued; /* non-zero if the delayed work is queued */
+        struct delayed_work sync_work; /* FS sync delayed work */
+        spinlock_t work_lock; /* protects sync_work and work_queued */
 };
 struct ufs_inode_info {
@@ -123,6 +127,7 @@ extern __printf(3, 4)
 void ufs_error(struct super_block *, const char *, const char *, ...);
 extern __printf(3, 4)
 void ufs_panic(struct super_block *, const char *, const char *, ...);
+void ufs_mark_sb_dirty(struct super_block *sb);
 /* symlink.c */
 extern const struct inode_operations ufs_fast_symlink_inode_operations;
diff --git a/fs/ufs/ufs_fs.h b/fs/ufs/ufs_fs.h
index 8aba544f9fad..0cbd5d340b67 100644
--- a/fs/ufs/ufs_fs.h
+++ b/fs/ufs/ufs_fs.h
@@ -34,6 +34,7 @@
 #include <linux/kernel.h>
 #include <linux/stat.h>
 #include <linux/fs.h>
+#include <linux/workqueue.h>
 #include <asm/div64.h>
 typedef __u64 __bitwise __fs64;
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 229641fb8e67..4f33c32affe3 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -1074,12 +1074,13 @@ restart:
         * If we couldn't get anything, give up.
         */
        if (bno_cur_lt == NULL && bno_cur_gt == NULL) {
+                xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
                if (!forced++) {
                        trace_xfs_alloc_near_busy(args);
                        xfs_log_force(args->mp, XFS_LOG_SYNC);
                        goto restart;
                }
                trace_xfs_alloc_size_neither(args);
                args->agbno = NULLAGBLOCK;
                return 0;
@@ -2433,15 +2434,24 @@ xfs_alloc_vextent_worker(
        current_restore_flags_nested(&pflags, PF_FSTRANS);
 }
+/*
-int                             /* error */
+ * Data allocation requests often come in with little stack to work on. Push
+ * them off to a worker thread so there is lots of stack to use. Metadata
+ * requests, OTOH, are generally from low stack usage paths, so avoid the
+ * context switch overhead here.
+ */
+int
 xfs_alloc_vextent(
-        xfs_alloc_arg_t *args)  /* allocation argument structure */
+        struct xfs_alloc_arg    *args)
 {
        DECLARE_COMPLETION_ONSTACK(done);
+        if (!args->userdata)
+                return __xfs_alloc_vextent(args);
        args->done = &done;
-        INIT_WORK(&args->work, xfs_alloc_vextent_worker);
+        INIT_WORK_ONSTACK(&args->work, xfs_alloc_vextent_worker);
        queue_work(xfs_alloc_wq, &args->work);
        wait_for_completion(&done);
        return args->result;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index ae31c313a79e..8dad722c0041 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -981,10 +981,15 @@ xfs_vm_writepage(
                                imap_valid = 0;
                        }
                } else {
-                        if (PageUptodate(page)) {
+                        if (PageUptodate(page))
                                ASSERT(buffer_mapped(bh));
-                                imap_valid = 0;
+                        /*
-                        }
+                         * This buffer is not uptodate and will not be
+                         * written to disk.  Ensure that we will put any
+                         * subsequent writeable buffers into a new
+                         * ioend.
+                         */
+                        imap_valid = 0;
                        continue;
                }
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 172d3cc8f8cb..269b35c084da 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -201,14 +201,7 @@ xfs_buf_alloc(
        bp->b_length = numblks;
        bp->b_io_length = numblks;
        bp->b_flags = flags;
+        bp->b_bn = blkno;
-        /*
-         * We do not set the block number here in the buffer because we have not
-         * finished initialising the buffer. We insert the buffer into the cache
-         * in this state, so this ensures that we are unable to do IO on a
-         * buffer that hasn't been fully initialised.
-         */
-        bp->b_bn = XFS_BUF_DADDR_NULL;
        atomic_set(&bp->b_pin_count, 0);
        init_waitqueue_head(&bp->b_waiters);
@@ -567,11 +560,6 @@ xfs_buf_get(
        if (bp != new_bp)
                xfs_buf_free(new_bp);
-        /*
-         * Now we have a workable buffer, fill in the block number so
-         * that we can do IO on it.
-         */
-        bp->b_bn = blkno;
        bp->b_io_length = bp->b_length;
 found:
@@ -772,7 +760,7 @@ xfs_buf_get_uncached(
        int                     error, i;
        xfs_buf_t               *bp;
-        bp = xfs_buf_alloc(target, 0, numblks, 0);
+        bp = xfs_buf_alloc(target, XFS_BUF_DADDR_NULL, numblks, 0);
        if (unlikely(bp == NULL))
                goto fail;
@@ -1001,27 +989,6 @@ xfs_buf_ioerror_alert(
                (__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);
 }
-int
-xfs_bwrite(
-        struct xfs_buf          *bp)
-{
-        int                     error;
-        ASSERT(xfs_buf_islocked(bp));
-        bp->b_flags |= XBF_WRITE;
-        bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q);
-        xfs_bdstrat_cb(bp);
-        error = xfs_buf_iowait(bp);
-        if (error) {
-                xfs_force_shutdown(bp->b_target->bt_mount,
-                                   SHUTDOWN_META_IO_ERROR);
-        }
-        return error;
-}
 /*
 * Called when we want to stop a buffer from getting written or read.
 * We attach the EIO error, muck with its flags, and call xfs_buf_ioend
@@ -1091,14 +1058,7 @@ xfs_bioerror_relse(
        return EIO;
 }
+STATIC int
-/*
- * All xfs metadata buffers except log state machine buffers
- * get this attached as their b_bdstrat callback function.
- * This is so that we can catch a buffer
- * after prematurely unpinning it to forcibly shutdown the filesystem.
- */
-int
 xfs_bdstrat_cb(
        struct xfs_buf  *bp)
 {
@@ -1119,6 +1079,27 @@ xfs_bdstrat_cb(
        return 0;
 }
+int
+xfs_bwrite(
+        struct xfs_buf          *bp)
+{
+        int                     error;
+        ASSERT(xfs_buf_islocked(bp));
+        bp->b_flags |= XBF_WRITE;
+        bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q);
+        xfs_bdstrat_cb(bp);
+        error = xfs_buf_iowait(bp);
+        if (error) {
+                xfs_force_shutdown(bp->b_target->bt_mount,
+                                   SHUTDOWN_META_IO_ERROR);
+        }
+        return error;
+}
 /*
 * Wrapper around bdstrat so that we can stop data from going to disk in case
 * we are shutting down the filesystem.  Typically user data goes thru this
@@ -1255,7 +1236,7 @@ xfs_buf_iorequest(
         */
        atomic_set(&bp->b_io_remaining, 1);
        _xfs_buf_ioapply(bp);
-        _xfs_buf_ioend(bp, 0);
+        _xfs_buf_ioend(bp, 1);
        xfs_buf_rele(bp);
 }
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 7f1d1392ce37..79344c48008e 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -180,7 +180,6 @@ extern void xfs_buf_unlock(xfs_buf_t *);
 extern int xfs_bwrite(struct xfs_buf *bp);
 extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
-extern int xfs_bdstrat_cb(struct xfs_buf *);
 extern void xfs_buf_ioend(xfs_buf_t *,  int);
 extern void xfs_buf_ioerror(xfs_buf_t *, int);
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 45df2b857d48..d9e451115f98 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -954,7 +954,7 @@ xfs_buf_iodone_callbacks(
                if (!XFS_BUF_ISSTALE(bp)) {
                        bp->b_flags |= XBF_WRITE | XBF_ASYNC | XBF_DONE;
-                        xfs_bdstrat_cb(bp);
+                        xfs_buf_iorequest(bp);
                } else {
                        xfs_buf_relse(bp);
                }
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 6cdbf90c6f7b..d041d47d9d86 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -505,6 +505,14 @@ xfs_inode_item_push(
        }
        /*
+         * Stale inode items should force out the iclog.
+         */
+        if (ip->i_flags & XFS_ISTALE) {
+                rval = XFS_ITEM_PINNED;
+                goto out_unlock;
+        }
+        /*
         * Someone else is already flushing the inode.  Nothing we can do
         * here but wait for the flush to finish and remove the item from
         * the AIL.
@@ -514,15 +522,6 @@ xfs_inode_item_push(
                goto out_unlock;
        }
-        /*
-         * Stale inode items should force out the iclog.
-         */
-        if (ip->i_flags & XFS_ISTALE) {
-                xfs_ifunlock(ip);
-                xfs_iunlock(ip, XFS_ILOCK_SHARED);
-                return XFS_ITEM_PINNED;
-        }
        ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
        ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 3a05a41b5d76..1f1535d25a9b 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -208,6 +208,7 @@ xfs_open_by_handle(
        struct inode            *inode;
        struct dentry           *dentry;
        fmode_t                 fmode;
+        struct path             path;
        if (!capable(CAP_SYS_ADMIN))
                return -XFS_ERROR(EPERM);
@@ -252,8 +253,10 @@ xfs_open_by_handle(
                goto out_dput;
        }
-        filp = dentry_open(dentry, mntget(parfilp->f_path.mnt),
+        path.mnt = parfilp->f_path.mnt;
-                           hreq->oflags, cred);
+        path.dentry = dentry;
+        filp = dentry_open(&path, hreq->oflags, cred);
+        dput(dentry);
        if (IS_ERR(filp)) {
                put_unused_fd(fd);
                return PTR_ERR(filp);
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 1a25fd802798..9c4340f5c3e0 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -179,7 +179,7 @@ xfs_vn_create(
        struct inode    *dir,
        struct dentry   *dentry,
        umode_t         mode,
-        struct nameidata *nd)
+        bool            flags)
 {
        return xfs_vn_mknod(dir, dentry, mode, 0);
 }
@@ -197,7 +197,7 @@ STATIC struct dentry *
 xfs_vn_lookup(
        struct inode    *dir,
        struct dentry   *dentry,
-        struct nameidata *nd)
+        unsigned int flags)
 {
        struct xfs_inode *cip;
        struct xfs_name name;
@@ -222,7 +222,7 @@ STATIC struct dentry *
 xfs_vn_ci_lookup(
        struct inode    *dir,
        struct dentry   *dentry,
-        struct nameidata *nd)
+        unsigned int flags)
 {
        struct xfs_inode *ip;
        struct xfs_name xname;
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index f30d9807dc48..d90d4a388609 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -38,13 +38,21 @@
 kmem_zone_t     *xfs_log_ticket_zone;
 /* Local miscellaneous function prototypes */
-STATIC int       xlog_commit_record(struct log *log, struct xlog_ticket *ticket,
+STATIC int
-                                    xlog_in_core_t **, xfs_lsn_t *);
+xlog_commit_record(
+        struct xlog             *log,
+        struct xlog_ticket      *ticket,
+        struct xlog_in_core     **iclog,
+        xfs_lsn_t               *commitlsnp);
 STATIC xlog_t *  xlog_alloc_log(xfs_mount_t     *mp,
                                xfs_buftarg_t   *log_target,
                                xfs_daddr_t     blk_offset,
                                int             num_bblks);
-STATIC int       xlog_space_left(struct log *log, atomic64_t *head);
+STATIC int
+xlog_space_left(
+        struct xlog             *log,
+        atomic64_t              *head);
 STATIC int       xlog_sync(xlog_t *log, xlog_in_core_t *iclog);
 STATIC void      xlog_dealloc_log(xlog_t *log);
@@ -64,8 +72,10 @@ STATIC void xlog_state_switch_iclogs(xlog_t		*log,
                                     int                eventual_size);
 STATIC void xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog);
-STATIC void xlog_grant_push_ail(struct log      *log,
+STATIC void
-                                int             need_bytes);
+xlog_grant_push_ail(
+        struct xlog     *log,
+        int             need_bytes);
 STATIC void xlog_regrant_reserve_log_space(xlog_t        *log,
                                           xlog_ticket_t *ticket);
 STATIC void xlog_ungrant_log_space(xlog_t        *log,
@@ -73,7 +83,9 @@ STATIC void xlog_ungrant_log_space(xlog_t	 *log,
 #if defined(DEBUG)
 STATIC void     xlog_verify_dest_ptr(xlog_t *log, char *ptr);
-STATIC void     xlog_verify_grant_tail(struct log *log);
+STATIC void
+xlog_verify_grant_tail(
+        struct xlog     *log);
 STATIC void     xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog,
                                  int count, boolean_t syncing);
 STATIC void     xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog,
@@ -89,9 +101,9 @@ STATIC int	xlog_iclogs_empty(xlog_t *log);
 static void
 xlog_grant_sub_space(
-        struct log      *log,
+        struct xlog             *log,
-        atomic64_t      *head,
+        atomic64_t              *head,
-        int             bytes)
+        int                     bytes)
 {
        int64_t head_val = atomic64_read(head);
        int64_t new, old;
@@ -115,9 +127,9 @@ xlog_grant_sub_space(
 static void
 xlog_grant_add_space(
-        struct log      *log,
+        struct xlog             *log,
-        atomic64_t      *head,
+        atomic64_t              *head,
-        int             bytes)
+        int                     bytes)
 {
        int64_t head_val = atomic64_read(head);
        int64_t new, old;
@@ -165,7 +177,7 @@ xlog_grant_head_wake_all(
 static inline int
 xlog_ticket_reservation(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic)
 {
@@ -182,7 +194,7 @@ xlog_ticket_reservation(
 STATIC bool
 xlog_grant_head_wake(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        int                     *free_bytes)
 {
@@ -204,7 +216,7 @@ xlog_grant_head_wake(
 STATIC int
 xlog_grant_head_wait(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic,
        int                     need_bytes)
@@ -256,7 +268,7 @@ shutdown:
 */
 STATIC int
 xlog_grant_head_check(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic,
        int                     *need_bytes)
@@ -323,7 +335,7 @@ xfs_log_regrant(
        struct xfs_mount        *mp,
        struct xlog_ticket      *tic)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     need_bytes;
        int                     error = 0;
@@ -389,7 +401,7 @@ xfs_log_reserve(
        bool                    permanent,
        uint                    t_type)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_ticket      *tic;
        int                     need_bytes;
        int                     error = 0;
@@ -465,7 +477,7 @@ xfs_log_done(
        struct xlog_in_core     **iclog,
        uint                    flags)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        xfs_lsn_t               lsn = 0;
        if (XLOG_FORCED_SHUTDOWN(log) ||
@@ -810,6 +822,7 @@ xfs_log_unmount_write(xfs_mount_t *mp)
 void
 xfs_log_unmount(xfs_mount_t *mp)
 {
+        cancel_delayed_work_sync(&mp->m_sync_work);
        xfs_trans_ail_destroy(mp);
        xlog_dealloc_log(mp->m_log);
 }
@@ -838,7 +851,7 @@ void
 xfs_log_space_wake(
        struct xfs_mount        *mp)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     free_bytes;
        if (XLOG_FORCED_SHUTDOWN(log))
@@ -916,7 +929,7 @@ xfs_lsn_t
 xlog_assign_tail_lsn_locked(
        struct xfs_mount        *mp)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xfs_log_item     *lip;
        xfs_lsn_t               tail_lsn;
@@ -965,7 +978,7 @@ xlog_assign_tail_lsn(
 */
 STATIC int
 xlog_space_left(
-        struct log      *log,
+        struct xlog     *log,
        atomic64_t      *head)
 {
        int             free_bytes;
@@ -1277,7 +1290,7 @@ out:
 */
 STATIC int
 xlog_commit_record(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_ticket      *ticket,
        struct xlog_in_core     **iclog,
        xfs_lsn_t               *commitlsnp)
@@ -1311,7 +1324,7 @@ xlog_commit_record(
 */
 STATIC void
 xlog_grant_push_ail(
-        struct log      *log,
+        struct xlog     *log,
        int             need_bytes)
 {
        xfs_lsn_t       threshold_lsn = 0;
@@ -1790,7 +1803,7 @@ xlog_write_start_rec(
 static xlog_op_header_t *
 xlog_write_setup_ophdr(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_op_header   *ophdr,
        struct xlog_ticket      *ticket,
        uint                    flags)
@@ -1873,7 +1886,7 @@ xlog_write_setup_copy(
 static int
 xlog_write_copy_finish(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_in_core     *iclog,
        uint                    flags,
        int                     *record_cnt,
@@ -1958,7 +1971,7 @@ xlog_write_copy_finish(
 */
 int
 xlog_write(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *log_vector,
        struct xlog_ticket      *ticket,
        xfs_lsn_t               *start_lsn,
@@ -2821,7 +2834,7 @@ _xfs_log_force(
        uint                    flags,
        int                     *log_flushed)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_in_core     *iclog;
        xfs_lsn_t               lsn;
@@ -2969,7 +2982,7 @@ _xfs_log_force_lsn(
        uint                    flags,
        int                     *log_flushed)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_in_core     *iclog;
        int                     already_slept = 0;
@@ -3147,7 +3160,7 @@ xfs_log_ticket_get(
 */
 xlog_ticket_t *
 xlog_ticket_alloc(
-        struct log      *log,
+        struct xlog     *log,
        int             unit_bytes,
        int             cnt,
        char            client,
@@ -3278,7 +3291,7 @@ xlog_ticket_alloc(
 */
 void
 xlog_verify_dest_ptr(
-        struct log      *log,
+        struct xlog     *log,
        char            *ptr)
 {
        int i;
@@ -3307,7 +3320,7 @@ xlog_verify_dest_ptr(
 */
 STATIC void
 xlog_verify_grant_tail(
-        struct log      *log)
+        struct xlog     *log)
 {
        int             tail_cycle, tail_blocks;
        int             cycle, space;
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index 7d6197c58493..ddc4529d07d3 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -44,7 +44,7 @@
 */
 static struct xlog_ticket *
 xlog_cil_ticket_alloc(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xlog_ticket *tic;
@@ -72,7 +72,7 @@ xlog_cil_ticket_alloc(
 */
 void
 xlog_cil_init_post_recovery(
-        struct log      *log)
+        struct xlog     *log)
 {
        log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
        log->l_cilp->xc_ctx->sequence = 1;
@@ -182,7 +182,7 @@ xlog_cil_prepare_log_vecs(
 */
 STATIC void
 xfs_cil_prepare_item(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *lv,
        int                     *len,
        int                     *diff_iovecs)
@@ -231,7 +231,7 @@ xfs_cil_prepare_item(
 */
 static void
 xlog_cil_insert_items(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *log_vector,
        struct xlog_ticket      *ticket)
 {
@@ -373,7 +373,7 @@ xlog_cil_committed(
 */
 STATIC int
 xlog_cil_push(
-        struct log              *log)
+        struct xlog             *log)
 {
        struct xfs_cil          *cil = log->l_cilp;
        struct xfs_log_vec      *lv;
@@ -601,7 +601,7 @@ xlog_cil_push_work(
 */
 static void
 xlog_cil_push_background(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xfs_cil  *cil = log->l_cilp;
@@ -629,7 +629,7 @@ xlog_cil_push_background(
 static void
 xlog_cil_push_foreground(
-        struct log      *log,
+        struct xlog     *log,
        xfs_lsn_t       push_seq)
 {
        struct xfs_cil  *cil = log->l_cilp;
@@ -683,7 +683,7 @@ xfs_log_commit_cil(
        xfs_lsn_t               *commit_lsn,
        int                     flags)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     log_flags = 0;
        struct xfs_log_vec      *log_vector;
@@ -754,7 +754,7 @@ xfs_log_commit_cil(
 */
 xfs_lsn_t
 xlog_cil_force_lsn(
-        struct log      *log,
+        struct xlog     *log,
        xfs_lsn_t       sequence)
 {
        struct xfs_cil          *cil = log->l_cilp;
@@ -833,7 +833,7 @@ xfs_log_item_in_current_chkpt(
 */
 int
 xlog_cil_init(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xfs_cil  *cil;
        struct xfs_cil_ctx *ctx;
@@ -869,7 +869,7 @@ xlog_cil_init(
 void
 xlog_cil_destroy(
-        struct log      *log)
+        struct xlog     *log)
 {
        if (log->l_cilp->xc_ctx) {
                if (log->l_cilp->xc_ctx->ticket)
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 5bc33261f5be..72eba2201b14 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -19,7 +19,7 @@
 #define __XFS_LOG_PRIV_H__
 struct xfs_buf;
-struct log;
+struct xlog;
 struct xlog_ticket;
 struct xfs_mount;
@@ -352,7 +352,7 @@ typedef struct xlog_in_core {
        struct xlog_in_core     *ic_next;
        struct xlog_in_core     *ic_prev;
        struct xfs_buf          *ic_bp;
-        struct log              *ic_log;
+        struct xlog             *ic_log;
        int                     ic_size;
        int                     ic_offset;
        int                     ic_bwritecnt;
@@ -409,7 +409,7 @@ struct xfs_cil_ctx {
 * operations almost as efficient as the old logging methods.
 */
 struct xfs_cil {
-        struct log              *xc_log;
+        struct xlog             *xc_log;
        struct list_head        xc_cil;
        spinlock_t              xc_cil_lock;
        struct xfs_cil_ctx      *xc_ctx;
@@ -487,7 +487,7 @@ struct xlog_grant_head {
 * overflow 31 bits worth of byte offset, so using a byte number will mean
 * that round off problems won't occur when releasing partial reservations.
 */
-typedef struct log {
+typedef struct xlog {
        /* The following fields don't need locking */
        struct xfs_mount        *l_mp;          /* mount point */
        struct xfs_ail          *l_ailp;        /* AIL log is working with */
@@ -553,9 +553,14 @@ extern int	 xlog_recover_finish(xlog_t *log);
 extern void      xlog_pack_data(xlog_t *log, xlog_in_core_t *iclog, int);
 extern kmem_zone_t *xfs_log_ticket_zone;
-struct xlog_ticket *xlog_ticket_alloc(struct log *log, int unit_bytes,
+struct xlog_ticket *
-                                int count, char client, bool permanent,
+xlog_ticket_alloc(
-                                xfs_km_flags_t alloc_flags);
+        struct xlog     *log,
+        int             unit_bytes,
+        int             count,
+        char            client,
+        bool            permanent,
+        xfs_km_flags_t  alloc_flags);
 static inline void
@@ -567,9 +572,14 @@ xlog_write_adv_cnt(void **ptr, int *len, int *off, size_t bytes)
 }
 void    xlog_print_tic_res(struct xfs_mount *mp, struct xlog_ticket *ticket);
-int     xlog_write(struct log *log, struct xfs_log_vec *log_vector,
+int
-                                struct xlog_ticket *tic, xfs_lsn_t *start_lsn,
+xlog_write(
-                                xlog_in_core_t **commit_iclog, uint flags);
+        struct xlog             *log,
+        struct xfs_log_vec      *log_vector,
+        struct xlog_ticket      *tic,
+        xfs_lsn_t               *start_lsn,
+        struct xlog_in_core     **commit_iclog,
+        uint                    flags);
 /*
 * When we crack an atomic LSN, we sample it first so that the value will not
@@ -629,17 +639,23 @@ xlog_assign_grant_head(atomic64_t *head, int cycle, int space)
 /*
 * Committed Item List interfaces
 */
-int     xlog_cil_init(struct log *log);
+int
-void    xlog_cil_init_post_recovery(struct log *log);
+xlog_cil_init(struct xlog *log);
-void    xlog_cil_destroy(struct log *log);
+void
+xlog_cil_init_post_recovery(struct xlog *log);
+void
+xlog_cil_destroy(struct xlog *log);
 /*
 * CIL force routines
 */
-xfs_lsn_t xlog_cil_force_lsn(struct log *log, xfs_lsn_t sequence);
+xfs_lsn_t
+xlog_cil_force_lsn(
+        struct xlog *log,
+        xfs_lsn_t sequence);
 static inline void
-xlog_cil_force(struct log *log)
+xlog_cil_force(struct xlog *log)
 {
        xlog_cil_force_lsn(log, log->l_cilp->xc_current_sequence);
 }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index ca386909131a..a7be98abd6a9 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1471,8 +1471,8 @@ xlog_recover_add_item(
 STATIC int
 xlog_recover_add_to_cont_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        xfs_caddr_t             dp,
        int                     len)
 {
@@ -1517,8 +1517,8 @@ xlog_recover_add_to_cont_trans(
 */
 STATIC int
 xlog_recover_add_to_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        xfs_caddr_t             dp,
        int                     len)
 {
@@ -1588,8 +1588,8 @@ xlog_recover_add_to_trans(
 */
 STATIC int
 xlog_recover_reorder_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        int                     pass)
 {
        xlog_recover_item_t     *item, *n;
@@ -1642,8 +1642,8 @@ xlog_recover_reorder_trans(
 */
 STATIC int
 xlog_recover_buffer_pass1(
-        struct log              *log,
+        struct xlog                     *log,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        xfs_buf_log_format_t    *buf_f = item->ri_buf[0].i_addr;
        struct list_head        *bucket;
@@ -1696,7 +1696,7 @@ xlog_recover_buffer_pass1(
 */
 STATIC int
 xlog_check_buffer_cancelled(
-        struct log              *log,
+        struct xlog             *log,
        xfs_daddr_t             blkno,
        uint                    len,
        ushort                  flags)
@@ -2689,9 +2689,9 @@ xlog_recover_free_trans(
 STATIC int
 xlog_recover_commit_pass1(
-        struct log              *log,
+        struct xlog                     *log,
-        struct xlog_recover     *trans,
+        struct xlog_recover             *trans,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
@@ -2716,10 +2716,10 @@ xlog_recover_commit_pass1(
 STATIC int
 xlog_recover_commit_pass2(
-        struct log              *log,
+        struct xlog                     *log,
-        struct xlog_recover     *trans,
+        struct xlog_recover             *trans,
-        struct list_head        *buffer_list,
+        struct list_head                *buffer_list,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
@@ -2753,7 +2753,7 @@ xlog_recover_commit_pass2(
 */
 STATIC int
 xlog_recover_commit_trans(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_recover     *trans,
        int                     pass)
 {
@@ -2793,8 +2793,8 @@ out:
 STATIC int
 xlog_recover_unmount_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans)
+        struct xlog_recover     *trans)
 {
        /* Do nothing now */
        xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 8b89c5ac72d9..90c1fc9eaea4 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -53,7 +53,7 @@ typedef struct xfs_trans_reservations {
 #include "xfs_sync.h"
-struct log;
+struct xlog;
 struct xfs_mount_args;
 struct xfs_inode;
 struct xfs_bmbt_irec;
@@ -133,7 +133,7 @@ typedef struct xfs_mount {
        uint                    m_readio_blocks; /* min read size blocks */
        uint                    m_writeio_log;  /* min write size log bytes */
        uint                    m_writeio_blocks; /* min write size blocks */
-        struct log              *m_log;         /* log specific stuff */
+        struct xlog             *m_log;         /* log specific stuff */
        int                     m_logbufs;      /* number of log buffers */
        int                     m_logbsize;     /* size of each log buffer */
        uint                    m_rsumlevels;   /* rt summary levels */
diff --git a/fs/xfs/xfs_sync.c b/fs/xfs/xfs_sync.c
index c9d3409c5ca3..1e9ee064dbb2 100644
--- a/fs/xfs/xfs_sync.c
+++ b/fs/xfs/xfs_sync.c
@@ -386,23 +386,23 @@ xfs_sync_worker(
         * We shouldn't write/force the log if we are in the mount/unmount
         * process or on a read only filesystem. The workqueue still needs to be
         * active in both cases, however, because it is used for inode reclaim
-         * during these times.  Use the s_umount semaphore to provide exclusion
+         * during these times.  Use the MS_ACTIVE flag to avoid doing anything
-         * with unmount.
+         * during mount.  Doing work during unmount is avoided by calling
+         * cancel_delayed_work_sync on this work queue before tearing down
+         * the ail and the log in xfs_log_unmount.
         */
-        if (down_read_trylock(&mp->m_super->s_umount)) {
+        if (!(mp->m_super->s_flags & MS_ACTIVE) &&
-                if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
+            !(mp->m_flags & XFS_MOUNT_RDONLY)) {
-                        /* dgc: errors ignored here */
+                /* dgc: errors ignored here */
-                        if (mp->m_super->s_frozen == SB_UNFROZEN &&
+                if (mp->m_super->s_frozen == SB_UNFROZEN &&
-                            xfs_log_need_covered(mp))
+                    xfs_log_need_covered(mp))
-                                error = xfs_fs_log_dummy(mp);
+                        error = xfs_fs_log_dummy(mp);
-                        else
+                else
-                                xfs_log_force(mp, 0);
+                        xfs_log_force(mp, 0);
-                        /* start pushing all the metadata that is currently
+                /* start pushing all the metadata that is currently
-                         * dirty */
+                 * dirty */
-                        xfs_ail_push_all(mp->m_ail);
+                xfs_ail_push_all(mp->m_ail);
-                }
-                up_read(&mp->m_super->s_umount);
        }
        /* queue us up again */
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 7cf9d3529e51..caf5dabfd553 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -32,7 +32,7 @@ struct xfs_da_node_entry;
 struct xfs_dquot;
 struct xfs_log_item;
 struct xlog_ticket;
-struct log;
+struct xlog;
 struct xlog_recover;
 struct xlog_recover_item;
 struct xfs_buf_log_format;
@@ -762,7 +762,7 @@ DEFINE_DQUOT_EVENT(xfs_dqflush_force);
 DEFINE_DQUOT_EVENT(xfs_dqflush_done);
 DECLARE_EVENT_CLASS(xfs_loggrant_class,
-        TP_PROTO(struct log *log, struct xlog_ticket *tic),
+        TP_PROTO(struct xlog *log, struct xlog_ticket *tic),
        TP_ARGS(log, tic),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -830,7 +830,7 @@ DECLARE_EVENT_CLASS(xfs_loggrant_class,
 #define DEFINE_LOGGRANT_EVENT(name) \
 DEFINE_EVENT(xfs_loggrant_class, name, \
-        TP_PROTO(struct log *log, struct xlog_ticket *tic), \
+        TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \
        TP_ARGS(log, tic))
 DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm);
 DEFINE_LOGGRANT_EVENT(xfs_log_done_perm);
@@ -1664,7 +1664,7 @@ DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before);
 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after);
 DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
-        TP_PROTO(struct log *log, struct xlog_recover *trans,
+        TP_PROTO(struct xlog *log, struct xlog_recover *trans,
                struct xlog_recover_item *item, int pass),
        TP_ARGS(log, trans, item, pass),
        TP_STRUCT__entry(
@@ -1698,7 +1698,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
 #define DEFINE_LOG_RECOVER_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_item_class, name, \
-        TP_PROTO(struct log *log, struct xlog_recover *trans, \
+        TP_PROTO(struct xlog *log, struct xlog_recover *trans, \
                struct xlog_recover_item *item, int pass), \
        TP_ARGS(log, trans, item, pass))
@@ -1709,7 +1709,7 @@ DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail);
 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover);
 DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
-        TP_PROTO(struct log *log, struct xfs_buf_log_format *buf_f),
+        TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f),
        TP_ARGS(log, buf_f),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -1739,7 +1739,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
 #define DEFINE_LOG_RECOVER_BUF_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \
-        TP_PROTO(struct log *log, struct xfs_buf_log_format *buf_f), \
+        TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \
        TP_ARGS(log, buf_f))
 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel);
@@ -1752,7 +1752,7 @@ DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf);
 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf);
 DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
-        TP_PROTO(struct log *log, struct xfs_inode_log_format *in_f),
+        TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f),
        TP_ARGS(log, in_f),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -1790,7 +1790,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
 )
 #define DEFINE_LOG_RECOVER_INO_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \
-        TP_PROTO(struct log *log, struct xfs_inode_log_format *in_f), \
+        TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \
        TP_ARGS(log, in_f))
 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover);