Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * Server-side XDR for NFSv4 |
| 3 | * |
| 4 | * Copyright (c) 2002 The Regents of the University of Michigan. |
| 5 | * All rights reserved. |
| 6 | * |
| 7 | * Kendrick Smith <kmsmith@umich.edu> |
| 8 | * Andy Adamson <andros@umich.edu> |
| 9 | * |
| 10 | * Redistribution and use in source and binary forms, with or without |
| 11 | * modification, are permitted provided that the following conditions |
| 12 | * are met: |
| 13 | * |
| 14 | * 1. Redistributions of source code must retain the above copyright |
| 15 | * notice, this list of conditions and the following disclaimer. |
| 16 | * 2. Redistributions in binary form must reproduce the above copyright |
| 17 | * notice, this list of conditions and the following disclaimer in the |
| 18 | * documentation and/or other materials provided with the distribution. |
| 19 | * 3. Neither the name of the University nor the names of its |
| 20 | * contributors may be used to endorse or promote products derived |
| 21 | * from this software without specific prior written permission. |
| 22 | * |
| 23 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| 24 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 25 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| 26 | * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 27 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 28 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 29 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| 30 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| 31 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| 32 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| 33 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 34 | * |
| 35 | * TODO: Neil Brown made the following observation: We currently |
| 36 | * initially reserve NFSD_BUFSIZE space on the transmit queue and |
| 37 | * never release any of that until the request is complete. |
| 38 | * It would be good to calculate a new maximum response size while |
| 39 | * decoding the COMPOUND, and call svc_reserve with this number |
| 40 | * at the end of nfs4svc_decode_compoundargs. |
| 41 | */ |
| 42 | |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 43 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | #include <linux/namei.h> |
Boaz Harrosh | 341eb18 | 2009-12-03 20:29:12 +0200 | [diff] [blame] | 45 | #include <linux/statfs.h> |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 46 | #include <linux/utsname.h> |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 47 | #include <linux/pagemap.h> |
J. Bruce Fields | 4796f45 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 48 | #include <linux/sunrpc/svcauth_gss.h> |
Boaz Harrosh | 9a74af2 | 2009-12-03 20:30:56 +0200 | [diff] [blame] | 49 | |
J. Bruce Fields | 2ca72e1 | 2011-01-04 17:37:15 -0500 | [diff] [blame] | 50 | #include "idmap.h" |
| 51 | #include "acl.h" |
Boaz Harrosh | 9a74af2 | 2009-12-03 20:30:56 +0200 | [diff] [blame] | 52 | #include "xdr4.h" |
J. Bruce Fields | 0a3adad | 2009-11-04 18:12:35 -0500 | [diff] [blame] | 53 | #include "vfs.h" |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 54 | #include "state.h" |
J. Bruce Fields | 1091006 | 2011-01-24 12:11:02 -0500 | [diff] [blame] | 55 | #include "cache.h" |
Stanislav Kinsbursky | 3d73371 | 2012-11-27 14:11:44 +0300 | [diff] [blame] | 56 | #include "netns.h" |
J. Bruce Fields | 2ca72e1 | 2011-01-04 17:37:15 -0500 | [diff] [blame] | 57 | |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 58 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
| 59 | #include <linux/security.h> |
| 60 | #endif |
| 61 | |
| 62 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | #define NFSDDBG_FACILITY NFSDDBG_XDR |
| 64 | |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 65 | /* |
| 66 | * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing |
| 67 | * directory in order to indicate to the client that a filesystem boundary is present |
| 68 | * We use a fixed fsid for a referral |
| 69 | */ |
| 70 | #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL |
| 71 | #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL |
| 72 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 73 | static __be32 |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 74 | check_filename(char *str, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | { |
| 76 | int i; |
| 77 | |
| 78 | if (len == 0) |
| 79 | return nfserr_inval; |
| 80 | if (isdotent(str, len)) |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 81 | return nfserr_badname; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | for (i = 0; i < len; i++) |
| 83 | if (str[i] == '/') |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 84 | return nfserr_badname; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | return 0; |
| 86 | } |
| 87 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | #define DECODE_HEAD \ |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 89 | __be32 *p; \ |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 90 | __be32 status |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | #define DECODE_TAIL \ |
| 92 | status = 0; \ |
| 93 | out: \ |
| 94 | return status; \ |
| 95 | xdr_error: \ |
Chuck Lever | 817cb9d | 2007-09-11 18:01:20 -0400 | [diff] [blame] | 96 | dprintk("NFSD: xdr error (%s:%d)\n", \ |
| 97 | __FILE__, __LINE__); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | status = nfserr_bad_xdr; \ |
| 99 | goto out |
| 100 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | #define READMEM(x,nbytes) do { \ |
| 102 | x = (char *)p; \ |
| 103 | p += XDR_QUADLEN(nbytes); \ |
| 104 | } while (0) |
| 105 | #define SAVEMEM(x,nbytes) do { \ |
| 106 | if (!(x = (p==argp->tmp || p == argp->tmpp) ? \ |
| 107 | savemem(argp, p, nbytes) : \ |
| 108 | (char *)p)) { \ |
Chuck Lever | 817cb9d | 2007-09-11 18:01:20 -0400 | [diff] [blame] | 109 | dprintk("NFSD: xdr error (%s:%d)\n", \ |
| 110 | __FILE__, __LINE__); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | goto xdr_error; \ |
| 112 | } \ |
| 113 | p += XDR_QUADLEN(nbytes); \ |
| 114 | } while (0) |
| 115 | #define COPYMEM(x,nbytes) do { \ |
| 116 | memcpy((x), p, nbytes); \ |
| 117 | p += XDR_QUADLEN(nbytes); \ |
| 118 | } while (0) |
| 119 | |
| 120 | /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */ |
| 121 | #define READ_BUF(nbytes) do { \ |
| 122 | if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \ |
| 123 | p = argp->p; \ |
| 124 | argp->p += XDR_QUADLEN(nbytes); \ |
| 125 | } else if (!(p = read_buf(argp, nbytes))) { \ |
Chuck Lever | 817cb9d | 2007-09-11 18:01:20 -0400 | [diff] [blame] | 126 | dprintk("NFSD: xdr error (%s:%d)\n", \ |
| 127 | __FILE__, __LINE__); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | goto xdr_error; \ |
| 129 | } \ |
| 130 | } while (0) |
| 131 | |
J. Bruce Fields | 590b743 | 2013-06-21 17:06:29 -0400 | [diff] [blame] | 132 | static void next_decode_page(struct nfsd4_compoundargs *argp) |
| 133 | { |
J. Bruce Fields | 590b743 | 2013-06-21 17:06:29 -0400 | [diff] [blame] | 134 | argp->p = page_address(argp->pagelist[0]); |
J. Bruce Fields | 365da4a | 2013-11-19 17:32:43 -0500 | [diff] [blame] | 135 | argp->pagelist++; |
J. Bruce Fields | 590b743 | 2013-06-21 17:06:29 -0400 | [diff] [blame] | 136 | if (argp->pagelen < PAGE_SIZE) { |
| 137 | argp->end = argp->p + (argp->pagelen>>2); |
| 138 | argp->pagelen = 0; |
| 139 | } else { |
| 140 | argp->end = argp->p + (PAGE_SIZE>>2); |
| 141 | argp->pagelen -= PAGE_SIZE; |
| 142 | } |
| 143 | } |
| 144 | |
J. Bruce Fields | ca2a05a | 2007-11-11 15:43:12 -0500 | [diff] [blame] | 145 | static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | { |
| 147 | /* We want more bytes than seem to be available. |
| 148 | * Maybe we need a new page, maybe we have just run out |
| 149 | */ |
J. Bruce Fields | ca2a05a | 2007-11-11 15:43:12 -0500 | [diff] [blame] | 150 | unsigned int avail = (char *)argp->end - (char *)argp->p; |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 151 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | if (avail + argp->pagelen < nbytes) |
| 153 | return NULL; |
| 154 | if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */ |
| 155 | return NULL; |
| 156 | /* ok, we can do it with the current plus the next page */ |
| 157 | if (nbytes <= sizeof(argp->tmp)) |
| 158 | p = argp->tmp; |
| 159 | else { |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 160 | kfree(argp->tmpp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL); |
| 162 | if (!p) |
| 163 | return NULL; |
| 164 | |
| 165 | } |
J. Bruce Fields | ca2a05a | 2007-11-11 15:43:12 -0500 | [diff] [blame] | 166 | /* |
| 167 | * The following memcpy is safe because read_buf is always |
| 168 | * called with nbytes > avail, and the two cases above both |
| 169 | * guarantee p points to at least nbytes bytes. |
| 170 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | memcpy(p, argp->p, avail); |
J. Bruce Fields | 590b743 | 2013-06-21 17:06:29 -0400 | [diff] [blame] | 172 | next_decode_page(argp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | memcpy(((char*)p)+avail, argp->p, (nbytes - avail)); |
| 174 | argp->p += XDR_QUADLEN(nbytes - avail); |
| 175 | return p; |
| 176 | } |
| 177 | |
Andy Adamson | 60adfc5 | 2009-04-03 08:28:50 +0300 | [diff] [blame] | 178 | static int zero_clientid(clientid_t *clid) |
| 179 | { |
| 180 | return (clid->cl_boot == 0) && (clid->cl_id == 0); |
| 181 | } |
| 182 | |
Christoph Hellwig | 2d8498d | 2013-11-20 00:24:11 -0800 | [diff] [blame] | 183 | /** |
| 184 | * defer_free - mark an allocation as deferred freed |
| 185 | * @argp: NFSv4 compound argument structure to be freed with |
| 186 | * @release: release callback to free @p, typically kfree() |
| 187 | * @p: pointer to be freed |
| 188 | * |
| 189 | * Marks @p to be freed when processing the compound operation |
| 190 | * described in @argp finishes. |
| 191 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | static int |
| 193 | defer_free(struct nfsd4_compoundargs *argp, |
| 194 | void (*release)(const void *), void *p) |
| 195 | { |
| 196 | struct tmpbuf *tb; |
| 197 | |
| 198 | tb = kmalloc(sizeof(*tb), GFP_KERNEL); |
| 199 | if (!tb) |
| 200 | return -ENOMEM; |
| 201 | tb->buf = p; |
| 202 | tb->release = release; |
| 203 | tb->next = argp->to_free; |
| 204 | argp->to_free = tb; |
| 205 | return 0; |
| 206 | } |
| 207 | |
Christoph Hellwig | 2d8498d | 2013-11-20 00:24:11 -0800 | [diff] [blame] | 208 | /** |
| 209 | * savemem - duplicate a chunk of memory for later processing |
| 210 | * @argp: NFSv4 compound argument structure to be freed with |
| 211 | * @p: pointer to be duplicated |
| 212 | * @nbytes: length to be duplicated |
| 213 | * |
| 214 | * Returns a pointer to a copy of @nbytes bytes of memory at @p |
| 215 | * that are preserved until processing of the NFSv4 compound |
| 216 | * operation described by @argp finishes. |
| 217 | */ |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 218 | static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | if (p == argp->tmp) { |
Thomas Meyer | 67114fe | 2011-11-17 23:43:40 +0100 | [diff] [blame] | 221 | p = kmemdup(argp->tmp, nbytes, GFP_KERNEL); |
J. Bruce Fields | a4db5fe | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 222 | if (!p) |
| 223 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | } else { |
Eric Sesterhenn | 73dff8b | 2006-10-03 23:37:14 +0200 | [diff] [blame] | 225 | BUG_ON(p != argp->tmpp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | argp->tmpp = NULL; |
| 227 | } |
| 228 | if (defer_free(argp, kfree, p)) { |
J. Bruce Fields | a4db5fe | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 229 | kfree(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | return NULL; |
| 231 | } else |
| 232 | return (char *)p; |
| 233 | } |
| 234 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 235 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval) |
| 237 | { |
| 238 | u32 bmlen; |
| 239 | DECODE_HEAD; |
| 240 | |
| 241 | bmval[0] = 0; |
| 242 | bmval[1] = 0; |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 243 | bmval[2] = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
| 245 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 246 | bmlen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | if (bmlen > 1000) |
| 248 | goto xdr_error; |
| 249 | |
| 250 | READ_BUF(bmlen << 2); |
| 251 | if (bmlen > 0) |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 252 | bmval[0] = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | if (bmlen > 1) |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 254 | bmval[1] = be32_to_cpup(p++); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 255 | if (bmlen > 2) |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 256 | bmval[2] = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | |
| 258 | DECODE_TAIL; |
| 259 | } |
| 260 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 261 | static __be32 |
Yu Zhiguo | 3c8e031 | 2009-05-16 16:22:31 +0800 | [diff] [blame] | 262 | nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval, |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 263 | struct iattr *iattr, struct nfs4_acl **acl, |
| 264 | struct xdr_netobj *label) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | { |
| 266 | int expected_len, len = 0; |
| 267 | u32 dummy32; |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 268 | u64 sec; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | char *buf; |
| 270 | |
| 271 | DECODE_HEAD; |
| 272 | iattr->ia_valid = 0; |
| 273 | if ((status = nfsd4_decode_bitmap(argp, bmval))) |
| 274 | return status; |
| 275 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 277 | expected_len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | |
| 279 | if (bmval[0] & FATTR4_WORD0_SIZE) { |
| 280 | READ_BUF(8); |
| 281 | len += 8; |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 282 | p = xdr_decode_hyper(p, &iattr->ia_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | iattr->ia_valid |= ATTR_SIZE; |
| 284 | } |
| 285 | if (bmval[0] & FATTR4_WORD0_ACL) { |
J. Bruce Fields | 64a817c | 2013-03-26 14:11:13 -0400 | [diff] [blame] | 286 | u32 nace; |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 287 | struct nfs4_ace *ace; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | |
| 289 | READ_BUF(4); len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 290 | nace = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 292 | if (nace > NFS4_ACL_MAX) |
J. Bruce Fields | 798df33 | 2014-01-29 16:39:05 -0500 | [diff] [blame] | 293 | return nfserr_fbig; |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 294 | |
| 295 | *acl = nfs4_acl_new(nace); |
Kinglong Mee | eba1c99 | 2013-12-09 18:23:46 +0800 | [diff] [blame] | 296 | if (*acl == NULL) |
| 297 | return nfserr_jukebox; |
| 298 | |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 299 | defer_free(argp, kfree, *acl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 301 | (*acl)->naces = nace; |
| 302 | for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | READ_BUF(16); len += 16; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 304 | ace->type = be32_to_cpup(p++); |
| 305 | ace->flag = be32_to_cpup(p++); |
| 306 | ace->access_mask = be32_to_cpup(p++); |
| 307 | dummy32 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | READ_BUF(dummy32); |
| 309 | len += XDR_QUADLEN(dummy32) << 2; |
| 310 | READMEM(buf, dummy32); |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 311 | ace->whotype = nfs4_acl_get_whotype(buf, dummy32); |
J. Bruce Fields | 3c72602 | 2011-01-04 17:53:52 -0500 | [diff] [blame] | 312 | status = nfs_ok; |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 313 | if (ace->whotype != NFS4_ACL_WHO_NAMED) |
Eric W. Biederman | ab8e4ae | 2013-02-02 05:18:08 -0800 | [diff] [blame] | 314 | ; |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 315 | else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) |
J. Bruce Fields | 3c72602 | 2011-01-04 17:53:52 -0500 | [diff] [blame] | 316 | status = nfsd_map_name_to_gid(argp->rqstp, |
Eric W. Biederman | ab8e4ae | 2013-02-02 05:18:08 -0800 | [diff] [blame] | 317 | buf, dummy32, &ace->who_gid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | else |
J. Bruce Fields | 3c72602 | 2011-01-04 17:53:52 -0500 | [diff] [blame] | 319 | status = nfsd_map_name_to_uid(argp->rqstp, |
Eric W. Biederman | ab8e4ae | 2013-02-02 05:18:08 -0800 | [diff] [blame] | 320 | buf, dummy32, &ace->who_uid); |
J. Bruce Fields | 3c72602 | 2011-01-04 17:53:52 -0500 | [diff] [blame] | 321 | if (status) |
| 322 | return status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | } |
| 324 | } else |
| 325 | *acl = NULL; |
| 326 | if (bmval[1] & FATTR4_WORD1_MODE) { |
| 327 | READ_BUF(4); |
| 328 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 329 | iattr->ia_mode = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | iattr->ia_mode &= (S_IFMT | S_IALLUGO); |
| 331 | iattr->ia_valid |= ATTR_MODE; |
| 332 | } |
| 333 | if (bmval[1] & FATTR4_WORD1_OWNER) { |
| 334 | READ_BUF(4); |
| 335 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 336 | dummy32 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | READ_BUF(dummy32); |
| 338 | len += (XDR_QUADLEN(dummy32) << 2); |
| 339 | READMEM(buf, dummy32); |
NeilBrown | 47c8529 | 2011-02-16 13:08:35 +1100 | [diff] [blame] | 340 | if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid))) |
| 341 | return status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | iattr->ia_valid |= ATTR_UID; |
| 343 | } |
| 344 | if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) { |
| 345 | READ_BUF(4); |
| 346 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 347 | dummy32 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | READ_BUF(dummy32); |
| 349 | len += (XDR_QUADLEN(dummy32) << 2); |
| 350 | READMEM(buf, dummy32); |
NeilBrown | 47c8529 | 2011-02-16 13:08:35 +1100 | [diff] [blame] | 351 | if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid))) |
| 352 | return status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | iattr->ia_valid |= ATTR_GID; |
| 354 | } |
| 355 | if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) { |
| 356 | READ_BUF(4); |
| 357 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 358 | dummy32 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | switch (dummy32) { |
| 360 | case NFS4_SET_TO_CLIENT_TIME: |
| 361 | /* We require the high 32 bits of 'seconds' to be 0, and we ignore |
| 362 | all 32 bits of 'nseconds'. */ |
| 363 | READ_BUF(12); |
| 364 | len += 12; |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 365 | p = xdr_decode_hyper(p, &sec); |
| 366 | iattr->ia_atime.tv_sec = (time_t)sec; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 367 | iattr->ia_atime.tv_nsec = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | if (iattr->ia_atime.tv_nsec >= (u32)1000000000) |
| 369 | return nfserr_inval; |
| 370 | iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); |
| 371 | break; |
| 372 | case NFS4_SET_TO_SERVER_TIME: |
| 373 | iattr->ia_valid |= ATTR_ATIME; |
| 374 | break; |
| 375 | default: |
| 376 | goto xdr_error; |
| 377 | } |
| 378 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) { |
| 380 | READ_BUF(4); |
| 381 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 382 | dummy32 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | switch (dummy32) { |
| 384 | case NFS4_SET_TO_CLIENT_TIME: |
| 385 | /* We require the high 32 bits of 'seconds' to be 0, and we ignore |
| 386 | all 32 bits of 'nseconds'. */ |
| 387 | READ_BUF(12); |
| 388 | len += 12; |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 389 | p = xdr_decode_hyper(p, &sec); |
| 390 | iattr->ia_mtime.tv_sec = sec; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 391 | iattr->ia_mtime.tv_nsec = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | if (iattr->ia_mtime.tv_nsec >= (u32)1000000000) |
| 393 | return nfserr_inval; |
| 394 | iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); |
| 395 | break; |
| 396 | case NFS4_SET_TO_SERVER_TIME: |
| 397 | iattr->ia_valid |= ATTR_MTIME; |
| 398 | break; |
| 399 | default: |
| 400 | goto xdr_error; |
| 401 | } |
| 402 | } |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 403 | |
| 404 | label->len = 0; |
| 405 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
| 406 | if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) { |
| 407 | READ_BUF(4); |
| 408 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 409 | dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */ |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 410 | READ_BUF(4); |
| 411 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 412 | dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */ |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 413 | READ_BUF(4); |
| 414 | len += 4; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 415 | dummy32 = be32_to_cpup(p++); |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 416 | READ_BUF(dummy32); |
| 417 | if (dummy32 > NFSD4_MAX_SEC_LABEL_LEN) |
| 418 | return nfserr_badlabel; |
| 419 | len += (XDR_QUADLEN(dummy32) << 2); |
| 420 | READMEM(buf, dummy32); |
| 421 | label->data = kzalloc(dummy32 + 1, GFP_KERNEL); |
| 422 | if (!label->data) |
| 423 | return nfserr_jukebox; |
J. Bruce Fields | 3378b7f | 2013-11-01 10:42:15 -0400 | [diff] [blame] | 424 | label->len = dummy32; |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 425 | defer_free(argp, kfree, label->data); |
| 426 | memcpy(label->data, buf, dummy32); |
| 427 | } |
| 428 | #endif |
| 429 | |
Yu Zhiguo | 3c8e031 | 2009-05-16 16:22:31 +0800 | [diff] [blame] | 430 | if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0 |
| 431 | || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1 |
| 432 | || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) |
| 433 | READ_BUF(expected_len - len); |
| 434 | else if (len != expected_len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | goto xdr_error; |
| 436 | |
| 437 | DECODE_TAIL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | } |
| 439 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 440 | static __be32 |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 441 | nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid) |
| 442 | { |
| 443 | DECODE_HEAD; |
| 444 | |
| 445 | READ_BUF(sizeof(stateid_t)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 446 | sid->si_generation = be32_to_cpup(p++); |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 447 | COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); |
| 448 | |
| 449 | DECODE_TAIL; |
| 450 | } |
| 451 | |
| 452 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access) |
| 454 | { |
| 455 | DECODE_HEAD; |
| 456 | |
| 457 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 458 | access->ac_req_access = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 459 | |
| 460 | DECODE_TAIL; |
| 461 | } |
| 462 | |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 463 | static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs) |
| 464 | { |
| 465 | DECODE_HEAD; |
J. Bruce Fields | 12fc3e9 | 2012-11-05 16:01:48 -0500 | [diff] [blame] | 466 | u32 dummy, uid, gid; |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 467 | char *machine_name; |
| 468 | int i; |
| 469 | int nr_secflavs; |
| 470 | |
| 471 | /* callback_sec_params4 */ |
| 472 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 473 | nr_secflavs = be32_to_cpup(p++); |
J. Bruce Fields | 57569a7 | 2013-05-17 16:25:32 -0400 | [diff] [blame] | 474 | if (nr_secflavs) |
| 475 | cbs->flavor = (u32)(-1); |
| 476 | else |
| 477 | /* Is this legal? Be generous, take it to mean AUTH_NONE: */ |
| 478 | cbs->flavor = 0; |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 479 | for (i = 0; i < nr_secflavs; ++i) { |
| 480 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 481 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 482 | switch (dummy) { |
| 483 | case RPC_AUTH_NULL: |
| 484 | /* Nothing to read */ |
J. Bruce Fields | 12fc3e9 | 2012-11-05 16:01:48 -0500 | [diff] [blame] | 485 | if (cbs->flavor == (u32)(-1)) |
| 486 | cbs->flavor = RPC_AUTH_NULL; |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 487 | break; |
| 488 | case RPC_AUTH_UNIX: |
| 489 | READ_BUF(8); |
| 490 | /* stamp */ |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 491 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 492 | |
| 493 | /* machine name */ |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 494 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 495 | READ_BUF(dummy); |
| 496 | SAVEMEM(machine_name, dummy); |
| 497 | |
| 498 | /* uid, gid */ |
| 499 | READ_BUF(8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 500 | uid = be32_to_cpup(p++); |
| 501 | gid = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 502 | |
| 503 | /* more gids */ |
| 504 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 505 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 506 | READ_BUF(dummy * 4); |
J. Bruce Fields | 12fc3e9 | 2012-11-05 16:01:48 -0500 | [diff] [blame] | 507 | if (cbs->flavor == (u32)(-1)) { |
Eric W. Biederman | 03bc6d1 | 2013-02-02 06:24:49 -0800 | [diff] [blame] | 508 | kuid_t kuid = make_kuid(&init_user_ns, uid); |
| 509 | kgid_t kgid = make_kgid(&init_user_ns, gid); |
| 510 | if (uid_valid(kuid) && gid_valid(kgid)) { |
| 511 | cbs->uid = kuid; |
| 512 | cbs->gid = kgid; |
| 513 | cbs->flavor = RPC_AUTH_UNIX; |
| 514 | } else { |
| 515 | dprintk("RPC_AUTH_UNIX with invalid" |
| 516 | "uid or gid ignoring!\n"); |
| 517 | } |
J. Bruce Fields | 12fc3e9 | 2012-11-05 16:01:48 -0500 | [diff] [blame] | 518 | } |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 519 | break; |
| 520 | case RPC_AUTH_GSS: |
| 521 | dprintk("RPC_AUTH_GSS callback secflavor " |
| 522 | "not supported!\n"); |
| 523 | READ_BUF(8); |
| 524 | /* gcbp_service */ |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 525 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 526 | /* gcbp_handle_from_server */ |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 527 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 528 | READ_BUF(dummy); |
| 529 | p += XDR_QUADLEN(dummy); |
| 530 | /* gcbp_handle_from_client */ |
| 531 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 532 | dummy = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 533 | READ_BUF(dummy); |
| 534 | break; |
| 535 | default: |
| 536 | dprintk("Illegal callback secflavor\n"); |
| 537 | return nfserr_inval; |
| 538 | } |
| 539 | } |
| 540 | DECODE_TAIL; |
| 541 | } |
| 542 | |
J. Bruce Fields | cb73a9f | 2012-11-01 18:09:48 -0400 | [diff] [blame] | 543 | static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc) |
| 544 | { |
| 545 | DECODE_HEAD; |
| 546 | |
| 547 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 548 | bc->bc_cb_program = be32_to_cpup(p++); |
J. Bruce Fields | cb73a9f | 2012-11-01 18:09:48 -0400 | [diff] [blame] | 549 | nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); |
| 550 | |
| 551 | DECODE_TAIL; |
| 552 | } |
| 553 | |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 554 | static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts) |
| 555 | { |
| 556 | DECODE_HEAD; |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 557 | |
| 558 | READ_BUF(NFS4_MAX_SESSIONID_LEN + 8); |
| 559 | COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 560 | bcts->dir = be32_to_cpup(p++); |
Bryan Schumaker | 6ce2357 | 2011-04-27 15:47:16 -0400 | [diff] [blame] | 561 | /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker |
| 562 | * could help us figure out we should be using it. */ |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 563 | DECODE_TAIL; |
| 564 | } |
| 565 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 566 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close) |
| 568 | { |
| 569 | DECODE_HEAD; |
| 570 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 571 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 572 | close->cl_seqid = be32_to_cpup(p++); |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 573 | return nfsd4_decode_stateid(argp, &close->cl_stateid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | |
| 575 | DECODE_TAIL; |
| 576 | } |
| 577 | |
| 578 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 579 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 580 | nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit) |
| 581 | { |
| 582 | DECODE_HEAD; |
| 583 | |
| 584 | READ_BUF(12); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 585 | p = xdr_decode_hyper(p, &commit->co_offset); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 586 | commit->co_count = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | |
| 588 | DECODE_TAIL; |
| 589 | } |
| 590 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 591 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 592 | nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create) |
| 593 | { |
| 594 | DECODE_HEAD; |
| 595 | |
| 596 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 597 | create->cr_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 598 | switch (create->cr_type) { |
| 599 | case NF4LNK: |
| 600 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 601 | create->cr_linklen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 602 | READ_BUF(create->cr_linklen); |
J. Bruce Fields | 76f47128 | 2014-06-19 16:44:48 -0400 | [diff] [blame] | 603 | /* |
| 604 | * The VFS will want a null-terminated string, and |
| 605 | * null-terminating in place isn't safe since this might |
| 606 | * end on a page boundary: |
| 607 | */ |
| 608 | create->cr_linkname = |
| 609 | kmalloc(create->cr_linklen + 1, GFP_KERNEL); |
| 610 | if (!create->cr_linkname) |
| 611 | return nfserr_jukebox; |
| 612 | memcpy(create->cr_linkname, p, create->cr_linklen); |
| 613 | create->cr_linkname[create->cr_linklen] = '\0'; |
| 614 | defer_free(argp, kfree, create->cr_linkname); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | break; |
| 616 | case NF4BLK: |
| 617 | case NF4CHR: |
| 618 | READ_BUF(8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 619 | create->cr_specdata1 = be32_to_cpup(p++); |
| 620 | create->cr_specdata2 = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 621 | break; |
| 622 | case NF4SOCK: |
| 623 | case NF4FIFO: |
| 624 | case NF4DIR: |
| 625 | default: |
| 626 | break; |
| 627 | } |
| 628 | |
| 629 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 630 | create->cr_namelen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 631 | READ_BUF(create->cr_namelen); |
| 632 | SAVEMEM(create->cr_name, create->cr_namelen); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 633 | if ((status = check_filename(create->cr_name, create->cr_namelen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 634 | return status; |
| 635 | |
Yu Zhiguo | 3c8e031 | 2009-05-16 16:22:31 +0800 | [diff] [blame] | 636 | status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr, |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 637 | &create->cr_acl, &create->cr_label); |
Benny Halevy | c0d6fc8 | 2009-04-03 08:29:05 +0300 | [diff] [blame] | 638 | if (status) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 639 | goto out; |
| 640 | |
| 641 | DECODE_TAIL; |
| 642 | } |
| 643 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 644 | static inline __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 645 | nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr) |
| 646 | { |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 647 | return nfsd4_decode_stateid(argp, &dr->dr_stateid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 648 | } |
| 649 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 650 | static inline __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 651 | nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr) |
| 652 | { |
| 653 | return nfsd4_decode_bitmap(argp, getattr->ga_bmval); |
| 654 | } |
| 655 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 656 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 657 | nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link) |
| 658 | { |
| 659 | DECODE_HEAD; |
| 660 | |
| 661 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 662 | link->li_namelen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 663 | READ_BUF(link->li_namelen); |
| 664 | SAVEMEM(link->li_name, link->li_namelen); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 665 | if ((status = check_filename(link->li_name, link->li_namelen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 666 | return status; |
| 667 | |
| 668 | DECODE_TAIL; |
| 669 | } |
| 670 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 671 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 672 | nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock) |
| 673 | { |
| 674 | DECODE_HEAD; |
| 675 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 676 | /* |
| 677 | * type, reclaim(boolean), offset, length, new_lock_owner(boolean) |
| 678 | */ |
| 679 | READ_BUF(28); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 680 | lock->lk_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 681 | if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) |
| 682 | goto xdr_error; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 683 | lock->lk_reclaim = be32_to_cpup(p++); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 684 | p = xdr_decode_hyper(p, &lock->lk_offset); |
| 685 | p = xdr_decode_hyper(p, &lock->lk_length); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 686 | lock->lk_is_new = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 687 | |
| 688 | if (lock->lk_is_new) { |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 689 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 690 | lock->lk_new_open_seqid = be32_to_cpup(p++); |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 691 | status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid); |
| 692 | if (status) |
| 693 | return status; |
| 694 | READ_BUF(8 + sizeof(clientid_t)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 695 | lock->lk_new_lock_seqid = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 696 | COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 697 | lock->lk_new_owner.len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 698 | READ_BUF(lock->lk_new_owner.len); |
| 699 | READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len); |
| 700 | } else { |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 701 | status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid); |
| 702 | if (status) |
| 703 | return status; |
| 704 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 705 | lock->lk_old_lock_seqid = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 706 | } |
| 707 | |
| 708 | DECODE_TAIL; |
| 709 | } |
| 710 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 711 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 712 | nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt) |
| 713 | { |
| 714 | DECODE_HEAD; |
| 715 | |
| 716 | READ_BUF(32); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 717 | lockt->lt_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 718 | if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) |
| 719 | goto xdr_error; |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 720 | p = xdr_decode_hyper(p, &lockt->lt_offset); |
| 721 | p = xdr_decode_hyper(p, &lockt->lt_length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | COPYMEM(&lockt->lt_clientid, 8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 723 | lockt->lt_owner.len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 724 | READ_BUF(lockt->lt_owner.len); |
| 725 | READMEM(lockt->lt_owner.data, lockt->lt_owner.len); |
| 726 | |
| 727 | DECODE_TAIL; |
| 728 | } |
| 729 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 730 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 731 | nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku) |
| 732 | { |
| 733 | DECODE_HEAD; |
| 734 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 735 | READ_BUF(8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 736 | locku->lu_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 737 | if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) |
| 738 | goto xdr_error; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 739 | locku->lu_seqid = be32_to_cpup(p++); |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 740 | status = nfsd4_decode_stateid(argp, &locku->lu_stateid); |
| 741 | if (status) |
| 742 | return status; |
| 743 | READ_BUF(16); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 744 | p = xdr_decode_hyper(p, &locku->lu_offset); |
| 745 | p = xdr_decode_hyper(p, &locku->lu_length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 746 | |
| 747 | DECODE_TAIL; |
| 748 | } |
| 749 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 750 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 751 | nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup) |
| 752 | { |
| 753 | DECODE_HEAD; |
| 754 | |
| 755 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 756 | lookup->lo_len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | READ_BUF(lookup->lo_len); |
| 758 | SAVEMEM(lookup->lo_name, lookup->lo_len); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 759 | if ((status = check_filename(lookup->lo_name, lookup->lo_len))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 760 | return status; |
| 761 | |
| 762 | DECODE_TAIL; |
| 763 | } |
| 764 | |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 765 | static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when) |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 766 | { |
| 767 | __be32 *p; |
| 768 | u32 w; |
| 769 | |
| 770 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 771 | w = be32_to_cpup(p++); |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 772 | *share_access = w & NFS4_SHARE_ACCESS_MASK; |
| 773 | *deleg_want = w & NFS4_SHARE_WANT_MASK; |
| 774 | if (deleg_when) |
| 775 | *deleg_when = w & NFS4_SHARE_WHEN_MASK; |
| 776 | |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 777 | switch (w & NFS4_SHARE_ACCESS_MASK) { |
| 778 | case NFS4_SHARE_ACCESS_READ: |
| 779 | case NFS4_SHARE_ACCESS_WRITE: |
| 780 | case NFS4_SHARE_ACCESS_BOTH: |
| 781 | break; |
| 782 | default: |
| 783 | return nfserr_bad_xdr; |
| 784 | } |
Benny Halevy | fc0d14f | 2011-10-27 20:43:01 +0200 | [diff] [blame] | 785 | w &= ~NFS4_SHARE_ACCESS_MASK; |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 786 | if (!w) |
| 787 | return nfs_ok; |
| 788 | if (!argp->minorversion) |
| 789 | return nfserr_bad_xdr; |
| 790 | switch (w & NFS4_SHARE_WANT_MASK) { |
| 791 | case NFS4_SHARE_WANT_NO_PREFERENCE: |
| 792 | case NFS4_SHARE_WANT_READ_DELEG: |
| 793 | case NFS4_SHARE_WANT_WRITE_DELEG: |
| 794 | case NFS4_SHARE_WANT_ANY_DELEG: |
| 795 | case NFS4_SHARE_WANT_NO_DELEG: |
| 796 | case NFS4_SHARE_WANT_CANCEL: |
| 797 | break; |
| 798 | default: |
| 799 | return nfserr_bad_xdr; |
| 800 | } |
Benny Halevy | 92bac8c | 2011-10-19 19:13:29 -0700 | [diff] [blame] | 801 | w &= ~NFS4_SHARE_WANT_MASK; |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 802 | if (!w) |
| 803 | return nfs_ok; |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 804 | |
| 805 | if (!deleg_when) /* open_downgrade */ |
| 806 | return nfserr_inval; |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 807 | switch (w) { |
| 808 | case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL: |
| 809 | case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED: |
Benny Halevy | c668fc6 | 2011-10-19 19:13:13 -0700 | [diff] [blame] | 810 | case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL | |
| 811 | NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED): |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 812 | return nfs_ok; |
| 813 | } |
| 814 | xdr_error: |
| 815 | return nfserr_bad_xdr; |
| 816 | } |
| 817 | |
| 818 | static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x) |
| 819 | { |
| 820 | __be32 *p; |
| 821 | |
| 822 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 823 | *x = be32_to_cpup(p++); |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 824 | /* Note: unlinke access bits, deny bits may be zero. */ |
Dan Carpenter | 01cd4afa | 2011-10-17 10:41:17 +0300 | [diff] [blame] | 825 | if (*x & ~NFS4_SHARE_DENY_BOTH) |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 826 | return nfserr_bad_xdr; |
| 827 | return nfs_ok; |
| 828 | xdr_error: |
| 829 | return nfserr_bad_xdr; |
| 830 | } |
| 831 | |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 832 | static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o) |
| 833 | { |
| 834 | __be32 *p; |
| 835 | |
| 836 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 837 | o->len = be32_to_cpup(p++); |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 838 | |
| 839 | if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT) |
| 840 | return nfserr_bad_xdr; |
| 841 | |
| 842 | READ_BUF(o->len); |
| 843 | SAVEMEM(o->data, o->len); |
| 844 | return nfs_ok; |
| 845 | xdr_error: |
| 846 | return nfserr_bad_xdr; |
| 847 | } |
| 848 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 849 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 850 | nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) |
| 851 | { |
| 852 | DECODE_HEAD; |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 853 | u32 dummy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 854 | |
| 855 | memset(open->op_bmval, 0, sizeof(open->op_bmval)); |
| 856 | open->op_iattr.ia_valid = 0; |
J. Bruce Fields | fe0750e | 2011-07-30 23:33:59 -0400 | [diff] [blame] | 857 | open->op_openowner = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | |
J. Bruce Fields | 9d313b1 | 2013-02-28 12:51:49 -0800 | [diff] [blame] | 859 | open->op_xdr_error = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 860 | /* seqid, share_access, share_deny, clientid, ownerlen */ |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 861 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 862 | open->op_seqid = be32_to_cpup(p++); |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 863 | /* decode, yet ignore deleg_when until supported */ |
| 864 | status = nfsd4_decode_share_access(argp, &open->op_share_access, |
| 865 | &open->op_deleg_want, &dummy); |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 866 | if (status) |
| 867 | goto xdr_error; |
| 868 | status = nfsd4_decode_share_deny(argp, &open->op_share_deny); |
| 869 | if (status) |
| 870 | goto xdr_error; |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 871 | READ_BUF(sizeof(clientid_t)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 872 | COPYMEM(&open->op_clientid, sizeof(clientid_t)); |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 873 | status = nfsd4_decode_opaque(argp, &open->op_owner); |
| 874 | if (status) |
| 875 | goto xdr_error; |
| 876 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 877 | open->op_create = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 878 | switch (open->op_create) { |
| 879 | case NFS4_OPEN_NOCREATE: |
| 880 | break; |
| 881 | case NFS4_OPEN_CREATE: |
| 882 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 883 | open->op_createmode = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 884 | switch (open->op_createmode) { |
| 885 | case NFS4_CREATE_UNCHECKED: |
| 886 | case NFS4_CREATE_GUARDED: |
Benny Halevy | c0d6fc8 | 2009-04-03 08:29:05 +0300 | [diff] [blame] | 887 | status = nfsd4_decode_fattr(argp, open->op_bmval, |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 888 | &open->op_iattr, &open->op_acl, &open->op_label); |
Benny Halevy | c0d6fc8 | 2009-04-03 08:29:05 +0300 | [diff] [blame] | 889 | if (status) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 890 | goto out; |
| 891 | break; |
| 892 | case NFS4_CREATE_EXCLUSIVE: |
Chuck Lever | ab4684d | 2012-03-02 17:13:50 -0500 | [diff] [blame] | 893 | READ_BUF(NFS4_VERIFIER_SIZE); |
| 894 | COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 895 | break; |
Benny Halevy | 79fb54a | 2009-04-03 08:29:17 +0300 | [diff] [blame] | 896 | case NFS4_CREATE_EXCLUSIVE4_1: |
| 897 | if (argp->minorversion < 1) |
| 898 | goto xdr_error; |
Chuck Lever | ab4684d | 2012-03-02 17:13:50 -0500 | [diff] [blame] | 899 | READ_BUF(NFS4_VERIFIER_SIZE); |
| 900 | COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); |
Benny Halevy | 79fb54a | 2009-04-03 08:29:17 +0300 | [diff] [blame] | 901 | status = nfsd4_decode_fattr(argp, open->op_bmval, |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 902 | &open->op_iattr, &open->op_acl, &open->op_label); |
Benny Halevy | 79fb54a | 2009-04-03 08:29:17 +0300 | [diff] [blame] | 903 | if (status) |
| 904 | goto out; |
| 905 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 906 | default: |
| 907 | goto xdr_error; |
| 908 | } |
| 909 | break; |
| 910 | default: |
| 911 | goto xdr_error; |
| 912 | } |
| 913 | |
| 914 | /* open_claim */ |
| 915 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 916 | open->op_claim_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 917 | switch (open->op_claim_type) { |
| 918 | case NFS4_OPEN_CLAIM_NULL: |
| 919 | case NFS4_OPEN_CLAIM_DELEGATE_PREV: |
| 920 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 921 | open->op_fname.len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 922 | READ_BUF(open->op_fname.len); |
| 923 | SAVEMEM(open->op_fname.data, open->op_fname.len); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 924 | if ((status = check_filename(open->op_fname.data, open->op_fname.len))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 925 | return status; |
| 926 | break; |
| 927 | case NFS4_OPEN_CLAIM_PREVIOUS: |
| 928 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 929 | open->op_delegate_type = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 930 | break; |
| 931 | case NFS4_OPEN_CLAIM_DELEGATE_CUR: |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 932 | status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); |
| 933 | if (status) |
| 934 | return status; |
| 935 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 936 | open->op_fname.len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 937 | READ_BUF(open->op_fname.len); |
| 938 | SAVEMEM(open->op_fname.data, open->op_fname.len); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 939 | if ((status = check_filename(open->op_fname.data, open->op_fname.len))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 940 | return status; |
| 941 | break; |
J. Bruce Fields | 8b289b2 | 2011-10-19 11:52:12 -0400 | [diff] [blame] | 942 | case NFS4_OPEN_CLAIM_FH: |
| 943 | case NFS4_OPEN_CLAIM_DELEG_PREV_FH: |
| 944 | if (argp->minorversion < 1) |
| 945 | goto xdr_error; |
| 946 | /* void */ |
| 947 | break; |
| 948 | case NFS4_OPEN_CLAIM_DELEG_CUR_FH: |
| 949 | if (argp->minorversion < 1) |
| 950 | goto xdr_error; |
| 951 | status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); |
| 952 | if (status) |
| 953 | return status; |
| 954 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 955 | default: |
| 956 | goto xdr_error; |
| 957 | } |
| 958 | |
| 959 | DECODE_TAIL; |
| 960 | } |
| 961 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 962 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 963 | nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf) |
| 964 | { |
| 965 | DECODE_HEAD; |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 966 | |
| 967 | if (argp->minorversion >= 1) |
| 968 | return nfserr_notsupp; |
| 969 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 970 | status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid); |
| 971 | if (status) |
| 972 | return status; |
| 973 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 974 | open_conf->oc_seqid = be32_to_cpup(p++); |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 975 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 976 | DECODE_TAIL; |
| 977 | } |
| 978 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 979 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 980 | nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down) |
| 981 | { |
| 982 | DECODE_HEAD; |
| 983 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 984 | status = nfsd4_decode_stateid(argp, &open_down->od_stateid); |
| 985 | if (status) |
| 986 | return status; |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 987 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 988 | open_down->od_seqid = be32_to_cpup(p++); |
Benny Halevy | 2c8bd7e | 2012-02-16 20:57:09 +0200 | [diff] [blame] | 989 | status = nfsd4_decode_share_access(argp, &open_down->od_share_access, |
| 990 | &open_down->od_deleg_want, NULL); |
J. Bruce Fields | 04f9e66 | 2011-10-10 14:37:13 -0400 | [diff] [blame] | 991 | if (status) |
| 992 | return status; |
| 993 | status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny); |
| 994 | if (status) |
| 995 | return status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 996 | DECODE_TAIL; |
| 997 | } |
| 998 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 999 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1000 | nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh) |
| 1001 | { |
| 1002 | DECODE_HEAD; |
| 1003 | |
| 1004 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1005 | putfh->pf_fhlen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1006 | if (putfh->pf_fhlen > NFS4_FHSIZE) |
| 1007 | goto xdr_error; |
| 1008 | READ_BUF(putfh->pf_fhlen); |
| 1009 | SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen); |
| 1010 | |
| 1011 | DECODE_TAIL; |
| 1012 | } |
| 1013 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1014 | static __be32 |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1015 | nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p) |
| 1016 | { |
| 1017 | if (argp->minorversion == 0) |
| 1018 | return nfs_ok; |
| 1019 | return nfserr_notsupp; |
| 1020 | } |
| 1021 | |
| 1022 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1023 | nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read) |
| 1024 | { |
| 1025 | DECODE_HEAD; |
| 1026 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 1027 | status = nfsd4_decode_stateid(argp, &read->rd_stateid); |
| 1028 | if (status) |
| 1029 | return status; |
| 1030 | READ_BUF(12); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 1031 | p = xdr_decode_hyper(p, &read->rd_offset); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1032 | read->rd_length = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1033 | |
| 1034 | DECODE_TAIL; |
| 1035 | } |
| 1036 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1037 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1038 | nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir) |
| 1039 | { |
| 1040 | DECODE_HEAD; |
| 1041 | |
| 1042 | READ_BUF(24); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 1043 | p = xdr_decode_hyper(p, &readdir->rd_cookie); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1044 | COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1045 | readdir->rd_dircount = be32_to_cpup(p++); |
| 1046 | readdir->rd_maxcount = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1047 | if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval))) |
| 1048 | goto out; |
| 1049 | |
| 1050 | DECODE_TAIL; |
| 1051 | } |
| 1052 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1053 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1054 | nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove) |
| 1055 | { |
| 1056 | DECODE_HEAD; |
| 1057 | |
| 1058 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1059 | remove->rm_namelen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1060 | READ_BUF(remove->rm_namelen); |
| 1061 | SAVEMEM(remove->rm_name, remove->rm_namelen); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 1062 | if ((status = check_filename(remove->rm_name, remove->rm_namelen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1063 | return status; |
| 1064 | |
| 1065 | DECODE_TAIL; |
| 1066 | } |
| 1067 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1068 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1069 | nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename) |
| 1070 | { |
| 1071 | DECODE_HEAD; |
| 1072 | |
| 1073 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1074 | rename->rn_snamelen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1075 | READ_BUF(rename->rn_snamelen + 4); |
| 1076 | SAVEMEM(rename->rn_sname, rename->rn_snamelen); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1077 | rename->rn_tnamelen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1078 | READ_BUF(rename->rn_tnamelen); |
| 1079 | SAVEMEM(rename->rn_tname, rename->rn_tnamelen); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 1080 | if ((status = check_filename(rename->rn_sname, rename->rn_snamelen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1081 | return status; |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 1082 | if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1083 | return status; |
| 1084 | |
| 1085 | DECODE_TAIL; |
| 1086 | } |
| 1087 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1088 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1089 | nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid) |
| 1090 | { |
| 1091 | DECODE_HEAD; |
| 1092 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1093 | if (argp->minorversion >= 1) |
| 1094 | return nfserr_notsupp; |
| 1095 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1096 | READ_BUF(sizeof(clientid_t)); |
| 1097 | COPYMEM(clientid, sizeof(clientid_t)); |
| 1098 | |
| 1099 | DECODE_TAIL; |
| 1100 | } |
| 1101 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1102 | static __be32 |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 1103 | nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp, |
| 1104 | struct nfsd4_secinfo *secinfo) |
| 1105 | { |
| 1106 | DECODE_HEAD; |
| 1107 | |
| 1108 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1109 | secinfo->si_namelen = be32_to_cpup(p++); |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 1110 | READ_BUF(secinfo->si_namelen); |
| 1111 | SAVEMEM(secinfo->si_name, secinfo->si_namelen); |
J. Bruce Fields | a36b172 | 2012-11-25 16:31:00 -0500 | [diff] [blame] | 1112 | status = check_filename(secinfo->si_name, secinfo->si_namelen); |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 1113 | if (status) |
| 1114 | return status; |
| 1115 | DECODE_TAIL; |
| 1116 | } |
| 1117 | |
| 1118 | static __be32 |
J. Bruce Fields | 04f4ad1 | 2010-12-16 09:51:13 -0500 | [diff] [blame] | 1119 | nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp, |
| 1120 | struct nfsd4_secinfo_no_name *sin) |
| 1121 | { |
| 1122 | DECODE_HEAD; |
| 1123 | |
| 1124 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1125 | sin->sin_style = be32_to_cpup(p++); |
J. Bruce Fields | 04f4ad1 | 2010-12-16 09:51:13 -0500 | [diff] [blame] | 1126 | DECODE_TAIL; |
| 1127 | } |
| 1128 | |
| 1129 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1130 | nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr) |
| 1131 | { |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 1132 | __be32 status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1133 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 1134 | status = nfsd4_decode_stateid(argp, &setattr->sa_stateid); |
| 1135 | if (status) |
| 1136 | return status; |
Yu Zhiguo | 3c8e031 | 2009-05-16 16:22:31 +0800 | [diff] [blame] | 1137 | return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr, |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1138 | &setattr->sa_acl, &setattr->sa_label); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1139 | } |
| 1140 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1141 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1142 | nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid) |
| 1143 | { |
| 1144 | DECODE_HEAD; |
| 1145 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1146 | if (argp->minorversion >= 1) |
| 1147 | return nfserr_notsupp; |
| 1148 | |
Chuck Lever | ab4684d | 2012-03-02 17:13:50 -0500 | [diff] [blame] | 1149 | READ_BUF(NFS4_VERIFIER_SIZE); |
| 1150 | COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1151 | |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 1152 | status = nfsd4_decode_opaque(argp, &setclientid->se_name); |
| 1153 | if (status) |
| 1154 | return nfserr_bad_xdr; |
| 1155 | READ_BUF(8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1156 | setclientid->se_callback_prog = be32_to_cpup(p++); |
| 1157 | setclientid->se_callback_netid_len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1158 | |
| 1159 | READ_BUF(setclientid->se_callback_netid_len + 4); |
| 1160 | SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1161 | setclientid->se_callback_addr_len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1162 | |
| 1163 | READ_BUF(setclientid->se_callback_addr_len + 4); |
| 1164 | SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1165 | setclientid->se_callback_ident = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1166 | |
| 1167 | DECODE_TAIL; |
| 1168 | } |
| 1169 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1170 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1171 | nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c) |
| 1172 | { |
| 1173 | DECODE_HEAD; |
| 1174 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1175 | if (argp->minorversion >= 1) |
| 1176 | return nfserr_notsupp; |
| 1177 | |
Chuck Lever | ab4684d | 2012-03-02 17:13:50 -0500 | [diff] [blame] | 1178 | READ_BUF(8 + NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1179 | COPYMEM(&scd_c->sc_clientid, 8); |
Chuck Lever | ab4684d | 2012-03-02 17:13:50 -0500 | [diff] [blame] | 1180 | COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1181 | |
| 1182 | DECODE_TAIL; |
| 1183 | } |
| 1184 | |
| 1185 | /* Also used for NVERIFY */ |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1186 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1187 | nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify) |
| 1188 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1189 | DECODE_HEAD; |
| 1190 | |
| 1191 | if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval))) |
| 1192 | goto out; |
| 1193 | |
| 1194 | /* For convenience's sake, we compare raw xdr'd attributes in |
J. Bruce Fields | e5f9570 | 2012-11-30 17:24:18 -0500 | [diff] [blame] | 1195 | * nfsd4_proc_verify */ |
| 1196 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1197 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1198 | verify->ve_attrlen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1199 | READ_BUF(verify->ve_attrlen); |
| 1200 | SAVEMEM(verify->ve_attrval, verify->ve_attrlen); |
| 1201 | |
| 1202 | DECODE_TAIL; |
| 1203 | } |
| 1204 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1205 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1206 | nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write) |
| 1207 | { |
| 1208 | int avail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1209 | int len; |
| 1210 | DECODE_HEAD; |
| 1211 | |
Benny Halevy | e31a1b6 | 2008-08-12 20:46:18 +0300 | [diff] [blame] | 1212 | status = nfsd4_decode_stateid(argp, &write->wr_stateid); |
| 1213 | if (status) |
| 1214 | return status; |
| 1215 | READ_BUF(16); |
J. Bruce Fields | 542d1ab | 2014-06-02 12:45:31 -0400 | [diff] [blame] | 1216 | p = xdr_decode_hyper(p, &write->wr_offset); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1217 | write->wr_stable_how = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1218 | if (write->wr_stable_how > 2) |
| 1219 | goto xdr_error; |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1220 | write->wr_buflen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1221 | |
| 1222 | /* Sorry .. no magic macros for this.. * |
| 1223 | * READ_BUF(write->wr_buflen); |
| 1224 | * SAVEMEM(write->wr_buf, write->wr_buflen); |
| 1225 | */ |
| 1226 | avail = (char*)argp->end - (char*)argp->p; |
| 1227 | if (avail + argp->pagelen < write->wr_buflen) { |
Chuck Lever | 817cb9d | 2007-09-11 18:01:20 -0400 | [diff] [blame] | 1228 | dprintk("NFSD: xdr error (%s:%d)\n", |
| 1229 | __FILE__, __LINE__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1230 | goto xdr_error; |
| 1231 | } |
J. Bruce Fields | 70cc7f7 | 2012-11-16 14:16:46 -0500 | [diff] [blame] | 1232 | write->wr_head.iov_base = p; |
| 1233 | write->wr_head.iov_len = avail; |
J. Bruce Fields | 70cc7f7 | 2012-11-16 14:16:46 -0500 | [diff] [blame] | 1234 | write->wr_pagelist = argp->pagelist; |
J. Bruce Fields | 5a80a54 | 2012-11-16 10:01:30 -0500 | [diff] [blame] | 1235 | |
| 1236 | len = XDR_QUADLEN(write->wr_buflen) << 2; |
| 1237 | if (len >= avail) { |
| 1238 | int pages; |
| 1239 | |
| 1240 | len -= avail; |
| 1241 | |
| 1242 | pages = len >> PAGE_SHIFT; |
| 1243 | argp->pagelist += pages; |
| 1244 | argp->pagelen -= pages * PAGE_SIZE; |
| 1245 | len -= pages * PAGE_SIZE; |
| 1246 | |
| 1247 | argp->p = (__be32 *)page_address(argp->pagelist[0]); |
J. Bruce Fields | 365da4a | 2013-11-19 17:32:43 -0500 | [diff] [blame] | 1248 | argp->pagelist++; |
J. Bruce Fields | 5a80a54 | 2012-11-16 10:01:30 -0500 | [diff] [blame] | 1249 | argp->end = argp->p + XDR_QUADLEN(PAGE_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1250 | } |
J. Bruce Fields | 5a80a54 | 2012-11-16 10:01:30 -0500 | [diff] [blame] | 1251 | argp->p += XDR_QUADLEN(len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1252 | |
| 1253 | DECODE_TAIL; |
| 1254 | } |
| 1255 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1256 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1257 | nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner) |
| 1258 | { |
| 1259 | DECODE_HEAD; |
| 1260 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1261 | if (argp->minorversion >= 1) |
| 1262 | return nfserr_notsupp; |
| 1263 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1264 | READ_BUF(12); |
| 1265 | COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1266 | rlockowner->rl_owner.len = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1267 | READ_BUF(rlockowner->rl_owner.len); |
| 1268 | READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len); |
| 1269 | |
Andy Adamson | 60adfc5 | 2009-04-03 08:28:50 +0300 | [diff] [blame] | 1270 | if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) |
| 1271 | return nfserr_inval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1272 | DECODE_TAIL; |
| 1273 | } |
| 1274 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1275 | static __be32 |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1276 | nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp, |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1277 | struct nfsd4_exchange_id *exid) |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1278 | { |
Mi Jinlong | 5afa040 | 2010-11-09 09:39:23 +0800 | [diff] [blame] | 1279 | int dummy, tmp; |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1280 | DECODE_HEAD; |
| 1281 | |
| 1282 | READ_BUF(NFS4_VERIFIER_SIZE); |
| 1283 | COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE); |
| 1284 | |
J. Bruce Fields | a084daf | 2011-10-10 15:07:40 -0400 | [diff] [blame] | 1285 | status = nfsd4_decode_opaque(argp, &exid->clname); |
| 1286 | if (status) |
| 1287 | return nfserr_bad_xdr; |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1288 | |
| 1289 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1290 | exid->flags = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1291 | |
| 1292 | /* Ignore state_protect4_a */ |
| 1293 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1294 | exid->spa_how = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1295 | switch (exid->spa_how) { |
| 1296 | case SP4_NONE: |
| 1297 | break; |
| 1298 | case SP4_MACH_CRED: |
| 1299 | /* spo_must_enforce */ |
| 1300 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1301 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1302 | READ_BUF(dummy * 4); |
| 1303 | p += dummy; |
| 1304 | |
| 1305 | /* spo_must_allow */ |
| 1306 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1307 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1308 | READ_BUF(dummy * 4); |
| 1309 | p += dummy; |
| 1310 | break; |
| 1311 | case SP4_SSV: |
| 1312 | /* ssp_ops */ |
| 1313 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1314 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1315 | READ_BUF(dummy * 4); |
| 1316 | p += dummy; |
| 1317 | |
| 1318 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1319 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1320 | READ_BUF(dummy * 4); |
| 1321 | p += dummy; |
| 1322 | |
| 1323 | /* ssp_hash_algs<> */ |
| 1324 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1325 | tmp = be32_to_cpup(p++); |
Mi Jinlong | 5afa040 | 2010-11-09 09:39:23 +0800 | [diff] [blame] | 1326 | while (tmp--) { |
| 1327 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1328 | dummy = be32_to_cpup(p++); |
Mi Jinlong | 5afa040 | 2010-11-09 09:39:23 +0800 | [diff] [blame] | 1329 | READ_BUF(dummy); |
| 1330 | p += XDR_QUADLEN(dummy); |
| 1331 | } |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1332 | |
| 1333 | /* ssp_encr_algs<> */ |
| 1334 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1335 | tmp = be32_to_cpup(p++); |
Mi Jinlong | 5afa040 | 2010-11-09 09:39:23 +0800 | [diff] [blame] | 1336 | while (tmp--) { |
| 1337 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1338 | dummy = be32_to_cpup(p++); |
Mi Jinlong | 5afa040 | 2010-11-09 09:39:23 +0800 | [diff] [blame] | 1339 | READ_BUF(dummy); |
| 1340 | p += XDR_QUADLEN(dummy); |
| 1341 | } |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1342 | |
| 1343 | /* ssp_window and ssp_num_gss_handles */ |
| 1344 | READ_BUF(8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1345 | dummy = be32_to_cpup(p++); |
| 1346 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1347 | break; |
| 1348 | default: |
| 1349 | goto xdr_error; |
| 1350 | } |
| 1351 | |
| 1352 | /* Ignore Implementation ID */ |
| 1353 | READ_BUF(4); /* nfs_impl_id4 array length */ |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1354 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1355 | |
| 1356 | if (dummy > 1) |
| 1357 | goto xdr_error; |
| 1358 | |
| 1359 | if (dummy == 1) { |
| 1360 | /* nii_domain */ |
| 1361 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1362 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1363 | READ_BUF(dummy); |
| 1364 | p += XDR_QUADLEN(dummy); |
| 1365 | |
| 1366 | /* nii_name */ |
| 1367 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1368 | dummy = be32_to_cpup(p++); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 1369 | READ_BUF(dummy); |
| 1370 | p += XDR_QUADLEN(dummy); |
| 1371 | |
| 1372 | /* nii_date */ |
| 1373 | READ_BUF(12); |
| 1374 | p += 3; |
| 1375 | } |
| 1376 | DECODE_TAIL; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1377 | } |
| 1378 | |
| 1379 | static __be32 |
| 1380 | nfsd4_decode_create_session(struct nfsd4_compoundargs *argp, |
| 1381 | struct nfsd4_create_session *sess) |
| 1382 | { |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1383 | DECODE_HEAD; |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1384 | u32 dummy; |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1385 | |
| 1386 | READ_BUF(16); |
| 1387 | COPYMEM(&sess->clientid, 8); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1388 | sess->seqid = be32_to_cpup(p++); |
| 1389 | sess->flags = be32_to_cpup(p++); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1390 | |
| 1391 | /* Fore channel attrs */ |
| 1392 | READ_BUF(28); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1393 | dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */ |
| 1394 | sess->fore_channel.maxreq_sz = be32_to_cpup(p++); |
| 1395 | sess->fore_channel.maxresp_sz = be32_to_cpup(p++); |
| 1396 | sess->fore_channel.maxresp_cached = be32_to_cpup(p++); |
| 1397 | sess->fore_channel.maxops = be32_to_cpup(p++); |
| 1398 | sess->fore_channel.maxreqs = be32_to_cpup(p++); |
| 1399 | sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1400 | if (sess->fore_channel.nr_rdma_attrs == 1) { |
| 1401 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1402 | sess->fore_channel.rdma_attrs = be32_to_cpup(p++); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1403 | } else if (sess->fore_channel.nr_rdma_attrs > 1) { |
| 1404 | dprintk("Too many fore channel attr bitmaps!\n"); |
| 1405 | goto xdr_error; |
| 1406 | } |
| 1407 | |
| 1408 | /* Back channel attrs */ |
| 1409 | READ_BUF(28); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1410 | dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */ |
| 1411 | sess->back_channel.maxreq_sz = be32_to_cpup(p++); |
| 1412 | sess->back_channel.maxresp_sz = be32_to_cpup(p++); |
| 1413 | sess->back_channel.maxresp_cached = be32_to_cpup(p++); |
| 1414 | sess->back_channel.maxops = be32_to_cpup(p++); |
| 1415 | sess->back_channel.maxreqs = be32_to_cpup(p++); |
| 1416 | sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1417 | if (sess->back_channel.nr_rdma_attrs == 1) { |
| 1418 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1419 | sess->back_channel.rdma_attrs = be32_to_cpup(p++); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1420 | } else if (sess->back_channel.nr_rdma_attrs > 1) { |
| 1421 | dprintk("Too many back channel attr bitmaps!\n"); |
| 1422 | goto xdr_error; |
| 1423 | } |
| 1424 | |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 1425 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1426 | sess->callback_prog = be32_to_cpup(p++); |
J. Bruce Fields | acb2887 | 2012-03-27 14:50:26 -0400 | [diff] [blame] | 1427 | nfsd4_decode_cb_sec(argp, &sess->cb_sec); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 1428 | DECODE_TAIL; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1429 | } |
| 1430 | |
| 1431 | static __be32 |
| 1432 | nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp, |
| 1433 | struct nfsd4_destroy_session *destroy_session) |
| 1434 | { |
Benny Halevy | e10e0cf | 2009-04-03 08:28:38 +0300 | [diff] [blame] | 1435 | DECODE_HEAD; |
| 1436 | READ_BUF(NFS4_MAX_SESSIONID_LEN); |
| 1437 | COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN); |
| 1438 | |
| 1439 | DECODE_TAIL; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1440 | } |
| 1441 | |
| 1442 | static __be32 |
Bryan Schumaker | e1ca12d | 2011-07-13 11:04:21 -0400 | [diff] [blame] | 1443 | nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp, |
| 1444 | struct nfsd4_free_stateid *free_stateid) |
| 1445 | { |
| 1446 | DECODE_HEAD; |
| 1447 | |
| 1448 | READ_BUF(sizeof(stateid_t)); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1449 | free_stateid->fr_stateid.si_generation = be32_to_cpup(p++); |
Bryan Schumaker | e1ca12d | 2011-07-13 11:04:21 -0400 | [diff] [blame] | 1450 | COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t)); |
| 1451 | |
| 1452 | DECODE_TAIL; |
| 1453 | } |
| 1454 | |
| 1455 | static __be32 |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1456 | nfsd4_decode_sequence(struct nfsd4_compoundargs *argp, |
| 1457 | struct nfsd4_sequence *seq) |
| 1458 | { |
Benny Halevy | b85d4c0 | 2009-04-03 08:28:08 +0300 | [diff] [blame] | 1459 | DECODE_HEAD; |
| 1460 | |
| 1461 | READ_BUF(NFS4_MAX_SESSIONID_LEN + 16); |
| 1462 | COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1463 | seq->seqid = be32_to_cpup(p++); |
| 1464 | seq->slotid = be32_to_cpup(p++); |
| 1465 | seq->maxslots = be32_to_cpup(p++); |
| 1466 | seq->cachethis = be32_to_cpup(p++); |
Benny Halevy | b85d4c0 | 2009-04-03 08:28:08 +0300 | [diff] [blame] | 1467 | |
| 1468 | DECODE_TAIL; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1469 | } |
| 1470 | |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1471 | static __be32 |
| 1472 | nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid) |
| 1473 | { |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1474 | int i; |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 1475 | __be32 *p, status; |
| 1476 | struct nfsd4_test_stateid_id *stateid; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1477 | |
| 1478 | READ_BUF(4); |
| 1479 | test_stateid->ts_num_ids = ntohl(*p++); |
| 1480 | |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 1481 | INIT_LIST_HEAD(&test_stateid->ts_stateid_list); |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1482 | |
| 1483 | for (i = 0; i < test_stateid->ts_num_ids; i++) { |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 1484 | stateid = kmalloc(sizeof(struct nfsd4_test_stateid_id), GFP_KERNEL); |
| 1485 | if (!stateid) { |
Al Viro | afcf679 | 2012-04-13 00:15:37 -0400 | [diff] [blame] | 1486 | status = nfserrno(-ENOMEM); |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 1487 | goto out; |
| 1488 | } |
| 1489 | |
| 1490 | defer_free(argp, kfree, stateid); |
| 1491 | INIT_LIST_HEAD(&stateid->ts_id_list); |
| 1492 | list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); |
| 1493 | |
| 1494 | status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid); |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1495 | if (status) |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 1496 | goto out; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1497 | } |
| 1498 | |
| 1499 | status = 0; |
| 1500 | out: |
| 1501 | return status; |
| 1502 | xdr_error: |
| 1503 | dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__); |
| 1504 | status = nfserr_bad_xdr; |
| 1505 | goto out; |
| 1506 | } |
| 1507 | |
Mi Jinlong | 345c284 | 2011-10-20 17:51:39 +0800 | [diff] [blame] | 1508 | static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc) |
| 1509 | { |
| 1510 | DECODE_HEAD; |
| 1511 | |
| 1512 | READ_BUF(8); |
| 1513 | COPYMEM(&dc->clientid, 8); |
| 1514 | |
| 1515 | DECODE_TAIL; |
| 1516 | } |
| 1517 | |
J. Bruce Fields | 4dc6ec0 | 2010-04-19 15:11:28 -0400 | [diff] [blame] | 1518 | static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc) |
| 1519 | { |
| 1520 | DECODE_HEAD; |
| 1521 | |
| 1522 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1523 | rc->rca_one_fs = be32_to_cpup(p++); |
J. Bruce Fields | 4dc6ec0 | 2010-04-19 15:11:28 -0400 | [diff] [blame] | 1524 | |
| 1525 | DECODE_TAIL; |
| 1526 | } |
| 1527 | |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1528 | static __be32 |
Benny Halevy | 347e0ad | 2008-07-02 11:13:41 +0300 | [diff] [blame] | 1529 | nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p) |
| 1530 | { |
| 1531 | return nfs_ok; |
| 1532 | } |
| 1533 | |
Benny Halevy | 3c375c6 | 2008-07-02 11:14:01 +0300 | [diff] [blame] | 1534 | static __be32 |
| 1535 | nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p) |
| 1536 | { |
Benny Halevy | 1e685ec | 2009-03-04 23:06:06 +0200 | [diff] [blame] | 1537 | return nfserr_notsupp; |
Benny Halevy | 3c375c6 | 2008-07-02 11:14:01 +0300 | [diff] [blame] | 1538 | } |
| 1539 | |
Benny Halevy | 347e0ad | 2008-07-02 11:13:41 +0300 | [diff] [blame] | 1540 | typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *); |
| 1541 | |
| 1542 | static nfsd4_dec nfsd4_dec_ops[] = { |
J. Bruce Fields | ad1060c | 2008-07-18 15:04:16 -0400 | [diff] [blame] | 1543 | [OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access, |
| 1544 | [OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close, |
| 1545 | [OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit, |
| 1546 | [OP_CREATE] = (nfsd4_dec)nfsd4_decode_create, |
| 1547 | [OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1548 | [OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn, |
| 1549 | [OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr, |
| 1550 | [OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop, |
| 1551 | [OP_LINK] = (nfsd4_dec)nfsd4_decode_link, |
| 1552 | [OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock, |
| 1553 | [OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt, |
| 1554 | [OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku, |
| 1555 | [OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup, |
| 1556 | [OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop, |
| 1557 | [OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify, |
| 1558 | [OP_OPEN] = (nfsd4_dec)nfsd4_decode_open, |
| 1559 | [OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1560 | [OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm, |
| 1561 | [OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade, |
| 1562 | [OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh, |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1563 | [OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_putpubfh, |
J. Bruce Fields | ad1060c | 2008-07-18 15:04:16 -0400 | [diff] [blame] | 1564 | [OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop, |
| 1565 | [OP_READ] = (nfsd4_dec)nfsd4_decode_read, |
| 1566 | [OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir, |
| 1567 | [OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop, |
| 1568 | [OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove, |
| 1569 | [OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename, |
| 1570 | [OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew, |
| 1571 | [OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop, |
| 1572 | [OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop, |
| 1573 | [OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo, |
| 1574 | [OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr, |
| 1575 | [OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid, |
| 1576 | [OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm, |
| 1577 | [OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify, |
| 1578 | [OP_WRITE] = (nfsd4_dec)nfsd4_decode_write, |
| 1579 | [OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1580 | |
| 1581 | /* new operations for NFSv4.1 */ |
J. Bruce Fields | cb73a9f | 2012-11-01 18:09:48 -0400 | [diff] [blame] | 1582 | [OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl, |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 1583 | [OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session, |
Randy Dunlap | 9064caa | 2009-04-28 16:48:25 -0700 | [diff] [blame] | 1584 | [OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id, |
| 1585 | [OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session, |
| 1586 | [OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session, |
Bryan Schumaker | e1ca12d | 2011-07-13 11:04:21 -0400 | [diff] [blame] | 1587 | [OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid, |
Randy Dunlap | 9064caa | 2009-04-28 16:48:25 -0700 | [diff] [blame] | 1588 | [OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1589 | [OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1590 | [OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1591 | [OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1592 | [OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp, |
| 1593 | [OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp, |
J. Bruce Fields | 04f4ad1 | 2010-12-16 09:51:13 -0500 | [diff] [blame] | 1594 | [OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name, |
Randy Dunlap | 9064caa | 2009-04-28 16:48:25 -0700 | [diff] [blame] | 1595 | [OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence, |
| 1596 | [OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp, |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 1597 | [OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid, |
Randy Dunlap | 9064caa | 2009-04-28 16:48:25 -0700 | [diff] [blame] | 1598 | [OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, |
Mi Jinlong | 345c284 | 2011-10-20 17:51:39 +0800 | [diff] [blame] | 1599 | [OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid, |
J. Bruce Fields | 4dc6ec0 | 2010-04-19 15:11:28 -0400 | [diff] [blame] | 1600 | [OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 1601 | }; |
| 1602 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1603 | static inline bool |
| 1604 | nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op) |
| 1605 | { |
Anna Schumaker | 8217d14 | 2013-10-30 13:38:13 -0400 | [diff] [blame] | 1606 | if (op->opnum < FIRST_NFS4_OP) |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1607 | return false; |
Anna Schumaker | 8217d14 | 2013-10-30 13:38:13 -0400 | [diff] [blame] | 1608 | else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1609 | return false; |
Anna Schumaker | 8217d14 | 2013-10-30 13:38:13 -0400 | [diff] [blame] | 1610 | else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) |
| 1611 | return false; |
| 1612 | else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1613 | return false; |
| 1614 | return true; |
| 1615 | } |
Benny Halevy | f2feb96 | 2008-07-02 11:14:22 +0300 | [diff] [blame] | 1616 | |
Benny Halevy | 347e0ad | 2008-07-02 11:13:41 +0300 | [diff] [blame] | 1617 | static __be32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1618 | nfsd4_decode_compound(struct nfsd4_compoundargs *argp) |
| 1619 | { |
| 1620 | DECODE_HEAD; |
| 1621 | struct nfsd4_op *op; |
J. Bruce Fields | 1091006 | 2011-01-24 12:11:02 -0500 | [diff] [blame] | 1622 | bool cachethis = false; |
J. Bruce Fields | a5cddc8 | 2014-05-12 18:10:58 -0400 | [diff] [blame] | 1623 | int auth_slack= argp->rqstp->rq_auth_slack; |
| 1624 | int max_reply = auth_slack + 8; /* opcnt, status */ |
J. Bruce Fields | b0e35fd | 2014-02-04 10:36:59 -0500 | [diff] [blame] | 1625 | int readcount = 0; |
| 1626 | int readbytes = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1627 | int i; |
| 1628 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1629 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1630 | argp->taglen = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1631 | READ_BUF(argp->taglen + 8); |
| 1632 | SAVEMEM(argp->tag, argp->taglen); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1633 | argp->minorversion = be32_to_cpup(p++); |
| 1634 | argp->opcnt = be32_to_cpup(p++); |
J. Bruce Fields | 4f0cefb | 2014-03-11 15:39:13 -0400 | [diff] [blame] | 1635 | max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1636 | |
| 1637 | if (argp->taglen > NFSD4_MAX_TAGLEN) |
| 1638 | goto xdr_error; |
| 1639 | if (argp->opcnt > 100) |
| 1640 | goto xdr_error; |
| 1641 | |
Tobias Klauser | e8c96f8 | 2006-03-24 03:15:34 -0800 | [diff] [blame] | 1642 | if (argp->opcnt > ARRAY_SIZE(argp->iops)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1643 | argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL); |
| 1644 | if (!argp->ops) { |
| 1645 | argp->ops = argp->iops; |
Chuck Lever | 817cb9d | 2007-09-11 18:01:20 -0400 | [diff] [blame] | 1646 | dprintk("nfsd: couldn't allocate room for COMPOUND\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1647 | goto xdr_error; |
| 1648 | } |
| 1649 | } |
| 1650 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1651 | if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) |
Benny Halevy | 30cff1f | 2008-07-02 11:13:18 +0300 | [diff] [blame] | 1652 | argp->opcnt = 0; |
| 1653 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1654 | for (i = 0; i < argp->opcnt; i++) { |
| 1655 | op = &argp->ops[i]; |
| 1656 | op->replay = NULL; |
| 1657 | |
J. Bruce Fields | 8a61b18 | 2012-11-16 22:28:38 -0500 | [diff] [blame] | 1658 | READ_BUF(4); |
J. Bruce Fields | 0655399 | 2014-06-02 12:32:51 -0400 | [diff] [blame] | 1659 | op->opnum = be32_to_cpup(p++); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1660 | |
Anna Schumaker | e1a90eb | 2013-10-30 10:00:20 -0400 | [diff] [blame] | 1661 | if (nfsd4_opnum_in_range(argp, op)) |
| 1662 | op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); |
Benny Halevy | 347e0ad | 2008-07-02 11:13:41 +0300 | [diff] [blame] | 1663 | else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1664 | op->opnum = OP_ILLEGAL; |
| 1665 | op->status = nfserr_op_illegal; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1666 | } |
J. Bruce Fields | 1091006 | 2011-01-24 12:11:02 -0500 | [diff] [blame] | 1667 | /* |
| 1668 | * We'll try to cache the result in the DRC if any one |
| 1669 | * op in the compound wants to be cached: |
| 1670 | */ |
| 1671 | cachethis |= nfsd4_cache_this_op(op); |
J. Bruce Fields | 6ff40de | 2013-11-05 15:07:16 -0500 | [diff] [blame] | 1672 | |
J. Bruce Fields | b0e35fd | 2014-02-04 10:36:59 -0500 | [diff] [blame] | 1673 | if (op->opnum == OP_READ) { |
| 1674 | readcount++; |
| 1675 | readbytes += nfsd4_max_reply(argp->rqstp, op); |
| 1676 | } else |
| 1677 | max_reply += nfsd4_max_reply(argp->rqstp, op); |
J. Bruce Fields | e372ba6 | 2014-05-19 12:27:11 -0400 | [diff] [blame] | 1678 | |
| 1679 | if (op->status) { |
| 1680 | argp->opcnt = i+1; |
| 1681 | break; |
| 1682 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1683 | } |
J. Bruce Fields | 1091006 | 2011-01-24 12:11:02 -0500 | [diff] [blame] | 1684 | /* Sessions make the DRC unnecessary: */ |
| 1685 | if (argp->minorversion) |
| 1686 | cachethis = false; |
J. Bruce Fields | b0e35fd | 2014-02-04 10:36:59 -0500 | [diff] [blame] | 1687 | svc_reserve(argp->rqstp, max_reply + readbytes); |
J. Bruce Fields | 1091006 | 2011-01-24 12:11:02 -0500 | [diff] [blame] | 1688 | argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1689 | |
J. Bruce Fields | a5cddc8 | 2014-05-12 18:10:58 -0400 | [diff] [blame] | 1690 | if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) |
J. Bruce Fields | b0e35fd | 2014-02-04 10:36:59 -0500 | [diff] [blame] | 1691 | argp->rqstp->rq_splice_ok = false; |
| 1692 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1693 | DECODE_TAIL; |
| 1694 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1695 | |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1696 | static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode) |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1697 | { |
| 1698 | if (IS_I_VERSION(inode)) { |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1699 | p = xdr_encode_hyper(p, inode->i_version); |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1700 | } else { |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1701 | *p++ = cpu_to_be32(stat->ctime.tv_sec); |
| 1702 | *p++ = cpu_to_be32(stat->ctime.tv_nsec); |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1703 | } |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1704 | return p; |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1705 | } |
| 1706 | |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1707 | static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c) |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1708 | { |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1709 | *p++ = cpu_to_be32(c->atomic); |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1710 | if (c->change_supported) { |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1711 | p = xdr_encode_hyper(p, c->before_change); |
| 1712 | p = xdr_encode_hyper(p, c->after_change); |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1713 | } else { |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1714 | *p++ = cpu_to_be32(c->before_ctime_sec); |
| 1715 | *p++ = cpu_to_be32(c->before_ctime_nsec); |
| 1716 | *p++ = cpu_to_be32(c->after_ctime_sec); |
| 1717 | *p++ = cpu_to_be32(c->after_ctime_nsec); |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1718 | } |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 1719 | return p; |
J. Bruce Fields | c654b8a | 2009-04-16 17:33:25 -0400 | [diff] [blame] | 1720 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1721 | |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1722 | /* Encode as an array of strings the string given with components |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1723 | * separated @sep, escaped with esc_enter and esc_exit. |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1724 | */ |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1725 | static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep, |
| 1726 | char *components, char esc_enter, |
| 1727 | char esc_exit) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1728 | { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1729 | __be32 *p; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 1730 | __be32 pathlen; |
| 1731 | int pathlen_offset; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1732 | int strlen, count=0; |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1733 | char *str, *end, *next; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1734 | |
| 1735 | dprintk("nfsd4_encode_components(%s)\n", components); |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 1736 | |
| 1737 | pathlen_offset = xdr->buf->len; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1738 | p = xdr_reserve_space(xdr, 4); |
| 1739 | if (!p) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1740 | return nfserr_resource; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 1741 | p++; /* We will fill this in with @count later */ |
| 1742 | |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1743 | end = str = components; |
| 1744 | while (*end) { |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1745 | bool found_esc = false; |
| 1746 | |
| 1747 | /* try to parse as esc_start, ..., esc_end, sep */ |
| 1748 | if (*str == esc_enter) { |
| 1749 | for (; *end && (*end != esc_exit); end++) |
| 1750 | /* find esc_exit or end of string */; |
| 1751 | next = end + 1; |
| 1752 | if (*end && (!*next || *next == sep)) { |
| 1753 | str++; |
| 1754 | found_esc = true; |
| 1755 | } |
| 1756 | } |
| 1757 | |
| 1758 | if (!found_esc) |
| 1759 | for (; *end && (*end != sep); end++) |
| 1760 | /* find sep or end of string */; |
| 1761 | |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1762 | strlen = end - str; |
| 1763 | if (strlen) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1764 | p = xdr_reserve_space(xdr, strlen + 4); |
| 1765 | if (!p) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1766 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 1767 | p = xdr_encode_opaque(p, str, strlen); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1768 | count++; |
| 1769 | } |
| 1770 | else |
| 1771 | end++; |
| 1772 | str = end; |
| 1773 | } |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 1774 | pathlen = htonl(xdr->buf->len - pathlen_offset); |
| 1775 | write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1776 | return 0; |
| 1777 | } |
| 1778 | |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1779 | /* Encode as an array of strings the string given with components |
| 1780 | * separated @sep. |
| 1781 | */ |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1782 | static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep, |
| 1783 | char *components) |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1784 | { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1785 | return nfsd4_encode_components_esc(xdr, sep, components, 0, 0); |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1786 | } |
| 1787 | |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1788 | /* |
| 1789 | * encode a location element of a fs_locations structure |
| 1790 | */ |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1791 | static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr, |
| 1792 | struct nfsd4_fs_location *location) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1793 | { |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1794 | __be32 status; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1795 | |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1796 | status = nfsd4_encode_components_esc(xdr, ':', location->hosts, |
Weston Andros Adamson | e7a0444 | 2012-04-24 11:07:59 -0400 | [diff] [blame] | 1797 | '[', ']'); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1798 | if (status) |
| 1799 | return status; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1800 | status = nfsd4_encode_components(xdr, '/', location->path); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1801 | if (status) |
| 1802 | return status; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1803 | return 0; |
| 1804 | } |
| 1805 | |
| 1806 | /* |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1807 | * Encode a path in RFC3530 'pathname4' format |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1808 | */ |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1809 | static __be32 nfsd4_encode_path(struct xdr_stream *xdr, |
| 1810 | const struct path *root, |
| 1811 | const struct path *path) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1812 | { |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1813 | struct path cur = *path; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1814 | __be32 *p; |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1815 | struct dentry **components = NULL; |
| 1816 | unsigned int ncomponents = 0; |
| 1817 | __be32 err = nfserr_jukebox; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1818 | |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1819 | dprintk("nfsd4_encode_components("); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1820 | |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1821 | path_get(&cur); |
| 1822 | /* First walk the path up to the nfsd root, and store the |
| 1823 | * dentries/path components in an array. |
| 1824 | */ |
| 1825 | for (;;) { |
| 1826 | if (cur.dentry == root->dentry && cur.mnt == root->mnt) |
| 1827 | break; |
| 1828 | if (cur.dentry == cur.mnt->mnt_root) { |
| 1829 | if (follow_up(&cur)) |
| 1830 | continue; |
| 1831 | goto out_free; |
| 1832 | } |
| 1833 | if ((ncomponents & 15) == 0) { |
| 1834 | struct dentry **new; |
| 1835 | new = krealloc(components, |
| 1836 | sizeof(*new) * (ncomponents + 16), |
| 1837 | GFP_KERNEL); |
| 1838 | if (!new) |
| 1839 | goto out_free; |
| 1840 | components = new; |
| 1841 | } |
| 1842 | components[ncomponents++] = cur.dentry; |
| 1843 | cur.dentry = dget_parent(cur.dentry); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1844 | } |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1845 | err = nfserr_resource; |
| 1846 | p = xdr_reserve_space(xdr, 4); |
| 1847 | if (!p) |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1848 | goto out_free; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 1849 | *p++ = cpu_to_be32(ncomponents); |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1850 | |
| 1851 | while (ncomponents) { |
| 1852 | struct dentry *dentry = components[ncomponents - 1]; |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1853 | unsigned int len; |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1854 | |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1855 | spin_lock(&dentry->d_lock); |
| 1856 | len = dentry->d_name.len; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1857 | p = xdr_reserve_space(xdr, len + 4); |
| 1858 | if (!p) { |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1859 | spin_unlock(&dentry->d_lock); |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1860 | goto out_free; |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1861 | } |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 1862 | p = xdr_encode_opaque(p, dentry->d_name.name, len); |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1863 | dprintk("/%s", dentry->d_name.name); |
Al Viro | 301f026 | 2013-09-01 16:06:39 -0400 | [diff] [blame] | 1864 | spin_unlock(&dentry->d_lock); |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1865 | dput(dentry); |
| 1866 | ncomponents--; |
| 1867 | } |
| 1868 | |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1869 | err = 0; |
| 1870 | out_free: |
| 1871 | dprintk(")\n"); |
| 1872 | while (ncomponents) |
| 1873 | dput(components[--ncomponents]); |
| 1874 | kfree(components); |
| 1875 | path_put(&cur); |
| 1876 | return err; |
| 1877 | } |
| 1878 | |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1879 | static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr, |
| 1880 | struct svc_rqst *rqstp, const struct path *path) |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1881 | { |
| 1882 | struct svc_export *exp_ps; |
| 1883 | __be32 res; |
| 1884 | |
| 1885 | exp_ps = rqst_find_fsidzero_export(rqstp); |
| 1886 | if (IS_ERR(exp_ps)) |
| 1887 | return nfserrno(PTR_ERR(exp_ps)); |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1888 | res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path); |
Trond Myklebust | ed748aa | 2011-09-12 19:37:06 -0400 | [diff] [blame] | 1889 | exp_put(exp_ps); |
| 1890 | return res; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1891 | } |
| 1892 | |
| 1893 | /* |
| 1894 | * encode a fs_locations structure |
| 1895 | */ |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1896 | static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr, |
| 1897 | struct svc_rqst *rqstp, struct svc_export *exp) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1898 | { |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1899 | __be32 status; |
Al Viro | cc45f01 | 2006-10-19 23:28:44 -0700 | [diff] [blame] | 1900 | int i; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1901 | __be32 *p; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1902 | struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1903 | |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1904 | status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1905 | if (status) |
| 1906 | return status; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1907 | p = xdr_reserve_space(xdr, 4); |
| 1908 | if (!p) |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1909 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 1910 | *p++ = cpu_to_be32(fslocs->locations_count); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1911 | for (i=0; i<fslocs->locations_count; i++) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1912 | status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1913 | if (status) |
| 1914 | return status; |
| 1915 | } |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 1916 | return 0; |
| 1917 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1918 | |
J. Bruce Fields | 3d2544b | 2011-08-15 11:49:30 -0400 | [diff] [blame] | 1919 | static u32 nfs4_file_type(umode_t mode) |
| 1920 | { |
| 1921 | switch (mode & S_IFMT) { |
| 1922 | case S_IFIFO: return NF4FIFO; |
| 1923 | case S_IFCHR: return NF4CHR; |
| 1924 | case S_IFDIR: return NF4DIR; |
| 1925 | case S_IFBLK: return NF4BLK; |
| 1926 | case S_IFLNK: return NF4LNK; |
| 1927 | case S_IFREG: return NF4REG; |
| 1928 | case S_IFSOCK: return NF4SOCK; |
| 1929 | default: return NF4BAD; |
| 1930 | }; |
| 1931 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1932 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1933 | static inline __be32 |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1934 | nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
| 1935 | struct nfs4_ace *ace) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1936 | { |
J. Bruce Fields | 3554116 | 2014-01-08 09:49:01 -0500 | [diff] [blame] | 1937 | if (ace->whotype != NFS4_ACL_WHO_NAMED) |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1938 | return nfs4_acl_write_who(xdr, ace->whotype); |
J. Bruce Fields | 3554116 | 2014-01-08 09:49:01 -0500 | [diff] [blame] | 1939 | else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1940 | return nfsd4_encode_group(xdr, rqstp, ace->who_gid); |
J. Bruce Fields | 3554116 | 2014-01-08 09:49:01 -0500 | [diff] [blame] | 1941 | else |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1942 | return nfsd4_encode_user(xdr, rqstp, ace->who_uid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1943 | } |
| 1944 | |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 1945 | #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \ |
| 1946 | FATTR4_WORD0_RDATTR_ERROR) |
| 1947 | #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID |
| 1948 | |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1949 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
| 1950 | static inline __be32 |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1951 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
| 1952 | void *context, int len) |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1953 | { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1954 | __be32 *p; |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1955 | |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1956 | p = xdr_reserve_space(xdr, len + 4 + 4 + 4); |
| 1957 | if (!p) |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1958 | return nfserr_resource; |
| 1959 | |
| 1960 | /* |
| 1961 | * For now we use a 0 here to indicate the null translation; in |
| 1962 | * the future we may place a call to translation code here. |
| 1963 | */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 1964 | *p++ = cpu_to_be32(0); /* lfs */ |
| 1965 | *p++ = cpu_to_be32(0); /* pi */ |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1966 | p = xdr_encode_opaque(p, context, len); |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1967 | return 0; |
| 1968 | } |
| 1969 | #else |
| 1970 | static inline __be32 |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 1971 | nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, |
| 1972 | void *context, int len) |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 1973 | { return 0; } |
| 1974 | #endif |
| 1975 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 1976 | static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err) |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 1977 | { |
| 1978 | /* As per referral draft: */ |
| 1979 | if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS || |
| 1980 | *bmval1 & ~WORD1_ABSENT_FS_ATTRS) { |
| 1981 | if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR || |
| 1982 | *bmval0 & FATTR4_WORD0_FS_LOCATIONS) |
| 1983 | *rdattr_err = NFSERR_MOVED; |
| 1984 | else |
| 1985 | return nfserr_moved; |
| 1986 | } |
| 1987 | *bmval0 &= WORD0_ABSENT_FS_ATTRS; |
| 1988 | *bmval1 &= WORD1_ABSENT_FS_ATTRS; |
| 1989 | return 0; |
| 1990 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1991 | |
J. Bruce Fields | ae7095a | 2012-10-01 17:50:56 -0400 | [diff] [blame] | 1992 | |
| 1993 | static int get_parent_attributes(struct svc_export *exp, struct kstat *stat) |
| 1994 | { |
| 1995 | struct path path = exp->ex_path; |
| 1996 | int err; |
| 1997 | |
| 1998 | path_get(&path); |
| 1999 | while (follow_up(&path)) { |
| 2000 | if (path.dentry != path.mnt->mnt_root) |
| 2001 | break; |
| 2002 | } |
Al Viro | 3dadecc | 2013-01-24 02:18:08 -0500 | [diff] [blame] | 2003 | err = vfs_getattr(&path, stat); |
J. Bruce Fields | ae7095a | 2012-10-01 17:50:56 -0400 | [diff] [blame] | 2004 | path_put(&path); |
| 2005 | return err; |
| 2006 | } |
| 2007 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2008 | /* |
| 2009 | * Note: @fhp can be NULL; in this case, we might have to compose the filehandle |
| 2010 | * ourselves. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2011 | */ |
Jeff Layton | da2ebce | 2014-05-30 09:09:25 -0400 | [diff] [blame] | 2012 | static __be32 |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2013 | nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, |
| 2014 | struct svc_export *exp, |
| 2015 | struct dentry *dentry, u32 *bmval, |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2016 | struct svc_rqst *rqstp, int ignore_crossmnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2017 | { |
| 2018 | u32 bmval0 = bmval[0]; |
| 2019 | u32 bmval1 = bmval[1]; |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2020 | u32 bmval2 = bmval[2]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2021 | struct kstat stat; |
J. Bruce Fields | d50e613 | 2014-01-15 12:21:12 -0500 | [diff] [blame] | 2022 | struct svc_fh *tempfh = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2023 | struct kstatfs statfs; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2024 | __be32 *p; |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 2025 | int starting_len = xdr->buf->len; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 2026 | int attrlen_offset; |
| 2027 | __be32 attrlen; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2028 | u32 dummy; |
| 2029 | u64 dummy64; |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 2030 | u32 rdattr_err = 0; |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2031 | __be32 status; |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2032 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2033 | int aclsupport = 0; |
| 2034 | struct nfs4_acl *acl = NULL; |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2035 | void *context = NULL; |
| 2036 | int contextlen; |
| 2037 | bool contextsupport = false; |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2038 | struct nfsd4_compoundres *resp = rqstp->rq_resp; |
| 2039 | u32 minorversion = resp->cstate.minorversion; |
Christoph Hellwig | ebabe9a | 2010-07-07 18:53:11 +0200 | [diff] [blame] | 2040 | struct path path = { |
| 2041 | .mnt = exp->ex_path.mnt, |
| 2042 | .dentry = dentry, |
| 2043 | }; |
Stanislav Kinsbursky | 3d73371 | 2012-11-27 14:11:44 +0300 | [diff] [blame] | 2044 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2045 | |
| 2046 | BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2047 | BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion)); |
| 2048 | BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion)); |
| 2049 | BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2050 | |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 2051 | if (exp->ex_fslocs.migrated) { |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2052 | BUG_ON(bmval[2]); |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 2053 | status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err); |
| 2054 | if (status) |
| 2055 | goto out; |
| 2056 | } |
| 2057 | |
Al Viro | 3dadecc | 2013-01-24 02:18:08 -0500 | [diff] [blame] | 2058 | err = vfs_getattr(&path, &stat); |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2059 | if (err) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2060 | goto out_nfserr; |
Christoph Hellwig | 1233790 | 2014-05-28 10:46:13 +0200 | [diff] [blame] | 2061 | if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE | |
| 2062 | FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) || |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2063 | (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | |
| 2064 | FATTR4_WORD1_SPACE_TOTAL))) { |
Christoph Hellwig | ebabe9a | 2010-07-07 18:53:11 +0200 | [diff] [blame] | 2065 | err = vfs_statfs(&path, &statfs); |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2066 | if (err) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2067 | goto out_nfserr; |
| 2068 | } |
| 2069 | if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) { |
J. Bruce Fields | d50e613 | 2014-01-15 12:21:12 -0500 | [diff] [blame] | 2070 | tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL); |
| 2071 | status = nfserr_jukebox; |
| 2072 | if (!tempfh) |
| 2073 | goto out; |
| 2074 | fh_init(tempfh, NFS4_FHSIZE); |
| 2075 | status = fh_compose(tempfh, exp, dentry, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2076 | if (status) |
| 2077 | goto out; |
J. Bruce Fields | d50e613 | 2014-01-15 12:21:12 -0500 | [diff] [blame] | 2078 | fhp = tempfh; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2079 | } |
| 2080 | if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT |
| 2081 | | FATTR4_WORD0_SUPPORTED_ATTRS)) { |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2082 | err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl); |
| 2083 | aclsupport = (err == 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2084 | if (bmval0 & FATTR4_WORD0_ACL) { |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2085 | if (err == -EOPNOTSUPP) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2086 | bmval0 &= ~FATTR4_WORD0_ACL; |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2087 | else if (err == -EINVAL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2088 | status = nfserr_attrnotsupp; |
| 2089 | goto out; |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2090 | } else if (err != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2091 | goto out_nfserr; |
| 2092 | } |
| 2093 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2094 | |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2095 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
| 2096 | if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) || |
| 2097 | bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) { |
| 2098 | err = security_inode_getsecctx(dentry->d_inode, |
| 2099 | &context, &contextlen); |
| 2100 | contextsupport = (err == 0); |
| 2101 | if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { |
| 2102 | if (err == -EOPNOTSUPP) |
| 2103 | bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL; |
| 2104 | else if (err) |
| 2105 | goto out_nfserr; |
| 2106 | } |
| 2107 | } |
| 2108 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
| 2109 | |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2110 | if (bmval2) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2111 | p = xdr_reserve_space(xdr, 16); |
| 2112 | if (!p) |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2113 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2114 | *p++ = cpu_to_be32(3); |
| 2115 | *p++ = cpu_to_be32(bmval0); |
| 2116 | *p++ = cpu_to_be32(bmval1); |
| 2117 | *p++ = cpu_to_be32(bmval2); |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2118 | } else if (bmval1) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2119 | p = xdr_reserve_space(xdr, 12); |
| 2120 | if (!p) |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2121 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2122 | *p++ = cpu_to_be32(2); |
| 2123 | *p++ = cpu_to_be32(bmval0); |
| 2124 | *p++ = cpu_to_be32(bmval1); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2125 | } else { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2126 | p = xdr_reserve_space(xdr, 8); |
| 2127 | if (!p) |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2128 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2129 | *p++ = cpu_to_be32(1); |
| 2130 | *p++ = cpu_to_be32(bmval0); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2131 | } |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 2132 | |
| 2133 | attrlen_offset = xdr->buf->len; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2134 | p = xdr_reserve_space(xdr, 4); |
| 2135 | if (!p) |
| 2136 | goto out_resource; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 2137 | p++; /* to be backfilled later */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2138 | |
| 2139 | if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) { |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2140 | u32 word0 = nfsd_suppattrs0(minorversion); |
| 2141 | u32 word1 = nfsd_suppattrs1(minorversion); |
| 2142 | u32 word2 = nfsd_suppattrs2(minorversion); |
| 2143 | |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 2144 | if (!aclsupport) |
| 2145 | word0 &= ~FATTR4_WORD0_ACL; |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2146 | if (!contextsupport) |
| 2147 | word2 &= ~FATTR4_WORD2_SECURITY_LABEL; |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2148 | if (!word2) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2149 | p = xdr_reserve_space(xdr, 12); |
| 2150 | if (!p) |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2151 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2152 | *p++ = cpu_to_be32(2); |
| 2153 | *p++ = cpu_to_be32(word0); |
| 2154 | *p++ = cpu_to_be32(word1); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2155 | } else { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2156 | p = xdr_reserve_space(xdr, 16); |
| 2157 | if (!p) |
Benny Halevy | 2b44f1b | 2010-09-30 20:47:46 +0200 | [diff] [blame] | 2158 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2159 | *p++ = cpu_to_be32(3); |
| 2160 | *p++ = cpu_to_be32(word0); |
| 2161 | *p++ = cpu_to_be32(word1); |
| 2162 | *p++ = cpu_to_be32(word2); |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2163 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2164 | } |
| 2165 | if (bmval0 & FATTR4_WORD0_TYPE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2166 | p = xdr_reserve_space(xdr, 4); |
| 2167 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2168 | goto out_resource; |
J. Bruce Fields | 3d2544b | 2011-08-15 11:49:30 -0400 | [diff] [blame] | 2169 | dummy = nfs4_file_type(stat.mode); |
J. Bruce Fields | 6b6d8137 | 2013-01-16 17:11:11 -0500 | [diff] [blame] | 2170 | if (dummy == NF4BAD) { |
| 2171 | status = nfserr_serverfault; |
| 2172 | goto out; |
| 2173 | } |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2174 | *p++ = cpu_to_be32(dummy); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2175 | } |
| 2176 | if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2177 | p = xdr_reserve_space(xdr, 4); |
| 2178 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2179 | goto out_resource; |
NeilBrown | 4964000 | 2005-06-23 22:02:58 -0700 | [diff] [blame] | 2180 | if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2181 | *p++ = cpu_to_be32(NFS4_FH_PERSISTENT); |
NeilBrown | 4964000 | 2005-06-23 22:02:58 -0700 | [diff] [blame] | 2182 | else |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2183 | *p++ = cpu_to_be32(NFS4_FH_PERSISTENT| |
| 2184 | NFS4_FH_VOL_RENAME); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2185 | } |
| 2186 | if (bmval0 & FATTR4_WORD0_CHANGE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2187 | p = xdr_reserve_space(xdr, 8); |
| 2188 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2189 | goto out_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 2190 | p = encode_change(p, &stat, dentry->d_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2191 | } |
| 2192 | if (bmval0 & FATTR4_WORD0_SIZE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2193 | p = xdr_reserve_space(xdr, 8); |
| 2194 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2195 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2196 | p = xdr_encode_hyper(p, stat.size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2197 | } |
| 2198 | if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2199 | p = xdr_reserve_space(xdr, 4); |
| 2200 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2201 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2202 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2203 | } |
| 2204 | if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2205 | p = xdr_reserve_space(xdr, 4); |
| 2206 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2207 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2208 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2209 | } |
| 2210 | if (bmval0 & FATTR4_WORD0_NAMED_ATTR) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2211 | p = xdr_reserve_space(xdr, 4); |
| 2212 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2213 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2214 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2215 | } |
| 2216 | if (bmval0 & FATTR4_WORD0_FSID) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2217 | p = xdr_reserve_space(xdr, 16); |
| 2218 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2219 | goto out_resource; |
J.Bruce Fields | 42ca099 | 2006-10-04 02:16:20 -0700 | [diff] [blame] | 2220 | if (exp->ex_fslocs.migrated) { |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2221 | p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR); |
| 2222 | p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 2223 | } else switch(fsid_source(fhp)) { |
| 2224 | case FSIDSOURCE_FSID: |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2225 | p = xdr_encode_hyper(p, (u64)exp->ex_fsid); |
| 2226 | p = xdr_encode_hyper(p, (u64)0); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 2227 | break; |
| 2228 | case FSIDSOURCE_DEV: |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2229 | *p++ = cpu_to_be32(0); |
| 2230 | *p++ = cpu_to_be32(MAJOR(stat.dev)); |
| 2231 | *p++ = cpu_to_be32(0); |
| 2232 | *p++ = cpu_to_be32(MINOR(stat.dev)); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 2233 | break; |
| 2234 | case FSIDSOURCE_UUID: |
Kinglong Mee | 94eb368 | 2014-05-23 20:00:19 +0800 | [diff] [blame] | 2235 | p = xdr_encode_opaque_fixed(p, exp->ex_uuid, |
| 2236 | EX_UUID_LEN); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 2237 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2238 | } |
| 2239 | } |
| 2240 | if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2241 | p = xdr_reserve_space(xdr, 4); |
| 2242 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2243 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2244 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2245 | } |
| 2246 | if (bmval0 & FATTR4_WORD0_LEASE_TIME) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2247 | p = xdr_reserve_space(xdr, 4); |
| 2248 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2249 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2250 | *p++ = cpu_to_be32(nn->nfsd4_lease); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2251 | } |
| 2252 | if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2253 | p = xdr_reserve_space(xdr, 4); |
| 2254 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2255 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2256 | *p++ = cpu_to_be32(rdattr_err); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2257 | } |
| 2258 | if (bmval0 & FATTR4_WORD0_ACL) { |
| 2259 | struct nfs4_ace *ace; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2260 | |
| 2261 | if (acl == NULL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2262 | p = xdr_reserve_space(xdr, 4); |
| 2263 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2264 | goto out_resource; |
| 2265 | |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2266 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2267 | goto out_acl; |
| 2268 | } |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2269 | p = xdr_reserve_space(xdr, 4); |
| 2270 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2271 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2272 | *p++ = cpu_to_be32(acl->naces); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2273 | |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 2274 | for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2275 | p = xdr_reserve_space(xdr, 4*3); |
| 2276 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2277 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2278 | *p++ = cpu_to_be32(ace->type); |
| 2279 | *p++ = cpu_to_be32(ace->flag); |
| 2280 | *p++ = cpu_to_be32(ace->access_mask & |
| 2281 | NFS4_ACE_MASK_ALL); |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2282 | status = nfsd4_encode_aclname(xdr, rqstp, ace); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2283 | if (status) |
| 2284 | goto out; |
| 2285 | } |
| 2286 | } |
| 2287 | out_acl: |
| 2288 | if (bmval0 & FATTR4_WORD0_ACLSUPPORT) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2289 | p = xdr_reserve_space(xdr, 4); |
| 2290 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2291 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2292 | *p++ = cpu_to_be32(aclsupport ? |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2293 | ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0); |
| 2294 | } |
| 2295 | if (bmval0 & FATTR4_WORD0_CANSETTIME) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2296 | p = xdr_reserve_space(xdr, 4); |
| 2297 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2298 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2299 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2300 | } |
| 2301 | if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2302 | p = xdr_reserve_space(xdr, 4); |
| 2303 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2304 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2305 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2306 | } |
| 2307 | if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2308 | p = xdr_reserve_space(xdr, 4); |
| 2309 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2310 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2311 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2312 | } |
| 2313 | if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2314 | p = xdr_reserve_space(xdr, 4); |
| 2315 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2316 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2317 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2318 | } |
| 2319 | if (bmval0 & FATTR4_WORD0_FILEHANDLE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2320 | p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); |
| 2321 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2322 | goto out_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2323 | p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, |
| 2324 | fhp->fh_handle.fh_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2325 | } |
| 2326 | if (bmval0 & FATTR4_WORD0_FILEID) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2327 | p = xdr_reserve_space(xdr, 8); |
| 2328 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2329 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2330 | p = xdr_encode_hyper(p, stat.ino); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2331 | } |
| 2332 | if (bmval0 & FATTR4_WORD0_FILES_AVAIL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2333 | p = xdr_reserve_space(xdr, 8); |
| 2334 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2335 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2336 | p = xdr_encode_hyper(p, (u64) statfs.f_ffree); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2337 | } |
| 2338 | if (bmval0 & FATTR4_WORD0_FILES_FREE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2339 | p = xdr_reserve_space(xdr, 8); |
| 2340 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2341 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2342 | p = xdr_encode_hyper(p, (u64) statfs.f_ffree); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2343 | } |
| 2344 | if (bmval0 & FATTR4_WORD0_FILES_TOTAL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2345 | p = xdr_reserve_space(xdr, 8); |
| 2346 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2347 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2348 | p = xdr_encode_hyper(p, (u64) statfs.f_files); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2349 | } |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 2350 | if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2351 | status = nfsd4_encode_fs_locations(xdr, rqstp, exp); |
J.Bruce Fields | 81c3f41 | 2006-10-04 02:16:19 -0700 | [diff] [blame] | 2352 | if (status) |
| 2353 | goto out; |
| 2354 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2355 | if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2356 | p = xdr_reserve_space(xdr, 4); |
| 2357 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2358 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2359 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2360 | } |
| 2361 | if (bmval0 & FATTR4_WORD0_MAXFILESIZE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2362 | p = xdr_reserve_space(xdr, 8); |
| 2363 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2364 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2365 | p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2366 | } |
| 2367 | if (bmval0 & FATTR4_WORD0_MAXLINK) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2368 | p = xdr_reserve_space(xdr, 4); |
| 2369 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2370 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2371 | *p++ = cpu_to_be32(255); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2372 | } |
| 2373 | if (bmval0 & FATTR4_WORD0_MAXNAME) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2374 | p = xdr_reserve_space(xdr, 4); |
| 2375 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2376 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2377 | *p++ = cpu_to_be32(statfs.f_namelen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2378 | } |
| 2379 | if (bmval0 & FATTR4_WORD0_MAXREAD) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2380 | p = xdr_reserve_space(xdr, 8); |
| 2381 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2382 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2383 | p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2384 | } |
| 2385 | if (bmval0 & FATTR4_WORD0_MAXWRITE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2386 | p = xdr_reserve_space(xdr, 8); |
| 2387 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2388 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2389 | p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2390 | } |
| 2391 | if (bmval1 & FATTR4_WORD1_MODE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2392 | p = xdr_reserve_space(xdr, 4); |
| 2393 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2394 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2395 | *p++ = cpu_to_be32(stat.mode & S_IALLUGO); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2396 | } |
| 2397 | if (bmval1 & FATTR4_WORD1_NO_TRUNC) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2398 | p = xdr_reserve_space(xdr, 4); |
| 2399 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2400 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2401 | *p++ = cpu_to_be32(1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2402 | } |
| 2403 | if (bmval1 & FATTR4_WORD1_NUMLINKS) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2404 | p = xdr_reserve_space(xdr, 4); |
| 2405 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2406 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2407 | *p++ = cpu_to_be32(stat.nlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2408 | } |
| 2409 | if (bmval1 & FATTR4_WORD1_OWNER) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2410 | status = nfsd4_encode_user(xdr, rqstp, stat.uid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2411 | if (status) |
| 2412 | goto out; |
| 2413 | } |
| 2414 | if (bmval1 & FATTR4_WORD1_OWNER_GROUP) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2415 | status = nfsd4_encode_group(xdr, rqstp, stat.gid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2416 | if (status) |
| 2417 | goto out; |
| 2418 | } |
| 2419 | if (bmval1 & FATTR4_WORD1_RAWDEV) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2420 | p = xdr_reserve_space(xdr, 8); |
| 2421 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2422 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2423 | *p++ = cpu_to_be32((u32) MAJOR(stat.rdev)); |
| 2424 | *p++ = cpu_to_be32((u32) MINOR(stat.rdev)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2425 | } |
| 2426 | if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2427 | p = xdr_reserve_space(xdr, 8); |
| 2428 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2429 | goto out_resource; |
| 2430 | dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2431 | p = xdr_encode_hyper(p, dummy64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2432 | } |
| 2433 | if (bmval1 & FATTR4_WORD1_SPACE_FREE) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2434 | p = xdr_reserve_space(xdr, 8); |
| 2435 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2436 | goto out_resource; |
| 2437 | dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2438 | p = xdr_encode_hyper(p, dummy64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2439 | } |
| 2440 | if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2441 | p = xdr_reserve_space(xdr, 8); |
| 2442 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2443 | goto out_resource; |
| 2444 | dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2445 | p = xdr_encode_hyper(p, dummy64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2446 | } |
| 2447 | if (bmval1 & FATTR4_WORD1_SPACE_USED) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2448 | p = xdr_reserve_space(xdr, 8); |
| 2449 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2450 | goto out_resource; |
| 2451 | dummy64 = (u64)stat.blocks << 9; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2452 | p = xdr_encode_hyper(p, dummy64); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2453 | } |
| 2454 | if (bmval1 & FATTR4_WORD1_TIME_ACCESS) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2455 | p = xdr_reserve_space(xdr, 12); |
| 2456 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2457 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2458 | p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2459 | *p++ = cpu_to_be32(stat.atime.tv_nsec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2460 | } |
| 2461 | if (bmval1 & FATTR4_WORD1_TIME_DELTA) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2462 | p = xdr_reserve_space(xdr, 12); |
| 2463 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2464 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2465 | *p++ = cpu_to_be32(0); |
| 2466 | *p++ = cpu_to_be32(1); |
| 2467 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2468 | } |
| 2469 | if (bmval1 & FATTR4_WORD1_TIME_METADATA) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2470 | p = xdr_reserve_space(xdr, 12); |
| 2471 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2472 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2473 | p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2474 | *p++ = cpu_to_be32(stat.ctime.tv_nsec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2475 | } |
| 2476 | if (bmval1 & FATTR4_WORD1_TIME_MODIFY) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2477 | p = xdr_reserve_space(xdr, 12); |
| 2478 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2479 | goto out_resource; |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2480 | p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2481 | *p++ = cpu_to_be32(stat.mtime.tv_nsec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2482 | } |
| 2483 | if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2484 | p = xdr_reserve_space(xdr, 8); |
| 2485 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2486 | goto out_resource; |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2487 | /* |
| 2488 | * Get parent's attributes if not ignoring crossmount |
| 2489 | * and this is the root of a cross-mounted filesystem. |
| 2490 | */ |
| 2491 | if (ignore_crossmnt == 0 && |
J. Bruce Fields | ae7095a | 2012-10-01 17:50:56 -0400 | [diff] [blame] | 2492 | dentry == exp->ex_path.mnt->mnt_root) |
| 2493 | get_parent_attributes(exp, &stat); |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2494 | p = xdr_encode_hyper(p, stat.ino); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2495 | } |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2496 | if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2497 | status = nfsd4_encode_security_label(xdr, rqstp, context, |
| 2498 | contextlen); |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2499 | if (status) |
| 2500 | goto out; |
| 2501 | } |
Benny Halevy | 8c18f20 | 2009-04-03 08:29:14 +0300 | [diff] [blame] | 2502 | if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) { |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 2503 | p = xdr_reserve_space(xdr, 16); |
| 2504 | if (!p) |
J. Bruce Fields | de3997a | 2014-01-28 16:05:15 -0500 | [diff] [blame] | 2505 | goto out_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2506 | *p++ = cpu_to_be32(3); |
| 2507 | *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD0); |
| 2508 | *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD1); |
| 2509 | *p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD2); |
Benny Halevy | 8c18f20 | 2009-04-03 08:29:14 +0300 | [diff] [blame] | 2510 | } |
Andy Adamson | 7e70570 | 2009-04-03 08:29:11 +0300 | [diff] [blame] | 2511 | |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 2512 | attrlen = htonl(xdr->buf->len - attrlen_offset - 4); |
| 2513 | write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2514 | status = nfs_ok; |
| 2515 | |
| 2516 | out: |
J. Bruce Fields | ba4e55b | 2013-05-15 10:27:52 -0400 | [diff] [blame] | 2517 | #ifdef CONFIG_NFSD_V4_SECURITY_LABEL |
David Quigley | 18032ca | 2013-05-02 13:19:10 -0400 | [diff] [blame] | 2518 | if (context) |
| 2519 | security_release_secctx(context, contextlen); |
J. Bruce Fields | ba4e55b | 2013-05-15 10:27:52 -0400 | [diff] [blame] | 2520 | #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ |
J. Bruce Fields | 28e05dd | 2007-02-16 01:28:30 -0800 | [diff] [blame] | 2521 | kfree(acl); |
Yan, Zheng | 18df11d0 | 2014-03-10 12:52:07 +0800 | [diff] [blame] | 2522 | if (tempfh) { |
J. Bruce Fields | d50e613 | 2014-01-15 12:21:12 -0500 | [diff] [blame] | 2523 | fh_put(tempfh); |
Yan, Zheng | 18df11d0 | 2014-03-10 12:52:07 +0800 | [diff] [blame] | 2524 | kfree(tempfh); |
| 2525 | } |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 2526 | if (status) |
| 2527 | xdr_truncate_encode(xdr, starting_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2528 | return status; |
| 2529 | out_nfserr: |
Al Viro | b8dd7b9 | 2006-10-19 23:29:01 -0700 | [diff] [blame] | 2530 | status = nfserrno(err); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2531 | goto out; |
| 2532 | out_resource: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2533 | status = nfserr_resource; |
| 2534 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2535 | } |
| 2536 | |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2537 | static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr, |
| 2538 | struct xdr_buf *buf, __be32 *p, int bytes) |
| 2539 | { |
| 2540 | xdr->scratch.iov_len = 0; |
| 2541 | memset(buf, 0, sizeof(struct xdr_buf)); |
| 2542 | buf->head[0].iov_base = p; |
| 2543 | buf->head[0].iov_len = 0; |
| 2544 | buf->len = 0; |
| 2545 | xdr->buf = buf; |
| 2546 | xdr->iov = buf->head; |
| 2547 | xdr->p = p; |
| 2548 | xdr->end = (void *)p + bytes; |
| 2549 | buf->buflen = bytes; |
| 2550 | } |
| 2551 | |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2552 | __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words, |
| 2553 | struct svc_fh *fhp, struct svc_export *exp, |
| 2554 | struct dentry *dentry, u32 *bmval, |
| 2555 | struct svc_rqst *rqstp, int ignore_crossmnt) |
| 2556 | { |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2557 | struct xdr_buf dummy; |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2558 | struct xdr_stream xdr; |
| 2559 | __be32 ret; |
| 2560 | |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2561 | svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2); |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2562 | ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp, |
| 2563 | ignore_crossmnt); |
| 2564 | *p = xdr.p; |
| 2565 | return ret; |
| 2566 | } |
| 2567 | |
J. Bruce Fields | c0ce6ec | 2008-02-11 15:48:47 -0500 | [diff] [blame] | 2568 | static inline int attributes_need_mount(u32 *bmval) |
| 2569 | { |
| 2570 | if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME)) |
| 2571 | return 1; |
| 2572 | if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID) |
| 2573 | return 1; |
| 2574 | return 0; |
| 2575 | } |
| 2576 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2577 | static __be32 |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2578 | nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd, |
| 2579 | const char *name, int namlen) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2580 | { |
| 2581 | struct svc_export *exp = cd->rd_fhp->fh_export; |
| 2582 | struct dentry *dentry; |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2583 | __be32 nfserr; |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2584 | int ignore_crossmnt = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2585 | |
| 2586 | dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen); |
| 2587 | if (IS_ERR(dentry)) |
| 2588 | return nfserrno(PTR_ERR(dentry)); |
J. Bruce Fields | b2c0cea | 2009-05-05 19:04:29 -0400 | [diff] [blame] | 2589 | if (!dentry->d_inode) { |
| 2590 | /* |
| 2591 | * nfsd_buffered_readdir drops the i_mutex between |
| 2592 | * readdir and calling this callback, leaving a window |
| 2593 | * where this directory entry could have gone away. |
| 2594 | */ |
| 2595 | dput(dentry); |
| 2596 | return nfserr_noent; |
| 2597 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2598 | |
| 2599 | exp_get(exp); |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2600 | /* |
| 2601 | * In the case of a mountpoint, the client may be asking for |
| 2602 | * attributes that are only properties of the underlying filesystem |
| 2603 | * as opposed to the cross-mounted file system. In such a case, |
| 2604 | * we will not follow the cross mount and will fill the attribtutes |
| 2605 | * directly from the mountpoint dentry. |
| 2606 | */ |
J. Bruce Fields | 3227fa4 | 2009-10-25 21:43:01 -0400 | [diff] [blame] | 2607 | if (nfsd_mountpoint(dentry, exp)) { |
J.Bruce Fields | 021d3a7 | 2006-12-13 00:35:24 -0800 | [diff] [blame] | 2608 | int err; |
| 2609 | |
J. Bruce Fields | 3227fa4 | 2009-10-25 21:43:01 -0400 | [diff] [blame] | 2610 | if (!(exp->ex_flags & NFSEXP_V4ROOT) |
| 2611 | && !attributes_need_mount(cd->rd_bmval)) { |
| 2612 | ignore_crossmnt = 1; |
| 2613 | goto out_encode; |
| 2614 | } |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 2615 | /* |
| 2616 | * Why the heck aren't we just using nfsd_lookup?? |
| 2617 | * Different "."/".." handling? Something else? |
| 2618 | * At least, add a comment here to explain.... |
| 2619 | */ |
J.Bruce Fields | 021d3a7 | 2006-12-13 00:35:24 -0800 | [diff] [blame] | 2620 | err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); |
| 2621 | if (err) { |
| 2622 | nfserr = nfserrno(err); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2623 | goto out_put; |
| 2624 | } |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 2625 | nfserr = check_nfsd_access(exp, cd->rd_rqstp); |
| 2626 | if (nfserr) |
| 2627 | goto out_put; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2628 | |
| 2629 | } |
J. Bruce Fields | 3227fa4 | 2009-10-25 21:43:01 -0400 | [diff] [blame] | 2630 | out_encode: |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2631 | nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval, |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2632 | cd->rd_rqstp, ignore_crossmnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2633 | out_put: |
| 2634 | dput(dentry); |
| 2635 | exp_put(exp); |
| 2636 | return nfserr; |
| 2637 | } |
| 2638 | |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 2639 | static __be32 * |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2640 | nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2641 | { |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2642 | __be32 *p; |
| 2643 | |
Kinglong Mee | c3a4561 | 2014-07-06 11:34:43 +0800 | [diff] [blame] | 2644 | p = xdr_reserve_space(xdr, 20); |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2645 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2646 | return NULL; |
| 2647 | *p++ = htonl(2); |
| 2648 | *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */ |
| 2649 | *p++ = htonl(0); /* bmval1 */ |
| 2650 | |
J. Bruce Fields | 87915c6 | 2013-01-16 17:33:28 -0500 | [diff] [blame] | 2651 | *p++ = htonl(4); /* attribute length */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2652 | *p++ = nfserr; /* no htonl */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2653 | return p; |
| 2654 | } |
| 2655 | |
| 2656 | static int |
NeilBrown | a0ad13e | 2007-01-26 00:57:10 -0800 | [diff] [blame] | 2657 | nfsd4_encode_dirent(void *ccdv, const char *name, int namlen, |
| 2658 | loff_t offset, u64 ino, unsigned int d_type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2659 | { |
NeilBrown | a0ad13e | 2007-01-26 00:57:10 -0800 | [diff] [blame] | 2660 | struct readdir_cd *ccd = ccdv; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2661 | struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2662 | struct xdr_stream *xdr = cd->xdr; |
| 2663 | int start_offset = xdr->buf->len; |
| 2664 | int cookie_offset; |
| 2665 | int entry_bytes; |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2666 | __be32 nfserr = nfserr_toosmall; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2667 | __be64 wire_offset; |
| 2668 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2669 | |
| 2670 | /* In nfsv4, "." and ".." never make it onto the wire.. */ |
| 2671 | if (name && isdotent(name, namlen)) { |
| 2672 | cd->common.err = nfs_ok; |
| 2673 | return 0; |
| 2674 | } |
| 2675 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2676 | if (cd->cookie_offset) { |
| 2677 | wire_offset = cpu_to_be64(offset); |
| 2678 | write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset, |
| 2679 | &wire_offset, 8); |
| 2680 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2681 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2682 | p = xdr_reserve_space(xdr, 4); |
| 2683 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2684 | goto fail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2685 | *p++ = xdr_one; /* mark entry present */ |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2686 | cookie_offset = xdr->buf->len; |
| 2687 | p = xdr_reserve_space(xdr, 3*4 + namlen); |
| 2688 | if (!p) |
| 2689 | goto fail; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2690 | p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */ |
| 2691 | p = xdr_encode_array(p, name, namlen); /* name length & name */ |
| 2692 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2693 | nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2694 | switch (nfserr) { |
| 2695 | case nfs_ok: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2696 | break; |
| 2697 | case nfserr_resource: |
| 2698 | nfserr = nfserr_toosmall; |
| 2699 | goto fail; |
J. Bruce Fields | b2c0cea | 2009-05-05 19:04:29 -0400 | [diff] [blame] | 2700 | case nfserr_noent: |
Kinglong Mee | f41c5ad | 2014-06-13 17:32:42 +0800 | [diff] [blame] | 2701 | xdr_truncate_encode(xdr, start_offset); |
J. Bruce Fields | b2c0cea | 2009-05-05 19:04:29 -0400 | [diff] [blame] | 2702 | goto skip_entry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2703 | default: |
| 2704 | /* |
| 2705 | * If the client requested the RDATTR_ERROR attribute, |
| 2706 | * we stuff the error code into this attribute |
| 2707 | * and continue. If this attribute was not requested, |
| 2708 | * then in accordance with the spec, we fail the |
| 2709 | * entire READDIR operation(!) |
| 2710 | */ |
| 2711 | if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) |
| 2712 | goto fail; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2713 | p = nfsd4_encode_rdattr_error(xdr, nfserr); |
Fred Isaman | 34081ef | 2006-01-18 17:43:40 -0800 | [diff] [blame] | 2714 | if (p == NULL) { |
| 2715 | nfserr = nfserr_toosmall; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2716 | goto fail; |
Fred Isaman | 34081ef | 2006-01-18 17:43:40 -0800 | [diff] [blame] | 2717 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2718 | } |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2719 | nfserr = nfserr_toosmall; |
| 2720 | entry_bytes = xdr->buf->len - start_offset; |
| 2721 | if (entry_bytes > cd->rd_maxcount) |
| 2722 | goto fail; |
| 2723 | cd->rd_maxcount -= entry_bytes; |
J. Bruce Fields | 3b29970 | 2014-03-20 21:20:26 -0400 | [diff] [blame] | 2724 | if (!cd->rd_dircount) |
| 2725 | goto fail; |
| 2726 | cd->rd_dircount--; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2727 | cd->cookie_offset = cookie_offset; |
J. Bruce Fields | b2c0cea | 2009-05-05 19:04:29 -0400 | [diff] [blame] | 2728 | skip_entry: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2729 | cd->common.err = nfs_ok; |
| 2730 | return 0; |
| 2731 | fail: |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 2732 | xdr_truncate_encode(xdr, start_offset); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2733 | cd->common.err = nfserr; |
| 2734 | return -EINVAL; |
| 2735 | } |
| 2736 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2737 | static __be32 |
| 2738 | nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid) |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2739 | { |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2740 | __be32 *p; |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2741 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2742 | p = xdr_reserve_space(xdr, sizeof(stateid_t)); |
| 2743 | if (!p) |
| 2744 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2745 | *p++ = cpu_to_be32(sid->si_generation); |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2746 | p = xdr_encode_opaque_fixed(p, &sid->si_opaque, |
| 2747 | sizeof(stateid_opaque_t)); |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2748 | return 0; |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2749 | } |
| 2750 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2751 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2752 | nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2753 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2754 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2755 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2756 | |
| 2757 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2758 | p = xdr_reserve_space(xdr, 8); |
| 2759 | if (!p) |
| 2760 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2761 | *p++ = cpu_to_be32(access->ac_supported); |
| 2762 | *p++ = cpu_to_be32(access->ac_resp_access); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2763 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2764 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2765 | } |
| 2766 | |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 2767 | static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts) |
| 2768 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2769 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 2770 | __be32 *p; |
| 2771 | |
| 2772 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2773 | p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8); |
| 2774 | if (!p) |
| 2775 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2776 | p = xdr_encode_opaque_fixed(p, bcts->sessionid.data, |
| 2777 | NFS4_MAX_SESSIONID_LEN); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2778 | *p++ = cpu_to_be32(bcts->dir); |
J. Bruce Fields | 6e67b5d | 2012-09-13 09:49:43 -0400 | [diff] [blame] | 2779 | /* Sorry, we do not yet support RDMA over 4.1: */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2780 | *p++ = cpu_to_be32(0); |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 2781 | } |
| 2782 | return nfserr; |
| 2783 | } |
| 2784 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2785 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2786 | nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2787 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2788 | struct xdr_stream *xdr = &resp->xdr; |
| 2789 | |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2790 | if (!nfserr) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2791 | nfserr = nfsd4_encode_stateid(xdr, &close->cl_stateid); |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2792 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2793 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2794 | } |
| 2795 | |
| 2796 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2797 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2798 | nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2799 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2800 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2801 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2802 | |
| 2803 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2804 | p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); |
| 2805 | if (!p) |
| 2806 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2807 | p = xdr_encode_opaque_fixed(p, commit->co_verf.data, |
| 2808 | NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2809 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2810 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2811 | } |
| 2812 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2813 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2814 | nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2815 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2816 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2817 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2818 | |
| 2819 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2820 | p = xdr_reserve_space(xdr, 32); |
| 2821 | if (!p) |
| 2822 | return nfserr_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 2823 | p = encode_cinfo(p, &create->cr_cinfo); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2824 | *p++ = cpu_to_be32(2); |
| 2825 | *p++ = cpu_to_be32(create->cr_bmval[0]); |
| 2826 | *p++ = cpu_to_be32(create->cr_bmval[1]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2827 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2828 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2829 | } |
| 2830 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2831 | static __be32 |
| 2832 | nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2833 | { |
| 2834 | struct svc_fh *fhp = getattr->ga_fhp; |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2835 | struct xdr_stream *xdr = &resp->xdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2836 | |
| 2837 | if (nfserr) |
| 2838 | return nfserr; |
| 2839 | |
J. Bruce Fields | d518465 | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 2840 | nfserr = nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry, |
| 2841 | getattr->ga_bmval, |
Frank Filz | 406a7ea | 2007-11-27 11:34:05 -0800 | [diff] [blame] | 2842 | resp->rqstp, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2843 | return nfserr; |
| 2844 | } |
| 2845 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2846 | static __be32 |
| 2847 | nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2848 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2849 | struct xdr_stream *xdr = &resp->xdr; |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2850 | struct svc_fh *fhp = *fhpp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2851 | unsigned int len; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2852 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2853 | |
| 2854 | if (!nfserr) { |
| 2855 | len = fhp->fh_handle.fh_size; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2856 | p = xdr_reserve_space(xdr, len + 4); |
| 2857 | if (!p) |
| 2858 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2859 | p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2860 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2861 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2862 | } |
| 2863 | |
| 2864 | /* |
| 2865 | * Including all fields other than the name, a LOCK4denied structure requires |
| 2866 | * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes. |
| 2867 | */ |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2868 | static __be32 |
| 2869 | nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2870 | { |
J. Bruce Fields | 7c13f34 | 2011-08-30 22:15:47 -0400 | [diff] [blame] | 2871 | struct xdr_netobj *conf = &ld->ld_owner; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2872 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2873 | |
J. Bruce Fields | 8c7424c | 2014-03-10 12:19:10 -0400 | [diff] [blame] | 2874 | again: |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2875 | p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len)); |
J. Bruce Fields | 8c7424c | 2014-03-10 12:19:10 -0400 | [diff] [blame] | 2876 | if (!p) { |
| 2877 | /* |
| 2878 | * Don't fail to return the result just because we can't |
| 2879 | * return the conflicting open: |
| 2880 | */ |
| 2881 | if (conf->len) { |
| 2882 | conf->len = 0; |
| 2883 | conf->data = NULL; |
| 2884 | goto again; |
| 2885 | } |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2886 | return nfserr_resource; |
J. Bruce Fields | 8c7424c | 2014-03-10 12:19:10 -0400 | [diff] [blame] | 2887 | } |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2888 | p = xdr_encode_hyper(p, ld->ld_start); |
| 2889 | p = xdr_encode_hyper(p, ld->ld_length); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2890 | *p++ = cpu_to_be32(ld->ld_type); |
J. Bruce Fields | 7c13f34 | 2011-08-30 22:15:47 -0400 | [diff] [blame] | 2891 | if (conf->len) { |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 2892 | p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8); |
| 2893 | p = xdr_encode_opaque(p, conf->data, conf->len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2894 | } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 2895 | p = xdr_encode_hyper(p, (u64)0); /* clientid */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2896 | *p++ = cpu_to_be32(0); /* length of owner name */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2897 | } |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2898 | return nfserr_denied; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2899 | } |
| 2900 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2901 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2902 | nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2903 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2904 | struct xdr_stream *xdr = &resp->xdr; |
| 2905 | |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2906 | if (!nfserr) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2907 | nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid); |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2908 | else if (nfserr == nfserr_denied) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2909 | nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied); |
J. Bruce Fields | 8c7424c | 2014-03-10 12:19:10 -0400 | [diff] [blame] | 2910 | kfree(lock->lk_denied.ld_owner.data); |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2911 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2912 | } |
| 2913 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2914 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2915 | nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2916 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2917 | struct xdr_stream *xdr = &resp->xdr; |
| 2918 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2919 | if (nfserr == nfserr_denied) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2920 | nfsd4_encode_lock_denied(xdr, &lockt->lt_denied); |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2921 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2922 | } |
| 2923 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2924 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2925 | nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2926 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2927 | struct xdr_stream *xdr = &resp->xdr; |
| 2928 | |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2929 | if (!nfserr) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2930 | nfserr = nfsd4_encode_stateid(xdr, &locku->lu_stateid); |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 2931 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2932 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2933 | } |
| 2934 | |
| 2935 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2936 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2937 | nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2938 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2939 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2940 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2941 | |
| 2942 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2943 | p = xdr_reserve_space(xdr, 20); |
| 2944 | if (!p) |
| 2945 | return nfserr_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 2946 | p = encode_cinfo(p, &link->li_cinfo); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2947 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2948 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2949 | } |
| 2950 | |
| 2951 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 2952 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 2953 | nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2954 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2955 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 2956 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2957 | |
| 2958 | if (nfserr) |
| 2959 | goto out; |
| 2960 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2961 | nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid); |
| 2962 | if (nfserr) |
| 2963 | goto out; |
| 2964 | p = xdr_reserve_space(xdr, 40); |
| 2965 | if (!p) |
| 2966 | return nfserr_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 2967 | p = encode_cinfo(p, &open->op_cinfo); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2968 | *p++ = cpu_to_be32(open->op_rflags); |
| 2969 | *p++ = cpu_to_be32(2); |
| 2970 | *p++ = cpu_to_be32(open->op_bmval[0]); |
| 2971 | *p++ = cpu_to_be32(open->op_bmval[1]); |
| 2972 | *p++ = cpu_to_be32(open->op_delegate_type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2973 | |
| 2974 | switch (open->op_delegate_type) { |
| 2975 | case NFS4_OPEN_DELEGATE_NONE: |
| 2976 | break; |
| 2977 | case NFS4_OPEN_DELEGATE_READ: |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2978 | nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); |
| 2979 | if (nfserr) |
| 2980 | return nfserr; |
| 2981 | p = xdr_reserve_space(xdr, 20); |
| 2982 | if (!p) |
| 2983 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2984 | *p++ = cpu_to_be32(open->op_recall); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2985 | |
| 2986 | /* |
| 2987 | * TODO: ACE's in delegations |
| 2988 | */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 2989 | *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); |
| 2990 | *p++ = cpu_to_be32(0); |
| 2991 | *p++ = cpu_to_be32(0); |
| 2992 | *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2993 | break; |
| 2994 | case NFS4_OPEN_DELEGATE_WRITE: |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 2995 | nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); |
| 2996 | if (nfserr) |
| 2997 | return nfserr; |
| 2998 | p = xdr_reserve_space(xdr, 32); |
| 2999 | if (!p) |
| 3000 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3001 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3002 | |
| 3003 | /* |
| 3004 | * TODO: space_limit's in delegations |
| 3005 | */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3006 | *p++ = cpu_to_be32(NFS4_LIMIT_SIZE); |
| 3007 | *p++ = cpu_to_be32(~(u32)0); |
| 3008 | *p++ = cpu_to_be32(~(u32)0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3009 | |
| 3010 | /* |
| 3011 | * TODO: ACE's in delegations |
| 3012 | */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3013 | *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); |
| 3014 | *p++ = cpu_to_be32(0); |
| 3015 | *p++ = cpu_to_be32(0); |
| 3016 | *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3017 | break; |
Benny Halevy | d24433c | 2012-02-16 20:57:17 +0200 | [diff] [blame] | 3018 | case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */ |
| 3019 | switch (open->op_why_no_deleg) { |
| 3020 | case WND4_CONTENTION: |
| 3021 | case WND4_RESOURCE: |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3022 | p = xdr_reserve_space(xdr, 8); |
| 3023 | if (!p) |
| 3024 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3025 | *p++ = cpu_to_be32(open->op_why_no_deleg); |
| 3026 | /* deleg signaling not supported yet: */ |
| 3027 | *p++ = cpu_to_be32(0); |
Benny Halevy | d24433c | 2012-02-16 20:57:17 +0200 | [diff] [blame] | 3028 | break; |
| 3029 | default: |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3030 | p = xdr_reserve_space(xdr, 4); |
| 3031 | if (!p) |
| 3032 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3033 | *p++ = cpu_to_be32(open->op_why_no_deleg); |
Benny Halevy | d24433c | 2012-02-16 20:57:17 +0200 | [diff] [blame] | 3034 | } |
Benny Halevy | d24433c | 2012-02-16 20:57:17 +0200 | [diff] [blame] | 3035 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3036 | default: |
| 3037 | BUG(); |
| 3038 | } |
| 3039 | /* XXX save filehandle here */ |
| 3040 | out: |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3041 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3042 | } |
| 3043 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3044 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3045 | nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3046 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3047 | struct xdr_stream *xdr = &resp->xdr; |
| 3048 | |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 3049 | if (!nfserr) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3050 | nfserr = nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3051 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3052 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3053 | } |
| 3054 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3055 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3056 | nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3057 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3058 | struct xdr_stream *xdr = &resp->xdr; |
| 3059 | |
Benny Halevy | e2f282b | 2008-08-12 20:45:07 +0300 | [diff] [blame] | 3060 | if (!nfserr) |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3061 | nfserr = nfsd4_encode_stateid(xdr, &od->od_stateid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3062 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3063 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3064 | } |
| 3065 | |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3066 | static __be32 nfsd4_encode_splice_read( |
| 3067 | struct nfsd4_compoundres *resp, |
| 3068 | struct nfsd4_read *read, |
| 3069 | struct file *file, unsigned long maxcount) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3070 | { |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3071 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3072 | struct xdr_buf *buf = xdr->buf; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3073 | u32 eof; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3074 | int space_left; |
| 3075 | __be32 nfserr; |
J. Bruce Fields | fec25fa | 2014-05-13 17:27:03 -0400 | [diff] [blame] | 3076 | __be32 *p = xdr->p - 2; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3077 | |
| 3078 | /* |
| 3079 | * Don't inline pages unless we know there's room for eof, |
| 3080 | * count, and possible padding: |
| 3081 | */ |
| 3082 | if (xdr->end - xdr->p < 3) |
| 3083 | return nfserr_resource; |
| 3084 | |
| 3085 | nfserr = nfsd_splice_read(read->rd_rqstp, file, |
| 3086 | read->rd_offset, &maxcount); |
| 3087 | if (nfserr) { |
| 3088 | /* |
| 3089 | * nfsd_splice_actor may have already messed with the |
| 3090 | * page length; reset it so as not to confuse |
| 3091 | * xdr_truncate_encode: |
| 3092 | */ |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3093 | buf->page_len = 0; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3094 | return nfserr; |
| 3095 | } |
| 3096 | |
| 3097 | eof = (read->rd_offset + maxcount >= |
| 3098 | read->rd_fhp->fh_dentry->d_inode->i_size); |
| 3099 | |
J. Bruce Fields | fec25fa | 2014-05-13 17:27:03 -0400 | [diff] [blame] | 3100 | *(p++) = htonl(eof); |
| 3101 | *(p++) = htonl(maxcount); |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3102 | |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3103 | buf->page_len = maxcount; |
| 3104 | buf->len += maxcount; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3105 | xdr->page_ptr += (maxcount + PAGE_SIZE - 1) / PAGE_SIZE; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3106 | |
| 3107 | /* Use rest of head for padding and remaining ops: */ |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3108 | buf->tail[0].iov_base = xdr->p; |
| 3109 | buf->tail[0].iov_len = 0; |
J. Bruce Fields | fec25fa | 2014-05-13 17:27:03 -0400 | [diff] [blame] | 3110 | xdr->iov = buf->tail; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3111 | if (maxcount&3) { |
J. Bruce Fields | fec25fa | 2014-05-13 17:27:03 -0400 | [diff] [blame] | 3112 | int pad = 4 - (maxcount&3); |
| 3113 | |
| 3114 | *(xdr->p++) = 0; |
| 3115 | |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3116 | buf->tail[0].iov_base += maxcount&3; |
J. Bruce Fields | fec25fa | 2014-05-13 17:27:03 -0400 | [diff] [blame] | 3117 | buf->tail[0].iov_len = pad; |
| 3118 | buf->len += pad; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3119 | } |
| 3120 | |
| 3121 | space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, |
J. Bruce Fields | 34a78b4 | 2014-05-13 16:32:04 -0400 | [diff] [blame] | 3122 | buf->buflen - buf->len); |
| 3123 | buf->buflen = buf->len + space_left; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3124 | xdr->end = (__be32 *)((void *)xdr->end + space_left); |
| 3125 | |
| 3126 | return 0; |
| 3127 | } |
| 3128 | |
| 3129 | static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp, |
| 3130 | struct nfsd4_read *read, |
| 3131 | struct file *file, unsigned long maxcount) |
| 3132 | { |
| 3133 | struct xdr_stream *xdr = &resp->xdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3134 | u32 eof; |
J. Bruce Fields | afc5940 | 2012-12-10 18:01:37 -0500 | [diff] [blame] | 3135 | int v; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3136 | int starting_len = xdr->buf->len - 8; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3137 | long len; |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3138 | int thislen; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3139 | __be32 nfserr; |
| 3140 | __be32 tmp; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3141 | __be32 *p; |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3142 | u32 zzz = 0; |
| 3143 | int pad; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3145 | len = maxcount; |
| 3146 | v = 0; |
J. Bruce Fields | 6ff9897 | 2014-03-11 16:51:23 -0400 | [diff] [blame] | 3147 | |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3148 | thislen = (void *)xdr->end - (void *)xdr->p; |
| 3149 | if (len < thislen) |
| 3150 | thislen = len; |
| 3151 | p = xdr_reserve_space(xdr, (thislen+3)&~3); |
| 3152 | WARN_ON_ONCE(!p); |
| 3153 | resp->rqstp->rq_vec[v].iov_base = p; |
| 3154 | resp->rqstp->rq_vec[v].iov_len = thislen; |
| 3155 | v++; |
| 3156 | len -= thislen; |
| 3157 | |
| 3158 | while (len) { |
J. Bruce Fields | 6ff9897 | 2014-03-11 16:51:23 -0400 | [diff] [blame] | 3159 | thislen = min_t(long, len, PAGE_SIZE); |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3160 | p = xdr_reserve_space(xdr, (thislen+3)&~3); |
| 3161 | WARN_ON_ONCE(!p); |
| 3162 | resp->rqstp->rq_vec[v].iov_base = p; |
J. Bruce Fields | 6ff9897 | 2014-03-11 16:51:23 -0400 | [diff] [blame] | 3163 | resp->rqstp->rq_vec[v].iov_len = thislen; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3164 | v++; |
J. Bruce Fields | 6ff9897 | 2014-03-11 16:51:23 -0400 | [diff] [blame] | 3165 | len -= thislen; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3166 | } |
| 3167 | read->rd_vlen = v; |
| 3168 | |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3169 | nfserr = nfsd_readv(file, read->rd_offset, resp->rqstp->rq_vec, |
| 3170 | read->rd_vlen, &maxcount); |
| 3171 | if (nfserr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3172 | return nfserr; |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3173 | xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3)); |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3174 | |
NeilBrown | 4452435 | 2006-10-04 02:15:46 -0700 | [diff] [blame] | 3175 | eof = (read->rd_offset + maxcount >= |
| 3176 | read->rd_fhp->fh_dentry->d_inode->i_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3177 | |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3178 | tmp = htonl(eof); |
| 3179 | write_bytes_to_xdr_buf(xdr->buf, starting_len , &tmp, 4); |
| 3180 | tmp = htonl(maxcount); |
| 3181 | write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4); |
| 3182 | |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3183 | pad = (maxcount&3) ? 4 - (maxcount&3) : 0; |
| 3184 | write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount, |
| 3185 | &zzz, pad); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3186 | return 0; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3187 | |
| 3188 | } |
| 3189 | |
| 3190 | static __be32 |
| 3191 | nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, |
| 3192 | struct nfsd4_read *read) |
| 3193 | { |
| 3194 | unsigned long maxcount; |
| 3195 | struct xdr_stream *xdr = &resp->xdr; |
| 3196 | struct file *file = read->rd_filp; |
| 3197 | int starting_len = xdr->buf->len; |
| 3198 | struct raparms *ra; |
| 3199 | __be32 *p; |
| 3200 | __be32 err; |
| 3201 | |
| 3202 | if (nfserr) |
| 3203 | return nfserr; |
| 3204 | |
| 3205 | p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */ |
| 3206 | if (!p) { |
| 3207 | WARN_ON_ONCE(resp->rqstp->rq_splice_ok); |
| 3208 | return nfserr_resource; |
| 3209 | } |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3210 | if (resp->xdr.buf->page_len && resp->rqstp->rq_splice_ok) { |
| 3211 | WARN_ON_ONCE(1); |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3212 | return nfserr_resource; |
| 3213 | } |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3214 | xdr_commit_encode(xdr); |
| 3215 | |
| 3216 | maxcount = svc_max_payload(resp->rqstp); |
J. Bruce Fields | b042098 | 2014-03-18 17:44:10 -0400 | [diff] [blame] | 3217 | if (maxcount > xdr->buf->buflen - xdr->buf->len) |
| 3218 | maxcount = xdr->buf->buflen - xdr->buf->len; |
J. Bruce Fields | dc97618 | 2014-03-18 17:01:51 -0400 | [diff] [blame] | 3219 | if (maxcount > read->rd_length) |
| 3220 | maxcount = read->rd_length; |
| 3221 | |
| 3222 | if (!read->rd_filp) { |
| 3223 | err = nfsd_get_tmp_read_open(resp->rqstp, read->rd_fhp, |
| 3224 | &file, &ra); |
| 3225 | if (err) |
| 3226 | goto err_truncate; |
| 3227 | } |
| 3228 | |
| 3229 | if (file->f_op->splice_read && resp->rqstp->rq_splice_ok) |
| 3230 | err = nfsd4_encode_splice_read(resp, read, file, maxcount); |
| 3231 | else |
| 3232 | err = nfsd4_encode_readv(resp, read, file, maxcount); |
| 3233 | |
| 3234 | if (!read->rd_filp) |
| 3235 | nfsd_put_tmp_read_open(file, ra); |
| 3236 | |
| 3237 | err_truncate: |
| 3238 | if (err) |
| 3239 | xdr_truncate_encode(xdr, starting_len); |
| 3240 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3241 | } |
| 3242 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3243 | static __be32 |
| 3244 | nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3245 | { |
| 3246 | int maxcount; |
J. Bruce Fields | 476a7b1 | 2014-01-20 17:08:27 -0500 | [diff] [blame] | 3247 | __be32 wire_count; |
| 3248 | int zero = 0; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 3249 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 3250 | int length_offset = xdr->buf->len; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3251 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3252 | |
| 3253 | if (nfserr) |
| 3254 | return nfserr; |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 3255 | |
| 3256 | p = xdr_reserve_space(xdr, 4); |
| 3257 | if (!p) |
| 3258 | return nfserr_resource; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3259 | maxcount = PAGE_SIZE; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3260 | |
J. Bruce Fields | 476a7b1 | 2014-01-20 17:08:27 -0500 | [diff] [blame] | 3261 | p = xdr_reserve_space(xdr, maxcount); |
| 3262 | if (!p) |
J. Bruce Fields | 4e21ac4 | 2014-03-22 15:15:11 -0400 | [diff] [blame] | 3263 | return nfserr_resource; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3264 | /* |
| 3265 | * XXX: By default, the ->readlink() VFS op will truncate symlinks |
| 3266 | * if they would overflow the buffer. Is this kosher in NFSv4? If |
| 3267 | * not, one easy fix is: if ->readlink() precisely fills the buffer, |
| 3268 | * assume that truncation occurred, and return NFS4ERR_RESOURCE. |
| 3269 | */ |
J. Bruce Fields | 476a7b1 | 2014-01-20 17:08:27 -0500 | [diff] [blame] | 3270 | nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, |
| 3271 | (char *)p, &maxcount); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3272 | if (nfserr == nfserr_isdir) |
J. Bruce Fields | d3f627c | 2014-02-26 17:00:38 -0500 | [diff] [blame] | 3273 | nfserr = nfserr_inval; |
| 3274 | if (nfserr) { |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 3275 | xdr_truncate_encode(xdr, length_offset); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3276 | return nfserr; |
J. Bruce Fields | d3f627c | 2014-02-26 17:00:38 -0500 | [diff] [blame] | 3277 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3278 | |
J. Bruce Fields | 476a7b1 | 2014-01-20 17:08:27 -0500 | [diff] [blame] | 3279 | wire_count = htonl(maxcount); |
| 3280 | write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4); |
Avi Kivity | 69bbd9c | 2014-06-26 17:23:12 +0300 | [diff] [blame] | 3281 | xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4)); |
J. Bruce Fields | 476a7b1 | 2014-01-20 17:08:27 -0500 | [diff] [blame] | 3282 | if (maxcount & 3) |
| 3283 | write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, |
| 3284 | &zero, 4 - (maxcount&3)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3285 | return 0; |
| 3286 | } |
| 3287 | |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3288 | static __be32 |
| 3289 | nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3290 | { |
| 3291 | int maxcount; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3292 | int bytes_left; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3293 | loff_t offset; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3294 | __be64 wire_offset; |
J. Bruce Fields | ddd1ea5 | 2013-08-27 21:32:25 -0400 | [diff] [blame] | 3295 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 3296 | int starting_len = xdr->buf->len; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3297 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3298 | |
| 3299 | if (nfserr) |
| 3300 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3301 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3302 | p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); |
| 3303 | if (!p) |
| 3304 | return nfserr_resource; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3305 | |
| 3306 | /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3307 | *p++ = cpu_to_be32(0); |
| 3308 | *p++ = cpu_to_be32(0); |
J. Bruce Fields | 4aea24b | 2014-01-15 15:17:58 -0500 | [diff] [blame] | 3309 | resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p) |
| 3310 | - (char *)resp->xdr.buf->head[0].iov_base; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3311 | |
| 3312 | /* |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3313 | * Number of bytes left for directory entries allowing for the |
| 3314 | * final 8 bytes of the readdir and a following failed op: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3315 | */ |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3316 | bytes_left = xdr->buf->buflen - xdr->buf->len |
| 3317 | - COMPOUND_ERR_SLACK_SPACE - 8; |
| 3318 | if (bytes_left < 0) { |
| 3319 | nfserr = nfserr_resource; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3320 | goto err_no_verf; |
| 3321 | } |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3322 | maxcount = min_t(u32, readdir->rd_maxcount, INT_MAX); |
| 3323 | /* |
| 3324 | * Note the rfc defines rd_maxcount as the size of the |
| 3325 | * READDIR4resok structure, which includes the verifier above |
| 3326 | * and the 8 bytes encoded at the end of this function: |
| 3327 | */ |
| 3328 | if (maxcount < 16) { |
| 3329 | nfserr = nfserr_toosmall; |
| 3330 | goto err_no_verf; |
| 3331 | } |
| 3332 | maxcount = min_t(int, maxcount-16, bytes_left); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3333 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3334 | readdir->xdr = xdr; |
| 3335 | readdir->rd_maxcount = maxcount; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3336 | readdir->common.err = 0; |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3337 | readdir->cookie_offset = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3338 | |
| 3339 | offset = readdir->rd_cookie; |
| 3340 | nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, |
| 3341 | &offset, |
| 3342 | &readdir->common, nfsd4_encode_dirent); |
| 3343 | if (nfserr == nfs_ok && |
| 3344 | readdir->common.err == nfserr_toosmall && |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3345 | xdr->buf->len == starting_len + 8) { |
| 3346 | /* nothing encoded; which limit did we hit?: */ |
| 3347 | if (maxcount - 16 < bytes_left) |
| 3348 | /* It was the fault of rd_maxcount: */ |
| 3349 | nfserr = nfserr_toosmall; |
| 3350 | else |
| 3351 | /* We ran out of buffer space: */ |
| 3352 | nfserr = nfserr_resource; |
| 3353 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3354 | if (nfserr) |
| 3355 | goto err_no_verf; |
| 3356 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3357 | if (readdir->cookie_offset) { |
| 3358 | wire_offset = cpu_to_be64(offset); |
| 3359 | write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, |
| 3360 | &wire_offset, 8); |
| 3361 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3362 | |
J. Bruce Fields | 561f0ed | 2014-01-20 16:37:11 -0500 | [diff] [blame] | 3363 | p = xdr_reserve_space(xdr, 8); |
| 3364 | if (!p) { |
| 3365 | WARN_ON_ONCE(1); |
| 3366 | goto err_no_verf; |
| 3367 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3368 | *p++ = 0; /* no more entries */ |
| 3369 | *p++ = htonl(readdir->common.err == nfserr_eof); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3370 | |
| 3371 | return 0; |
| 3372 | err_no_verf: |
J. Bruce Fields | 1fcea5b | 2014-02-26 20:17:02 -0500 | [diff] [blame] | 3373 | xdr_truncate_encode(xdr, starting_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3374 | return nfserr; |
| 3375 | } |
| 3376 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3377 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3378 | nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3379 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3380 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3381 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3382 | |
| 3383 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3384 | p = xdr_reserve_space(xdr, 20); |
| 3385 | if (!p) |
| 3386 | return nfserr_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 3387 | p = encode_cinfo(p, &remove->rm_cinfo); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3388 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3389 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3390 | } |
| 3391 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3392 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3393 | nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3394 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3395 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3396 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3397 | |
| 3398 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3399 | p = xdr_reserve_space(xdr, 40); |
| 3400 | if (!p) |
| 3401 | return nfserr_resource; |
J. Bruce Fields | d05d574 | 2014-03-22 18:48:39 -0400 | [diff] [blame] | 3402 | p = encode_cinfo(p, &rename->rn_sinfo); |
| 3403 | p = encode_cinfo(p, &rename->rn_tinfo); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3404 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3405 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3406 | } |
| 3407 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3408 | static __be32 |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3409 | nfsd4_do_encode_secinfo(struct xdr_stream *xdr, |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 3410 | __be32 nfserr, struct svc_export *exp) |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3411 | { |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3412 | u32 i, nflavs, supported; |
J. Bruce Fields | 4796f45 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3413 | struct exp_flavor_info *flavs; |
| 3414 | struct exp_flavor_info def_flavs[2]; |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3415 | __be32 *p, *flavorsp; |
| 3416 | static bool report = true; |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3417 | |
| 3418 | if (nfserr) |
| 3419 | goto out; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3420 | nfserr = nfserr_resource; |
J. Bruce Fields | 4796f45 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3421 | if (exp->ex_nflavors) { |
| 3422 | flavs = exp->ex_flavors; |
| 3423 | nflavs = exp->ex_nflavors; |
| 3424 | } else { /* Handling of some defaults in absence of real secinfo: */ |
| 3425 | flavs = def_flavs; |
| 3426 | if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { |
| 3427 | nflavs = 2; |
| 3428 | flavs[0].pseudoflavor = RPC_AUTH_UNIX; |
| 3429 | flavs[1].pseudoflavor = RPC_AUTH_NULL; |
| 3430 | } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { |
| 3431 | nflavs = 1; |
| 3432 | flavs[0].pseudoflavor |
| 3433 | = svcauth_gss_flavor(exp->ex_client); |
| 3434 | } else { |
| 3435 | nflavs = 1; |
| 3436 | flavs[0].pseudoflavor |
| 3437 | = exp->ex_client->flavour->flavour; |
| 3438 | } |
| 3439 | } |
| 3440 | |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3441 | supported = 0; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3442 | p = xdr_reserve_space(xdr, 4); |
| 3443 | if (!p) |
| 3444 | goto out; |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3445 | flavorsp = p++; /* to be backfilled later */ |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3446 | |
J. Bruce Fields | 4796f45 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3447 | for (i = 0; i < nflavs; i++) { |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3448 | rpc_authflavor_t pf = flavs[i].pseudoflavor; |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 3449 | struct rpcsec_gss_info info; |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3450 | |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3451 | if (rpcauth_get_gssinfo(pf, &info) == 0) { |
| 3452 | supported++; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3453 | p = xdr_reserve_space(xdr, 4 + 4 + |
| 3454 | XDR_LEN(info.oid.len) + 4 + 4); |
| 3455 | if (!p) |
| 3456 | goto out; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3457 | *p++ = cpu_to_be32(RPC_AUTH_GSS); |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3458 | p = xdr_encode_opaque(p, info.oid.data, info.oid.len); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3459 | *p++ = cpu_to_be32(info.qop); |
| 3460 | *p++ = cpu_to_be32(info.service); |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3461 | } else if (pf < RPC_AUTH_MAXFLAVOR) { |
| 3462 | supported++; |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3463 | p = xdr_reserve_space(xdr, 4); |
| 3464 | if (!p) |
| 3465 | goto out; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3466 | *p++ = cpu_to_be32(pf); |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3467 | } else { |
| 3468 | if (report) |
| 3469 | pr_warn("NFS: SECINFO: security flavor %u " |
| 3470 | "is not supported\n", pf); |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3471 | } |
| 3472 | } |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 3473 | |
Chuck Lever | 676e4eb | 2013-04-30 18:48:54 -0400 | [diff] [blame] | 3474 | if (nflavs != supported) |
| 3475 | report = false; |
| 3476 | *flavorsp = htonl(supported); |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3477 | nfserr = 0; |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3478 | out: |
| 3479 | if (exp) |
| 3480 | exp_put(exp); |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3481 | return nfserr; |
Andy Adamson | dcb488a3 | 2007-07-17 04:04:51 -0700 | [diff] [blame] | 3482 | } |
| 3483 | |
Mi Jinlong | 22b6dee | 2010-12-27 14:29:57 +0800 | [diff] [blame] | 3484 | static __be32 |
| 3485 | nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, |
| 3486 | struct nfsd4_secinfo *secinfo) |
| 3487 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3488 | struct xdr_stream *xdr = &resp->xdr; |
| 3489 | |
| 3490 | return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->si_exp); |
Mi Jinlong | 22b6dee | 2010-12-27 14:29:57 +0800 | [diff] [blame] | 3491 | } |
| 3492 | |
| 3493 | static __be32 |
| 3494 | nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, |
| 3495 | struct nfsd4_secinfo_no_name *secinfo) |
| 3496 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3497 | struct xdr_stream *xdr = &resp->xdr; |
| 3498 | |
| 3499 | return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->sin_exp); |
Mi Jinlong | 22b6dee | 2010-12-27 14:29:57 +0800 | [diff] [blame] | 3500 | } |
| 3501 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3502 | /* |
| 3503 | * The SETATTR encode routine is special -- it always encodes a bitmap, |
| 3504 | * regardless of the error status. |
| 3505 | */ |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3506 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3507 | nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3508 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3509 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3510 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3511 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3512 | p = xdr_reserve_space(xdr, 16); |
| 3513 | if (!p) |
| 3514 | return nfserr_resource; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3515 | if (nfserr) { |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3516 | *p++ = cpu_to_be32(3); |
| 3517 | *p++ = cpu_to_be32(0); |
| 3518 | *p++ = cpu_to_be32(0); |
| 3519 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3520 | } |
| 3521 | else { |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3522 | *p++ = cpu_to_be32(3); |
| 3523 | *p++ = cpu_to_be32(setattr->sa_bmval[0]); |
| 3524 | *p++ = cpu_to_be32(setattr->sa_bmval[1]); |
| 3525 | *p++ = cpu_to_be32(setattr->sa_bmval[2]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3526 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3527 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3528 | } |
| 3529 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3530 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3531 | nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3532 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3533 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3534 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3535 | |
| 3536 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3537 | p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE); |
| 3538 | if (!p) |
| 3539 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3540 | p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8); |
| 3541 | p = xdr_encode_opaque_fixed(p, &scd->se_confirm, |
| 3542 | NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3543 | } |
| 3544 | else if (nfserr == nfserr_clid_inuse) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3545 | p = xdr_reserve_space(xdr, 8); |
| 3546 | if (!p) |
| 3547 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3548 | *p++ = cpu_to_be32(0); |
| 3549 | *p++ = cpu_to_be32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3550 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3551 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3552 | } |
| 3553 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3554 | static __be32 |
Al Viro | b37ad28 | 2006-10-19 23:28:59 -0700 | [diff] [blame] | 3555 | nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3556 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3557 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3558 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3559 | |
| 3560 | if (!nfserr) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3561 | p = xdr_reserve_space(xdr, 16); |
| 3562 | if (!p) |
| 3563 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3564 | *p++ = cpu_to_be32(write->wr_bytes_written); |
| 3565 | *p++ = cpu_to_be32(write->wr_how_written); |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3566 | p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, |
| 3567 | NFS4_VERIFIER_SIZE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3568 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3569 | return nfserr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3570 | } |
| 3571 | |
J. Bruce Fields | 57266a6 | 2013-04-13 14:27:29 -0400 | [diff] [blame] | 3572 | static const u32 nfs4_minimal_spo_must_enforce[2] = { |
| 3573 | [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | |
| 3574 | 1 << (OP_EXCHANGE_ID - 32) | |
| 3575 | 1 << (OP_CREATE_SESSION - 32) | |
| 3576 | 1 << (OP_DESTROY_SESSION - 32) | |
| 3577 | 1 << (OP_DESTROY_CLIENTID - 32) |
| 3578 | }; |
| 3579 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3580 | static __be32 |
J. Bruce Fields | 57b7b43 | 2012-04-25 17:58:50 -0400 | [diff] [blame] | 3581 | nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3582 | struct nfsd4_exchange_id *exid) |
| 3583 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3584 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3585 | __be32 *p; |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3586 | char *major_id; |
| 3587 | char *server_scope; |
| 3588 | int major_id_sz; |
| 3589 | int server_scope_sz; |
| 3590 | uint64_t minor_id = 0; |
| 3591 | |
| 3592 | if (nfserr) |
| 3593 | return nfserr; |
| 3594 | |
| 3595 | major_id = utsname()->nodename; |
| 3596 | major_id_sz = strlen(major_id); |
| 3597 | server_scope = utsname()->nodename; |
| 3598 | server_scope_sz = strlen(server_scope); |
| 3599 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3600 | p = xdr_reserve_space(xdr, |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3601 | 8 /* eir_clientid */ + |
| 3602 | 4 /* eir_sequenceid */ + |
| 3603 | 4 /* eir_flags */ + |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3604 | 4 /* spr_how */); |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3605 | if (!p) |
| 3606 | return nfserr_resource; |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3607 | |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3608 | p = xdr_encode_opaque_fixed(p, &exid->clientid, 8); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3609 | *p++ = cpu_to_be32(exid->seqid); |
| 3610 | *p++ = cpu_to_be32(exid->flags); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3611 | |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3612 | *p++ = cpu_to_be32(exid->spa_how); |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3613 | |
J. Bruce Fields | 57266a6 | 2013-04-13 14:27:29 -0400 | [diff] [blame] | 3614 | switch (exid->spa_how) { |
| 3615 | case SP4_NONE: |
| 3616 | break; |
| 3617 | case SP4_MACH_CRED: |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3618 | /* spo_must_enforce, spo_must_allow */ |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3619 | p = xdr_reserve_space(xdr, 16); |
| 3620 | if (!p) |
| 3621 | return nfserr_resource; |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3622 | |
J. Bruce Fields | 57266a6 | 2013-04-13 14:27:29 -0400 | [diff] [blame] | 3623 | /* spo_must_enforce bitmap: */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3624 | *p++ = cpu_to_be32(2); |
| 3625 | *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[0]); |
| 3626 | *p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[1]); |
J. Bruce Fields | 57266a6 | 2013-04-13 14:27:29 -0400 | [diff] [blame] | 3627 | /* empty spo_must_allow bitmap: */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3628 | *p++ = cpu_to_be32(0); |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3629 | |
J. Bruce Fields | 57266a6 | 2013-04-13 14:27:29 -0400 | [diff] [blame] | 3630 | break; |
| 3631 | default: |
| 3632 | WARN_ON_ONCE(1); |
| 3633 | } |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3634 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3635 | p = xdr_reserve_space(xdr, |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3636 | 8 /* so_minor_id */ + |
| 3637 | 4 /* so_major_id.len */ + |
| 3638 | (XDR_QUADLEN(major_id_sz) * 4) + |
| 3639 | 4 /* eir_server_scope.len */ + |
| 3640 | (XDR_QUADLEN(server_scope_sz) * 4) + |
| 3641 | 4 /* eir_server_impl_id.count (0) */); |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3642 | if (!p) |
| 3643 | return nfserr_resource; |
Kinglong Mee | a8bb84b | 2013-12-10 15:24:36 +0800 | [diff] [blame] | 3644 | |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3645 | /* The server_owner struct */ |
J. Bruce Fields | b64c7f3 | 2014-03-22 17:11:35 -0400 | [diff] [blame] | 3646 | p = xdr_encode_hyper(p, minor_id); /* Minor id */ |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3647 | /* major id */ |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3648 | p = xdr_encode_opaque(p, major_id, major_id_sz); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3649 | |
| 3650 | /* Server scope */ |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3651 | p = xdr_encode_opaque(p, server_scope, server_scope_sz); |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3652 | |
| 3653 | /* Implementation id */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3654 | *p++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */ |
Andy Adamson | 0733d21 | 2009-04-03 08:28:01 +0300 | [diff] [blame] | 3655 | return 0; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3656 | } |
| 3657 | |
| 3658 | static __be32 |
J. Bruce Fields | 57b7b43 | 2012-04-25 17:58:50 -0400 | [diff] [blame] | 3659 | nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3660 | struct nfsd4_create_session *sess) |
| 3661 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3662 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3663 | __be32 *p; |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3664 | |
| 3665 | if (nfserr) |
| 3666 | return nfserr; |
| 3667 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3668 | p = xdr_reserve_space(xdr, 24); |
| 3669 | if (!p) |
| 3670 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3671 | p = xdr_encode_opaque_fixed(p, sess->sessionid.data, |
| 3672 | NFS4_MAX_SESSIONID_LEN); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3673 | *p++ = cpu_to_be32(sess->seqid); |
| 3674 | *p++ = cpu_to_be32(sess->flags); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3675 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3676 | p = xdr_reserve_space(xdr, 28); |
| 3677 | if (!p) |
| 3678 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3679 | *p++ = cpu_to_be32(0); /* headerpadsz */ |
| 3680 | *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); |
| 3681 | *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); |
| 3682 | *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); |
| 3683 | *p++ = cpu_to_be32(sess->fore_channel.maxops); |
| 3684 | *p++ = cpu_to_be32(sess->fore_channel.maxreqs); |
| 3685 | *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3686 | |
| 3687 | if (sess->fore_channel.nr_rdma_attrs) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3688 | p = xdr_reserve_space(xdr, 4); |
| 3689 | if (!p) |
| 3690 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3691 | *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3692 | } |
| 3693 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3694 | p = xdr_reserve_space(xdr, 28); |
| 3695 | if (!p) |
| 3696 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3697 | *p++ = cpu_to_be32(0); /* headerpadsz */ |
| 3698 | *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); |
| 3699 | *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); |
| 3700 | *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); |
| 3701 | *p++ = cpu_to_be32(sess->back_channel.maxops); |
| 3702 | *p++ = cpu_to_be32(sess->back_channel.maxreqs); |
| 3703 | *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3704 | |
| 3705 | if (sess->back_channel.nr_rdma_attrs) { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3706 | p = xdr_reserve_space(xdr, 4); |
| 3707 | if (!p) |
| 3708 | return nfserr_resource; |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3709 | *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); |
Andy Adamson | ec6b5d7 | 2009-04-03 08:28:28 +0300 | [diff] [blame] | 3710 | } |
| 3711 | return 0; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3712 | } |
| 3713 | |
| 3714 | static __be32 |
J. Bruce Fields | 57b7b43 | 2012-04-25 17:58:50 -0400 | [diff] [blame] | 3715 | nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3716 | struct nfsd4_sequence *seq) |
| 3717 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3718 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3719 | __be32 *p; |
Benny Halevy | b85d4c0 | 2009-04-03 08:28:08 +0300 | [diff] [blame] | 3720 | |
| 3721 | if (nfserr) |
| 3722 | return nfserr; |
| 3723 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3724 | p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20); |
| 3725 | if (!p) |
| 3726 | return nfserr_resource; |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3727 | p = xdr_encode_opaque_fixed(p, seq->sessionid.data, |
| 3728 | NFS4_MAX_SESSIONID_LEN); |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3729 | *p++ = cpu_to_be32(seq->seqid); |
| 3730 | *p++ = cpu_to_be32(seq->slotid); |
J. Bruce Fields | b7d7ca3 | 2011-08-31 15:39:30 -0400 | [diff] [blame] | 3731 | /* Note slotid's are numbered from zero: */ |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3732 | *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ |
| 3733 | *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ |
| 3734 | *p++ = cpu_to_be32(seq->status_flags); |
Benny Halevy | b85d4c0 | 2009-04-03 08:28:08 +0300 | [diff] [blame] | 3735 | |
J. Bruce Fields | f523601 | 2014-03-21 17:57:57 -0400 | [diff] [blame] | 3736 | resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ |
Benny Halevy | b85d4c0 | 2009-04-03 08:28:08 +0300 | [diff] [blame] | 3737 | return 0; |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3738 | } |
| 3739 | |
J. Bruce Fields | 2355c59 | 2012-04-25 16:56:22 -0400 | [diff] [blame] | 3740 | static __be32 |
J. Bruce Fields | 57b7b43 | 2012-04-25 17:58:50 -0400 | [diff] [blame] | 3741 | nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3742 | struct nfsd4_test_stateid *test_stateid) |
| 3743 | { |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3744 | struct xdr_stream *xdr = &resp->xdr; |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 3745 | struct nfsd4_test_stateid_id *stateid, *next; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3746 | __be32 *p; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3747 | |
J. Bruce Fields | a11fcce | 2014-02-03 16:31:42 -0500 | [diff] [blame] | 3748 | if (nfserr) |
| 3749 | return nfserr; |
| 3750 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3751 | p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids)); |
| 3752 | if (!p) |
| 3753 | return nfserr_resource; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3754 | *p++ = htonl(test_stateid->ts_num_ids); |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3755 | |
Bryan Schumaker | 03cfb42 | 2012-01-27 10:22:49 -0500 | [diff] [blame] | 3756 | list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { |
Al Viro | 02f5fde | 2012-04-13 00:10:34 -0400 | [diff] [blame] | 3757 | *p++ = stateid->ts_id_status; |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3758 | } |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3759 | |
| 3760 | return nfserr; |
| 3761 | } |
| 3762 | |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3763 | static __be32 |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3764 | nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p) |
| 3765 | { |
| 3766 | return nfserr; |
| 3767 | } |
| 3768 | |
| 3769 | typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *); |
| 3770 | |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3771 | /* |
| 3772 | * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1 |
| 3773 | * since we don't need to filter out obsolete ops as this is |
| 3774 | * done in the decoding phase. |
| 3775 | */ |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3776 | static nfsd4_enc nfsd4_enc_ops[] = { |
J. Bruce Fields | ad1060c | 2008-07-18 15:04:16 -0400 | [diff] [blame] | 3777 | [OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access, |
| 3778 | [OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close, |
| 3779 | [OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit, |
| 3780 | [OP_CREATE] = (nfsd4_enc)nfsd4_encode_create, |
| 3781 | [OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop, |
| 3782 | [OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop, |
| 3783 | [OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr, |
| 3784 | [OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh, |
| 3785 | [OP_LINK] = (nfsd4_enc)nfsd4_encode_link, |
| 3786 | [OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock, |
| 3787 | [OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt, |
| 3788 | [OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku, |
| 3789 | [OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop, |
| 3790 | [OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop, |
| 3791 | [OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop, |
| 3792 | [OP_OPEN] = (nfsd4_enc)nfsd4_encode_open, |
Benny Halevy | 84f09f4 | 2009-03-04 23:05:35 +0200 | [diff] [blame] | 3793 | [OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop, |
J. Bruce Fields | ad1060c | 2008-07-18 15:04:16 -0400 | [diff] [blame] | 3794 | [OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm, |
| 3795 | [OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade, |
| 3796 | [OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop, |
| 3797 | [OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop, |
| 3798 | [OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop, |
| 3799 | [OP_READ] = (nfsd4_enc)nfsd4_encode_read, |
| 3800 | [OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir, |
| 3801 | [OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink, |
| 3802 | [OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove, |
| 3803 | [OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename, |
| 3804 | [OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop, |
| 3805 | [OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop, |
| 3806 | [OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop, |
| 3807 | [OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo, |
| 3808 | [OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr, |
| 3809 | [OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid, |
| 3810 | [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop, |
| 3811 | [OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop, |
| 3812 | [OP_WRITE] = (nfsd4_enc)nfsd4_encode_write, |
| 3813 | [OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3814 | |
| 3815 | /* NFSv4.1 operations */ |
| 3816 | [OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop, |
J. Bruce Fields | 1d1bc8f | 2010-10-04 23:12:59 -0400 | [diff] [blame] | 3817 | [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3818 | [OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id, |
| 3819 | [OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session, |
Kinglong Mee | 43212cc | 2013-12-09 19:04:23 +0800 | [diff] [blame] | 3820 | [OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_noop, |
| 3821 | [OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_noop, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3822 | [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, |
| 3823 | [OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop, |
| 3824 | [OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop, |
| 3825 | [OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop, |
| 3826 | [OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop, |
| 3827 | [OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop, |
Mi Jinlong | 22b6dee | 2010-12-27 14:29:57 +0800 | [diff] [blame] | 3828 | [OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3829 | [OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence, |
| 3830 | [OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop, |
Bryan Schumaker | 1745680 | 2011-07-13 10:50:48 -0400 | [diff] [blame] | 3831 | [OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid, |
Andy Adamson | 2db134e | 2009-04-03 08:27:55 +0300 | [diff] [blame] | 3832 | [OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, |
| 3833 | [OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop, |
| 3834 | [OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop, |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3835 | }; |
| 3836 | |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3837 | /* |
J. Bruce Fields | a8095f7 | 2014-03-11 17:54:34 -0400 | [diff] [blame] | 3838 | * Calculate whether we still have space to encode repsize bytes. |
| 3839 | * There are two considerations: |
| 3840 | * - For NFS versions >=4.1, the size of the reply must stay within |
| 3841 | * session limits |
| 3842 | * - For all NFS versions, we must stay within limited preallocated |
| 3843 | * buffer space. |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3844 | * |
J. Bruce Fields | a8095f7 | 2014-03-11 17:54:34 -0400 | [diff] [blame] | 3845 | * This is called before the operation is processed, so can only provide |
| 3846 | * an upper estimate. For some nonidempotent operations (such as |
| 3847 | * getattr), it's not necessarily a problem if that estimate is wrong, |
| 3848 | * as we can fail it after processing without significant side effects. |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3849 | */ |
J. Bruce Fields | a8095f7 | 2014-03-11 17:54:34 -0400 | [diff] [blame] | 3850 | __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize) |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3851 | { |
J. Bruce Fields | 67492c9 | 2014-03-08 16:42:05 -0500 | [diff] [blame] | 3852 | struct xdr_buf *buf = &resp->rqstp->rq_res; |
J. Bruce Fields | 47ee529 | 2014-03-12 21:39:35 -0400 | [diff] [blame] | 3853 | struct nfsd4_slot *slot = resp->cstate.slot; |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3854 | |
J. Bruce Fields | 47ee529 | 2014-03-12 21:39:35 -0400 | [diff] [blame] | 3855 | if (buf->len + respsize <= buf->buflen) |
| 3856 | return nfs_ok; |
| 3857 | if (!nfsd4_has_session(&resp->cstate)) |
J. Bruce Fields | ea8d772 | 2014-03-08 17:19:55 -0500 | [diff] [blame] | 3858 | return nfserr_resource; |
J. Bruce Fields | 47ee529 | 2014-03-12 21:39:35 -0400 | [diff] [blame] | 3859 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { |
| 3860 | WARN_ON_ONCE(1); |
| 3861 | return nfserr_rep_too_big_to_cache; |
J. Bruce Fields | ea8d772 | 2014-03-08 17:19:55 -0500 | [diff] [blame] | 3862 | } |
J. Bruce Fields | 47ee529 | 2014-03-12 21:39:35 -0400 | [diff] [blame] | 3863 | return nfserr_rep_too_big; |
Andy Adamson | 496c262 | 2009-04-03 08:28:48 +0300 | [diff] [blame] | 3864 | } |
| 3865 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3866 | void |
| 3867 | nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) |
| 3868 | { |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3869 | struct xdr_stream *xdr = &resp->xdr; |
J. Bruce Fields | 9411b1d | 2013-04-01 16:37:12 -0400 | [diff] [blame] | 3870 | struct nfs4_stateowner *so = resp->cstate.replay_owner; |
J. Bruce Fields | 5f4ab94 | 2014-03-07 11:01:37 -0500 | [diff] [blame] | 3871 | struct svc_rqst *rqstp = resp->rqstp; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3872 | int post_err_offset; |
J. Bruce Fields | 07d1f80 | 2014-03-06 20:39:29 -0500 | [diff] [blame] | 3873 | nfsd4_enc encoder; |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3874 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3875 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3876 | p = xdr_reserve_space(xdr, 8); |
| 3877 | if (!p) { |
| 3878 | WARN_ON_ONCE(1); |
| 3879 | return; |
| 3880 | } |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3881 | *p++ = cpu_to_be32(op->opnum); |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3882 | post_err_offset = xdr->buf->len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3883 | |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3884 | if (op->opnum == OP_ILLEGAL) |
| 3885 | goto status; |
| 3886 | BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || |
| 3887 | !nfsd4_enc_ops[op->opnum]); |
J. Bruce Fields | 07d1f80 | 2014-03-06 20:39:29 -0500 | [diff] [blame] | 3888 | encoder = nfsd4_enc_ops[op->opnum]; |
| 3889 | op->status = encoder(resp, op->status, &op->u); |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 3890 | xdr_commit_encode(xdr); |
| 3891 | |
J. Bruce Fields | 067e1ac | 2014-03-21 17:26:44 -0400 | [diff] [blame] | 3892 | /* nfsd4_check_resp_size guarantees enough room for error status */ |
J. Bruce Fields | 5f4ab94 | 2014-03-07 11:01:37 -0500 | [diff] [blame] | 3893 | if (!op->status) { |
| 3894 | int space_needed = 0; |
| 3895 | if (!nfsd4_last_compound_op(rqstp)) |
| 3896 | space_needed = COMPOUND_ERR_SLACK_SPACE; |
| 3897 | op->status = nfsd4_check_resp_size(resp, space_needed); |
| 3898 | } |
J. Bruce Fields | c8f13d9 | 2014-05-08 17:38:18 -0400 | [diff] [blame] | 3899 | if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) { |
| 3900 | struct nfsd4_slot *slot = resp->cstate.slot; |
| 3901 | |
| 3902 | if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) |
| 3903 | op->status = nfserr_rep_too_big_to_cache; |
| 3904 | else |
| 3905 | op->status = nfserr_rep_too_big; |
| 3906 | } |
J. Bruce Fields | 07d1f80 | 2014-03-06 20:39:29 -0500 | [diff] [blame] | 3907 | if (op->status == nfserr_resource || |
| 3908 | op->status == nfserr_rep_too_big || |
| 3909 | op->status == nfserr_rep_too_big_to_cache) { |
| 3910 | /* |
| 3911 | * The operation may have already been encoded or |
| 3912 | * partially encoded. No op returns anything additional |
| 3913 | * in the case of one of these three errors, so we can |
| 3914 | * just truncate back to after the status. But it's a |
| 3915 | * bug if we had to do this on a non-idempotent op: |
| 3916 | */ |
| 3917 | warn_on_nonidempotent_op(op); |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3918 | xdr_truncate_encode(xdr, post_err_offset); |
J. Bruce Fields | 07d1f80 | 2014-03-06 20:39:29 -0500 | [diff] [blame] | 3919 | } |
J. Bruce Fields | 9411b1d | 2013-04-01 16:37:12 -0400 | [diff] [blame] | 3920 | if (so) { |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3921 | int len = xdr->buf->len - post_err_offset; |
| 3922 | |
J. Bruce Fields | 9411b1d | 2013-04-01 16:37:12 -0400 | [diff] [blame] | 3923 | so->so_replay.rp_status = op->status; |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3924 | so->so_replay.rp_buflen = len; |
| 3925 | read_bytes_from_xdr_buf(xdr->buf, post_err_offset, |
| 3926 | so->so_replay.rp_buf, len); |
J. Bruce Fields | 9411b1d | 2013-04-01 16:37:12 -0400 | [diff] [blame] | 3927 | } |
Benny Halevy | 695e12f | 2008-07-04 14:38:33 +0300 | [diff] [blame] | 3928 | status: |
J. Bruce Fields | 082d4bd | 2013-08-29 15:42:52 -0400 | [diff] [blame] | 3929 | /* Note that op->status is already in network byte order: */ |
| 3930 | write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3931 | } |
| 3932 | |
| 3933 | /* |
| 3934 | * Encode the reply stored in the stateowner reply cache |
| 3935 | * |
| 3936 | * XDR note: do not encode rp->rp_buflen: the buffer contains the |
| 3937 | * previously sent already encoded operation. |
| 3938 | * |
| 3939 | * called with nfs4_lock_state() held |
| 3940 | */ |
| 3941 | void |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3942 | nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3943 | { |
J. Bruce Fields | bc749ca | 2009-04-07 16:55:27 -0700 | [diff] [blame] | 3944 | __be32 *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3945 | struct nfs4_replay *rp = op->replay; |
| 3946 | |
| 3947 | BUG_ON(!rp); |
| 3948 | |
J. Bruce Fields | d0a381d | 2014-01-30 17:18:38 -0500 | [diff] [blame] | 3949 | p = xdr_reserve_space(xdr, 8 + rp->rp_buflen); |
| 3950 | if (!p) { |
| 3951 | WARN_ON_ONCE(1); |
| 3952 | return; |
| 3953 | } |
J. Bruce Fields | c373b0a | 2014-03-22 17:09:18 -0400 | [diff] [blame] | 3954 | *p++ = cpu_to_be32(op->opnum); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3955 | *p++ = rp->rp_status; /* already xdr'ed */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3956 | |
J. Bruce Fields | 0c0c267 | 2014-03-22 18:43:16 -0400 | [diff] [blame] | 3957 | p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3958 | } |
| 3959 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3960 | int |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 3961 | nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3962 | { |
| 3963 | return xdr_ressize_check(rqstp, p); |
| 3964 | } |
| 3965 | |
J. Bruce Fields | 3e98abf | 2011-07-16 17:15:10 -0400 | [diff] [blame] | 3966 | int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3967 | { |
J. Bruce Fields | 3e98abf | 2011-07-16 17:15:10 -0400 | [diff] [blame] | 3968 | struct svc_rqst *rqstp = rq; |
| 3969 | struct nfsd4_compoundargs *args = rqstp->rq_argp; |
| 3970 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3971 | if (args->ops != args->iops) { |
| 3972 | kfree(args->ops); |
| 3973 | args->ops = args->iops; |
| 3974 | } |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 3975 | kfree(args->tmpp); |
| 3976 | args->tmpp = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3977 | while (args->to_free) { |
| 3978 | struct tmpbuf *tb = args->to_free; |
| 3979 | args->to_free = tb->next; |
| 3980 | tb->release(tb->buf); |
| 3981 | kfree(tb); |
| 3982 | } |
J. Bruce Fields | 3e98abf | 2011-07-16 17:15:10 -0400 | [diff] [blame] | 3983 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3984 | } |
| 3985 | |
| 3986 | int |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 3987 | nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3988 | { |
Jeff Layton | e874f9f | 2014-03-10 11:34:55 -0400 | [diff] [blame] | 3989 | if (rqstp->rq_arg.head[0].iov_len % 4) { |
| 3990 | /* client is nuts */ |
| 3991 | dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)", |
| 3992 | __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid)); |
| 3993 | return 0; |
| 3994 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3995 | args->p = p; |
| 3996 | args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len; |
| 3997 | args->pagelist = rqstp->rq_arg.pages; |
| 3998 | args->pagelen = rqstp->rq_arg.page_len; |
| 3999 | args->tmpp = NULL; |
| 4000 | args->to_free = NULL; |
| 4001 | args->ops = args->iops; |
| 4002 | args->rqstp = rqstp; |
| 4003 | |
J. Bruce Fields | 3e98abf | 2011-07-16 17:15:10 -0400 | [diff] [blame] | 4004 | return !nfsd4_decode_compound(args); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4005 | } |
| 4006 | |
| 4007 | int |
Al Viro | 2ebbc01 | 2006-10-19 23:28:58 -0700 | [diff] [blame] | 4008 | nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4009 | { |
| 4010 | /* |
| 4011 | * All that remains is to write the tag and operation count... |
| 4012 | */ |
Andy Adamson | 557ce26 | 2009-08-28 08:45:04 -0400 | [diff] [blame] | 4013 | struct nfsd4_compound_state *cs = &resp->cstate; |
J. Bruce Fields | 6ac9039 | 2014-02-26 17:39:35 -0500 | [diff] [blame] | 4014 | struct xdr_buf *buf = resp->xdr.buf; |
| 4015 | |
| 4016 | WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len + |
| 4017 | buf->tail[0].iov_len); |
J. Bruce Fields | dd97fdd | 2014-02-26 17:16:27 -0500 | [diff] [blame] | 4018 | |
J. Bruce Fields | 2825a7f | 2013-08-26 16:04:46 -0400 | [diff] [blame] | 4019 | rqstp->rq_next_page = resp->xdr.page_ptr + 1; |
| 4020 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4021 | p = resp->tagp; |
| 4022 | *p++ = htonl(resp->taglen); |
| 4023 | memcpy(p, resp->tag, resp->taglen); |
| 4024 | p += XDR_QUADLEN(resp->taglen); |
| 4025 | *p++ = htonl(resp->opcnt); |
| 4026 | |
J. Bruce Fields | 26c0c75 | 2010-04-24 15:35:43 -0400 | [diff] [blame] | 4027 | if (nfsd4_has_session(cs)) { |
J. Bruce Fields | f0f51f5 | 2013-06-18 14:26:02 -0400 | [diff] [blame] | 4028 | struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); |
| 4029 | struct nfs4_client *clp = cs->session->se_client; |
J. Bruce Fields | 26c0c75 | 2010-04-24 15:35:43 -0400 | [diff] [blame] | 4030 | if (cs->status != nfserr_replay_cache) { |
| 4031 | nfsd4_store_cache_entry(resp); |
J. Bruce Fields | 73e7948 | 2012-02-13 16:39:00 -0500 | [diff] [blame] | 4032 | cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE; |
J. Bruce Fields | 26c0c75 | 2010-04-24 15:35:43 -0400 | [diff] [blame] | 4033 | } |
Benny Halevy | d768298 | 2010-05-12 00:13:54 +0300 | [diff] [blame] | 4034 | /* Renew the clientid on success and on replay */ |
J. Bruce Fields | f0f51f5 | 2013-06-18 14:26:02 -0400 | [diff] [blame] | 4035 | spin_lock(&nn->client_lock); |
J. Bruce Fields | 221a687 | 2013-04-01 22:23:49 -0400 | [diff] [blame] | 4036 | nfsd4_put_session(cs->session); |
J. Bruce Fields | f0f51f5 | 2013-06-18 14:26:02 -0400 | [diff] [blame] | 4037 | spin_unlock(&nn->client_lock); |
| 4038 | put_client_renew(clp); |
Andy Adamson | da3846a | 2009-04-03 08:28:22 +0300 | [diff] [blame] | 4039 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4040 | return 1; |
| 4041 | } |
| 4042 | |
| 4043 | /* |
| 4044 | * Local variables: |
| 4045 | * c-basic-offset: 8 |
| 4046 | * End: |
| 4047 | */ |