18 files changed, 238 insertions, 247 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index 062177956239..aae0686a15fb 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -29,6 +29,7 @@ config EXT2_FS_XATTR
 config EXT2_FS_POSIX_ACL
         bool "Ext2 POSIX Access Control Lists"
         depends on EXT2_FS_XATTR
+        select FS_POSIX_ACL
         help
           Posix Access Control Lists (ACLs) support permissions for users and
           groups beyond the owner/group/world scheme.
@@ -114,6 +115,7 @@ config EXT3_FS_XATTR
 config EXT3_FS_POSIX_ACL
         bool "Ext3 POSIX Access Control Lists"
         depends on EXT3_FS_XATTR
+        select FS_POSIX_ACL
         help
           Posix Access Control Lists (ACLs) support permissions for users and
           groups beyond the owner/group/world scheme.
@@ -241,6 +243,7 @@ config REISERFS_FS_XATTR
 config REISERFS_FS_POSIX_ACL
         bool "ReiserFS POSIX Access Control Lists"
         depends on REISERFS_FS_XATTR
+        select FS_POSIX_ACL
         help
           Posix Access Control Lists (ACLs) support permissions for users and
           groups beyond the owner/group/world scheme.
@@ -274,6 +277,7 @@ config JFS_FS
 config JFS_POSIX_ACL
         bool "JFS POSIX Access Control Lists"
         depends on JFS_FS
+        select FS_POSIX_ACL
         help
           Posix Access Control Lists (ACLs) support permissions for users and
           groups beyond the owner/group/world scheme.
@@ -318,8 +322,7 @@ config FS_POSIX_ACL
 #       Never use this symbol for ifdefs.
 #
         bool
-        depends on EXT2_FS_POSIX_ACL || EXT3_FS_POSIX_ACL || JFS_POSIX_ACL || REISERFS_FS_POSIX_ACL || NFSD_V4
-        default y
+        default n
 
 source "fs/xfs/Kconfig"
 
@@ -1438,6 +1441,7 @@ config NFSD_V4
         select NFSD_TCP
         select CRYPTO_MD5
         select CRYPTO
+        select FS_POSIX_ACL
         help
           If you would like to include the NFSv4 server as well as the NFSv2
           and NFSv3 servers, say Y here.  This feature is experimental, and
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index fa2348dcd671..3df86285a1c7 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -231,8 +231,8 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                 int type = (notify == NFY_MOUNT ?
                         autofs_ptype_missing : autofs_ptype_expire_multi);
 
