13 files changed, 148 insertions, 106 deletions

diff --git a/fs/nfs/callback.h b/fs/nfs/callback.h
index db3d7919c601..c2bb14e053e1 100644
--- a/fs/nfs/callback.h
+++ b/fs/nfs/callback.h
@@ -24,7 +24,7 @@ enum nfs4_callback_opnum {
 };
 
 struct cb_compound_hdr_arg {
-        int taglen;
+        unsigned int taglen;
         const char *tag;
         unsigned int callback_ident;
         unsigned nops;
@@ -32,7 +32,7 @@ struct cb_compound_hdr_arg {
 
 struct cb_compound_hdr_res {
         __be32 *status;
-        int taglen;
+        unsigned int taglen;
         const char *tag;
         __be32 *nops;
 };
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 50c6821bad26..881fa4900923 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -12,7 +12,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
-
+#include <linux/sched.h>
 #include <linux/time.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 841c99a9b11c..7f37d1bea83f 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -226,7 +226,7 @@ restart:
         spin_unlock(&clp->cl_lock);
 }
 
-int nfs_do_expire_all_delegations(void *ptr)
+static int nfs_do_expire_all_delegations(void *ptr)
 {
         struct nfs_client *clp = ptr;
         struct nfs_delegation *delegation;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 3df428816559..c27258b5d3e1 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -33,6 +33,7 @@
 #include <linux/pagevec.h>
 #include <linux/namei.h>
 #include <linux/mount.h>
+#include <linux/sched.h>
 
 #include "nfs4_fs.h"
 #include "delegation.h"
@@ -607,7 +608,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
         return res;
 }
 
-loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
+static loff_t nfs_llseek_dir(struct file *filp, loff_t offset, int origin)
 {
         mutex_lock(&filp->f_path.dentry->d_inode->i_mutex);
         switch (origin) {
@@ -633,7 +634,7 @@ out:
  * All directory operations under NFS are synchronous, so fsync()
  * is a dummy operation.
  */
-int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
+static int nfs_fsync_dir(struct file *filp, struct dentry *dentry, int datasync)
 {
         dfprintk(VFS, "NFS: fsync_dir(%s/%s) datasync %d\n",
                         dentry->d_parent->d_name.name, dentry->d_name.name,
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 345aa5c0f382..00eee87510fe 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -122,19 +122,25 @@ ssize_t nfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, loff_
         return -EINVAL;
 }
 
-static void nfs_direct_dirty_pages(struct page **pages, int npages)
+static void nfs_direct_dirty_pages(struct page **pages, unsigned int pgbase, size_t count)
 {
-        int i;
+        unsigned int npages;
+        unsigned int i;
+
+        if (count == 0)
+                return;
+        pages += (pgbase >> PAGE_SHIFT);
+        npages = (count + (pgbase & ~PAGE_MASK) + PAGE_SIZE - 1) >> PAGE_SHIFT;
         for (i = 0; i < npages; i++) {
                 struct page *page = pages[i];
                 if (!PageCompound(page))
-                        set_page_dirty_lock(page);
+                        set_page_dirty(page);
         }
 }
 
-static void nfs_direct_release_pages(struct page **pages, int npages)
+static void nfs_direct_release_pages(struct page **pages, unsigned int npages)
 {
-        int i;
+        unsigned int i;
         for (i = 0; i < npages; i++)
                 page_cache_release(pages[i]);
 }
@@ -162,7 +168,7 @@ static inline struct nfs_direct_req *nfs_direct_req_alloc(void)
         return dreq;
 }
 
-static void nfs_direct_req_release(struct kref *kref)
+static void nfs_direct_req_free(struct kref *kref)
 {
         struct nfs_direct_req *dreq = container_of(kref, struct nfs_direct_req, kref);
 
@@ -171,6 +177,11 @@ static void nfs_direct_req_release(struct kref *kref)
         kmem_cache_free(nfs_direct_cachep, dreq);
 }
 
+static void nfs_direct_req_release(struct nfs_direct_req *dreq)
+{
+        kref_put(&dreq->kref, nfs_direct_req_free);
+}
+
 /*
  * Collects and returns the final error value/byte-count.
  */
@@ -190,7 +201,6 @@ static ssize_t nfs_direct_wait(struct nfs_direct_req *dreq)
                 result = dreq->count;
 
 out:
-        kref_put(&dreq->kref, nfs_direct_req_release);
         return (ssize_t) result;
 }
 
@@ -208,7 +218,7 @@ static void nfs_direct_complete(struct nfs_direct_req *dreq)
         }
         complete_all(&dreq->completion);
 
-        kref_put(&dreq->kref, nfs_direct_req_release);
+        nfs_direct_req_release(dreq);
 }
 
 /*
@@ -224,17 +234,18 @@ static void nfs_direct_read_result(struct rpc_task *task, void *calldata)
         if (nfs_readpage_result(task, data) != 0)
                 return;
 
-        nfs_direct_dirty_pages(data->pagevec, data->npages);
-        nfs_direct_release_pages(data->pagevec, data->npages);
-
         spin_lock(&dreq->lock);
-
-        if (likely(task->tk_status >= 0))
-                dreq->count += data->res.count;
-        else
+        if (unlikely(task->tk_status < 0)) {
                 dreq->error = task->tk_status;
-
-        spin_unlock(&dreq->lock);
+                spin_unlock(&dreq->lock);
+        } else {
+                dreq->count += data->res.count;
+                spin_unlock(&dreq->lock);
+                nfs_direct_dirty_pages(data->pagevec,
+                                data->args.pgbase,
+                                data->res.count);
+        }
+        nfs_direct_release_pages(data->pagevec, data->npages);
 
         if (put_dreq(dreq))
                 nfs_direct_complete(dreq);
@@ -279,9 +290,12 @@ static ssize_t nfs_direct_read_schedule(struct nfs_direct_req *dreq, unsigned lo
                 result = get_user_pages(current, current->mm, user_addr,
                                         data->npages, 1, 0, data->pagevec, NULL);
                 up_read(&current->mm->mmap_sem);
-                if (unlikely(result < data->npages)) {
-                        if (result > 0)
-                                nfs_direct_release_pages(data->pagevec, result);
+                if (result < 0) {
+                        nfs_readdata_release(data);
+                        break;
+                }
+                if ((unsigned)result < data->npages) {
+                        nfs_direct_release_pages(data->pagevec, result);
                         nfs_readdata_release(data);
                         break;
                 }
@@ -359,6 +373,7 @@ static ssize_t nfs_direct_read(struct kiocb *iocb, unsigned long user_addr, size
         if (!result)
                 result = nfs_direct_wait(dreq);
         rpc_clnt_sigunmask(clnt, &oldset);
+        nfs_direct_req_release(dreq);
 
         return result;
 }
@@ -610,9 +625,12 @@ static ssize_t nfs_direct_write_schedule(struct nfs_direct_req *dreq, unsigned l
                 result = get_user_pages(current, current->mm, user_addr,
                                         data->npages, 0, 0, data->pagevec, NULL);
                 up_read(&current->mm->mmap_sem);
-                if (unlikely(result < data->npages)) {
-                        if (result > 0)
-                                nfs_direct_release_pages(data->pagevec, result);
+                if (result < 0) {
+                        nfs_writedata_release(data);
+                        break;
+                }
+                if ((unsigned)result < data->npages) {
+                        nfs_direct_release_pages(data->pagevec, result);
                         nfs_writedata_release(data);
                         break;
                 }
@@ -703,6 +721,7 @@ static ssize_t nfs_direct_write(struct kiocb *iocb, unsigned long user_addr, siz
         if (!result)
                 result = nfs_direct_wait(dreq);
         rpc_clnt_sigunmask(clnt, &oldset);
+        nfs_direct_req_release(dreq);
 
         return result;
 }
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 5eaee6dd040b..9eb8eb4e4a08 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
+#include <linux/aio.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 2a3fd9573207..bd9f5a836592 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -15,7 +15,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
-
+#include <linux/sched.h>
 #include <linux/time.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
@@ -1164,21 +1164,19 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 {
         struct nfs_inode *nfsi = (struct nfs_inode *) foo;
 
-        if (flags & SLAB_CTOR_CONSTRUCTOR) {
-                inode_init_once(&nfsi->vfs_inode);
-                spin_lock_init(&nfsi->req_lock);
-                INIT_LIST_HEAD(&nfsi->dirty);
-                INIT_LIST_HEAD(&nfsi->commit);
-                INIT_LIST_HEAD(&nfsi->open_files);
-                INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
-                INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
-                INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
-                atomic_set(&nfsi->data_updates, 0);
-                nfsi->ndirty = 0;
-                nfsi->ncommit = 0;
-                nfsi->npages = 0;
-                nfs4_init_once(nfsi);
-        }
+        inode_init_once(&nfsi->vfs_inode);
+        spin_lock_init(&nfsi->req_lock);
+        INIT_LIST_HEAD(&nfsi->dirty);
+        INIT_LIST_HEAD(&nfsi->commit);
+        INIT_LIST_HEAD(&nfsi->open_files);
+        INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
+        INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
+        INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
+        atomic_set(&nfsi->data_updates, 0);
+        nfsi->ndirty = 0;
+        nfsi->ncommit = 0;
+        nfsi->npages = 0;
+        nfs4_init_once(nfsi);
 }
  
 static int __init nfs_init_inodecache(void)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index d6a30e965787..648e0ac0f90e 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -790,7 +790,7 @@ out:
         return -EACCES;
 }
 
-int nfs4_recover_expired_lease(struct nfs_server *server)
+static int nfs4_recover_expired_lease(struct nfs_server *server)
 {
         struct nfs_client *clp = server->nfs_client;
         int ret;
@@ -2748,7 +2748,7 @@ static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
 /* This is the error handling routine for processes that are allowed
  * to sleep.
  */
