SUNRPC/NFSD: Implement xdr_reserve_space_vec()

Reserving space for a large READ payload requires special handling when
reserving space in the xdr buffer pages. One problem we can have is use
of the scratch buffer, which is used to get a pointer to a contiguous
region of data up to PAGE_SIZE. When using the scratch buffer, calls to
xdr_commit_encode() shift the data to it's proper alignment in the xdr
buffer. If we've reserved several pages in a vector, then this could
potentially invalidate earlier pointers and result in incorrect READ
data being sent to the client.

I get around this by looking at the amount of space left in the current
page, and never reserve more than that for each entry in the read
vector. This lets us place data directly where it needs to go in the
buffer pages.

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

diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 3d263fd20df08cdbff2eb8fdc29487f4beeab7cb..36a54827085bb6d073db2576893d3286953796b1 100644 (file)
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -3814,36 +3814,14 @@ static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
 {
        struct xdr_stream *xdr = &resp->xdr;
        u32 eof;
-       int v;
        int starting_len = xdr->buf->len - 8;
-       long len;
-       int thislen;
        __be32 nfserr;
        __be32 tmp;
-       __be32 *p;
        int pad;
 
-       /*
-        * svcrdma requires every READ payload to start somewhere
-        * in xdr->pages.
-        */
-       if (xdr->iov == xdr->buf->head) {
-               xdr->iov = NULL;
-               xdr->end = xdr->p;
-       }
-
-       len = maxcount;
-       v = 0;
-       while (len) {
-               thislen = min_t(long, len, PAGE_SIZE);
-               p = xdr_reserve_space(xdr, thislen);
-               WARN_ON_ONCE(!p);
-               resp->rqstp->rq_vec[v].iov_base = p;
-               resp->rqstp->rq_vec[v].iov_len = thislen;
-               v++;
-               len -= thislen;
-       }
-       read->rd_vlen = v;
+       read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, maxcount);
+       if (read->rd_vlen < 0)
+               return nfserr_resource;
 
        nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
                            resp->rqstp->rq_vec, read->rd_vlen, &maxcount,

diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 5a6a81b7cd9f7fde40d3b5e0eda242dd332ac981..6613d96a30295dacb3ffd286ee52acc4d308803e 100644 (file)
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -234,6 +234,8 @@ typedef int (*kxdrdproc_t)(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
 extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf,
                            __be32 *p, struct rpc_rqst *rqst);
 extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
+extern int xdr_reserve_space_vec(struct xdr_stream *xdr, struct kvec *vec,
+               size_t nbytes);
 extern void xdr_commit_encode(struct xdr_stream *xdr);
 extern void xdr_truncate_encode(struct xdr_stream *xdr, size_t len);
 extern int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen);

diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 3bd5bef0299666b0aa92507bcf9efa3be4b4779e..b45af330f9f3ef0b28c0867ccb540043cfa15e48 100644 (file)
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -648,6 +648,51 @@ __be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
 }
 EXPORT_SYMBOL_GPL(xdr_reserve_space);
 
+
+/**
+ * xdr_reserve_space_vec - Reserves a large amount of buffer space for sending
+ * @xdr: pointer to xdr_stream
+ * @vec: pointer to a kvec array
+ * @nbytes: number of bytes to reserve
+ *
+ * Reserves enough buffer space to encode 'nbytes' of data and stores the
+ * pointers in 'vec'. The size argument passed to xdr_reserve_space() is
+ * determined based on the number of bytes remaining in the current page to
+ * avoid invalidating iov_base pointers when xdr_commit_encode() is called.
+ */
+int xdr_reserve_space_vec(struct xdr_stream *xdr, struct kvec *vec, size_t nbytes)
+{
+       int thislen;
+       int v = 0;
+       __be32 *p;
+
+       /*
+        * svcrdma requires every READ payload to start somewhere
+        * in xdr->pages.
+        */
+       if (xdr->iov == xdr->buf->head) {
+               xdr->iov = NULL;
+               xdr->end = xdr->p;
+       }
+
+       while (nbytes) {
+               thislen = xdr->buf->page_len % PAGE_SIZE;
+               thislen = min_t(size_t, nbytes, PAGE_SIZE - thislen);
+
+               p = xdr_reserve_space(xdr, thislen);
+               if (!p)
+                       return -EIO;
+
+               vec[v].iov_base = p;
+               vec[v].iov_len = thislen;
+               v++;
+               nbytes -= thislen;
+       }
+
+       return v;
+}
+EXPORT_SYMBOL_GPL(xdr_reserve_space_vec);
+
 /**
  * xdr_truncate_encode - truncate an encode buffer
  * @xdr: pointer to xdr_stream