-                DPRINTK(("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
-                        (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify));
+                DPRINTK("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
+                        (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify);
 
                 /* autofs4_notify_daemon() may block */
                 autofs4_notify_daemon(sbi, wq, type);
diff --git a/fs/bio.c b/fs/bio.c
index 3a1472acc361..ca8f7a850fe3 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -52,7 +52,7 @@ struct biovec_slab {
  */
 
 #define BV(x) { .nr_vecs = x, .name = "biovec-"__stringify(x) }
-static struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] = {
+static struct biovec_slab bvec_slabs[BIOVEC_NR_POOLS] __read_mostly = {
         BV(1), BV(4), BV(16), BV(64), BV(128), BV(BIO_MAX_PAGES),
 };
 #undef BV
diff --git a/fs/buffer.c b/fs/buffer.c
index 561e63a14966..6a25d7df89b1 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -513,8 +513,8 @@ static void free_more_memory(void)
  */
 static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
 {
-        static DEFINE_SPINLOCK(page_uptodate_lock);
         unsigned long flags;
+        struct buffer_head *first;
         struct buffer_head *tmp;
         struct page *page;
         int page_uptodate = 1;
@@ -536,7 +536,9 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
          * two buffer heads end IO at almost the same time and both
          * decide that the page is now completely done.
          */
-        spin_lock_irqsave(&page_uptodate_lock, flags);
+        first = page_buffers(page);
+        local_irq_save(flags);
+        bit_spin_lock(BH_Uptodate_Lock, &first->b_state);
         clear_buffer_async_read(bh);
         unlock_buffer(bh);
         tmp = bh;
@@ -549,7 +551,8 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
                 }
                 tmp = tmp->b_this_page;
         } while (tmp != bh);
-        spin_unlock_irqrestore(&page_uptodate_lock, flags);
+        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
+        local_irq_restore(flags);
 
         /*
          * If none of the buffers had errors and they are all
@@ -561,7 +564,8 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)
         return;
 
 still_busy:
-        spin_unlock_irqrestore(&page_uptodate_lock, flags);
+        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
+        local_irq_restore(flags);
         return;
 }
 
@@ -572,8 +576,8 @@ still_busy:
 void end_buffer_async_write(struct buffer_head *bh, int uptodate)
 {
         char b[BDEVNAME_SIZE];
-        static DEFINE_SPINLOCK(page_uptodate_lock);
         unsigned long flags;
+        struct buffer_head *first;
         struct buffer_head *tmp;
         struct page *page;
 
@@ -594,7 +598,10 @@ void end_buffer_async_write(struct buffer_head *bh, int uptodate)
                 SetPageError(page);
         }
 
-        spin_lock_irqsave(&page_uptodate_lock, flags);
+        first = page_buffers(page);
+        local_irq_save(flags);
+        bit_spin_lock(BH_Uptodate_Lock, &first->b_state);
+
         clear_buffer_async_write(bh);
         unlock_buffer(bh);
         tmp = bh->b_this_page;
@@ -605,12 +612,14 @@ void end_buffer_async_write(struct buffer_head *bh, int uptodate)
                 }
                 tmp = tmp->b_this_page;
         }
-        spin_unlock_irqrestore(&page_uptodate_lock, flags);
+        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
+        local_irq_restore(flags);
         end_page_writeback(page);
         return;
 
 still_busy:
-        spin_unlock_irqrestore(&page_uptodate_lock, flags);
+        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);
+        local_irq_restore(flags);
         return;
 }
 
diff --git a/fs/dcookies.c b/fs/dcookies.c
index 581aac959cd3..02aa0ddc582a 100644
--- a/fs/dcookies.c
+++ b/fs/dcookies.c
@@ -94,12 +94,10 @@ static struct dcookie_struct * alloc_dcookie(struct dentry * dentry,
         if (!dcs)
                 return NULL;
 
-        atomic_inc(&dentry->d_count);
-        atomic_inc(&vfsmnt->mnt_count);
         dentry->d_cookie = dcs;
 
-        dcs->dentry = dentry;
-        dcs->vfsmnt = vfsmnt;
+        dcs->dentry = dget(dentry);
+        dcs->vfsmnt = mntget(vfsmnt);
         hash_dcookie(dcs);
 
         return dcs;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 0b2db4f618cb..9989fdcf4d5a 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -2663,7 +2663,7 @@ static int ext3_do_update_inode(handle_t *handle,
         } else for (block = 0; block < EXT3_N_BLOCKS; block++)
                 raw_inode->i_block[block] = ei->i_data[block];
 
-        if (EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE)
+        if (ei->i_extra_isize)
                 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
 
         BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs_kern.c
index f8e0cbd0cb60..6f553e17c375 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs_kern.c
@@ -4,6 +4,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/file.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -491,7 +492,7 @@ static int hppfs_open(struct inode *inode, struct file *file)
                 fd = open_host_sock(host_file, &filter);
                 if(fd > 0){
                         data->contents = hppfs_get_data(fd, filter,
-                                                        &data->proc_file,
+                                                        data->proc_file,
                                                         file, &data->len);
                         if(!IS_ERR(data->contents))
                                 data->host_fd = fd;
@@ -543,7 +544,7 @@ static int hppfs_dir_open(struct inode *inode, struct file *file)
 static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
 {
         struct hppfs_private *data = file->private_data;
-        struct file *proc_file = &data->proc_file;
+        struct file *proc_file = data->proc_file;
         loff_t (*llseek)(struct file *, loff_t, int);
         loff_t ret;
 
@@ -586,7 +587,7 @@ static int hppfs_filldir(void *d, const char *name, int size,
 static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
 {
         struct hppfs_private *data = file->private_data;
-        struct file *proc_file = &data->proc_file;
+        struct file *proc_file = data->proc_file;
         int (*readdir)(struct file *, void *, filldir_t);
         struct hppfs_dirent dirent = ((struct hppfs_dirent)
                                       { .vfs_dirent     = ent,
diff --git a/fs/inode.c b/fs/inode.c
index 1f9a3a2b89bc..6d695037a0a3 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1052,7 +1052,7 @@ static void generic_forget_inode(struct inode *inode)
  * inode when the usage count drops to zero, and
  * i_nlink is zero.
  */
-static void generic_drop_inode(struct inode *inode)
+void generic_drop_inode(struct inode *inode)
 {
         if (!inode->i_nlink)
                 generic_delete_inode(inode);
@@ -1060,6 +1060,8 @@ static void generic_drop_inode(struct inode *inode)
                 generic_forget_inode(inode);
 }
 
+EXPORT_SYMBOL_GPL(generic_drop_inode);
+
 /*
  * Called when we're dropping the last reference
  * to an inode. 
diff --git a/fs/ioprio.c b/fs/ioprio.c
index 663e420636d6..97e1f088ba00 100644
--- a/fs/ioprio.c
+++ b/fs/ioprio.c
@@ -43,7 +43,7 @@ static int set_task_ioprio(struct task_struct *task, int ioprio)
         return 0;
 }
 
-asmlinkage int sys_ioprio_set(int which, int who, int ioprio)
+asmlinkage long sys_ioprio_set(int which, int who, int ioprio)
 {
         int class = IOPRIO_PRIO_CLASS(ioprio);
         int data = IOPRIO_PRIO_DATA(ioprio);
@@ -115,7 +115,7 @@ asmlinkage int sys_ioprio_set(int which, int who, int ioprio)
         return ret;
 }
 
-asmlinkage int sys_ioprio_get(int which, int who)
+asmlinkage long sys_ioprio_get(int which, int who)
 {
         struct task_struct *g, *p;
         struct user_struct *user;
diff --git a/fs/locks.c b/fs/locks.c
index a0bc03495bd4..29fa5da6c117 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1276,7 +1276,7 @@ int fcntl_getlease(struct file *filp)
  */
 static int __setlease(struct file *filp, long arg, struct file_lock **flp)
 {
-        struct file_lock *fl, **before, **my_before = NULL, *lease = *flp;
+        struct file_lock *fl, **before, **my_before = NULL, *lease;
         struct dentry *dentry = filp->f_dentry;
         struct inode *inode = dentry->d_inode;
         int error, rdlease_count = 0, wrlease_count = 0;
@@ -1287,6 +1287,8 @@ static int __setlease(struct file *filp, long arg, struct file_lock **flp)
         if (!flp || !(*flp) || !(*flp)->fl_lmops || !(*flp)->fl_lmops->fl_break)
                 goto out;
 
+        lease = *flp;
+
         error = -EAGAIN;
         if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
                 goto out;
diff --git a/fs/namei.c b/fs/namei.c
index fa8df81ce8ca..1d93cb4f7c5f 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -314,7 +314,7 @@ void path_release(struct nameidata *nd)
 void path_release_on_umount(struct nameidata *nd)
 {
         dput(nd->dentry);
-        _mntput(nd->mnt);
+        mntput_no_expire(nd->mnt);
 }
 
 /*
diff --git a/fs/namespace.c b/fs/namespace.c
index 208c079e9fdb..587eb0d707ee 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -61,7 +61,7 @@ struct vfsmount *alloc_vfsmnt(const char *name)
                 INIT_LIST_HEAD(&mnt->mnt_child);
                 INIT_LIST_HEAD(&mnt->mnt_mounts);
                 INIT_LIST_HEAD(&mnt->mnt_list);
-                INIT_LIST_HEAD(&mnt->mnt_fslink);
+                INIT_LIST_HEAD(&mnt->mnt_expire);
                 if (name) {
                         int size = strlen(name)+1;
                         char *newname = kmalloc(size, GFP_KERNEL);
@@ -165,8 +165,8 @@ clone_mnt(struct vfsmount *old, struct dentry *root)
                 /* stick the duplicate mount on the same expiry list
                  * as the original if that was on one */
                 spin_lock(&vfsmount_lock);
-                if (!list_empty(&old->mnt_fslink))
-                        list_add(&mnt->mnt_fslink, &old->mnt_fslink);
+                if (!list_empty(&old->mnt_expire))
+                        list_add(&mnt->mnt_expire, &old->mnt_expire);
                 spin_unlock(&vfsmount_lock);
         }
         return mnt;
@@ -345,12 +345,13 @@ static void umount_tree(struct vfsmount *mnt)
         for (p = mnt; p; p = next_mnt(p, mnt)) {
                 list_del(&p->mnt_list);
                 list_add(&p->mnt_list, &kill);
+                p->mnt_namespace = NULL;
         }
 
         while (!list_empty(&kill)) {
                 mnt = list_entry(kill.next, struct vfsmount, mnt_list);
                 list_del_init(&mnt->mnt_list);
-                list_del_init(&mnt->mnt_fslink);
+                list_del_init(&mnt->mnt_expire);
                 if (mnt->mnt_parent == mnt) {
                         spin_unlock(&vfsmount_lock);
                 } else {
@@ -644,7 +645,7 @@ static int do_loopback(struct nameidata *nd, char *old_name, int recurse)
         if (mnt) {
                 /* stop bind mounts from expiring */
                 spin_lock(&vfsmount_lock);
-                list_del_init(&mnt->mnt_fslink);
+                list_del_init(&mnt->mnt_expire);
                 spin_unlock(&vfsmount_lock);
 
                 err = graft_tree(mnt, nd);
@@ -743,7 +744,7 @@ static int do_move_mount(struct nameidata *nd, char *old_name)
 
         /* if the mount is moved, it should no longer be expire
          * automatically */
-        list_del_init(&old_nd.mnt->mnt_fslink);
+        list_del_init(&old_nd.mnt->mnt_expire);
 out2:
         spin_unlock(&vfsmount_lock);
 out1:
@@ -807,12 +808,13 @@ int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
                 goto unlock;
 
         newmnt->mnt_flags = mnt_flags;
+        newmnt->mnt_namespace = current->namespace;
         err = graft_tree(newmnt, nd);
 
         if (err == 0 && fslist) {
                 /* add to the specified expiration list */
                 spin_lock(&vfsmount_lock);
-                list_add_tail(&newmnt->mnt_fslink, fslist);
+                list_add_tail(&newmnt->mnt_expire, fslist);
                 spin_unlock(&vfsmount_lock);
         }
 
@@ -824,6 +826,54 @@ unlock:
 
 EXPORT_SYMBOL_GPL(do_add_mount);
 
+static void expire_mount(struct vfsmount *mnt, struct list_head *mounts)
+{
+        spin_lock(&vfsmount_lock);
+
+        /*
+         * Check if mount is still attached, if not, let whoever holds it deal
+         * with the sucker
+         */
+        if (mnt->mnt_parent == mnt) {
+                spin_unlock(&vfsmount_lock);
+                return;
+        }
+
+        /*
+         * Check that it is still dead: the count should now be 2 - as
+         * contributed by the vfsmount parent and the mntget above
+         */
+        if (atomic_read(&mnt->mnt_count) == 2) {
+                struct nameidata old_nd;
+
+                /* delete from the namespace */
+                list_del_init(&mnt->mnt_list);
+                mnt->mnt_namespace = NULL;
+                detach_mnt(mnt, &old_nd);
+                spin_unlock(&vfsmount_lock);
+                path_release(&old_nd);
+
+                /*
+                 * Now lay it to rest if this was the last ref on the superblock
+                 */
+                if (atomic_read(&mnt->mnt_sb->s_active) == 1) {
+                        /* last instance - try to be smart */
+                        lock_kernel();
+                        DQUOT_OFF(mnt->mnt_sb);
+                        acct_auto_close(mnt->mnt_sb);
+                        unlock_kernel();
+                }
+                mntput(mnt);
+        } else {
+                /*
+                 * Someone brought it back to life whilst we didn't have any
+                 * locks held so return it to the expiration list
+                 */
+                list_add_tail(&mnt->mnt_expire, mounts);
+                spin_unlock(&vfsmount_lock);
+        }
+}
+
 /*
  * process a list of expirable mountpoints with the intent of discarding any
  * mountpoints that aren't in use and haven't been touched since last we came
@@ -846,13 +896,13 @@ void mark_mounts_for_expiry(struct list_head *mounts)
          * - still marked for expiry (marked on the last call here; marks are
          *   cleared by mntput())
          */
-        list_for_each_entry_safe(mnt, next, mounts, mnt_fslink) {
+        list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
                 if (!xchg(&mnt->mnt_expiry_mark, 1) ||
                     atomic_read(&mnt->mnt_count) != 1)
                         continue;
 
                 mntget(mnt);
-                list_move(&mnt->mnt_fslink, &graveyard);
+                list_move(&mnt->mnt_expire, &graveyard);
         }
 
         /*
@@ -862,61 +912,19 @@ void mark_mounts_for_expiry(struct list_head *mounts)
          * - dispose of the corpse
          */
         while (!list_empty(&graveyard)) {
-                mnt = list_entry(graveyard.next, struct vfsmount, mnt_fslink);
-                list_del_init(&mnt->mnt_fslink);
+                mnt = list_entry(graveyard.next, struct vfsmount, mnt_expire);
+                list_del_init(&mnt->mnt_expire);
 
                 /* don't do anything if the namespace is dead - all the
                  * vfsmounts from it are going away anyway */
                 namespace = mnt->mnt_namespace;
-                if (!namespace || atomic_read(&namespace->count) <= 0)
+                if (!namespace || !namespace->root)
                         continue;
                 get_namespace(namespace);
 
                 spin_unlock(&vfsmount_lock);
                 down_write(&namespace->sem);
-                spin_lock(&vfsmount_lock);
-
-                /* check that it is still dead: the count should now be 2 - as
-                 * contributed by the vfsmount parent and the mntget above */
-                if (atomic_read(&mnt->mnt_count) == 2) {
-                        struct vfsmount *xdmnt;
-                        struct dentry *xdentry;
-
-                        /* delete from the namespace */
-                        list_del_init(&mnt->mnt_list);
-                        list_del_init(&mnt->mnt_child);
-                        list_del_init(&mnt->mnt_hash);
-                        mnt->mnt_mountpoint->d_mounted--;
-
-                        xdentry = mnt->mnt_mountpoint;
-                        mnt->mnt_mountpoint = mnt->mnt_root;
-                        xdmnt = mnt->mnt_parent;
-                        mnt->mnt_parent = mnt;
-
-                        spin_unlock(&vfsmount_lock);
-
-                        mntput(xdmnt);
-                        dput(xdentry);
-
-                        /* now lay it to rest if this was the last ref on the
-                         * superblock */
-                        if (atomic_read(&mnt->mnt_sb->s_active) == 1) {
-                                /* last instance - try to be smart */
-                                lock_kernel();
-                                DQUOT_OFF(mnt->mnt_sb);
-                                acct_auto_close(mnt->mnt_sb);
-                                unlock_kernel();
-                        }
-
-                        mntput(mnt);
-                } else {
-                        /* someone brought it back to life whilst we didn't
-                         * have any locks held so return it to the expiration
-                         * list */
-                        list_add_tail(&mnt->mnt_fslink, mounts);
-                        spin_unlock(&vfsmount_lock);
-                }
-
+                expire_mount(mnt, mounts);
                 up_write(&namespace->sem);
 
                 mntput(mnt);
@@ -1449,16 +1457,12 @@ void __init mnt_init(unsigned long mempages)
 
 void __put_namespace(struct namespace *namespace)
 {
-        struct vfsmount *mnt;
-
+        struct vfsmount *root = namespace->root;
+        namespace->root = NULL;
+        spin_unlock(&vfsmount_lock);
         down_write(&namespace->sem);
         spin_lock(&vfsmount_lock);
-
-        list_for_each_entry(mnt, &namespace->list, mnt_list) {
-                mnt->mnt_namespace = NULL;
-        }
-
-        umount_tree(namespace->root);
+        umount_tree(root);
         spin_unlock(&vfsmount_lock);
         up_write(&namespace->sem);
         kfree(namespace);
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index d71f14517b9c..e08edc17c6a0 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -169,12 +169,6 @@ nfsd4_open(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open
                 (int)open->op_fname.len, open->op_fname.data,
                 open->op_stateowner);
 
-        if (nfs4_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
-                return nfserr_grace;
-
-        if (!nfs4_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
-                return nfserr_no_grace;
-
         /* This check required by spec. */
         if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
                 return nfserr_inval;
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index 095f1740f3ae..57ed50fe7f85 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -119,25 +119,12 @@ out:
         return status;
 }
 
-static int
-nfsd4_rec_fsync(struct dentry *dentry)
+static void
+nfsd4_sync_rec_dir(void)
 {
-        struct file *filp;
-        int status = nfs_ok;
-
-        dprintk("NFSD: nfs4_fsync_rec_dir\n");
-        filp = dentry_open(dget(dentry), mntget(rec_dir.mnt), O_RDWR);
-        if (IS_ERR(filp)) {
-                status = PTR_ERR(filp);
-                goto out;
-        }
-        if (filp->f_op && filp->f_op->fsync)
-                status = filp->f_op->fsync(filp, filp->f_dentry, 0);
-        fput(filp);
-out:
-        if (status)
-                printk("nfsd4: unable to sync recovery directory\n");
-        return status;
+        down(&rec_dir.dentry->d_inode->i_sem);
+        nfsd_sync_dir(rec_dir.dentry);
+        up(&rec_dir.dentry->d_inode->i_sem);
 }
 
 int
@@ -176,7 +163,7 @@ out_unlock:
         up(&rec_dir.dentry->d_inode->i_sem);
         if (status == 0) {
                 clp->cl_firststate = 1;
-                status = nfsd4_rec_fsync(rec_dir.dentry);
+                nfsd4_sync_rec_dir();
         }
         nfs4_reset_user(uid, gid);
         dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status);
@@ -302,7 +289,9 @@ nfsd4_unlink_clid_dir(char *name, int namlen)
 
         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 
+        down(&rec_dir.dentry->d_inode->i_sem);
         dentry = lookup_one_len(name, rec_dir.dentry, namlen);
+        up(&rec_dir.dentry->d_inode->i_sem);
         if (IS_ERR(dentry)) {
                 status = PTR_ERR(dentry);
                 return status;
@@ -327,11 +316,12 @@ nfsd4_remove_clid_dir(struct nfs4_client *clp)
         if (!rec_dir_init || !clp->cl_firststate)
                 return;
 
+        clp->cl_firststate = 0;
         nfs4_save_user(&uid, &gid);
         status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
         nfs4_reset_user(uid, gid);
         if (status == 0)
-                status = nfsd4_rec_fsync(rec_dir.dentry);
+                nfsd4_sync_rec_dir();
         if (status)
                 printk("NFSD: Failed to remove expired client state directory"
                                 " %.*s\n", HEXDIR_LEN, clp->cl_recdir);
@@ -362,7 +352,7 @@ nfsd4_recdir_purge_old(void) {
                 return;
         status = nfsd4_list_rec_dir(rec_dir.dentry, purge_old);
         if (status == 0)
-                status = nfsd4_rec_fsync(rec_dir.dentry);
+                nfsd4_sync_rec_dir();
         if (status)
                 printk("nfsd4: failed to purge old clients from recovery"
                         " directory %s\n", rec_dir.dentry->d_name.name);
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 89e36526d7f2..b83f8fb441e1 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -874,6 +874,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, struct nfsd4_setclientid_confi
                           * change request correctly. */
                         atomic_set(&conf->cl_callback.cb_set, 0);
                         gen_confirm(conf);
+                        nfsd4_remove_clid_dir(unconf);
                         expire_client(unconf);
                         status = nfs_ok;
 
@@ -1159,6 +1160,7 @@ init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *
         stp->st_deny_bmap = 0;
         __set_bit(open->op_share_access, &stp->st_access_bmap);
         __set_bit(open->op_share_deny, &stp->st_deny_bmap);
+        stp->st_openstp = NULL;
 }
 
 static void
@@ -1294,7 +1296,7 @@ nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
         fp = find_file(ino);
         if (!fp)
                 return nfs_ok;
-        ret = nfserr_share_denied;
+        ret = nfserr_locked;
         /* Search for conflicting share reservations */
         list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
                 if (test_bit(deny_type, &stp->st_deny_bmap) ||
@@ -1482,7 +1484,7 @@ nfsd4_process_open1(struct nfsd4_open *open)
         if (sop) {
                 open->op_stateowner = sop;
                 /* check for replay */
-                if (open->op_seqid == sop->so_seqid){
+                if (open->op_seqid == sop->so_seqid - 1){
                         if (sop->so_replay.rp_buflen)
                                 return NFSERR_REPLAY_ME;
                         else {
@@ -1497,7 +1499,7 @@ nfsd4_process_open1(struct nfsd4_open *open)
                                 goto renew;
                         }
                 } else if (sop->so_confirmed) {
-                        if (open->op_seqid == sop->so_seqid + 1)
+                        if (open->op_seqid == sop->so_seqid)
                                 goto renew;
                         status = nfserr_bad_seqid;
                         goto out;
@@ -1530,8 +1532,6 @@ renew:
         status = nfs_ok;
         renew_client(sop->so_client);
 out:
-        if (status && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
-                status = nfserr_reclaim_bad;
         return status;
 }
 
@@ -1685,19 +1685,11 @@ nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_sta
 }
 
 
-/* decrement seqid on successful reclaim, it will be bumped in encode_open */
 static void
-nfs4_set_claim_prev(struct nfsd4_open *open, int *status)
+nfs4_set_claim_prev(struct nfsd4_open *open)
 {
-        if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) {
-                if (*status)
-                        *status = nfserr_reclaim_bad;
-                else {
-                        open->op_stateowner->so_confirmed = 1;
-                        open->op_stateowner->so_client->cl_firststate = 1;
-                        open->op_stateowner->so_seqid--;
-                }
-        }
+        open->op_stateowner->so_confirmed = 1;
+        open->op_stateowner->so_client->cl_firststate = 1;
 }
 
 /*
@@ -1789,6 +1781,12 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf
         struct nfs4_delegation *dp = NULL;
         int status;
 
+        if (nfs4_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
+                return nfserr_grace;
+
+        if (!nfs4_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
+                return nfserr_no_grace;
+
         status = nfserr_inval;
         if (!TEST_ACCESS(open->op_share_access) || !TEST_DENY(open->op_share_deny))
                 goto out;
@@ -1823,6 +1821,7 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf
                 status = nfs4_upgrade_open(rqstp, current_fh, stp, open);
                 if (status)
                         goto out;
+                update_stateid(&stp->st_stateid);
         } else {
                 /* Stateid was not found, this is a new OPEN */
                 int flags = 0;
@@ -1856,8 +1855,8 @@ nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nf
 out:
         if (fp)
                 put_nfs4_file(fp);
-        /* CLAIM_PREVIOUS has different error returns */
-        nfs4_set_claim_prev(open, &status);
+        if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
+                nfs4_set_claim_prev(open);
         /*
         * To finish the open response, we just need to set the rflags.
         */
@@ -1990,14 +1989,11 @@ laundromat_main(void *not_used)
         queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
 }
 
-/* search ownerid_hashtbl[] and close_lru for stateid owner
- * (stateid->si_stateownerid)
- */
 static struct nfs4_stateowner *
-find_openstateowner_id(u32 st_id, int flags) {
+search_close_lru(u32 st_id, int flags)
+{
         struct nfs4_stateowner *local = NULL;
 
-        dprintk("NFSD: find_openstateowner_id %d\n", st_id);
         if (flags & CLOSE_STATE) {
                 list_for_each_entry(local, &close_lru, so_close_lru) {
                         if (local->so_id == st_id)
@@ -2163,14 +2159,19 @@ out:
         return status;
 }
 
+static inline int
+setlkflg (int type)
+{
+        return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
+                RD_STATE : WR_STATE;
+}
 
 /* 
  * Checks for sequence id mutating operations. 
  */
 static int
-nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *stateid, int flags, struct nfs4_stateowner **sopp, struct nfs4_stateid **stpp, clientid_t *lockclid)
+nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *stateid, int flags, struct nfs4_stateowner **sopp, struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
 {
-        int status;
         struct nfs4_stateid *stp;
         struct nfs4_stateowner *sop;
 
@@ -2178,53 +2179,65 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei
                         "stateid = (%08x/%08x/%08x/%08x)\n", seqid,
                 stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
                 stateid->si_generation);
-                                
+
         *stpp = NULL;
         *sopp = NULL;
 
-        status = nfserr_bad_stateid;
         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
                 printk("NFSD: preprocess_seqid_op: magic stateid!\n");
-                goto out;
+                return nfserr_bad_stateid;
         }
 
-        status = nfserr_stale_stateid;
         if (STALE_STATEID(stateid))
-                goto out;
+                return nfserr_stale_stateid;
         /*
         * We return BAD_STATEID if filehandle doesn't match stateid, 
         * the confirmed flag is incorrecly set, or the generation 
         * number is incorrect.  
-        * If there is no entry in the openfile table for this id, 
-        * we can't always return BAD_STATEID;
-        * this might be a retransmitted CLOSE which has arrived after 
-        * the openfile has been released.
         */
-        if (!(stp = find_stateid(stateid, flags)))
-                goto no_nfs4_stateid;
-
-        status = nfserr_bad_stateid;
+        stp = find_stateid(stateid, flags);
+        if (stp == NULL) {
+                /*
+                 * Also, we should make sure this isn't just the result of
+                 * a replayed close:
+                 */
+                sop = search_close_lru(stateid->si_stateownerid, flags);
+                if (sop == NULL)
+                        return nfserr_bad_stateid;
+                *sopp = sop;
+                goto check_replay;
+        }
 
-        /* for new lock stateowners:
-         * check that the lock->v.new.open_stateid
-         * refers to an open stateowner
-         *
-         * check that the lockclid (nfs4_lock->v.new.clientid) is the same
-         * as the open_stateid->st_stateowner->so_client->clientid
-         */
-        if (lockclid) {
+        if (lock) {
                 struct nfs4_stateowner *sop = stp->st_stateowner;
+                clientid_t *lockclid = &lock->v.new.clientid;
                 struct nfs4_client *clp = sop->so_client;
+                int lkflg = 0;
+                int status;
+
+                lkflg = setlkflg(lock->lk_type);
+
+                if (lock->lk_is_new) {
+                       if (!sop->so_is_open_owner)
+                               return nfserr_bad_stateid;
+                       if (!cmp_clid(&clp->cl_clientid, lockclid))
+                               return nfserr_bad_stateid;
+                       /* stp is the open stateid */
+                       status = nfs4_check_openmode(stp, lkflg);
+                       if (status)
+                               return status;
+               } else {
+                       /* stp is the lock stateid */
+                       status = nfs4_check_openmode(stp->st_openstp, lkflg);
+                       if (status)
+                               return status;
+               }
 
-                if (!sop->so_is_open_owner)
-                        goto out;
-                if (!cmp_clid(&clp->cl_clientid, lockclid))
-                        goto out;
         }
 
         if ((flags & CHECK_FH) && nfs4_check_fh(current_fh, stp)) {
                 printk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
-                goto out;
+                return nfserr_bad_stateid;
         }
 
         *stpp = stp;
@@ -2235,63 +2248,41 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei
         *  For the moment, we ignore the possibility of 
         *  generation number wraparound.
         */
-        if (seqid != sop->so_seqid + 1)
+        if (seqid != sop->so_seqid)
                 goto check_replay;
 
-        if (sop->so_confirmed) {
-                if (flags & CONFIRM) {
-                        printk("NFSD: preprocess_seqid_op: expected unconfirmed stateowner!\n");
-                        goto out;
-                }
+        if (sop->so_confirmed && flags & CONFIRM) {
+                printk("NFSD: preprocess_seqid_op: expected"
+                                " unconfirmed stateowner!\n");
+                return nfserr_bad_stateid;
         }
-        else {
-                if (!(flags & CONFIRM)) {
-                        printk("NFSD: preprocess_seqid_op: stateowner not confirmed yet!\n");
-                        goto out;
-                }
+        if (!sop->so_confirmed && !(flags & CONFIRM)) {
+                printk("NFSD: preprocess_seqid_op: stateowner not"
+                                " confirmed yet!\n");
+                return nfserr_bad_stateid;
         }
         if (stateid->si_generation > stp->st_stateid.si_generation) {
                 printk("NFSD: preprocess_seqid_op: future stateid?!\n");
-                goto out;
+                return nfserr_bad_stateid;
         }
 
-        status = nfserr_old_stateid;
         if (stateid->si_generation < stp->st_stateid.si_generation) {
                 printk("NFSD: preprocess_seqid_op: old stateid!\n");
-                goto out;
+                return nfserr_old_stateid;
         }
-        /* XXX renew the client lease here */
-        status = nfs_ok;
-
-out:
-        return status;
-
-no_nfs4_stateid:
-
-        /*
-        * We determine whether this is a bad stateid or a replay, 
-        * starting by trying to look up the stateowner.
-        * If stateowner is not found - stateid is bad.
-        */
-        if (!(sop = find_openstateowner_id(stateid->si_stateownerid, flags))) {
-                printk("NFSD: preprocess_seqid_op: no stateowner or nfs4_stateid!\n");
-                status = nfserr_bad_stateid;
-                goto out;
-        }
-        *sopp = sop;
+        renew_client(sop->so_client);
+        return nfs_ok;
 
 check_replay:
-        if (seqid == sop->so_seqid) {
+        if (seqid == sop->so_seqid - 1) {
                 printk("NFSD: preprocess_seqid_op: retransmission?\n");
                 /* indicate replay to calling function */
-                status = NFSERR_REPLAY_ME;
-        } else  {
-                printk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d\n", sop->so_seqid +1, seqid);
-
-                *sopp = NULL;
-                status = nfserr_bad_seqid;
+                return NFSERR_REPLAY_ME;
         }
-        goto out;
+        printk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
+                        sop->so_seqid, seqid);
+        *sopp = NULL;
+        return nfserr_bad_seqid;
 }
 
 int
@@ -2609,7 +2600,6 @@ find_lockstateowner_str(struct inode *inode, clientid_t *clid,
  * occured. 
  *
  * strhashval = lock_ownerstr_hashval 
- * so_seqid = lock->lk_new_lock_seqid - 1: it gets bumped in encode 
  */
 
 static struct nfs4_stateowner *
@@ -2634,7 +2624,7 @@ alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, str
         sop->so_is_open_owner = 0;
         sop->so_id = current_ownerid++;
         sop->so_client = clp;
-        sop->so_seqid = lock->lk_new_lock_seqid - 1;
+        sop->so_seqid = lock->lk_new_lock_seqid;
         sop->so_confirmed = 1;
         rp = &sop->so_replay;
         rp->rp_status = NFSERR_SERVERFAULT;
@@ -2669,6 +2659,7 @@ alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struc
         stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */
         stp->st_access_bmap = open_stp->st_access_bmap;
         stp->st_deny_bmap = open_stp->st_deny_bmap;
+        stp->st_openstp = open_stp;
 
 out:
         return stp;
@@ -2699,22 +2690,17 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                 (long long) lock->lk_offset,
                 (long long) lock->lk_length);
 
-        if (nfs4_in_grace() && !lock->lk_reclaim)
-                return nfserr_grace;
-        if (!nfs4_in_grace() && lock->lk_reclaim)
-                return nfserr_no_grace;
-
         if (check_lock_length(lock->lk_offset, lock->lk_length))
                  return nfserr_inval;
 
         nfs4_lock_state();
 
         if (lock->lk_is_new) {
-        /*
-         * Client indicates that this is a new lockowner.
-         * Use open owner and open stateid to create lock owner and lock 
-         * stateid.
-         */
+                /*
+                 * Client indicates that this is a new lockowner.
+                 * Use open owner and open stateid to create lock owner and
+                 * lock stateid.
+                 */
                 struct nfs4_stateid *open_stp = NULL;
                 struct nfs4_file *fp;
                 
@@ -2724,23 +2710,14 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                         goto out;
                 }
 
-                /* is the new lock seqid presented by the client zero? */
-                status = nfserr_bad_seqid;
-                if (lock->v.new.lock_seqid != 0)
-                        goto out;
-
                 /* validate and update open stateid and open seqid */
                 status = nfs4_preprocess_seqid_op(current_fh, 
                                         lock->lk_new_open_seqid,
                                         &lock->lk_new_open_stateid,
                                         CHECK_FH | OPEN_STATE,
-                                        &open_sop, &open_stp,
-                                        &lock->v.new.clientid);
-                if (status) {
-                        if (lock->lk_reclaim)
-                                status = nfserr_reclaim_bad;
+                                        &open_sop, &open_stp, lock);
+                if (status)
                         goto out;
-                }
                 /* create lockowner and lock stateid */
                 fp = open_stp->st_file;
                 strhashval = lock_ownerstr_hashval(fp->fi_inode, 
@@ -2766,7 +2743,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                                        lock->lk_old_lock_seqid, 
                                        &lock->lk_old_lock_stateid, 
                                        CHECK_FH | LOCK_STATE, 
-                                       &lock->lk_stateowner, &lock_stp, NULL);
+                                       &lock->lk_stateowner, &lock_stp, lock);
                 if (status)
                         goto out;
         }
@@ -2778,6 +2755,13 @@ nfsd4_lock(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_lock
                 goto out;
         }
 
+        status = nfserr_grace;
+        if (nfs4_in_grace() && !lock->lk_reclaim)
+                goto out;
+        status = nfserr_no_grace;
+        if (!nfs4_in_grace() && lock->lk_reclaim)
+                goto out;
+
         locks_init_lock(&file_lock);
         switch (lock->lk_type) {
                 case NFS4_READ_LT:
@@ -2844,10 +2828,10 @@ conflicting_lock:
 out_destroy_new_stateid:
         if (lock->lk_is_new) {
                 dprintk("NFSD: nfsd4_lock: destroy new stateid!\n");
-        /*
-        * An error encountered after instantiation of the new
-        * stateid has forced us to destroy it.
-        */
+                /*
+                 * An error encountered after instantiation of the new
+                 * stateid has forced us to destroy it.
+                 */
                 if (!seqid_mutating_err(status))
                         open_sop->so_seqid--;
 
@@ -3083,7 +3067,12 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp, struct nfsd4_release_lockowner *
          * of the lockowner state released; so don't release any until all
          * have been checked. */
         status = nfs_ok;
-        list_for_each_entry(sop, &matches, so_perclient) {
+        while (!list_empty(&matches)) {
+                sop = list_entry(matches.next, struct nfs4_stateowner,
+                                                                so_perclient);
+                /* unhash_stateowner deletes so_perclient only
+                 * for openowners. */
+                list_del(&sop->so_perclient);
                 release_stateowner(sop);
         }
 out:
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 91fb171d2ace..4c4146350236 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -1210,16 +1210,15 @@ nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
         save = resp->p;
 
 /*
- * Routine for encoding the result of a
- * "seqid-mutating" NFSv4 operation.  This is
- * where seqids are incremented, and the
- * replay cache is filled.
+ * Routine for encoding the result of a "seqid-mutating" NFSv4 operation.  This
+ * is where sequence id's are incremented, and the replay cache is filled.
+ * Note that we increment sequence id's here, at the last moment, so we're sure
+ * we know whether the error to be returned is a sequence id mutating error.
  */
 
 #define ENCODE_SEQID_OP_TAIL(stateowner) do {                   \
         if (seqid_mutating_err(nfserr) && stateowner) {         \
-                if (stateowner->so_confirmed)                   \
-                        stateowner->so_seqid++;                 \
+                stateowner->so_seqid++;                         \
                 stateowner->so_replay.rp_status = nfserr;       \
                 stateowner->so_replay.rp_buflen =               \
                           (((char *)(resp)->p - (char *)save)); \
@@ -1367,9 +1366,9 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
                 if ((buflen -= 4) < 0)
                         goto out_resource;
                 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
-                        WRITE32(NFS4_FH_VOLATILE_ANY);
+                        WRITE32(NFS4_FH_PERSISTENT);
                 else
-                        WRITE32(NFS4_FH_VOLATILE_ANY|NFS4_FH_VOL_RENAME);
+                        WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME);
         }
         if (bmval0 & FATTR4_WORD0_CHANGE) {
                 /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index be24ead89d94..5e0bf3917607 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -733,7 +733,7 @@ nfsd_sync(struct file *filp)
         up(&inode->i_sem);
 }
 
-static void
+void
 nfsd_sync_dir(struct dentry *dp)
 {
         nfsd_dosync(NULL, dp, dp->d_inode->i_fop);
diff --git a/fs/super.c b/fs/super.c
index 25bc1ec6bc5d..6e57ee252e14 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -840,7 +840,6 @@ do_kern_mount(const char *fstype, int flags, const char *name, void *data)
         mnt->mnt_root = dget(sb->s_root);
         mnt->mnt_mountpoint = sb->s_root;
         mnt->mnt_parent = mnt;
-        mnt->mnt_namespace = current->namespace;
         up_write(&sb->s_umount);
         free_secdata(secdata);
         put_filesystem(type);