-int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
+static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
 {
         struct nfs_client *clp = server->nfs_client;
         int ret = errorcode;
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 5fffbdfa971f..8ed79d5c54f9 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -104,7 +104,7 @@ struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp)
         return cred;
 }
 
-struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
+static struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
 {
         struct nfs4_state_owner *sp;
 
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 938f37166788..8003c91ccb9a 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -646,10 +646,10 @@ static int encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg)
 {
         __be32 *p;
 
-        RESERVE_SPACE(8+sizeof(arg->stateid->data));
+        RESERVE_SPACE(8+NFS4_STATEID_SIZE);
         WRITE32(OP_CLOSE);
         WRITE32(arg->seqid->sequence->counter);
-        WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+        WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
         
         return 0;
 }
@@ -793,17 +793,17 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
         WRITE64(nfs4_lock_length(args->fl));
         WRITE32(args->new_lock_owner);
         if (args->new_lock_owner){
-                RESERVE_SPACE(40);
+                RESERVE_SPACE(4+NFS4_STATEID_SIZE+20);
                 WRITE32(args->open_seqid->sequence->counter);
-                WRITEMEM(args->open_stateid->data, sizeof(args->open_stateid->data));
+                WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
                 WRITE32(args->lock_seqid->sequence->counter);
                 WRITE64(args->lock_owner.clientid);
                 WRITE32(4);
                 WRITE32(args->lock_owner.id);
         }
         else {
-                RESERVE_SPACE(20);
-                WRITEMEM(args->lock_stateid->data, sizeof(args->lock_stateid->data));
+                RESERVE_SPACE(NFS4_STATEID_SIZE+4);
+                WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
                 WRITE32(args->lock_seqid->sequence->counter);
         }
 
