nfsd4: cleanup: replace rq_resused count by rq_next_page pointer

It may be a matter of personal taste, but I find this makes the code
clearer.

Signed-off-by: J. Bruce Fields <bfields@redhat.com>

7 files changed, 47 insertions, 49 deletions

diff --git a/fs/nfsd/nfs2acl.c b/fs/nfsd/nfs2acl.c
index b314888825d5..9170861c804a 100644
--- a/fs/nfsd/nfs2acl.c
+++ b/fs/nfsd/nfs2acl.c
@@ -253,7 +253,7 @@ static int nfsaclsvc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
                 (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
                 (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
         while (w > 0) {
-                if (!rqstp->rq_respages[rqstp->rq_resused++])
+                if (!*(rqstp->rq_next_page++))
                         return 0;
                 w -= PAGE_SIZE;
         }
diff --git a/fs/nfsd/nfs3acl.c b/fs/nfsd/nfs3acl.c
index a596e9d987e4..9cbc1a841f87 100644
--- a/fs/nfsd/nfs3acl.c
+++ b/fs/nfsd/nfs3acl.c
@@ -184,7 +184,7 @@ static int nfs3svc_encode_getaclres(struct svc_rqst *rqstp, __be32 *p,
                         (resp->mask & NFS_ACL)   ? resp->acl_access  : NULL,
                         (resp->mask & NFS_DFACL) ? resp->acl_default : NULL);
                 while (w > 0) {
-                        if (!rqstp->rq_respages[rqstp->rq_resused++])
+                        if (!*(rqstp->rq_next_page++))
                                 return 0;
                         w -= PAGE_SIZE;
                 }
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 97d90d1c8608..1fc02dfdc5c4 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -460,7 +460,7 @@ nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
         __be32  nfserr;
         int     count = 0;
         loff_t  offset;
-        int     i;
+        struct page **p;
         caddr_t page_addr = NULL;
 
         dprintk("nfsd: READDIR+(3) %s %d bytes at %d\n",
@@ -484,8 +484,8 @@ nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
                                      &resp->common,
                                      nfs3svc_encode_entry_plus);
         memcpy(resp->verf, argp->verf, 8);
-        for (i=1; i<rqstp->rq_resused ; i++) {
-                page_addr = page_address(rqstp->rq_respages[i]);
+        for (p = rqstp->rq_respages + 1; p < rqstp->rq_next_page; p++) {
+                page_addr = page_address(*p);
 
                 if (((caddr_t)resp->buffer >= page_addr) &&
                     ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) {
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 2b8618de6c27..324c0baf7cda 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -325,7 +325,7 @@ nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
                                         struct nfsd3_readargs *args)
 {
         unsigned int len;
-        int v,pn;
+        int v;
         u32 max_blocksize = svc_max_payload(rqstp);
 
         if (!(p = decode_fh(p, &args->fh)))
@@ -340,8 +340,9 @@ nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
         /* set up the kvec */
         v=0;
         while (len > 0) {
-                pn = rqstp->rq_resused++;
-                rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_respages[pn]);
+                struct page *p = *(rqstp->rq_next_page++);
+
+                rqstp->rq_vec[v].iov_base = page_address(p);
                 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE? len : PAGE_SIZE;
                 len -= rqstp->rq_vec[v].iov_len;
                 v++;
@@ -463,8 +464,7 @@ nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
         len = ntohl(*p++);
         if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
                 return 0;
-        args->tname = new =
-                page_address(rqstp->rq_respages[rqstp->rq_resused++]);
+        args->tname = new = page_address(*(rqstp->rq_next_page++));
         args->tlen = len;
         /* first copy and check from the first page */
         old = (char*)p;
@@ -535,8 +535,7 @@ nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
 {
         if (!(p = decode_fh(p, &args->fh)))
                 return 0;
-        args->buffer =
-                page_address(rqstp->rq_respages[rqstp->rq_resused++]);
+        args->buffer = page_address(*(rqstp->rq_next_page++));
 
         return xdr_argsize_check(rqstp, p);
 }
@@ -567,8 +566,7 @@ nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
         if (args->count > PAGE_SIZE)
                 args->count = PAGE_SIZE;
 
-        args->buffer =
-                page_address(rqstp->rq_respages[rqstp->rq_resused++]);
+        args->buffer = page_address(*(rqstp->rq_next_page++));
 
         return xdr_argsize_check(rqstp, p);
 }
@@ -577,7 +575,7 @@ int
 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
                                         struct nfsd3_readdirargs *args)
 {
-        int len, pn;
+        int len;
         u32 max_blocksize = svc_max_payload(rqstp);
 
         if (!(p = decode_fh(p, &args->fh)))
@@ -592,9 +590,9 @@ nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
         args->count = len;
 
         while (len > 0) {
-                pn = rqstp->rq_resused++;
+                struct page *p = *(rqstp->rq_next_page++);
                 if (!args->buffer)
-                        args->buffer = page_address(rqstp->rq_respages[pn]);
+                        args->buffer = page_address(p);
                 len -= PAGE_SIZE;
         }
 
@@ -880,7 +878,7 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
                                                         common);
         __be32          *p = cd->buffer;
         caddr_t         curr_page_addr = NULL;
-        int             pn;             /* current page number */
+        struct page **  page;
         int             slen;           /* string (name) length */
         int             elen;           /* estimated entry length in words */
         int             num_entry_words = 0;    /* actual number of words */
@@ -917,8 +915,9 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
         }
 
         /* determine which page in rq_respages[] we are currently filling */
-        for (pn=1; pn < cd->rqstp->rq_resused; pn++) {
-                curr_page_addr = page_address(cd->rqstp->rq_respages[pn]);
+        for (page = cd->rqstp->rq_respages + 1;
+                                page < cd->rqstp->rq_next_page; page++) {
+                curr_page_addr = page_address(*page);
 
                 if (((caddr_t)cd->buffer >= curr_page_addr) &&
                     ((caddr_t)cd->buffer <  curr_page_addr + PAGE_SIZE))
@@ -933,14 +932,14 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
                 if (plus)
                         p = encode_entryplus_baggage(cd, p, name, namlen);
                 num_entry_words = p - cd->buffer;
-        } else if (cd->rqstp->rq_respages[pn+1] != NULL) {
+        } else if (*(page+1) != NULL) {
                 /* temporarily encode entry into next page, then move back to
                  * current and next page in rq_respages[] */
                 __be32 *p1, *tmp;
                 int len1, len2;
 
                 /* grab next page for temporary storage of entry */
-                p1 = tmp = page_address(cd->rqstp->rq_respages[pn+1]);
+                p1 = tmp = page_address(*(page+1));
 
                 p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
 
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index d7a3be5ab777..0dc11586682f 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -2906,7 +2906,8 @@ nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
                   struct nfsd4_read *read)
 {
         u32 eof;
-        int v, pn;
+        int v;
+        struct page *page;
         unsigned long maxcount; 
         long len;
         __be32 *p;
@@ -2925,16 +2926,15 @@ nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
         len = maxcount;
         v = 0;
         while (len > 0) {
-                pn = resp->rqstp->rq_resused;
-                if (!resp->rqstp->rq_respages[pn]) { /* ran out of pages */
+                page = *(resp->rqstp->rq_next_page);
+                if (!page) { /* ran out of pages */
                         maxcount -= len;
                         break;
                 }
-                resp->rqstp->rq_vec[v].iov_base =
-                        page_address(resp->rqstp->rq_respages[pn]);
+                resp->rqstp->rq_vec[v].iov_base = page_address(page);
                 resp->rqstp->rq_vec[v].iov_len =
                         len < PAGE_SIZE ? len : PAGE_SIZE;
-                resp->rqstp->rq_resused++;
+                resp->rqstp->rq_next_page++;
                 v++;
                 len -= PAGE_SIZE;
         }
@@ -2980,10 +2980,10 @@ nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd
                 return nfserr;
         if (resp->xbuf->page_len)
                 return nfserr_resource;
-        if (!resp->rqstp->rq_respages[resp->rqstp->rq_resused])
+        if (!*resp->rqstp->rq_next_page)
                 return nfserr_resource;
 
-        page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
+        page = page_address(*(resp->rqstp->rq_next_page++));
 
         maxcount = PAGE_SIZE;
         RESERVE_SPACE(4);
@@ -3031,7 +3031,7 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4
                 return nfserr;
         if (resp->xbuf->page_len)
                 return nfserr_resource;
-        if (!resp->rqstp->rq_respages[resp->rqstp->rq_resused])
+        if (!*resp->rqstp->rq_next_page)
                 return nfserr_resource;
 
         RESERVE_SPACE(NFS4_VERIFIER_SIZE);
@@ -3059,7 +3059,7 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4
                 goto err_no_verf;
         }
 
-        page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused++]);
+        page = page_address(*(resp->rqstp->rq_next_page++));
         readdir->common.err = 0;
         readdir->buflen = maxcount;
         readdir->buffer = page;
@@ -3082,8 +3082,8 @@ nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4
         p = readdir->buffer;
         *p++ = 0;       /* no more entries */
         *p++ = htonl(readdir->common.err == nfserr_eof);
-        resp->xbuf->page_len = ((char*)p) - (char*)page_address(
-                resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]);
+        resp->xbuf->page_len = ((char*)p) -
+                (char*)page_address(*(resp->rqstp->rq_next_page-1));
 
         /* Use rest of head for padding and remaining ops: */
         resp->xbuf->tail[0].iov_base = tailbase;
diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
index 65ec595e2226..979b42106979 100644
--- a/fs/nfsd/nfsxdr.c
+++ b/fs/nfsd/nfsxdr.c
@@ -246,7 +246,7 @@ nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
                                         struct nfsd_readargs *args)
 {
         unsigned int len;
-        int v,pn;
+        int v;
         if (!(p = decode_fh(p, &args->fh)))
                 return 0;
 
@@ -262,8 +262,9 @@ nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
          */
         v=0;
         while (len > 0) {
-                pn = rqstp->rq_resused++;
-                rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_respages[pn]);
+                struct page *p = *(rqstp->rq_next_page++);
+
+                rqstp->rq_vec[v].iov_base = page_address(p);
                 rqstp->rq_vec[v].iov_len = len < PAGE_SIZE?len:PAGE_SIZE;
                 len -= rqstp->rq_vec[v].iov_len;
                 v++;
@@ -355,7 +356,7 @@ nfssvc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd_readli
 {
         if (!(p = decode_fh(p, &args->fh)))
                 return 0;
-        args->buffer = page_address(rqstp->rq_respages[rqstp->rq_resused++]);
+        args->buffer = page_address(*(rqstp->rq_next_page++));
 
         return xdr_argsize_check(rqstp, p);
 }
@@ -396,7 +397,7 @@ nfssvc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
         if (args->count > PAGE_SIZE)
                 args->count = PAGE_SIZE;
 
-        args->buffer = page_address(rqstp->rq_respages[rqstp->rq_resused++]);
+        args->buffer = page_address(*(rqstp->rq_next_page++));
 
         return xdr_argsize_check(rqstp, p);
 }
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index b31e46eeb026..f0a6d88d7fff 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -886,7 +886,7 @@ nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
                   struct splice_desc *sd)
 {
         struct svc_rqst *rqstp = sd->u.data;
-        struct page **pp = rqstp->rq_respages + rqstp->rq_resused;
+        struct page **pp = rqstp->rq_next_page;
         struct page *page = buf->page;
         size_t size;
 
@@ -894,17 +894,15 @@ nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
 
         if (rqstp->rq_res.page_len == 0) {
                 get_page(page);
-                put_page(*pp);
-                *pp = page;
-                rqstp->rq_resused++;
+                put_page(*rqstp->rq_next_page);
+                *(rqstp->rq_next_page++) = page;
                 rqstp->rq_res.page_base = buf->offset;
                 rqstp->rq_res.page_len = size;
         } else if (page != pp[-1]) {
                 get_page(page);
-                if (*pp)
-                        put_page(*pp);
-                *pp = page;
-                rqstp->rq_resused++;
+                if (*rqstp->rq_next_page)
+                        put_page(*rqstp->rq_next_page);
+                *(rqstp->rq_next_page++) = page;
                 rqstp->rq_res.page_len += size;
         } else
                 rqstp->rq_res.page_len += size;
@@ -936,8 +934,8 @@ nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                         .u.data         = rqstp,
                 };
 
-                WARN_ON_ONCE(rqstp->rq_resused != 1);
-                rqstp->rq_resused = 1;
+                WARN_ON_ONCE(rqstp->rq_next_page != rqstp->rq_respages + 1);
+                rqstp->rq_next_page = rqstp->rq_respages + 1;
                 host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
         } else {
                 oldfs = get_fs();