Merge remote-tracking branch 'nfsd/nfsd-next'

[karo-tx-linux.git] / fs / nfs / nfs4proc.c

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 4bfc33ad05637f58f9f0b675f058fd90085d4271..e810ab57a5115f4e30d6f0e4aa2f9668ae616740 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -4707,20 +4707,17 @@ out:
 /*
  * The getxattr API returns the required buffer length when called with a
  * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
- * the required buf.  On a NULL buf, we send a page of data to the server
- * guessing that the ACL request can be serviced by a page. If so, we cache
- * up to the page of ACL data, and the 2nd call to getxattr is serviced by
- * the cache. If not so, we throw away the page, and cache the required
- * length. The next getxattr call will then produce another round trip to
- * the server, this time with the input buf of the required size.
+ * the required buf. Cache the result from the first getxattr call to avoid
+ * sending another RPC.
  */
 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
 {
-       struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
+       /* enough pages to hold ACL data plus the bitmap and acl length */
+       struct page *pages[NFS4ACL_MAXPAGES + 1] = {NULL, };
        struct nfs_getaclargs args = {
                .fh = NFS_FH(inode),
+               /* The xdr layer may allocate pages here. */
                .acl_pages = pages,
-               .acl_len = buflen,
        };
        struct nfs_getaclres res = {
                .acl_len = buflen,
@@ -4730,31 +4727,24 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
                .rpc_argp = &args,
                .rpc_resp = &res,
        };
-       unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
        int ret = -ENOMEM, i;
 
-       /* As long as we're doing a round trip to the server anyway,
-        * let's be prepared for a page of acl data. */
-       if (npages == 0)
-               npages = 1;
-       if (npages > ARRAY_SIZE(pages))
-               return -ERANGE;
-
-       for (i = 0; i < npages; i++) {
-               pages[i] = alloc_page(GFP_KERNEL);
-               if (!pages[i])
-                       goto out_free;
-       }
+       /*
+        * There will be some data returned by the server, how much is not
+        * known yet. Allocate one page and let the XDR layer allocate
+        * more if needed.
+        */
+       pages[0] = alloc_page(GFP_KERNEL);
 
        /* for decoding across pages */
        res.acl_scratch = alloc_page(GFP_KERNEL);
        if (!res.acl_scratch)
                goto out_free;
 
-       args.acl_len = npages * PAGE_SIZE;
+       args.acl_len = ARRAY_SIZE(pages) << PAGE_SHIFT;
 
-       dprintk("%s  buf %p buflen %zu npages %d args.acl_len %zu\n",
-               __func__, buf, buflen, npages, args.acl_len);
+       dprintk("%s  buf %p buflen %zu args.acl_len %zu\n",
+               __func__, buf, buflen, args.acl_len);
        ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
                             &msg, &args.seq_args, &res.seq_res, 0);
        if (ret)
@@ -4779,7 +4769,7 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
 out_ok:
        ret = res.acl_len;
 out_free:
-       for (i = 0; i < npages; i++)
+       for (i = 0; i < ARRAY_SIZE(pages) && pages[i]; i++)
                if (pages[i])
                        __free_page(pages[i]);
        if (res.acl_scratch)