@@ -830,11 +830,11 @@ static int encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *arg
 {
         __be32 *p;
 
-        RESERVE_SPACE(44);
+        RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
         WRITE32(OP_LOCKU);
         WRITE32(nfs4_lock_type(args->fl, 0));
         WRITE32(args->seqid->sequence->counter);
-        WRITEMEM(args->stateid->data, sizeof(args->stateid->data));
+        WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
         WRITE64(args->fl->fl_start);
         WRITE64(nfs4_lock_length(args->fl));
 
@@ -966,9 +966,9 @@ static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struc
 {
         __be32 *p;
 
-        RESERVE_SPACE(4+sizeof(stateid->data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE);
         WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
-        WRITEMEM(stateid->data, sizeof(stateid->data));
+        WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
         encode_string(xdr, name->len, name->name);
 }
 
@@ -996,9 +996,9 @@ static int encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_con
 {
         __be32 *p;
 
-        RESERVE_SPACE(8+sizeof(arg->stateid->data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
         WRITE32(OP_OPEN_CONFIRM);
-        WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+        WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
         WRITE32(arg->seqid->sequence->counter);
 
         return 0;
@@ -1008,9 +1008,9 @@ static int encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closea
 {
         __be32 *p;
 
-        RESERVE_SPACE(8+sizeof(arg->stateid->data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
         WRITE32(OP_OPEN_DOWNGRADE);
-        WRITEMEM(arg->stateid->data, sizeof(arg->stateid->data));
+        WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
         WRITE32(arg->seqid->sequence->counter);
         encode_share_access(xdr, arg->open_flags);
         return 0;
@@ -1045,12 +1045,12 @@ static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context
         nfs4_stateid stateid;
         __be32 *p;
 
-        RESERVE_SPACE(16);
+        RESERVE_SPACE(NFS4_STATEID_SIZE);
         if (ctx->state != NULL) {
                 nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
-                WRITEMEM(stateid.data, sizeof(stateid.data));
+                WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
         } else
-                WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
+                WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
 }
 
 static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
@@ -1079,10 +1079,10 @@ static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
         int replen;
         __be32 *p;
 
-        RESERVE_SPACE(32+sizeof(nfs4_verifier));
+        RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
         WRITE32(OP_READDIR);
         WRITE64(readdir->cookie);
-        WRITEMEM(readdir->verifier.data, sizeof(readdir->verifier.data));
+        WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
         WRITE32(readdir->count >> 1);  /* We're not doing readdirplus */
         WRITE32(readdir->count);
         WRITE32(2);
@@ -1190,9 +1190,9 @@ encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg)
 {
         __be32 *p;
 
-        RESERVE_SPACE(4+sizeof(zero_stateid.data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE);
         WRITE32(OP_SETATTR);
-        WRITEMEM(zero_stateid.data, sizeof(zero_stateid.data));
+        WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
         RESERVE_SPACE(2*4);
         WRITE32(1);
         WRITE32(FATTR4_WORD0_ACL);
@@ -1220,9 +1220,9 @@ static int encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *
         int status;
         __be32 *p;
         
-        RESERVE_SPACE(4+sizeof(arg->stateid.data));
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE);
         WRITE32(OP_SETATTR);
-        WRITEMEM(arg->stateid.data, sizeof(arg->stateid.data));
+        WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
 
         if ((status = encode_attrs(xdr, arg->iap, server)))
                 return status;
@@ -1234,9 +1234,9 @@ static int encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclien
 {
         __be32 *p;
 
-        RESERVE_SPACE(4 + sizeof(setclientid->sc_verifier->data));
+        RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
         WRITE32(OP_SETCLIENTID);
-        WRITEMEM(setclientid->sc_verifier->data, sizeof(setclientid->sc_verifier->data));
+        WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
 
         encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
         RESERVE_SPACE(4);
@@ -1253,10 +1253,10 @@ static int encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_c
 {
         __be32 *p;
 
-        RESERVE_SPACE(12 + sizeof(client_state->cl_confirm.data));
+        RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
         WRITE32(OP_SETCLIENTID_CONFIRM);
         WRITE64(client_state->cl_clientid);
-        WRITEMEM(client_state->cl_confirm.data, sizeof(client_state->cl_confirm.data));
+        WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
 
         return 0;
 }
@@ -1284,10 +1284,10 @@ static int encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *statei
 {
         __be32 *p;
 
-        RESERVE_SPACE(20);
+        RESERVE_SPACE(4+NFS4_STATEID_SIZE);
 
         WRITE32(OP_DELEGRETURN);
-        WRITEMEM(stateid->data, sizeof(stateid->data));
+        WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
         return 0;
 
 }
@@ -2494,7 +2494,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
                                 int i;
                                 dprintk("%s: using first %d of %d servers returned for location %d\n", __FUNCTION__, NFS4_FS_LOCATION_MAXSERVERS, m, res->nlocations);
                                 for (i = loc->nservers; i < m; i++) {
-                                        int len;
+                                        unsigned int len;
                                         char *data;
                                         status = decode_opaque_inline(xdr, &len, &data);
                                         if (unlikely(status != 0))
@@ -2642,7 +2642,7 @@ static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t
         return 0;
 }
 
-static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *uid)
+static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
 {
         uint32_t len;
         __be32 *p;
@@ -2667,7 +2667,7 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
         return 0;
 }
 
-static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, int32_t *gid)
+static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
 {
         uint32_t len;
         __be32 *p;
@@ -2897,8 +2897,8 @@ static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
         status = decode_op_hdr(xdr, OP_CLOSE);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         return 0;
 }
 
@@ -3186,8 +3186,8 @@ static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
 
         status = decode_op_hdr(xdr, OP_LOCK);
         if (status == 0) {
-                READ_BUF(sizeof(res->stateid.data));
-                COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+                READ_BUF(NFS4_STATEID_SIZE);
+                COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         } else if (status == -NFS4ERR_DENIED)
                 return decode_lock_denied(xdr, NULL);
         return status;
@@ -3209,8 +3209,8 @@ static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
 
         status = decode_op_hdr(xdr, OP_LOCKU);
         if (status == 0) {
-                READ_BUF(sizeof(res->stateid.data));
-                COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+                READ_BUF(NFS4_STATEID_SIZE);
+                COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         }
         return status;
 }
@@ -3251,8 +3251,8 @@ static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
                 res->delegation_type = 0;
                 return 0;
         }
-        READ_BUF(20);
-        COPYMEM(res->delegation.data, sizeof(res->delegation.data));
+        READ_BUF(NFS4_STATEID_SIZE+4);
+        COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
         READ32(res->do_recall);
         switch (delegation_type) {
                 case NFS4_OPEN_DELEGATE_READ:
@@ -3275,8 +3275,8 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
         status = decode_op_hdr(xdr, OP_OPEN);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
 
         decode_change_info(xdr, &res->cinfo);
 
@@ -3302,8 +3302,8 @@ static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmre
         status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         return 0;
 }
 
@@ -3315,8 +3315,8 @@ static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *re
         status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
         if (status)
                 return status;
-        READ_BUF(sizeof(res->stateid.data));
-        COPYMEM(res->stateid.data, sizeof(res->stateid.data));
+        READ_BUF(NFS4_STATEID_SIZE);
+        COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
         return 0;
 }
 
@@ -3590,9 +3590,9 @@ static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
         }
         READ32(nfserr);
         if (nfserr == NFS_OK) {
-                READ_BUF(8 + sizeof(clp->cl_confirm.data));
+                READ_BUF(8 + NFS4_VERIFIER_SIZE);
                 READ64(clp->cl_clientid);
-                COPYMEM(clp->cl_confirm.data, sizeof(clp->cl_confirm.data));
+                COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
         } else if (nfserr == NFSERR_CLID_INUSE) {
                 uint32_t len;
 
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index e12054c86d0d..c5bb51a29e80 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -11,6 +11,7 @@
 
 #include <linux/slab.h>
 #include <linux/file.h>
+#include <linux/sched.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/nfs3.h>
 #include <linux/nfs4.h>
@@ -354,6 +355,26 @@ void nfs_pageio_complete(struct nfs_pageio_descriptor *desc)
         nfs_pageio_doio(desc);
 }
 
+/**
+ * nfs_pageio_cond_complete - Conditional I/O completion
+ * @desc: pointer to io descriptor
+ * @index: page index
+ *
+ * It is important to ensure that processes don't try to take locks
+ * on non-contiguous ranges of pages as that might deadlock. This
+ * function should be called before attempting to wait on a locked
+ * nfs_page. It will complete the I/O if the page index 'index'
+ * is not contiguous with the existing list of pages in 'desc'.
+ */
+void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc, pgoff_t index)
+{
+        if (!list_empty(&desc->pg_list)) {
+                struct nfs_page *prev = nfs_list_entry(desc->pg_list.prev);
+                if (index != prev->wb_index + 1)
+                        nfs_pageio_doio(desc);
+        }
+}
+
 #define NFS_SCAN_MAXENTRIES 16
 /**
  * nfs_scan_list - Scan a list for matching requests
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 9a55807b2a70..7bd7cb95c034 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -79,7 +79,7 @@ void nfs_readdata_release(void *data)
 static
 int nfs_return_empty_page(struct page *page)
 {
-        memclear_highpage_flush(page, 0, PAGE_CACHE_SIZE);
+        zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
         SetPageUptodate(page);
         unlock_page(page);
         return 0;
@@ -103,10 +103,10 @@ static void nfs_readpage_truncate_uninitialised_page(struct nfs_read_data *data)
         pglen = PAGE_CACHE_SIZE - base;
         for (;;) {
                 if (remainder <= pglen) {
-                        memclear_highpage_flush(*pages, base, remainder);
+                        zero_user_page(*pages, base, remainder, KM_USER0);
                         break;
                 }
-                memclear_highpage_flush(*pages, base, pglen);
+                zero_user_page(*pages, base, pglen, KM_USER0);
                 pages++;
                 remainder -= pglen;
                 pglen = PAGE_CACHE_SIZE;
@@ -130,7 +130,7 @@ static int nfs_readpage_async(struct nfs_open_context *ctx, struct inode *inode,
                 return PTR_ERR(new);
         }
         if (len < PAGE_CACHE_SIZE)
-                memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
+                zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
 
         nfs_list_add_request(new, &one_request);
         if (NFS_SERVER(inode)->rsize < PAGE_CACHE_SIZE)
@@ -532,7 +532,7 @@ readpage_async_filler(void *data, struct page *page)
                         return PTR_ERR(new);
         }
         if (len < PAGE_CACHE_SIZE)
-                memclear_highpage_flush(page, len, PAGE_CACHE_SIZE - len);
+                zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
         nfs_pageio_add_request(desc->pgio, new);
         return 0;
 }
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index de92b9509d94..af344a158e01 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -58,7 +58,7 @@ struct nfs_write_data *nfs_commit_alloc(void)
         return p;
 }
 
-void nfs_commit_rcu_free(struct rcu_head *head)
+static void nfs_commit_rcu_free(struct rcu_head *head)
 {
         struct nfs_write_data *p = container_of(head, struct nfs_write_data, task.u.tk_rcu);
         if (p && (p->pagevec != &p->page_array[0]))
@@ -168,7 +168,7 @@ static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int
         if (count != nfs_page_length(page))
                 return;
         if (count != PAGE_CACHE_SIZE)
-                memclear_highpage_flush(page, count, PAGE_CACHE_SIZE - count);
+                zero_user_page(page, count, PAGE_CACHE_SIZE - count, KM_USER0);
         SetPageUptodate(page);
 }
 
@@ -273,8 +273,6 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                  *       request as dirty (in which case we don't care).
                  */
                 spin_unlock(req_lock);
-                /* Prevent deadlock! */
-                nfs_pageio_complete(pgio);
                 ret = nfs_wait_on_request(req);
                 nfs_release_request(req);
                 if (ret != 0)
@@ -321,6 +319,8 @@ static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc
                 pgio = &mypgio;
         }
 
+        nfs_pageio_cond_complete(pgio, page->index);
+
         err = nfs_page_async_flush(pgio, page);
         if (err <= 0)
                 goto out;
@@ -329,6 +329,8 @@ static int nfs_writepage_locked(struct page *page, struct writeback_control *wbc
         if (!offset)
                 goto out;
 
+        nfs_pageio_cond_complete(pgio, page->index);
+
         ctx = nfs_find_open_context(inode, NULL, FMODE_WRITE);
         if (ctx == NULL) {
                 err = -EBADF;
@@ -922,7 +924,7 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned i
         return 0;
  out_bad:
         while (!list_empty(head)) {
-                struct nfs_page *req = nfs_list_entry(head->next);
+                req = nfs_list_entry(head->next);
                 nfs_list_remove_request(req);
                 nfs_redirty_request(req);
                 nfs_end_page_writeback(req->wb_page);