nfs4xdr.c 111.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 *  Server-side XDR for NFSv4
 *
 *  Copyright (c) 2002 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Kendrick Smith <kmsmith@umich.edu>
 *  Andy Adamson   <andros@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

36
#include <linux/slab.h>
L
Linus Torvalds 已提交
37
#include <linux/namei.h>
38
#include <linux/statfs.h>
A
Andy Adamson 已提交
39
#include <linux/utsname.h>
40
#include <linux/pagemap.h>
41
#include <linux/sunrpc/svcauth_gss.h>
42

43 44
#include "idmap.h"
#include "acl.h"
45
#include "xdr4.h"
46
#include "vfs.h"
47
#include "state.h"
48
#include "cache.h"
49
#include "netns.h"
50
#include "pnfs.h"
51

52 53 54 55 56
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
#include <linux/security.h>
#endif


L
Linus Torvalds 已提交
57 58
#define NFSDDBG_FACILITY		NFSDDBG_XDR

59 60 61 62 63 64 65 66
/*
 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
 * directory in order to indicate to the client that a filesystem boundary is present
 * We use a fixed fsid for a referral
 */
#define NFS4_REFERRAL_FSID_MAJOR	0x8000000ULL
#define NFS4_REFERRAL_FSID_MINOR	0x8000000ULL

67
static __be32
68
check_filename(char *str, int len)
L
Linus Torvalds 已提交
69 70 71 72 73 74
{
	int i;

	if (len == 0)
		return nfserr_inval;
	if (isdotent(str, len))
75
		return nfserr_badname;
L
Linus Torvalds 已提交
76 77
	for (i = 0; i < len; i++)
		if (str[i] == '/')
78
			return nfserr_badname;
L
Linus Torvalds 已提交
79 80 81 82
	return 0;
}

#define DECODE_HEAD				\
A
Al Viro 已提交
83
	__be32 *p;				\
84
	__be32 status
L
Linus Torvalds 已提交
85 86 87 88 89
#define DECODE_TAIL				\
	status = 0;				\
out:						\
	return status;				\
xdr_error:					\
90 91
	dprintk("NFSD: xdr error (%s:%d)\n",	\
			__FILE__, __LINE__);	\
L
Linus Torvalds 已提交
92 93 94 95 96 97 98 99 100 101 102
	status = nfserr_bad_xdr;		\
	goto out

#define READMEM(x,nbytes) do {			\
	x = (char *)p;				\
	p += XDR_QUADLEN(nbytes);		\
} while (0)
#define SAVEMEM(x,nbytes) do {			\
	if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
 		savemem(argp, p, nbytes) :	\
 		(char *)p)) {			\
103 104
		dprintk("NFSD: xdr error (%s:%d)\n", \
				__FILE__, __LINE__); \
L
Linus Torvalds 已提交
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
		goto xdr_error;			\
		}				\
	p += XDR_QUADLEN(nbytes);		\
} while (0)
#define COPYMEM(x,nbytes) do {			\
	memcpy((x), p, nbytes);			\
	p += XDR_QUADLEN(nbytes);		\
} while (0)

/* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */
#define READ_BUF(nbytes)  do {			\
	if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) {	\
		p = argp->p;			\
		argp->p += XDR_QUADLEN(nbytes);	\
	} else if (!(p = read_buf(argp, nbytes))) { \
120 121
		dprintk("NFSD: xdr error (%s:%d)\n", \
				__FILE__, __LINE__); \
L
Linus Torvalds 已提交
122 123 124 125
		goto xdr_error;			\
	}					\
} while (0)

J
J. Bruce Fields 已提交
126 127 128
static void next_decode_page(struct nfsd4_compoundargs *argp)
{
	argp->p = page_address(argp->pagelist[0]);
129
	argp->pagelist++;
J
J. Bruce Fields 已提交
130 131 132 133 134 135 136 137 138
	if (argp->pagelen < PAGE_SIZE) {
		argp->end = argp->p + (argp->pagelen>>2);
		argp->pagelen = 0;
	} else {
		argp->end = argp->p + (PAGE_SIZE>>2);
		argp->pagelen -= PAGE_SIZE;
	}
}

139
static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
L
Linus Torvalds 已提交
140 141 142 143
{
	/* We want more bytes than seem to be available.
	 * Maybe we need a new page, maybe we have just run out
	 */
144
	unsigned int avail = (char *)argp->end - (char *)argp->p;
A
Al Viro 已提交
145
	__be32 *p;
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153
	if (avail + argp->pagelen < nbytes)
		return NULL;
	if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
		return NULL;
	/* ok, we can do it with the current plus the next page */
	if (nbytes <= sizeof(argp->tmp))
		p = argp->tmp;
	else {
J
Jesper Juhl 已提交
154
		kfree(argp->tmpp);
L
Linus Torvalds 已提交
155 156 157 158 159
		p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
		if (!p)
			return NULL;
		
	}
160 161 162 163 164
	/*
	 * The following memcpy is safe because read_buf is always
	 * called with nbytes > avail, and the two cases above both
	 * guarantee p points to at least nbytes bytes.
	 */
L
Linus Torvalds 已提交
165
	memcpy(p, argp->p, avail);
J
J. Bruce Fields 已提交
166
	next_decode_page(argp);
L
Linus Torvalds 已提交
167 168 169 170 171
	memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
	argp->p += XDR_QUADLEN(nbytes - avail);
	return p;
}

A
Andy Adamson 已提交
172 173 174 175 176
static int zero_clientid(clientid_t *clid)
{
	return (clid->cl_boot == 0) && (clid->cl_id == 0);
}

177
/**
178
 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
179 180
 * @argp: NFSv4 compound argument structure
 * @p: pointer to be freed (with kfree())
181 182 183 184
 *
 * Marks @p to be freed when processing the compound operation
 * described in @argp finishes.
 */
185 186
static void *
svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
L
Linus Torvalds 已提交
187
{
188
	struct svcxdr_tmpbuf *tb;
L
Linus Torvalds 已提交
189

190
	tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
L
Linus Torvalds 已提交
191
	if (!tb)
192
		return NULL;
L
Linus Torvalds 已提交
193 194
	tb->next = argp->to_free;
	argp->to_free = tb;
195
	return tb->buf;
L
Linus Torvalds 已提交
196 197
}

198 199 200 201 202 203 204 205 206 207
/*
 * For xdr strings that need to be passed to other kernel api's
 * as null-terminated strings.
 *
 * Note null-terminating in place usually isn't safe since the
 * buffer might end on a page boundary.
 */
static char *
svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)
{
208
	char *p = svcxdr_tmpalloc(argp, len + 1);
209 210 211 212 213 214

	if (!p)
		return NULL;
	memcpy(p, buf, len);
	p[len] = '\0';
	return p;
L
Linus Torvalds 已提交
215 216
}

217 218 219 220 221 222 223 224 225 226
/**
 * savemem - duplicate a chunk of memory for later processing
 * @argp: NFSv4 compound argument structure to be freed with
 * @p: pointer to be duplicated
 * @nbytes: length to be duplicated
 *
 * Returns a pointer to a copy of @nbytes bytes of memory at @p
 * that are preserved until processing of the NFSv4 compound
 * operation described by @argp finishes.
 */
A
Al Viro 已提交
227
static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
L
Linus Torvalds 已提交
228
{
229 230 231 232
	void *ret;

	ret = svcxdr_tmpalloc(argp, nbytes);
	if (!ret)
L
Linus Torvalds 已提交
233
		return NULL;
234 235
	memcpy(ret, p, nbytes);
	return ret;
L
Linus Torvalds 已提交
236 237
}

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
/*
 * We require the high 32 bits of 'seconds' to be 0, and
 * we ignore all 32 bits of 'nseconds'.
 */
static __be32
nfsd4_decode_time(struct nfsd4_compoundargs *argp, struct timespec *tv)
{
	DECODE_HEAD;
	u64 sec;

	READ_BUF(12);
	p = xdr_decode_hyper(p, &sec);
	tv->tv_sec = sec;
	tv->tv_nsec = be32_to_cpup(p++);
	if (tv->tv_nsec >= (u32)1000000000)
		return nfserr_inval;

	DECODE_TAIL;
}

258
static __be32
L
Linus Torvalds 已提交
259 260 261 262 263 264 265
nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
{
	u32 bmlen;
	DECODE_HEAD;

	bmval[0] = 0;
	bmval[1] = 0;
266
	bmval[2] = 0;
L
Linus Torvalds 已提交
267 268

	READ_BUF(4);
J
J. Bruce Fields 已提交
269
	bmlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
270 271 272 273 274
	if (bmlen > 1000)
		goto xdr_error;

	READ_BUF(bmlen << 2);
	if (bmlen > 0)
J
J. Bruce Fields 已提交
275
		bmval[0] = be32_to_cpup(p++);
L
Linus Torvalds 已提交
276
	if (bmlen > 1)
J
J. Bruce Fields 已提交
277
		bmval[1] = be32_to_cpup(p++);
278
	if (bmlen > 2)
J
J. Bruce Fields 已提交
279
		bmval[2] = be32_to_cpup(p++);
L
Linus Torvalds 已提交
280 281 282 283

	DECODE_TAIL;
}

284
static __be32
285
nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
286 287
		   struct iattr *iattr, struct nfs4_acl **acl,
		   struct xdr_netobj *label)
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295 296 297 298
{
	int expected_len, len = 0;
	u32 dummy32;
	char *buf;

	DECODE_HEAD;
	iattr->ia_valid = 0;
	if ((status = nfsd4_decode_bitmap(argp, bmval)))
		return status;

	READ_BUF(4);
J
J. Bruce Fields 已提交
299
	expected_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
300 301 302 303

	if (bmval[0] & FATTR4_WORD0_SIZE) {
		READ_BUF(8);
		len += 8;
J
J. Bruce Fields 已提交
304
		p = xdr_decode_hyper(p, &iattr->ia_size);
L
Linus Torvalds 已提交
305 306 307
		iattr->ia_valid |= ATTR_SIZE;
	}
	if (bmval[0] & FATTR4_WORD0_ACL) {
308
		u32 nace;
309
		struct nfs4_ace *ace;
L
Linus Torvalds 已提交
310 311

		READ_BUF(4); len += 4;
J
J. Bruce Fields 已提交
312
		nace = be32_to_cpup(p++);
L
Linus Torvalds 已提交
313

314
		if (nace > NFS4_ACL_MAX)
315
			return nfserr_fbig;
316

317
		*acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace));
318 319 320
		if (*acl == NULL)
			return nfserr_jukebox;

321 322
		(*acl)->naces = nace;
		for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
L
Linus Torvalds 已提交
323
			READ_BUF(16); len += 16;
J
J. Bruce Fields 已提交
324 325 326 327
			ace->type = be32_to_cpup(p++);
			ace->flag = be32_to_cpup(p++);
			ace->access_mask = be32_to_cpup(p++);
			dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
328 329 330
			READ_BUF(dummy32);
			len += XDR_QUADLEN(dummy32) << 2;
			READMEM(buf, dummy32);
331
			ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
332
			status = nfs_ok;
333
			if (ace->whotype != NFS4_ACL_WHO_NAMED)
334
				;
335
			else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
336
				status = nfsd_map_name_to_gid(argp->rqstp,
337
						buf, dummy32, &ace->who_gid);
L
Linus Torvalds 已提交
338
			else
339
				status = nfsd_map_name_to_uid(argp->rqstp,
340
						buf, dummy32, &ace->who_uid);
341 342
			if (status)
				return status;
L
Linus Torvalds 已提交
343 344 345 346 347 348
		}
	} else
		*acl = NULL;
	if (bmval[1] & FATTR4_WORD1_MODE) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
349
		iattr->ia_mode = be32_to_cpup(p++);
L
Linus Torvalds 已提交
350 351 352 353 354 355
		iattr->ia_mode &= (S_IFMT | S_IALLUGO);
		iattr->ia_valid |= ATTR_MODE;
	}
	if (bmval[1] & FATTR4_WORD1_OWNER) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
356
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
357 358 359
		READ_BUF(dummy32);
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
360 361
		if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
			return status;
L
Linus Torvalds 已提交
362 363 364 365 366
		iattr->ia_valid |= ATTR_UID;
	}
	if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
367
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
368 369 370
		READ_BUF(dummy32);
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
371 372
		if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
			return status;
L
Linus Torvalds 已提交
373 374 375 376 377
		iattr->ia_valid |= ATTR_GID;
	}
	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
378
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
379 380 381
		switch (dummy32) {
		case NFS4_SET_TO_CLIENT_TIME:
			len += 12;
382 383 384
			status = nfsd4_decode_time(argp, &iattr->ia_atime);
			if (status)
				return status;
L
Linus Torvalds 已提交
385 386 387 388 389 390 391 392 393 394 395 396
			iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
			break;
		case NFS4_SET_TO_SERVER_TIME:
			iattr->ia_valid |= ATTR_ATIME;
			break;
		default:
			goto xdr_error;
		}
	}
	if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
397
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
398 399 400
		switch (dummy32) {
		case NFS4_SET_TO_CLIENT_TIME:
			len += 12;
401 402 403
			status = nfsd4_decode_time(argp, &iattr->ia_mtime);
			if (status)
				return status;
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411 412
			iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
			break;
		case NFS4_SET_TO_SERVER_TIME:
			iattr->ia_valid |= ATTR_MTIME;
			break;
		default:
			goto xdr_error;
		}
	}
413 414 415 416 417 418

	label->len = 0;
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
	if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
419
		dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */
420 421
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
422
		dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */
423 424
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
425
		dummy32 = be32_to_cpup(p++);
426 427 428 429 430
		READ_BUF(dummy32);
		if (dummy32 > NFSD4_MAX_SEC_LABEL_LEN)
			return nfserr_badlabel;
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
431 432
		label->len = dummy32;
		label->data = svcxdr_dupstr(argp, buf, dummy32);
433 434 435 436 437
		if (!label->data)
			return nfserr_jukebox;
	}
#endif

438 439 440 441 442
	if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
	    || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
	    || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2)
		READ_BUF(expected_len - len);
	else if (len != expected_len)
L
Linus Torvalds 已提交
443 444 445 446 447
		goto xdr_error;

	DECODE_TAIL;
}

448 449 450 451 452 453
static __be32
nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
{
	DECODE_HEAD;

	READ_BUF(sizeof(stateid_t));
J
J. Bruce Fields 已提交
454
	sid->si_generation = be32_to_cpup(p++);
455 456 457 458 459
	COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

	DECODE_TAIL;
}

460
static __be32
L
Linus Torvalds 已提交
461 462 463 464 465
nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
466
	access->ac_req_access = be32_to_cpup(p++);
L
Linus Torvalds 已提交
467 468 469 470

	DECODE_TAIL;
}

471 472 473
static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
{
	DECODE_HEAD;
474
	u32 dummy, uid, gid;
475 476 477 478 479 480
	char *machine_name;
	int i;
	int nr_secflavs;

	/* callback_sec_params4 */
	READ_BUF(4);
J
J. Bruce Fields 已提交
481
	nr_secflavs = be32_to_cpup(p++);
482 483 484 485 486
	if (nr_secflavs)
		cbs->flavor = (u32)(-1);
	else
		/* Is this legal? Be generous, take it to mean AUTH_NONE: */
		cbs->flavor = 0;
487 488
	for (i = 0; i < nr_secflavs; ++i) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
489
		dummy = be32_to_cpup(p++);
490 491 492
		switch (dummy) {
		case RPC_AUTH_NULL:
			/* Nothing to read */
493 494
			if (cbs->flavor == (u32)(-1))
				cbs->flavor = RPC_AUTH_NULL;
495 496 497 498
			break;
		case RPC_AUTH_UNIX:
			READ_BUF(8);
			/* stamp */
J
J. Bruce Fields 已提交
499
			dummy = be32_to_cpup(p++);
500 501

			/* machine name */
J
J. Bruce Fields 已提交
502
			dummy = be32_to_cpup(p++);
503 504 505 506 507
			READ_BUF(dummy);
			SAVEMEM(machine_name, dummy);

			/* uid, gid */
			READ_BUF(8);
J
J. Bruce Fields 已提交
508 509
			uid = be32_to_cpup(p++);
			gid = be32_to_cpup(p++);
510 511 512

			/* more gids */
			READ_BUF(4);
J
J. Bruce Fields 已提交
513
			dummy = be32_to_cpup(p++);
514
			READ_BUF(dummy * 4);
515
			if (cbs->flavor == (u32)(-1)) {
516 517 518 519 520 521 522 523 524 525
				kuid_t kuid = make_kuid(&init_user_ns, uid);
				kgid_t kgid = make_kgid(&init_user_ns, gid);
				if (uid_valid(kuid) && gid_valid(kgid)) {
					cbs->uid = kuid;
					cbs->gid = kgid;
					cbs->flavor = RPC_AUTH_UNIX;
				} else {
					dprintk("RPC_AUTH_UNIX with invalid"
						"uid or gid ignoring!\n");
				}
526
			}
527 528 529 530 531 532
			break;
		case RPC_AUTH_GSS:
			dprintk("RPC_AUTH_GSS callback secflavor "
				"not supported!\n");
			READ_BUF(8);
			/* gcbp_service */
J
J. Bruce Fields 已提交
533
			dummy = be32_to_cpup(p++);
534
			/* gcbp_handle_from_server */
J
J. Bruce Fields 已提交
535
			dummy = be32_to_cpup(p++);
536 537 538 539
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
			/* gcbp_handle_from_client */
			READ_BUF(4);
J
J. Bruce Fields 已提交
540
			dummy = be32_to_cpup(p++);
541 542 543 544 545 546 547 548 549 550
			READ_BUF(dummy);
			break;
		default:
			dprintk("Illegal callback secflavor\n");
			return nfserr_inval;
		}
	}
	DECODE_TAIL;
}

551 552 553 554 555
static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
556
	bc->bc_cb_program = be32_to_cpup(p++);
557 558 559 560 561
	nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);

	DECODE_TAIL;
}

562 563 564 565 566 567
static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
{
	DECODE_HEAD;

	READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);
	COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
568
	bcts->dir = be32_to_cpup(p++);
569 570
	/* XXX: skipping ctsa_use_conn_in_rdma_mode.  Perhaps Tom Tucker
	 * could help us figure out we should be using it. */
571 572 573
	DECODE_TAIL;
}

574
static __be32
L
Linus Torvalds 已提交
575 576 577 578
nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
{
	DECODE_HEAD;

579
	READ_BUF(4);
J
J. Bruce Fields 已提交
580
	close->cl_seqid = be32_to_cpup(p++);
581
	return nfsd4_decode_stateid(argp, &close->cl_stateid);
L
Linus Torvalds 已提交
582 583 584 585 586

	DECODE_TAIL;
}


587
static __be32
L
Linus Torvalds 已提交
588 589 590 591 592
nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
{
	DECODE_HEAD;

	READ_BUF(12);
J
J. Bruce Fields 已提交
593
	p = xdr_decode_hyper(p, &commit->co_offset);
J
J. Bruce Fields 已提交
594
	commit->co_count = be32_to_cpup(p++);
L
Linus Torvalds 已提交
595 596 597 598

	DECODE_TAIL;
}

599
static __be32
L
Linus Torvalds 已提交
600 601 602 603 604
nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
605
	create->cr_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
606 607 608
	switch (create->cr_type) {
	case NF4LNK:
		READ_BUF(4);
609 610
		create->cr_datalen = be32_to_cpup(p++);
		READ_BUF(create->cr_datalen);
611
		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
612
		if (!create->cr_data)
613
			return nfserr_jukebox;
L
Linus Torvalds 已提交
614 615 616 617
		break;
	case NF4BLK:
	case NF4CHR:
		READ_BUF(8);
J
J. Bruce Fields 已提交
618 619
		create->cr_specdata1 = be32_to_cpup(p++);
		create->cr_specdata2 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
620 621 622 623 624 625 626 627 628
		break;
	case NF4SOCK:
	case NF4FIFO:
	case NF4DIR:
	default:
		break;
	}

	READ_BUF(4);
J
J. Bruce Fields 已提交
629
	create->cr_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
630 631
	READ_BUF(create->cr_namelen);
	SAVEMEM(create->cr_name, create->cr_namelen);
632
	if ((status = check_filename(create->cr_name, create->cr_namelen)))
L
Linus Torvalds 已提交
633 634
		return status;

635
	status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
636
				    &create->cr_acl, &create->cr_label);
637
	if (status)
L
Linus Torvalds 已提交
638 639 640 641 642
		goto out;

	DECODE_TAIL;
}

643
static inline __be32
L
Linus Torvalds 已提交
644 645
nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
{
646
	return nfsd4_decode_stateid(argp, &dr->dr_stateid);
L
Linus Torvalds 已提交
647 648
}

649
static inline __be32
L
Linus Torvalds 已提交
650 651 652 653 654
nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
{
	return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
}

655
static __be32
L
Linus Torvalds 已提交
656 657 658 659 660
nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
661
	link->li_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
662 663
	READ_BUF(link->li_namelen);
	SAVEMEM(link->li_name, link->li_namelen);
664
	if ((status = check_filename(link->li_name, link->li_namelen)))
L
Linus Torvalds 已提交
665 666 667 668 669
		return status;

	DECODE_TAIL;
}

670
static __be32
L
Linus Torvalds 已提交
671 672 673 674 675 676 677 678
nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
{
	DECODE_HEAD;

	/*
	* type, reclaim(boolean), offset, length, new_lock_owner(boolean)
	*/
	READ_BUF(28);
J
J. Bruce Fields 已提交
679
	lock->lk_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
680 681
	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
682
	lock->lk_reclaim = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
683 684
	p = xdr_decode_hyper(p, &lock->lk_offset);
	p = xdr_decode_hyper(p, &lock->lk_length);
J
J. Bruce Fields 已提交
685
	lock->lk_is_new = be32_to_cpup(p++);
L
Linus Torvalds 已提交
686 687

	if (lock->lk_is_new) {
688
		READ_BUF(4);
J
J. Bruce Fields 已提交
689
		lock->lk_new_open_seqid = be32_to_cpup(p++);
690 691 692 693
		status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
		if (status)
			return status;
		READ_BUF(8 + sizeof(clientid_t));
J
J. Bruce Fields 已提交
694
		lock->lk_new_lock_seqid = be32_to_cpup(p++);
L
Linus Torvalds 已提交
695
		COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
J
J. Bruce Fields 已提交
696
		lock->lk_new_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
697 698 699
		READ_BUF(lock->lk_new_owner.len);
		READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
	} else {
700 701 702 703
		status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
		if (status)
			return status;
		READ_BUF(4);
J
J. Bruce Fields 已提交
704
		lock->lk_old_lock_seqid = be32_to_cpup(p++);
L
Linus Torvalds 已提交
705 706 707 708 709
	}

	DECODE_TAIL;
}

710
static __be32
L
Linus Torvalds 已提交
711 712 713 714 715
nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
{
	DECODE_HEAD;
		        
	READ_BUF(32);
J
J. Bruce Fields 已提交
716
	lockt->lt_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
717 718
	if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
719 720
	p = xdr_decode_hyper(p, &lockt->lt_offset);
	p = xdr_decode_hyper(p, &lockt->lt_length);
L
Linus Torvalds 已提交
721
	COPYMEM(&lockt->lt_clientid, 8);
J
J. Bruce Fields 已提交
722
	lockt->lt_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
723 724 725 726 727 728
	READ_BUF(lockt->lt_owner.len);
	READMEM(lockt->lt_owner.data, lockt->lt_owner.len);

	DECODE_TAIL;
}

729
static __be32
L
Linus Torvalds 已提交
730 731 732 733
nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
{
	DECODE_HEAD;

734
	READ_BUF(8);
J
J. Bruce Fields 已提交
735
	locku->lu_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
736 737
	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
738
	locku->lu_seqid = be32_to_cpup(p++);
739 740 741 742
	status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
	if (status)
		return status;
	READ_BUF(16);
J
J. Bruce Fields 已提交
743 744
	p = xdr_decode_hyper(p, &locku->lu_offset);
	p = xdr_decode_hyper(p, &locku->lu_length);
L
Linus Torvalds 已提交
745 746 747 748

	DECODE_TAIL;
}

749
static __be32
L
Linus Torvalds 已提交
750 751 752 753 754
nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
755
	lookup->lo_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
756 757
	READ_BUF(lookup->lo_len);
	SAVEMEM(lookup->lo_name, lookup->lo_len);
758
	if ((status = check_filename(lookup->lo_name, lookup->lo_len)))
L
Linus Torvalds 已提交
759 760 761 762 763
		return status;

	DECODE_TAIL;
}

764
static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
765 766 767 768 769
{
	__be32 *p;
	u32 w;

	READ_BUF(4);
J
J. Bruce Fields 已提交
770
	w = be32_to_cpup(p++);
771 772 773 774 775
	*share_access = w & NFS4_SHARE_ACCESS_MASK;
	*deleg_want = w & NFS4_SHARE_WANT_MASK;
	if (deleg_when)
		*deleg_when = w & NFS4_SHARE_WHEN_MASK;

776 777 778 779 780 781 782 783
	switch (w & NFS4_SHARE_ACCESS_MASK) {
	case NFS4_SHARE_ACCESS_READ:
	case NFS4_SHARE_ACCESS_WRITE:
	case NFS4_SHARE_ACCESS_BOTH:
		break;
	default:
		return nfserr_bad_xdr;
	}
784
	w &= ~NFS4_SHARE_ACCESS_MASK;
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
	if (!w)
		return nfs_ok;
	if (!argp->minorversion)
		return nfserr_bad_xdr;
	switch (w & NFS4_SHARE_WANT_MASK) {
	case NFS4_SHARE_WANT_NO_PREFERENCE:
	case NFS4_SHARE_WANT_READ_DELEG:
	case NFS4_SHARE_WANT_WRITE_DELEG:
	case NFS4_SHARE_WANT_ANY_DELEG:
	case NFS4_SHARE_WANT_NO_DELEG:
	case NFS4_SHARE_WANT_CANCEL:
		break;
	default:
		return nfserr_bad_xdr;
	}
800
	w &= ~NFS4_SHARE_WANT_MASK;
801 802
	if (!w)
		return nfs_ok;
803 804 805

	if (!deleg_when)	/* open_downgrade */
		return nfserr_inval;
806 807 808
	switch (w) {
	case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
	case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
809 810
	case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
	      NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
811 812 813 814 815 816 817 818 819 820 821
		return nfs_ok;
	}
xdr_error:
	return nfserr_bad_xdr;
}

static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)
{
	__be32 *p;

	READ_BUF(4);
J
J. Bruce Fields 已提交
822
	*x = be32_to_cpup(p++);
823
	/* Note: unlinke access bits, deny bits may be zero. */
824
	if (*x & ~NFS4_SHARE_DENY_BOTH)
825 826 827 828 829 830
		return nfserr_bad_xdr;
	return nfs_ok;
xdr_error:
	return nfserr_bad_xdr;
}

831 832 833 834 835
static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
{
	__be32 *p;

	READ_BUF(4);
J
J. Bruce Fields 已提交
836
	o->len = be32_to_cpup(p++);
837 838 839 840 841 842 843 844 845 846 847

	if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT)
		return nfserr_bad_xdr;

	READ_BUF(o->len);
	SAVEMEM(o->data, o->len);
	return nfs_ok;
xdr_error:
	return nfserr_bad_xdr;
}

848
static __be32
L
Linus Torvalds 已提交
849 850 851
nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
{
	DECODE_HEAD;
852
	u32 dummy;
L
Linus Torvalds 已提交
853 854 855

	memset(open->op_bmval, 0, sizeof(open->op_bmval));
	open->op_iattr.ia_valid = 0;
856
	open->op_openowner = NULL;
L
Linus Torvalds 已提交
857

858
	open->op_xdr_error = 0;
L
Linus Torvalds 已提交
859
	/* seqid, share_access, share_deny, clientid, ownerlen */
860
	READ_BUF(4);
J
J. Bruce Fields 已提交
861
	open->op_seqid = be32_to_cpup(p++);
862 863 864
	/* decode, yet ignore deleg_when until supported */
	status = nfsd4_decode_share_access(argp, &open->op_share_access,
					   &open->op_deleg_want, &dummy);
865 866 867 868 869
	if (status)
		goto xdr_error;
	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
	if (status)
		goto xdr_error;
870
	READ_BUF(sizeof(clientid_t));
L
Linus Torvalds 已提交
871
	COPYMEM(&open->op_clientid, sizeof(clientid_t));
872 873 874 875
	status = nfsd4_decode_opaque(argp, &open->op_owner);
	if (status)
		goto xdr_error;
	READ_BUF(4);
J
J. Bruce Fields 已提交
876
	open->op_create = be32_to_cpup(p++);
L
Linus Torvalds 已提交
877 878 879 880 881
	switch (open->op_create) {
	case NFS4_OPEN_NOCREATE:
		break;
	case NFS4_OPEN_CREATE:
		READ_BUF(4);
J
J. Bruce Fields 已提交
882
		open->op_createmode = be32_to_cpup(p++);
L
Linus Torvalds 已提交
883 884 885
		switch (open->op_createmode) {
		case NFS4_CREATE_UNCHECKED:
		case NFS4_CREATE_GUARDED:
886
			status = nfsd4_decode_fattr(argp, open->op_bmval,
887
				&open->op_iattr, &open->op_acl, &open->op_label);
888
			if (status)
L
Linus Torvalds 已提交
889 890 891
				goto out;
			break;
		case NFS4_CREATE_EXCLUSIVE:
892 893
			READ_BUF(NFS4_VERIFIER_SIZE);
			COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
894
			break;
B
Benny Halevy 已提交
895 896 897
		case NFS4_CREATE_EXCLUSIVE4_1:
			if (argp->minorversion < 1)
				goto xdr_error;
898 899
			READ_BUF(NFS4_VERIFIER_SIZE);
			COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
B
Benny Halevy 已提交
900
			status = nfsd4_decode_fattr(argp, open->op_bmval,
901
				&open->op_iattr, &open->op_acl, &open->op_label);
B
Benny Halevy 已提交
902 903 904
			if (status)
				goto out;
			break;
L
Linus Torvalds 已提交
905 906 907 908 909 910 911 912 913 914
		default:
			goto xdr_error;
		}
		break;
	default:
		goto xdr_error;
	}

	/* open_claim */
	READ_BUF(4);
J
J. Bruce Fields 已提交
915
	open->op_claim_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
916 917 918 919
	switch (open->op_claim_type) {
	case NFS4_OPEN_CLAIM_NULL:
	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
		READ_BUF(4);
J
J. Bruce Fields 已提交
920
		open->op_fname.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
921 922
		READ_BUF(open->op_fname.len);
		SAVEMEM(open->op_fname.data, open->op_fname.len);
923
		if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
L
Linus Torvalds 已提交
924 925 926 927
			return status;
		break;
	case NFS4_OPEN_CLAIM_PREVIOUS:
		READ_BUF(4);
J
J. Bruce Fields 已提交
928
		open->op_delegate_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
929 930
		break;
	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
931 932 933 934
		status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
		if (status)
			return status;
		READ_BUF(4);
J
J. Bruce Fields 已提交
935
		open->op_fname.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
936 937
		READ_BUF(open->op_fname.len);
		SAVEMEM(open->op_fname.data, open->op_fname.len);
938
		if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
L
Linus Torvalds 已提交
939 940
			return status;
		break;
941 942 943 944 945 946 947 948 949 950 951 952 953
	case NFS4_OPEN_CLAIM_FH:
	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
		if (argp->minorversion < 1)
			goto xdr_error;
		/* void */
		break;
	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
		if (argp->minorversion < 1)
			goto xdr_error;
		status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
		if (status)
			return status;
		break;
L
Linus Torvalds 已提交
954 955 956 957 958 959 960
	default:
		goto xdr_error;
	}

	DECODE_TAIL;
}

961
static __be32
L
Linus Torvalds 已提交
962 963 964
nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
{
	DECODE_HEAD;
965 966 967 968

	if (argp->minorversion >= 1)
		return nfserr_notsupp;

969 970 971 972
	status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
	if (status)
		return status;
	READ_BUF(4);
J
J. Bruce Fields 已提交
973
	open_conf->oc_seqid = be32_to_cpup(p++);
974

L
Linus Torvalds 已提交
975 976 977
	DECODE_TAIL;
}

978
static __be32
L
Linus Torvalds 已提交
979 980 981 982
nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
{
	DECODE_HEAD;
		    
983 984 985
	status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
	if (status)
		return status;
986
	READ_BUF(4);
J
J. Bruce Fields 已提交
987
	open_down->od_seqid = be32_to_cpup(p++);
988 989
	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
					   &open_down->od_deleg_want, NULL);
990 991 992 993 994
	if (status)
		return status;
	status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
	if (status)
		return status;
L
Linus Torvalds 已提交
995 996 997
	DECODE_TAIL;
}

998
static __be32
L
Linus Torvalds 已提交
999 1000 1001 1002 1003
nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1004
	putfh->pf_fhlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010 1011 1012
	if (putfh->pf_fhlen > NFS4_FHSIZE)
		goto xdr_error;
	READ_BUF(putfh->pf_fhlen);
	SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);

	DECODE_TAIL;
}

1013 1014 1015 1016 1017 1018 1019 1020
static __be32
nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p)
{
	if (argp->minorversion == 0)
		return nfs_ok;
	return nfserr_notsupp;
}

1021
static __be32
L
Linus Torvalds 已提交
1022 1023 1024 1025
nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
{
	DECODE_HEAD;

1026 1027 1028 1029
	status = nfsd4_decode_stateid(argp, &read->rd_stateid);
	if (status)
		return status;
	READ_BUF(12);
J
J. Bruce Fields 已提交
1030
	p = xdr_decode_hyper(p, &read->rd_offset);
J
J. Bruce Fields 已提交
1031
	read->rd_length = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1032 1033 1034 1035

	DECODE_TAIL;
}

1036
static __be32
L
Linus Torvalds 已提交
1037 1038 1039 1040 1041
nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
{
	DECODE_HEAD;

	READ_BUF(24);
J
J. Bruce Fields 已提交
1042
	p = xdr_decode_hyper(p, &readdir->rd_cookie);
L
Linus Torvalds 已提交
1043
	COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
J
J. Bruce Fields 已提交
1044 1045
	readdir->rd_dircount = be32_to_cpup(p++);
	readdir->rd_maxcount = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051
	if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
		goto out;

	DECODE_TAIL;
}

1052
static __be32
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057
nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1058
	remove->rm_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1059 1060
	READ_BUF(remove->rm_namelen);
	SAVEMEM(remove->rm_name, remove->rm_namelen);
1061
	if ((status = check_filename(remove->rm_name, remove->rm_namelen)))
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066
		return status;

	DECODE_TAIL;
}

1067
static __be32
L
Linus Torvalds 已提交
1068 1069 1070 1071 1072
nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1073
	rename->rn_snamelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1074 1075
	READ_BUF(rename->rn_snamelen + 4);
	SAVEMEM(rename->rn_sname, rename->rn_snamelen);
J
J. Bruce Fields 已提交
1076
	rename->rn_tnamelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1077 1078
	READ_BUF(rename->rn_tnamelen);
	SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
1079
	if ((status = check_filename(rename->rn_sname, rename->rn_snamelen)))
L
Linus Torvalds 已提交
1080
		return status;
1081
	if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen)))
L
Linus Torvalds 已提交
1082 1083 1084 1085 1086
		return status;

	DECODE_TAIL;
}

1087
static __be32
L
Linus Torvalds 已提交
1088 1089 1090 1091
nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
{
	DECODE_HEAD;

1092 1093 1094
	if (argp->minorversion >= 1)
		return nfserr_notsupp;

L
Linus Torvalds 已提交
1095 1096 1097 1098 1099 1100
	READ_BUF(sizeof(clientid_t));
	COPYMEM(clientid, sizeof(clientid_t));

	DECODE_TAIL;
}

A
Andy Adamson 已提交
1101 1102 1103 1104 1105 1106 1107
static __be32
nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
		     struct nfsd4_secinfo *secinfo)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1108
	secinfo->si_namelen = be32_to_cpup(p++);
A
Andy Adamson 已提交
1109 1110
	READ_BUF(secinfo->si_namelen);
	SAVEMEM(secinfo->si_name, secinfo->si_namelen);
1111
	status = check_filename(secinfo->si_name, secinfo->si_namelen);
A
Andy Adamson 已提交
1112 1113 1114 1115 1116
	if (status)
		return status;
	DECODE_TAIL;
}

J
J. Bruce Fields 已提交
1117 1118 1119 1120 1121 1122 1123
static __be32
nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
		     struct nfsd4_secinfo_no_name *sin)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1124
	sin->sin_style = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
1125 1126 1127
	DECODE_TAIL;
}

1128
static __be32
L
Linus Torvalds 已提交
1129 1130
nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
{
1131
	__be32 status;
L
Linus Torvalds 已提交
1132

1133 1134 1135
	status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
	if (status)
		return status;
1136
	return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
1137
				  &setattr->sa_acl, &setattr->sa_label);
L
Linus Torvalds 已提交
1138 1139
}

1140
static __be32
L
Linus Torvalds 已提交
1141 1142 1143 1144
nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
{
	DECODE_HEAD;

1145 1146 1147
	if (argp->minorversion >= 1)
		return nfserr_notsupp;

1148 1149
	READ_BUF(NFS4_VERIFIER_SIZE);
	COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1150

1151 1152 1153 1154
	status = nfsd4_decode_opaque(argp, &setclientid->se_name);
	if (status)
		return nfserr_bad_xdr;
	READ_BUF(8);
J
J. Bruce Fields 已提交
1155 1156
	setclientid->se_callback_prog = be32_to_cpup(p++);
	setclientid->se_callback_netid_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1157 1158 1159

	READ_BUF(setclientid->se_callback_netid_len + 4);
	SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
J
J. Bruce Fields 已提交
1160
	setclientid->se_callback_addr_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1161 1162 1163

	READ_BUF(setclientid->se_callback_addr_len + 4);
	SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
J
J. Bruce Fields 已提交
1164
	setclientid->se_callback_ident = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1165 1166 1167 1168

	DECODE_TAIL;
}

1169
static __be32
L
Linus Torvalds 已提交
1170 1171 1172 1173
nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
{
	DECODE_HEAD;

1174 1175 1176
	if (argp->minorversion >= 1)
		return nfserr_notsupp;

1177
	READ_BUF(8 + NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1178
	COPYMEM(&scd_c->sc_clientid, 8);
1179
	COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184

	DECODE_TAIL;
}

/* Also used for NVERIFY */
1185
static __be32
L
Linus Torvalds 已提交
1186 1187 1188 1189 1190 1191 1192 1193
nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)
{
	DECODE_HEAD;

	if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval)))
		goto out;

	/* For convenience's sake, we compare raw xdr'd attributes in
1194 1195
	 * nfsd4_proc_verify */

L
Linus Torvalds 已提交
1196
	READ_BUF(4);
J
J. Bruce Fields 已提交
1197
	verify->ve_attrlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203
	READ_BUF(verify->ve_attrlen);
	SAVEMEM(verify->ve_attrval, verify->ve_attrlen);

	DECODE_TAIL;
}

1204
static __be32
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209 1210
nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
{
	int avail;
	int len;
	DECODE_HEAD;

1211 1212 1213 1214
	status = nfsd4_decode_stateid(argp, &write->wr_stateid);
	if (status)
		return status;
	READ_BUF(16);
J
J. Bruce Fields 已提交
1215
	p = xdr_decode_hyper(p, &write->wr_offset);
J
J. Bruce Fields 已提交
1216
	write->wr_stable_how = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1217 1218
	if (write->wr_stable_how > 2)
		goto xdr_error;
J
J. Bruce Fields 已提交
1219
	write->wr_buflen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1220 1221 1222 1223 1224 1225 1226

	/* Sorry .. no magic macros for this.. *
	 * READ_BUF(write->wr_buflen);
	 * SAVEMEM(write->wr_buf, write->wr_buflen);
	 */
	avail = (char*)argp->end - (char*)argp->p;
	if (avail + argp->pagelen < write->wr_buflen) {
1227 1228
		dprintk("NFSD: xdr error (%s:%d)\n",
				__FILE__, __LINE__);
L
Linus Torvalds 已提交
1229 1230
		goto xdr_error;
	}
1231 1232 1233
	write->wr_head.iov_base = p;
	write->wr_head.iov_len = avail;
	write->wr_pagelist = argp->pagelist;
J
J. Bruce Fields 已提交
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246

	len = XDR_QUADLEN(write->wr_buflen) << 2;
	if (len >= avail) {
		int pages;

		len -= avail;

		pages = len >> PAGE_SHIFT;
		argp->pagelist += pages;
		argp->pagelen -= pages * PAGE_SIZE;
		len -= pages * PAGE_SIZE;

		argp->p = (__be32 *)page_address(argp->pagelist[0]);
1247
		argp->pagelist++;
J
J. Bruce Fields 已提交
1248
		argp->end = argp->p + XDR_QUADLEN(PAGE_SIZE);
L
Linus Torvalds 已提交
1249
	}
J
J. Bruce Fields 已提交
1250
	argp->p += XDR_QUADLEN(len);
L
Linus Torvalds 已提交
1251 1252 1253 1254

	DECODE_TAIL;
}

1255
static __be32
L
Linus Torvalds 已提交
1256 1257 1258 1259
nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
{
	DECODE_HEAD;

1260 1261 1262
	if (argp->minorversion >= 1)
		return nfserr_notsupp;

L
Linus Torvalds 已提交
1263 1264
	READ_BUF(12);
	COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
J
J. Bruce Fields 已提交
1265
	rlockowner->rl_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1266 1267 1268
	READ_BUF(rlockowner->rl_owner.len);
	READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);

A
Andy Adamson 已提交
1269 1270
	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
		return nfserr_inval;
L
Linus Torvalds 已提交
1271 1272 1273
	DECODE_TAIL;
}

A
Andy Adamson 已提交
1274 1275
static __be32
nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
A
Andy Adamson 已提交
1276
			 struct nfsd4_exchange_id *exid)
A
Andy Adamson 已提交
1277
{
1278
	int dummy, tmp;
A
Andy Adamson 已提交
1279 1280 1281 1282 1283
	DECODE_HEAD;

	READ_BUF(NFS4_VERIFIER_SIZE);
	COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE);

1284 1285 1286
	status = nfsd4_decode_opaque(argp, &exid->clname);
	if (status)
		return nfserr_bad_xdr;
A
Andy Adamson 已提交
1287 1288

	READ_BUF(4);
J
J. Bruce Fields 已提交
1289
	exid->flags = be32_to_cpup(p++);
A
Andy Adamson 已提交
1290 1291 1292

	/* Ignore state_protect4_a */
	READ_BUF(4);
J
J. Bruce Fields 已提交
1293
	exid->spa_how = be32_to_cpup(p++);
A
Andy Adamson 已提交
1294 1295 1296 1297 1298 1299
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
	case SP4_MACH_CRED:
		/* spo_must_enforce */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1300
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1301 1302 1303 1304 1305
		READ_BUF(dummy * 4);
		p += dummy;

		/* spo_must_allow */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1306
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1307 1308 1309 1310 1311 1312
		READ_BUF(dummy * 4);
		p += dummy;
		break;
	case SP4_SSV:
		/* ssp_ops */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1313
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1314 1315 1316 1317
		READ_BUF(dummy * 4);
		p += dummy;

		READ_BUF(4);
J
J. Bruce Fields 已提交
1318
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1319 1320 1321 1322 1323
		READ_BUF(dummy * 4);
		p += dummy;

		/* ssp_hash_algs<> */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1324
		tmp = be32_to_cpup(p++);
1325 1326
		while (tmp--) {
			READ_BUF(4);
J
J. Bruce Fields 已提交
1327
			dummy = be32_to_cpup(p++);
1328 1329 1330
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
		}
A
Andy Adamson 已提交
1331 1332 1333

		/* ssp_encr_algs<> */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1334
		tmp = be32_to_cpup(p++);
1335 1336
		while (tmp--) {
			READ_BUF(4);
J
J. Bruce Fields 已提交
1337
			dummy = be32_to_cpup(p++);
1338 1339 1340
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
		}
A
Andy Adamson 已提交
1341 1342 1343

		/* ssp_window and ssp_num_gss_handles */
		READ_BUF(8);
J
J. Bruce Fields 已提交
1344 1345
		dummy = be32_to_cpup(p++);
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1346 1347 1348 1349 1350 1351 1352
		break;
	default:
		goto xdr_error;
	}

	/* Ignore Implementation ID */
	READ_BUF(4);    /* nfs_impl_id4 array length */
J
J. Bruce Fields 已提交
1353
	dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1354 1355 1356 1357 1358 1359 1360

	if (dummy > 1)
		goto xdr_error;

	if (dummy == 1) {
		/* nii_domain */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1361
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1362 1363 1364 1365 1366
		READ_BUF(dummy);
		p += XDR_QUADLEN(dummy);

		/* nii_name */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1367
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1368 1369 1370 1371 1372 1373 1374 1375
		READ_BUF(dummy);
		p += XDR_QUADLEN(dummy);

		/* nii_date */
		READ_BUF(12);
		p += 3;
	}
	DECODE_TAIL;
A
Andy Adamson 已提交
1376 1377 1378 1379 1380 1381
}

static __be32
nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
			    struct nfsd4_create_session *sess)
{
A
Andy Adamson 已提交
1382 1383 1384 1385 1386
	DECODE_HEAD;
	u32 dummy;

	READ_BUF(16);
	COPYMEM(&sess->clientid, 8);
J
J. Bruce Fields 已提交
1387 1388
	sess->seqid = be32_to_cpup(p++);
	sess->flags = be32_to_cpup(p++);
A
Andy Adamson 已提交
1389 1390 1391

	/* Fore channel attrs */
	READ_BUF(28);
J
J. Bruce Fields 已提交
1392 1393 1394 1395 1396 1397 1398
	dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */
	sess->fore_channel.maxreq_sz = be32_to_cpup(p++);
	sess->fore_channel.maxresp_sz = be32_to_cpup(p++);
	sess->fore_channel.maxresp_cached = be32_to_cpup(p++);
	sess->fore_channel.maxops = be32_to_cpup(p++);
	sess->fore_channel.maxreqs = be32_to_cpup(p++);
	sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1399 1400
	if (sess->fore_channel.nr_rdma_attrs == 1) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
1401
		sess->fore_channel.rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1402 1403 1404 1405 1406 1407 1408
	} else if (sess->fore_channel.nr_rdma_attrs > 1) {
		dprintk("Too many fore channel attr bitmaps!\n");
		goto xdr_error;
	}

	/* Back channel attrs */
	READ_BUF(28);
J
J. Bruce Fields 已提交
1409 1410 1411 1412 1413 1414 1415
	dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */
	sess->back_channel.maxreq_sz = be32_to_cpup(p++);
	sess->back_channel.maxresp_sz = be32_to_cpup(p++);
	sess->back_channel.maxresp_cached = be32_to_cpup(p++);
	sess->back_channel.maxops = be32_to_cpup(p++);
	sess->back_channel.maxreqs = be32_to_cpup(p++);
	sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1416 1417
	if (sess->back_channel.nr_rdma_attrs == 1) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
1418
		sess->back_channel.rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1419 1420 1421 1422 1423
	} else if (sess->back_channel.nr_rdma_attrs > 1) {
		dprintk("Too many back channel attr bitmaps!\n");
		goto xdr_error;
	}

1424
	READ_BUF(4);
J
J. Bruce Fields 已提交
1425
	sess->callback_prog = be32_to_cpup(p++);
1426
	nfsd4_decode_cb_sec(argp, &sess->cb_sec);
A
Andy Adamson 已提交
1427
	DECODE_TAIL;
A
Andy Adamson 已提交
1428 1429 1430 1431 1432 1433
}

static __be32
nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
			     struct nfsd4_destroy_session *destroy_session)
{
B
Benny Halevy 已提交
1434 1435 1436 1437 1438
	DECODE_HEAD;
	READ_BUF(NFS4_MAX_SESSIONID_LEN);
	COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);

	DECODE_TAIL;
A
Andy Adamson 已提交
1439 1440
}

1441 1442 1443 1444 1445 1446 1447
static __be32
nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
			  struct nfsd4_free_stateid *free_stateid)
{
	DECODE_HEAD;

	READ_BUF(sizeof(stateid_t));
J
J. Bruce Fields 已提交
1448
	free_stateid->fr_stateid.si_generation = be32_to_cpup(p++);
1449 1450 1451 1452 1453
	COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));

	DECODE_TAIL;
}

A
Andy Adamson 已提交
1454 1455 1456 1457
static __be32
nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
		      struct nfsd4_sequence *seq)
{
B
Benny Halevy 已提交
1458 1459 1460 1461
	DECODE_HEAD;

	READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
	COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
1462 1463 1464 1465
	seq->seqid = be32_to_cpup(p++);
	seq->slotid = be32_to_cpup(p++);
	seq->maxslots = be32_to_cpup(p++);
	seq->cachethis = be32_to_cpup(p++);
B
Benny Halevy 已提交
1466 1467

	DECODE_TAIL;
A
Andy Adamson 已提交
1468 1469
}

1470 1471 1472 1473
static __be32
nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
{
	int i;
1474 1475
	__be32 *p, status;
	struct nfsd4_test_stateid_id *stateid;
1476 1477 1478 1479

	READ_BUF(4);
	test_stateid->ts_num_ids = ntohl(*p++);

1480
	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
1481 1482

	for (i = 0; i < test_stateid->ts_num_ids; i++) {
1483
		stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
1484
		if (!stateid) {
1485
			status = nfserrno(-ENOMEM);
1486 1487 1488 1489 1490 1491 1492
			goto out;
		}

		INIT_LIST_HEAD(&stateid->ts_id_list);
		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);

		status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid);
1493
		if (status)
1494
			goto out;
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
	}

	status = 0;
out:
	return status;
xdr_error:
	dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__);
	status = nfserr_bad_xdr;
	goto out;
}

1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc)
{
	DECODE_HEAD;

	READ_BUF(8);
	COPYMEM(&dc->clientid, 8);

	DECODE_TAIL;
}

1516 1517 1518 1519 1520
static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1521
	rc->rca_one_fs = be32_to_cpup(p++);
1522 1523 1524 1525

	DECODE_TAIL;
}

1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
#ifdef CONFIG_NFSD_PNFS
static __be32
nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp,
		struct nfsd4_getdeviceinfo *gdev)
{
	DECODE_HEAD;
	u32 num, i;

	READ_BUF(sizeof(struct nfsd4_deviceid) + 3 * 4);
	COPYMEM(&gdev->gd_devid, sizeof(struct nfsd4_deviceid));
	gdev->gd_layout_type = be32_to_cpup(p++);
	gdev->gd_maxcount = be32_to_cpup(p++);
	num = be32_to_cpup(p++);
	if (num) {
		READ_BUF(4 * num);
		gdev->gd_notify_types = be32_to_cpup(p++);
		for (i = 1; i < num; i++) {
			if (be32_to_cpup(p++)) {
				status = nfserr_inval;
				goto out;
			}
		}
	}
	DECODE_TAIL;
}

static __be32
nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp,
		struct nfsd4_layoutget *lgp)
{
	DECODE_HEAD;

	READ_BUF(36);
	lgp->lg_signal = be32_to_cpup(p++);
	lgp->lg_layout_type = be32_to_cpup(p++);
	lgp->lg_seg.iomode = be32_to_cpup(p++);
	p = xdr_decode_hyper(p, &lgp->lg_seg.offset);
	p = xdr_decode_hyper(p, &lgp->lg_seg.length);
	p = xdr_decode_hyper(p, &lgp->lg_minlength);
1565 1566 1567 1568 1569

	status = nfsd4_decode_stateid(argp, &lgp->lg_sid);
	if (status)
		return status;

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
	READ_BUF(4);
	lgp->lg_maxcount = be32_to_cpup(p++);

	DECODE_TAIL;
}

static __be32
nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp,
		struct nfsd4_layoutcommit *lcp)
{
	DECODE_HEAD;
	u32 timechange;

	READ_BUF(20);
	p = xdr_decode_hyper(p, &lcp->lc_seg.offset);
	p = xdr_decode_hyper(p, &lcp->lc_seg.length);
	lcp->lc_reclaim = be32_to_cpup(p++);
1587 1588 1589 1590 1591

	status = nfsd4_decode_stateid(argp, &lcp->lc_sid);
	if (status)
		return status;

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
	READ_BUF(4);
	lcp->lc_newoffset = be32_to_cpup(p++);
	if (lcp->lc_newoffset) {
		READ_BUF(8);
		p = xdr_decode_hyper(p, &lcp->lc_last_wr);
	} else
		lcp->lc_last_wr = 0;
	READ_BUF(4);
	timechange = be32_to_cpup(p++);
	if (timechange) {
		status = nfsd4_decode_time(argp, &lcp->lc_mtime);
		if (status)
			return status;
	} else {
		lcp->lc_mtime.tv_nsec = UTIME_NOW;
	}
	READ_BUF(8);
	lcp->lc_layout_type = be32_to_cpup(p++);

	/*
	 * Save the layout update in XDR format and let the layout driver deal
	 * with it later.
	 */
	lcp->lc_up_len = be32_to_cpup(p++);
	if (lcp->lc_up_len > 0) {
		READ_BUF(lcp->lc_up_len);
		READMEM(lcp->lc_up_layout, lcp->lc_up_len);
	}

	DECODE_TAIL;
}

static __be32
nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp,
		struct nfsd4_layoutreturn *lrp)
{
	DECODE_HEAD;

	READ_BUF(16);
	lrp->lr_reclaim = be32_to_cpup(p++);
	lrp->lr_layout_type = be32_to_cpup(p++);
	lrp->lr_seg.iomode = be32_to_cpup(p++);
	lrp->lr_return_type = be32_to_cpup(p++);
	if (lrp->lr_return_type == RETURN_FILE) {
		READ_BUF(16);
		p = xdr_decode_hyper(p, &lrp->lr_seg.offset);
		p = xdr_decode_hyper(p, &lrp->lr_seg.length);
1639 1640 1641 1642 1643

		status = nfsd4_decode_stateid(argp, &lrp->lr_sid);
		if (status)
			return status;

1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
		READ_BUF(4);
		lrp->lrf_body_len = be32_to_cpup(p++);
		if (lrp->lrf_body_len > 0) {
			READ_BUF(lrp->lrf_body_len);
			READMEM(lrp->lrf_body, lrp->lrf_body_len);
		}
	} else {
		lrp->lr_seg.offset = 0;
		lrp->lr_seg.length = NFS4_MAX_UINT64;
	}

	DECODE_TAIL;
}
#endif /* CONFIG_NFSD_PNFS */

A
Anna Schumaker 已提交
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
static __be32
nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp,
		       struct nfsd4_fallocate *fallocate)
{
	DECODE_HEAD;

	status = nfsd4_decode_stateid(argp, &fallocate->falloc_stateid);
	if (status)
		return status;

	READ_BUF(16);
	p = xdr_decode_hyper(p, &fallocate->falloc_offset);
	xdr_decode_hyper(p, &fallocate->falloc_length);

	DECODE_TAIL;
}

A
Anna Schumaker 已提交
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
static __be32
nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek)
{
	DECODE_HEAD;

	status = nfsd4_decode_stateid(argp, &seek->seek_stateid);
	if (status)
		return status;

	READ_BUF(8 + 4);
	p = xdr_decode_hyper(p, &seek->seek_offset);
	seek->seek_whence = be32_to_cpup(p);

	DECODE_TAIL;
}

1692 1693 1694 1695 1696 1697
static __be32
nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
{
	return nfs_ok;
}

1698 1699 1700
static __be32
nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
{
1701
	return nfserr_notsupp;
1702 1703
}

1704 1705 1706
typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);

static nfsd4_dec nfsd4_dec_ops[] = {
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
	[OP_ACCESS]		= (nfsd4_dec)nfsd4_decode_access,
	[OP_CLOSE]		= (nfsd4_dec)nfsd4_decode_close,
	[OP_COMMIT]		= (nfsd4_dec)nfsd4_decode_commit,
	[OP_CREATE]		= (nfsd4_dec)nfsd4_decode_create,
	[OP_DELEGPURGE]		= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_DELEGRETURN]	= (nfsd4_dec)nfsd4_decode_delegreturn,
	[OP_GETATTR]		= (nfsd4_dec)nfsd4_decode_getattr,
	[OP_GETFH]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_LINK]		= (nfsd4_dec)nfsd4_decode_link,
	[OP_LOCK]		= (nfsd4_dec)nfsd4_decode_lock,
	[OP_LOCKT]		= (nfsd4_dec)nfsd4_decode_lockt,
	[OP_LOCKU]		= (nfsd4_dec)nfsd4_decode_locku,
	[OP_LOOKUP]		= (nfsd4_dec)nfsd4_decode_lookup,
	[OP_LOOKUPP]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_NVERIFY]		= (nfsd4_dec)nfsd4_decode_verify,
	[OP_OPEN]		= (nfsd4_dec)nfsd4_decode_open,
	[OP_OPENATTR]		= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_OPEN_CONFIRM]	= (nfsd4_dec)nfsd4_decode_open_confirm,
	[OP_OPEN_DOWNGRADE]	= (nfsd4_dec)nfsd4_decode_open_downgrade,
	[OP_PUTFH]		= (nfsd4_dec)nfsd4_decode_putfh,
1727
	[OP_PUTPUBFH]		= (nfsd4_dec)nfsd4_decode_putpubfh,
1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
	[OP_PUTROOTFH]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_READ]		= (nfsd4_dec)nfsd4_decode_read,
	[OP_READDIR]		= (nfsd4_dec)nfsd4_decode_readdir,
	[OP_READLINK]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_REMOVE]		= (nfsd4_dec)nfsd4_decode_remove,
	[OP_RENAME]		= (nfsd4_dec)nfsd4_decode_rename,
	[OP_RENEW]		= (nfsd4_dec)nfsd4_decode_renew,
	[OP_RESTOREFH]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_SAVEFH]		= (nfsd4_dec)nfsd4_decode_noop,
	[OP_SECINFO]		= (nfsd4_dec)nfsd4_decode_secinfo,
	[OP_SETATTR]		= (nfsd4_dec)nfsd4_decode_setattr,
	[OP_SETCLIENTID]	= (nfsd4_dec)nfsd4_decode_setclientid,
	[OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,
	[OP_VERIFY]		= (nfsd4_dec)nfsd4_decode_verify,
	[OP_WRITE]		= (nfsd4_dec)nfsd4_decode_write,
	[OP_RELEASE_LOCKOWNER]	= (nfsd4_dec)nfsd4_decode_release_lockowner,
A
Andy Adamson 已提交
1744 1745

	/* new operations for NFSv4.1 */
1746
	[OP_BACKCHANNEL_CTL]	= (nfsd4_dec)nfsd4_decode_backchannel_ctl,
1747
	[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
R
Randy Dunlap 已提交
1748 1749 1750
	[OP_EXCHANGE_ID]	= (nfsd4_dec)nfsd4_decode_exchange_id,
	[OP_CREATE_SESSION]	= (nfsd4_dec)nfsd4_decode_create_session,
	[OP_DESTROY_SESSION]	= (nfsd4_dec)nfsd4_decode_destroy_session,
1751
	[OP_FREE_STATEID]	= (nfsd4_dec)nfsd4_decode_free_stateid,
R
Randy Dunlap 已提交
1752
	[OP_GET_DIR_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
1753 1754 1755 1756 1757 1758 1759
#ifdef CONFIG_NFSD_PNFS
	[OP_GETDEVICEINFO]	= (nfsd4_dec)nfsd4_decode_getdeviceinfo,
	[OP_GETDEVICELIST]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTCOMMIT]	= (nfsd4_dec)nfsd4_decode_layoutcommit,
	[OP_LAYOUTGET]		= (nfsd4_dec)nfsd4_decode_layoutget,
	[OP_LAYOUTRETURN]	= (nfsd4_dec)nfsd4_decode_layoutreturn,
#else
R
Randy Dunlap 已提交
1760 1761 1762 1763 1764
	[OP_GETDEVICEINFO]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_GETDEVICELIST]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTCOMMIT]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTGET]		= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTRETURN]	= (nfsd4_dec)nfsd4_decode_notsupp,
1765
#endif
J
J. Bruce Fields 已提交
1766
	[OP_SECINFO_NO_NAME]	= (nfsd4_dec)nfsd4_decode_secinfo_no_name,
R
Randy Dunlap 已提交
1767 1768
	[OP_SEQUENCE]		= (nfsd4_dec)nfsd4_decode_sequence,
	[OP_SET_SSV]		= (nfsd4_dec)nfsd4_decode_notsupp,
1769
	[OP_TEST_STATEID]	= (nfsd4_dec)nfsd4_decode_test_stateid,
R
Randy Dunlap 已提交
1770
	[OP_WANT_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
1771
	[OP_DESTROY_CLIENTID]	= (nfsd4_dec)nfsd4_decode_destroy_clientid,
1772
	[OP_RECLAIM_COMPLETE]	= (nfsd4_dec)nfsd4_decode_reclaim_complete,
1773 1774

	/* new operations for NFSv4.2 */
A
Anna Schumaker 已提交
1775
	[OP_ALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
1776 1777
	[OP_COPY]		= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_COPY_NOTIFY]	= (nfsd4_dec)nfsd4_decode_notsupp,
A
Anna Schumaker 已提交
1778
	[OP_DEALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
1779 1780 1781 1782 1783 1784
	[OP_IO_ADVISE]		= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTERROR]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_LAYOUTSTATS]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_OFFLOAD_CANCEL]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_OFFLOAD_STATUS]	= (nfsd4_dec)nfsd4_decode_notsupp,
	[OP_READ_PLUS]		= (nfsd4_dec)nfsd4_decode_notsupp,
A
Anna Schumaker 已提交
1785
	[OP_SEEK]		= (nfsd4_dec)nfsd4_decode_seek,
1786
	[OP_WRITE_SAME]		= (nfsd4_dec)nfsd4_decode_notsupp,
A
Andy Adamson 已提交
1787 1788
};

1789 1790 1791
static inline bool
nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
{
1792
	if (op->opnum < FIRST_NFS4_OP)
1793
		return false;
1794
	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
1795
		return false;
1796 1797 1798
	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
		return false;
	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
1799 1800 1801
		return false;
	return true;
}
1802

1803
static __be32
L
Linus Torvalds 已提交
1804 1805 1806 1807
nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
{
	DECODE_HEAD;
	struct nfsd4_op *op;
1808
	bool cachethis = false;
1809 1810
	int auth_slack= argp->rqstp->rq_auth_slack;
	int max_reply = auth_slack + 8; /* opcnt, status */
1811 1812
	int readcount = 0;
	int readbytes = 0;
L
Linus Torvalds 已提交
1813 1814 1815
	int i;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1816
	argp->taglen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1817 1818
	READ_BUF(argp->taglen + 8);
	SAVEMEM(argp->tag, argp->taglen);
J
J. Bruce Fields 已提交
1819 1820
	argp->minorversion = be32_to_cpup(p++);
	argp->opcnt = be32_to_cpup(p++);
1821
	max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2);
L
Linus Torvalds 已提交
1822 1823 1824 1825 1826 1827

	if (argp->taglen > NFSD4_MAX_TAGLEN)
		goto xdr_error;
	if (argp->opcnt > 100)
		goto xdr_error;

1828
	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
1829
		argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
L
Linus Torvalds 已提交
1830 1831
		if (!argp->ops) {
			argp->ops = argp->iops;
1832
			dprintk("nfsd: couldn't allocate room for COMPOUND\n");
L
Linus Torvalds 已提交
1833 1834 1835 1836
			goto xdr_error;
		}
	}

1837
	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
1838 1839
		argp->opcnt = 0;

L
Linus Torvalds 已提交
1840 1841 1842 1843
	for (i = 0; i < argp->opcnt; i++) {
		op = &argp->ops[i];
		op->replay = NULL;

J
J. Bruce Fields 已提交
1844
		READ_BUF(4);
J
J. Bruce Fields 已提交
1845
		op->opnum = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1846

1847 1848
		if (nfsd4_opnum_in_range(argp, op))
			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
1849
		else {
L
Linus Torvalds 已提交
1850 1851 1852
			op->opnum = OP_ILLEGAL;
			op->status = nfserr_op_illegal;
		}
1853 1854 1855 1856 1857
		/*
		 * We'll try to cache the result in the DRC if any one
		 * op in the compound wants to be cached:
		 */
		cachethis |= nfsd4_cache_this_op(op);
1858

1859 1860 1861 1862 1863
		if (op->opnum == OP_READ) {
			readcount++;
			readbytes += nfsd4_max_reply(argp->rqstp, op);
		} else
			max_reply += nfsd4_max_reply(argp->rqstp, op);
1864 1865 1866 1867 1868 1869 1870 1871
		/*
		 * OP_LOCK may return a conflicting lock.  (Special case
		 * because it will just skip encoding this if it runs
		 * out of xdr buffer space, and it is the only operation
		 * that behaves this way.)
		 */
		if (op->opnum == OP_LOCK)
			max_reply += NFS4_OPAQUE_LIMIT;
1872 1873 1874 1875 1876

		if (op->status) {
			argp->opcnt = i+1;
			break;
		}
L
Linus Torvalds 已提交
1877
	}
1878 1879 1880
	/* Sessions make the DRC unnecessary: */
	if (argp->minorversion)
		cachethis = false;
1881
	svc_reserve(argp->rqstp, max_reply + readbytes);
1882
	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
L
Linus Torvalds 已提交
1883

1884
	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
1885
		clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
1886

L
Linus Torvalds 已提交
1887 1888 1889
	DECODE_TAIL;
}

J
J. Bruce Fields 已提交
1890
static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode)
J
J. Bruce Fields 已提交
1891 1892
{
	if (IS_I_VERSION(inode)) {
J
J. Bruce Fields 已提交
1893
		p = xdr_encode_hyper(p, inode->i_version);
J
J. Bruce Fields 已提交
1894
	} else {
J
J. Bruce Fields 已提交
1895 1896
		*p++ = cpu_to_be32(stat->ctime.tv_sec);
		*p++ = cpu_to_be32(stat->ctime.tv_nsec);
J
J. Bruce Fields 已提交
1897
	}
J
J. Bruce Fields 已提交
1898
	return p;
J
J. Bruce Fields 已提交
1899 1900
}

J
J. Bruce Fields 已提交
1901
static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
J
J. Bruce Fields 已提交
1902
{
J
J. Bruce Fields 已提交
1903
	*p++ = cpu_to_be32(c->atomic);
J
J. Bruce Fields 已提交
1904
	if (c->change_supported) {
J
J. Bruce Fields 已提交
1905 1906
		p = xdr_encode_hyper(p, c->before_change);
		p = xdr_encode_hyper(p, c->after_change);
J
J. Bruce Fields 已提交
1907
	} else {
J
J. Bruce Fields 已提交
1908 1909 1910 1911
		*p++ = cpu_to_be32(c->before_ctime_sec);
		*p++ = cpu_to_be32(c->before_ctime_nsec);
		*p++ = cpu_to_be32(c->after_ctime_sec);
		*p++ = cpu_to_be32(c->after_ctime_nsec);
J
J. Bruce Fields 已提交
1912
	}
J
J. Bruce Fields 已提交
1913
	return p;
J
J. Bruce Fields 已提交
1914
}
L
Linus Torvalds 已提交
1915

1916
/* Encode as an array of strings the string given with components
1917
 * separated @sep, escaped with esc_enter and esc_exit.
1918
 */
1919 1920 1921
static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
					  char *components, char esc_enter,
					  char esc_exit)
1922
{
1923
	__be32 *p;
1924 1925
	__be32 pathlen;
	int pathlen_offset;
1926
	int strlen, count=0;
1927
	char *str, *end, *next;
1928 1929

	dprintk("nfsd4_encode_components(%s)\n", components);
1930 1931

	pathlen_offset = xdr->buf->len;
1932 1933
	p = xdr_reserve_space(xdr, 4);
	if (!p)
1934
		return nfserr_resource;
1935 1936
	p++; /* We will fill this in with @count later */

1937 1938
	end = str = components;
	while (*end) {
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
		bool found_esc = false;

		/* try to parse as esc_start, ..., esc_end, sep */
		if (*str == esc_enter) {
			for (; *end && (*end != esc_exit); end++)
				/* find esc_exit or end of string */;
			next = end + 1;
			if (*end && (!*next || *next == sep)) {
				str++;
				found_esc = true;
			}
		}

		if (!found_esc)
			for (; *end && (*end != sep); end++)
				/* find sep or end of string */;

1956 1957
		strlen = end - str;
		if (strlen) {
1958 1959
			p = xdr_reserve_space(xdr, strlen + 4);
			if (!p)
1960
				return nfserr_resource;
J
J. Bruce Fields 已提交
1961
			p = xdr_encode_opaque(p, str, strlen);
1962 1963 1964 1965
			count++;
		}
		else
			end++;
1966 1967 1968
		if (found_esc)
			end = next;

1969 1970
		str = end;
	}
1971
	pathlen = htonl(count);
1972
	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
1973 1974 1975
	return 0;
}

1976 1977 1978
/* Encode as an array of strings the string given with components
 * separated @sep.
 */
1979 1980
static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
				      char *components)
1981
{
1982
	return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
1983 1984
}

1985 1986 1987
/*
 * encode a location element of a fs_locations structure
 */
1988 1989
static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
					struct nfsd4_fs_location *location)
1990
{
1991
	__be32 status;
1992

1993
	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
1994
						'[', ']');
1995 1996
	if (status)
		return status;
1997
	status = nfsd4_encode_components(xdr, '/', location->path);
1998 1999 2000 2001 2002 2003
	if (status)
		return status;
	return 0;
}

/*
T
Trond Myklebust 已提交
2004
 * Encode a path in RFC3530 'pathname4' format
2005
 */
2006 2007 2008
static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
				const struct path *root,
				const struct path *path)
2009
{
2010
	struct path cur = *path;
2011
	__be32 *p;
T
Trond Myklebust 已提交
2012 2013 2014
	struct dentry **components = NULL;
	unsigned int ncomponents = 0;
	__be32 err = nfserr_jukebox;
2015

T
Trond Myklebust 已提交
2016
	dprintk("nfsd4_encode_components(");
2017

T
Trond Myklebust 已提交
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
	path_get(&cur);
	/* First walk the path up to the nfsd root, and store the
	 * dentries/path components in an array.
	 */
	for (;;) {
		if (cur.dentry == root->dentry && cur.mnt == root->mnt)
			break;
		if (cur.dentry == cur.mnt->mnt_root) {
			if (follow_up(&cur))
				continue;
			goto out_free;
		}
		if ((ncomponents & 15) == 0) {
			struct dentry **new;
			new = krealloc(components,
					sizeof(*new) * (ncomponents + 16),
					GFP_KERNEL);
			if (!new)
				goto out_free;
			components = new;
		}
		components[ncomponents++] = cur.dentry;
		cur.dentry = dget_parent(cur.dentry);
	}
2042 2043 2044
	err = nfserr_resource;
	p = xdr_reserve_space(xdr, 4);
	if (!p)
T
Trond Myklebust 已提交
2045
		goto out_free;
J
J. Bruce Fields 已提交
2046
	*p++ = cpu_to_be32(ncomponents);
T
Trond Myklebust 已提交
2047 2048 2049

	while (ncomponents) {
		struct dentry *dentry = components[ncomponents - 1];
2050
		unsigned int len;
T
Trond Myklebust 已提交
2051

2052 2053
		spin_lock(&dentry->d_lock);
		len = dentry->d_name.len;
2054 2055
		p = xdr_reserve_space(xdr, len + 4);
		if (!p) {
2056
			spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
2057
			goto out_free;
2058
		}
J
J. Bruce Fields 已提交
2059
		p = xdr_encode_opaque(p, dentry->d_name.name, len);
A
Al Viro 已提交
2060
		dprintk("/%pd", dentry);
2061
		spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
2062 2063
		dput(dentry);
		ncomponents--;
2064
	}
T
Trond Myklebust 已提交
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075

	err = 0;
out_free:
	dprintk(")\n");
	while (ncomponents)
		dput(components[--ncomponents]);
	kfree(components);
	path_put(&cur);
	return err;
}

2076 2077
static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
			struct svc_rqst *rqstp, const struct path *path)
T
Trond Myklebust 已提交
2078 2079 2080 2081 2082 2083 2084
{
	struct svc_export *exp_ps;
	__be32 res;

	exp_ps = rqst_find_fsidzero_export(rqstp);
	if (IS_ERR(exp_ps))
		return nfserrno(PTR_ERR(exp_ps));
2085
	res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
T
Trond Myklebust 已提交
2086 2087
	exp_put(exp_ps);
	return res;
2088 2089 2090 2091 2092
}

/*
 *  encode a fs_locations structure
 */
2093 2094
static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
			struct svc_rqst *rqstp, struct svc_export *exp)
2095
{
2096
	__be32 status;
2097
	int i;
2098
	__be32 *p;
2099 2100
	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;

2101
	status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
2102 2103
	if (status)
		return status;
2104 2105
	p = xdr_reserve_space(xdr, 4);
	if (!p)
2106
		return nfserr_resource;
J
J. Bruce Fields 已提交
2107
	*p++ = cpu_to_be32(fslocs->locations_count);
2108
	for (i=0; i<fslocs->locations_count; i++) {
2109
		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2110 2111 2112 2113 2114
		if (status)
			return status;
	}
	return 0;
}
L
Linus Torvalds 已提交
2115

2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
static u32 nfs4_file_type(umode_t mode)
{
	switch (mode & S_IFMT) {
	case S_IFIFO:	return NF4FIFO;
	case S_IFCHR:	return NF4CHR;
	case S_IFDIR:	return NF4DIR;
	case S_IFBLK:	return NF4BLK;
	case S_IFLNK:	return NF4LNK;
	case S_IFREG:	return NF4REG;
	case S_IFSOCK:	return NF4SOCK;
	default:	return NF4BAD;
	};
}
L
Linus Torvalds 已提交
2129

2130
static inline __be32
2131 2132
nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
		     struct nfs4_ace *ace)
L
Linus Torvalds 已提交
2133
{
2134
	if (ace->whotype != NFS4_ACL_WHO_NAMED)
2135
		return nfs4_acl_write_who(xdr, ace->whotype);
2136
	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2137
		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2138
	else
2139
		return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
L
Linus Torvalds 已提交
2140 2141
}

2142 2143 2144 2145
#define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
			      FATTR4_WORD0_RDATTR_ERROR)
#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID

2146 2147
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
static inline __be32
2148 2149
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
			    void *context, int len)
2150
{
2151
	__be32 *p;
2152

2153 2154
	p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
	if (!p)
2155 2156 2157 2158 2159 2160
		return nfserr_resource;

	/*
	 * For now we use a 0 here to indicate the null translation; in
	 * the future we may place a call to translation code here.
	 */
J
J. Bruce Fields 已提交
2161 2162
	*p++ = cpu_to_be32(0); /* lfs */
	*p++ = cpu_to_be32(0); /* pi */
2163 2164 2165 2166 2167
	p = xdr_encode_opaque(p, context, len);
	return 0;
}
#else
static inline __be32
2168 2169
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
			    void *context, int len)
2170 2171 2172
{ return 0; }
#endif

2173
static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err)
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
{
	/* As per referral draft:  */
	if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
	    *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
		if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
	            *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
			*rdattr_err = NFSERR_MOVED;
		else
			return nfserr_moved;
	}
	*bmval0 &= WORD0_ABSENT_FS_ATTRS;
	*bmval1 &= WORD1_ABSENT_FS_ATTRS;
	return 0;
}
L
Linus Torvalds 已提交
2188

2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199

static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
{
	struct path path = exp->ex_path;
	int err;

	path_get(&path);
	while (follow_up(&path)) {
		if (path.dentry != path.mnt->mnt_root)
			break;
	}
A
Al Viro 已提交
2200
	err = vfs_getattr(&path, stat);
2201 2202 2203 2204
	path_put(&path);
	return err;
}

L
Linus Torvalds 已提交
2205 2206 2207 2208
/*
 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
 * ourselves.
 */
2209
static __be32
2210 2211 2212
nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
		struct svc_export *exp,
		struct dentry *dentry, u32 *bmval,
2213
		struct svc_rqst *rqstp, int ignore_crossmnt)
L
Linus Torvalds 已提交
2214 2215 2216
{
	u32 bmval0 = bmval[0];
	u32 bmval1 = bmval[1];
2217
	u32 bmval2 = bmval[2];
L
Linus Torvalds 已提交
2218
	struct kstat stat;
2219
	struct svc_fh *tempfh = NULL;
L
Linus Torvalds 已提交
2220
	struct kstatfs statfs;
2221
	__be32 *p;
J
J. Bruce Fields 已提交
2222
	int starting_len = xdr->buf->len;
2223 2224
	int attrlen_offset;
	__be32 attrlen;
L
Linus Torvalds 已提交
2225 2226
	u32 dummy;
	u64 dummy64;
2227
	u32 rdattr_err = 0;
2228
	__be32 status;
2229
	int err;
L
Linus Torvalds 已提交
2230 2231
	int aclsupport = 0;
	struct nfs4_acl *acl = NULL;
2232 2233 2234
	void *context = NULL;
	int contextlen;
	bool contextsupport = false;
2235 2236
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
	u32 minorversion = resp->cstate.minorversion;
2237 2238 2239 2240
	struct path path = {
		.mnt	= exp->ex_path.mnt,
		.dentry	= dentry,
	};
2241
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
2242 2243

	BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
2244 2245 2246
	BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion));
	BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion));
	BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion));
L
Linus Torvalds 已提交
2247

2248
	if (exp->ex_fslocs.migrated) {
2249
		BUG_ON(bmval[2]);
2250 2251 2252 2253 2254
		status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err);
		if (status)
			goto out;
	}

A
Al Viro 已提交
2255
	err = vfs_getattr(&path, &stat);
2256
	if (err)
L
Linus Torvalds 已提交
2257
		goto out_nfserr;
2258 2259
	if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
			FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
L
Linus Torvalds 已提交
2260 2261
	    (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
		       FATTR4_WORD1_SPACE_TOTAL))) {
2262
		err = vfs_statfs(&path, &statfs);
2263
		if (err)
L
Linus Torvalds 已提交
2264 2265 2266
			goto out_nfserr;
	}
	if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
2267 2268 2269 2270 2271 2272
		tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
		status = nfserr_jukebox;
		if (!tempfh)
			goto out;
		fh_init(tempfh, NFS4_FHSIZE);
		status = fh_compose(tempfh, exp, dentry, NULL);
L
Linus Torvalds 已提交
2273 2274
		if (status)
			goto out;
2275
		fhp = tempfh;
L
Linus Torvalds 已提交
2276 2277 2278
	}
	if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT
			| FATTR4_WORD0_SUPPORTED_ATTRS)) {
2279 2280
		err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
		aclsupport = (err == 0);
L
Linus Torvalds 已提交
2281
		if (bmval0 & FATTR4_WORD0_ACL) {
2282
			if (err == -EOPNOTSUPP)
L
Linus Torvalds 已提交
2283
				bmval0 &= ~FATTR4_WORD0_ACL;
2284
			else if (err == -EINVAL) {
L
Linus Torvalds 已提交
2285 2286
				status = nfserr_attrnotsupp;
				goto out;
2287
			} else if (err != 0)
L
Linus Torvalds 已提交
2288 2289 2290 2291
				goto out_nfserr;
		}
	}

2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
	if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) ||
			bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
		err = security_inode_getsecctx(dentry->d_inode,
						&context, &contextlen);
		contextsupport = (err == 0);
		if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
			if (err == -EOPNOTSUPP)
				bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL;
			else if (err)
				goto out_nfserr;
		}
	}
#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */

2307
	if (bmval2) {
2308 2309
		p = xdr_reserve_space(xdr, 16);
		if (!p)
2310
			goto out_resource;
J
J. Bruce Fields 已提交
2311 2312 2313 2314
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(bmval0);
		*p++ = cpu_to_be32(bmval1);
		*p++ = cpu_to_be32(bmval2);
2315
	} else if (bmval1) {
2316 2317
		p = xdr_reserve_space(xdr, 12);
		if (!p)
2318
			goto out_resource;
J
J. Bruce Fields 已提交
2319 2320 2321
		*p++ = cpu_to_be32(2);
		*p++ = cpu_to_be32(bmval0);
		*p++ = cpu_to_be32(bmval1);
2322
	} else {
2323 2324
		p = xdr_reserve_space(xdr, 8);
		if (!p)
2325
			goto out_resource;
J
J. Bruce Fields 已提交
2326 2327
		*p++ = cpu_to_be32(1);
		*p++ = cpu_to_be32(bmval0);
2328
	}
2329 2330

	attrlen_offset = xdr->buf->len;
2331 2332 2333
	p = xdr_reserve_space(xdr, 4);
	if (!p)
		goto out_resource;
2334
	p++;                /* to be backfilled later */
L
Linus Torvalds 已提交
2335 2336

	if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2337 2338 2339 2340
		u32 word0 = nfsd_suppattrs0(minorversion);
		u32 word1 = nfsd_suppattrs1(minorversion);
		u32 word2 = nfsd_suppattrs2(minorversion);

2341 2342
		if (!aclsupport)
			word0 &= ~FATTR4_WORD0_ACL;
2343 2344
		if (!contextsupport)
			word2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2345
		if (!word2) {
2346 2347
			p = xdr_reserve_space(xdr, 12);
			if (!p)
2348
				goto out_resource;
J
J. Bruce Fields 已提交
2349 2350 2351
			*p++ = cpu_to_be32(2);
			*p++ = cpu_to_be32(word0);
			*p++ = cpu_to_be32(word1);
2352
		} else {
2353 2354
			p = xdr_reserve_space(xdr, 16);
			if (!p)
2355
				goto out_resource;
J
J. Bruce Fields 已提交
2356 2357 2358 2359
			*p++ = cpu_to_be32(3);
			*p++ = cpu_to_be32(word0);
			*p++ = cpu_to_be32(word1);
			*p++ = cpu_to_be32(word2);
2360
		}
L
Linus Torvalds 已提交
2361 2362
	}
	if (bmval0 & FATTR4_WORD0_TYPE) {
2363 2364
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2365
			goto out_resource;
2366
		dummy = nfs4_file_type(stat.mode);
2367 2368 2369 2370
		if (dummy == NF4BAD) {
			status = nfserr_serverfault;
			goto out;
		}
J
J. Bruce Fields 已提交
2371
		*p++ = cpu_to_be32(dummy);
L
Linus Torvalds 已提交
2372 2373
	}
	if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2374 2375
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2376
			goto out_resource;
N
NeilBrown 已提交
2377
		if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
J
J. Bruce Fields 已提交
2378
			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
N
NeilBrown 已提交
2379
		else
J
J. Bruce Fields 已提交
2380 2381
			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
						NFS4_FH_VOL_RENAME);
L
Linus Torvalds 已提交
2382 2383
	}
	if (bmval0 & FATTR4_WORD0_CHANGE) {
2384 2385
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2386
			goto out_resource;
J
J. Bruce Fields 已提交
2387
		p = encode_change(p, &stat, dentry->d_inode);
L
Linus Torvalds 已提交
2388 2389
	}
	if (bmval0 & FATTR4_WORD0_SIZE) {
2390 2391
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2392
			goto out_resource;
J
J. Bruce Fields 已提交
2393
		p = xdr_encode_hyper(p, stat.size);
L
Linus Torvalds 已提交
2394 2395
	}
	if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2396 2397
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2398
			goto out_resource;
J
J. Bruce Fields 已提交
2399
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2400 2401
	}
	if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2402 2403
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2404
			goto out_resource;
J
J. Bruce Fields 已提交
2405
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2406 2407
	}
	if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2408 2409
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2410
			goto out_resource;
J
J. Bruce Fields 已提交
2411
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2412 2413
	}
	if (bmval0 & FATTR4_WORD0_FSID) {
2414 2415
		p = xdr_reserve_space(xdr, 16);
		if (!p)
L
Linus Torvalds 已提交
2416
			goto out_resource;
2417
		if (exp->ex_fslocs.migrated) {
J
J. Bruce Fields 已提交
2418 2419
			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
2420 2421
		} else switch(fsid_source(fhp)) {
		case FSIDSOURCE_FSID:
J
J. Bruce Fields 已提交
2422 2423
			p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
			p = xdr_encode_hyper(p, (u64)0);
2424 2425
			break;
		case FSIDSOURCE_DEV:
J
J. Bruce Fields 已提交
2426 2427 2428 2429
			*p++ = cpu_to_be32(0);
			*p++ = cpu_to_be32(MAJOR(stat.dev));
			*p++ = cpu_to_be32(0);
			*p++ = cpu_to_be32(MINOR(stat.dev));
2430 2431
			break;
		case FSIDSOURCE_UUID:
2432 2433
			p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
								EX_UUID_LEN);
2434
			break;
L
Linus Torvalds 已提交
2435 2436 2437
		}
	}
	if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
2438 2439
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2440
			goto out_resource;
J
J. Bruce Fields 已提交
2441
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2442 2443
	}
	if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
2444 2445
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2446
			goto out_resource;
J
J. Bruce Fields 已提交
2447
		*p++ = cpu_to_be32(nn->nfsd4_lease);
L
Linus Torvalds 已提交
2448 2449
	}
	if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
2450 2451
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2452
			goto out_resource;
J
J. Bruce Fields 已提交
2453
		*p++ = cpu_to_be32(rdattr_err);
L
Linus Torvalds 已提交
2454 2455 2456 2457 2458
	}
	if (bmval0 & FATTR4_WORD0_ACL) {
		struct nfs4_ace *ace;

		if (acl == NULL) {
2459 2460
			p = xdr_reserve_space(xdr, 4);
			if (!p)
L
Linus Torvalds 已提交
2461 2462
				goto out_resource;

J
J. Bruce Fields 已提交
2463
			*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2464 2465
			goto out_acl;
		}
2466 2467
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2468
			goto out_resource;
J
J. Bruce Fields 已提交
2469
		*p++ = cpu_to_be32(acl->naces);
L
Linus Torvalds 已提交
2470

2471
		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
2472 2473
			p = xdr_reserve_space(xdr, 4*3);
			if (!p)
L
Linus Torvalds 已提交
2474
				goto out_resource;
J
J. Bruce Fields 已提交
2475 2476 2477 2478
			*p++ = cpu_to_be32(ace->type);
			*p++ = cpu_to_be32(ace->flag);
			*p++ = cpu_to_be32(ace->access_mask &
							NFS4_ACE_MASK_ALL);
2479
			status = nfsd4_encode_aclname(xdr, rqstp, ace);
L
Linus Torvalds 已提交
2480 2481 2482 2483 2484 2485
			if (status)
				goto out;
		}
	}
out_acl:
	if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
2486 2487
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2488
			goto out_resource;
J
J. Bruce Fields 已提交
2489
		*p++ = cpu_to_be32(aclsupport ?
L
Linus Torvalds 已提交
2490 2491 2492
			ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
	}
	if (bmval0 & FATTR4_WORD0_CANSETTIME) {
2493 2494
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2495
			goto out_resource;
J
J. Bruce Fields 已提交
2496
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2497 2498
	}
	if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
2499 2500
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2501
			goto out_resource;
J
J. Bruce Fields 已提交
2502
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2503 2504
	}
	if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
2505 2506
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2507
			goto out_resource;
J
J. Bruce Fields 已提交
2508
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2509 2510
	}
	if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
2511 2512
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2513
			goto out_resource;
J
J. Bruce Fields 已提交
2514
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2515 2516
	}
	if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
2517 2518
		p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
		if (!p)
L
Linus Torvalds 已提交
2519
			goto out_resource;
J
J. Bruce Fields 已提交
2520 2521
		p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base,
					fhp->fh_handle.fh_size);
L
Linus Torvalds 已提交
2522 2523
	}
	if (bmval0 & FATTR4_WORD0_FILEID) {
2524 2525
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2526
			goto out_resource;
J
J. Bruce Fields 已提交
2527
		p = xdr_encode_hyper(p, stat.ino);
L
Linus Torvalds 已提交
2528 2529
	}
	if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
2530 2531
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2532
			goto out_resource;
J
J. Bruce Fields 已提交
2533
		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
L
Linus Torvalds 已提交
2534 2535
	}
	if (bmval0 & FATTR4_WORD0_FILES_FREE) {
2536 2537
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2538
			goto out_resource;
J
J. Bruce Fields 已提交
2539
		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
L
Linus Torvalds 已提交
2540 2541
	}
	if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
2542 2543
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2544
			goto out_resource;
J
J. Bruce Fields 已提交
2545
		p = xdr_encode_hyper(p, (u64) statfs.f_files);
L
Linus Torvalds 已提交
2546
	}
2547
	if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
2548
		status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
2549 2550 2551
		if (status)
			goto out;
	}
L
Linus Torvalds 已提交
2552
	if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
2553 2554
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2555
			goto out_resource;
J
J. Bruce Fields 已提交
2556
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2557 2558
	}
	if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
2559 2560
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2561
			goto out_resource;
J
J. Bruce Fields 已提交
2562
		p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
L
Linus Torvalds 已提交
2563 2564
	}
	if (bmval0 & FATTR4_WORD0_MAXLINK) {
2565 2566
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2567
			goto out_resource;
J
J. Bruce Fields 已提交
2568
		*p++ = cpu_to_be32(255);
L
Linus Torvalds 已提交
2569 2570
	}
	if (bmval0 & FATTR4_WORD0_MAXNAME) {
2571 2572
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2573
			goto out_resource;
J
J. Bruce Fields 已提交
2574
		*p++ = cpu_to_be32(statfs.f_namelen);
L
Linus Torvalds 已提交
2575 2576
	}
	if (bmval0 & FATTR4_WORD0_MAXREAD) {
2577 2578
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2579
			goto out_resource;
J
J. Bruce Fields 已提交
2580
		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
L
Linus Torvalds 已提交
2581 2582
	}
	if (bmval0 & FATTR4_WORD0_MAXWRITE) {
2583 2584
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2585
			goto out_resource;
J
J. Bruce Fields 已提交
2586
		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
L
Linus Torvalds 已提交
2587 2588
	}
	if (bmval1 & FATTR4_WORD1_MODE) {
2589 2590
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2591
			goto out_resource;
J
J. Bruce Fields 已提交
2592
		*p++ = cpu_to_be32(stat.mode & S_IALLUGO);
L
Linus Torvalds 已提交
2593 2594
	}
	if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
2595 2596
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2597
			goto out_resource;
J
J. Bruce Fields 已提交
2598
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2599 2600
	}
	if (bmval1 & FATTR4_WORD1_NUMLINKS) {
2601 2602
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2603
			goto out_resource;
J
J. Bruce Fields 已提交
2604
		*p++ = cpu_to_be32(stat.nlink);
L
Linus Torvalds 已提交
2605 2606
	}
	if (bmval1 & FATTR4_WORD1_OWNER) {
2607
		status = nfsd4_encode_user(xdr, rqstp, stat.uid);
L
Linus Torvalds 已提交
2608 2609 2610 2611
		if (status)
			goto out;
	}
	if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
2612
		status = nfsd4_encode_group(xdr, rqstp, stat.gid);
L
Linus Torvalds 已提交
2613 2614 2615 2616
		if (status)
			goto out;
	}
	if (bmval1 & FATTR4_WORD1_RAWDEV) {
2617 2618
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2619
			goto out_resource;
J
J. Bruce Fields 已提交
2620 2621
		*p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
		*p++ = cpu_to_be32((u32) MINOR(stat.rdev));
L
Linus Torvalds 已提交
2622 2623
	}
	if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
2624 2625
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2626 2627
			goto out_resource;
		dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2628
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2629 2630
	}
	if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
2631 2632
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2633 2634
			goto out_resource;
		dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2635
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2636 2637
	}
	if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
2638 2639
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2640 2641
			goto out_resource;
		dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2642
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2643 2644
	}
	if (bmval1 & FATTR4_WORD1_SPACE_USED) {
2645 2646
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2647 2648
			goto out_resource;
		dummy64 = (u64)stat.blocks << 9;
J
J. Bruce Fields 已提交
2649
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2650 2651
	}
	if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
2652 2653
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2654
			goto out_resource;
J
J. Bruce Fields 已提交
2655
		p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
J
J. Bruce Fields 已提交
2656
		*p++ = cpu_to_be32(stat.atime.tv_nsec);
L
Linus Torvalds 已提交
2657 2658
	}
	if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
2659 2660
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2661
			goto out_resource;
J
J. Bruce Fields 已提交
2662 2663 2664
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(1);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2665 2666
	}
	if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
2667 2668
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2669
			goto out_resource;
J
J. Bruce Fields 已提交
2670
		p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
J
J. Bruce Fields 已提交
2671
		*p++ = cpu_to_be32(stat.ctime.tv_nsec);
L
Linus Torvalds 已提交
2672 2673
	}
	if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
2674 2675
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2676
			goto out_resource;
J
J. Bruce Fields 已提交
2677
		p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
J
J. Bruce Fields 已提交
2678
		*p++ = cpu_to_be32(stat.mtime.tv_nsec);
L
Linus Torvalds 已提交
2679 2680
	}
	if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
2681 2682
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2683
                	goto out_resource;
2684 2685 2686 2687 2688
		/*
		 * Get parent's attributes if not ignoring crossmount
		 * and this is the root of a cross-mounted filesystem.
		 */
		if (ignore_crossmnt == 0 &&
2689 2690
		    dentry == exp->ex_path.mnt->mnt_root)
			get_parent_attributes(exp, &stat);
J
J. Bruce Fields 已提交
2691
		p = xdr_encode_hyper(p, stat.ino);
L
Linus Torvalds 已提交
2692
	}
2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716
#ifdef CONFIG_NFSD_PNFS
	if ((bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) ||
	    (bmval2 & FATTR4_WORD2_LAYOUT_TYPES)) {
		if (exp->ex_layout_type) {
			p = xdr_reserve_space(xdr, 8);
			if (!p)
				goto out_resource;
			*p++ = cpu_to_be32(1);
			*p++ = cpu_to_be32(exp->ex_layout_type);
		} else {
			p = xdr_reserve_space(xdr, 4);
			if (!p)
				goto out_resource;
			*p++ = cpu_to_be32(0);
		}
	}

	if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) {
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			goto out_resource;
		*p++ = cpu_to_be32(stat.blksize);
	}
#endif /* CONFIG_NFSD_PNFS */
2717
	if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
2718 2719
		status = nfsd4_encode_security_label(xdr, rqstp, context,
								contextlen);
2720 2721 2722
		if (status)
			goto out;
	}
2723
	if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
2724 2725
		p = xdr_reserve_space(xdr, 16);
		if (!p)
2726
			goto out_resource;
J
J. Bruce Fields 已提交
2727 2728 2729 2730
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD0);
		*p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD1);
		*p++ = cpu_to_be32(NFSD_SUPPATTR_EXCLCREAT_WORD2);
2731
	}
2732

2733 2734
	attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
	write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
L
Linus Torvalds 已提交
2735 2736 2737
	status = nfs_ok;

out:
2738
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2739 2740
	if (context)
		security_release_secctx(context, contextlen);
2741
#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2742
	kfree(acl);
2743
	if (tempfh) {
2744
		fh_put(tempfh);
2745 2746
		kfree(tempfh);
	}
J
J. Bruce Fields 已提交
2747 2748
	if (status)
		xdr_truncate_encode(xdr, starting_len);
L
Linus Torvalds 已提交
2749 2750
	return status;
out_nfserr:
2751
	status = nfserrno(err);
L
Linus Torvalds 已提交
2752 2753 2754 2755 2756 2757
	goto out;
out_resource:
	status = nfserr_resource;
	goto out;
}

2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
				struct xdr_buf *buf, __be32 *p, int bytes)
{
	xdr->scratch.iov_len = 0;
	memset(buf, 0, sizeof(struct xdr_buf));
	buf->head[0].iov_base = p;
	buf->head[0].iov_len = 0;
	buf->len = 0;
	xdr->buf = buf;
	xdr->iov = buf->head;
	xdr->p = p;
	xdr->end = (void *)p + bytes;
	buf->buflen = bytes;
}

2773 2774 2775 2776 2777
__be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
			struct svc_fh *fhp, struct svc_export *exp,
			struct dentry *dentry, u32 *bmval,
			struct svc_rqst *rqstp, int ignore_crossmnt)
{
2778
	struct xdr_buf dummy;
2779 2780 2781
	struct xdr_stream xdr;
	__be32 ret;

2782
	svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
2783 2784 2785 2786 2787 2788
	ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
							ignore_crossmnt);
	*p = xdr.p;
	return ret;
}

2789 2790 2791 2792 2793 2794 2795 2796 2797
static inline int attributes_need_mount(u32 *bmval)
{
	if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
		return 1;
	if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
		return 1;
	return 0;
}

2798
static __be32
J
J. Bruce Fields 已提交
2799 2800
nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
			const char *name, int namlen)
L
Linus Torvalds 已提交
2801 2802 2803
{
	struct svc_export *exp = cd->rd_fhp->fh_export;
	struct dentry *dentry;
2804
	__be32 nfserr;
2805
	int ignore_crossmnt = 0;
L
Linus Torvalds 已提交
2806 2807 2808 2809

	dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen);
	if (IS_ERR(dentry))
		return nfserrno(PTR_ERR(dentry));
2810 2811 2812 2813 2814 2815 2816 2817 2818
	if (!dentry->d_inode) {
		/*
		 * nfsd_buffered_readdir drops the i_mutex between
		 * readdir and calling this callback, leaving a window
		 * where this directory entry could have gone away.
		 */
		dput(dentry);
		return nfserr_noent;
	}
L
Linus Torvalds 已提交
2819 2820

	exp_get(exp);
2821 2822 2823 2824 2825 2826 2827
	/*
	 * In the case of a mountpoint, the client may be asking for
	 * attributes that are only properties of the underlying filesystem
	 * as opposed to the cross-mounted file system. In such a case,
	 * we will not follow the cross mount and will fill the attribtutes
	 * directly from the mountpoint dentry.
	 */
2828
	if (nfsd_mountpoint(dentry, exp)) {
2829 2830
		int err;

2831 2832 2833 2834 2835
		if (!(exp->ex_flags & NFSEXP_V4ROOT)
				&& !attributes_need_mount(cd->rd_bmval)) {
			ignore_crossmnt = 1;
			goto out_encode;
		}
A
Andy Adamson 已提交
2836 2837 2838 2839 2840
		/*
		 * Why the heck aren't we just using nfsd_lookup??
		 * Different "."/".." handling?  Something else?
		 * At least, add a comment here to explain....
		 */
2841 2842 2843
		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
		if (err) {
			nfserr = nfserrno(err);
L
Linus Torvalds 已提交
2844 2845
			goto out_put;
		}
A
Andy Adamson 已提交
2846 2847 2848
		nfserr = check_nfsd_access(exp, cd->rd_rqstp);
		if (nfserr)
			goto out_put;
L
Linus Torvalds 已提交
2849 2850

	}
2851
out_encode:
J
J. Bruce Fields 已提交
2852
	nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
2853
					cd->rd_rqstp, ignore_crossmnt);
L
Linus Torvalds 已提交
2854 2855 2856 2857 2858 2859
out_put:
	dput(dentry);
	exp_put(exp);
	return nfserr;
}

A
Al Viro 已提交
2860
static __be32 *
J
J. Bruce Fields 已提交
2861
nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
L
Linus Torvalds 已提交
2862
{
J
J. Bruce Fields 已提交
2863 2864
	__be32 *p;

2865
	p = xdr_reserve_space(xdr, 20);
J
J. Bruce Fields 已提交
2866
	if (!p)
L
Linus Torvalds 已提交
2867 2868 2869 2870 2871
		return NULL;
	*p++ = htonl(2);
	*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
	*p++ = htonl(0);			 /* bmval1 */

2872
	*p++ = htonl(4);     /* attribute length */
L
Linus Torvalds 已提交
2873 2874 2875 2876 2877
	*p++ = nfserr;       /* no htonl */
	return p;
}

static int
2878 2879
nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
		    loff_t offset, u64 ino, unsigned int d_type)
L
Linus Torvalds 已提交
2880
{
2881
	struct readdir_cd *ccd = ccdv;
L
Linus Torvalds 已提交
2882
	struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
J
J. Bruce Fields 已提交
2883 2884 2885
	struct xdr_stream *xdr = cd->xdr;
	int start_offset = xdr->buf->len;
	int cookie_offset;
2886
	u32 name_and_cookie;
J
J. Bruce Fields 已提交
2887
	int entry_bytes;
2888
	__be32 nfserr = nfserr_toosmall;
J
J. Bruce Fields 已提交
2889 2890
	__be64 wire_offset;
	__be32 *p;
L
Linus Torvalds 已提交
2891 2892 2893 2894 2895 2896 2897

	/* In nfsv4, "." and ".." never make it onto the wire.. */
	if (name && isdotent(name, namlen)) {
		cd->common.err = nfs_ok;
		return 0;
	}

J
J. Bruce Fields 已提交
2898 2899 2900 2901 2902
	if (cd->cookie_offset) {
		wire_offset = cpu_to_be64(offset);
		write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
							&wire_offset, 8);
	}
L
Linus Torvalds 已提交
2903

J
J. Bruce Fields 已提交
2904 2905
	p = xdr_reserve_space(xdr, 4);
	if (!p)
L
Linus Torvalds 已提交
2906 2907
		goto fail;
	*p++ = xdr_one;                             /* mark entry present */
J
J. Bruce Fields 已提交
2908 2909 2910 2911
	cookie_offset = xdr->buf->len;
	p = xdr_reserve_space(xdr, 3*4 + namlen);
	if (!p)
		goto fail;
L
Linus Torvalds 已提交
2912 2913 2914
	p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
	p = xdr_encode_array(p, name, namlen);      /* name length & name */

J
J. Bruce Fields 已提交
2915
	nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
L
Linus Torvalds 已提交
2916 2917 2918 2919 2920 2921
	switch (nfserr) {
	case nfs_ok:
		break;
	case nfserr_resource:
		nfserr = nfserr_toosmall;
		goto fail;
2922
	case nfserr_noent:
2923
		xdr_truncate_encode(xdr, start_offset);
2924
		goto skip_entry;
L
Linus Torvalds 已提交
2925 2926 2927 2928 2929 2930 2931 2932 2933 2934
	default:
		/*
		 * If the client requested the RDATTR_ERROR attribute,
		 * we stuff the error code into this attribute
		 * and continue.  If this attribute was not requested,
		 * then in accordance with the spec, we fail the
		 * entire READDIR operation(!)
		 */
		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
			goto fail;
J
J. Bruce Fields 已提交
2935
		p = nfsd4_encode_rdattr_error(xdr, nfserr);
2936 2937
		if (p == NULL) {
			nfserr = nfserr_toosmall;
L
Linus Torvalds 已提交
2938
			goto fail;
2939
		}
L
Linus Torvalds 已提交
2940
	}
J
J. Bruce Fields 已提交
2941 2942 2943 2944 2945
	nfserr = nfserr_toosmall;
	entry_bytes = xdr->buf->len - start_offset;
	if (entry_bytes > cd->rd_maxcount)
		goto fail;
	cd->rd_maxcount -= entry_bytes;
2946 2947 2948 2949
	/*
	 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
	 * let's always let through the first entry, at least:
	 */
2950 2951 2952
	if (!cd->rd_dircount)
		goto fail;
	name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
2953 2954 2955
	if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
		goto fail;
	cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
2956

J
J. Bruce Fields 已提交
2957
	cd->cookie_offset = cookie_offset;
2958
skip_entry:
L
Linus Torvalds 已提交
2959 2960 2961
	cd->common.err = nfs_ok;
	return 0;
fail:
J
J. Bruce Fields 已提交
2962
	xdr_truncate_encode(xdr, start_offset);
L
Linus Torvalds 已提交
2963 2964 2965 2966
	cd->common.err = nfserr;
	return -EINVAL;
}

2967 2968
static __be32
nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
2969
{
2970
	__be32 *p;
2971

2972 2973 2974
	p = xdr_reserve_space(xdr, sizeof(stateid_t));
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
2975
	*p++ = cpu_to_be32(sid->si_generation);
J
J. Bruce Fields 已提交
2976 2977
	p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
					sizeof(stateid_opaque_t));
2978
	return 0;
2979 2980
}

2981
static __be32
2982
nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
L
Linus Torvalds 已提交
2983
{
2984
	struct xdr_stream *xdr = &resp->xdr;
2985
	__be32 *p;
L
Linus Torvalds 已提交
2986 2987

	if (!nfserr) {
2988 2989 2990
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
2991 2992
		*p++ = cpu_to_be32(access->ac_supported);
		*p++ = cpu_to_be32(access->ac_resp_access);
L
Linus Torvalds 已提交
2993
	}
2994
	return nfserr;
L
Linus Torvalds 已提交
2995 2996
}

2997 2998
static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
{
2999
	struct xdr_stream *xdr = &resp->xdr;
3000 3001 3002
	__be32 *p;

	if (!nfserr) {
3003 3004 3005
		p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3006 3007
		p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
						NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
3008
		*p++ = cpu_to_be32(bcts->dir);
3009
		/* Sorry, we do not yet support RDMA over 4.1: */
J
J. Bruce Fields 已提交
3010
		*p++ = cpu_to_be32(0);
3011 3012 3013 3014
	}
	return nfserr;
}

3015
static __be32
3016
nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
L
Linus Torvalds 已提交
3017
{
3018 3019
	struct xdr_stream *xdr = &resp->xdr;

3020
	if (!nfserr)
3021
		nfserr = nfsd4_encode_stateid(xdr, &close->cl_stateid);
3022

3023
	return nfserr;
L
Linus Torvalds 已提交
3024 3025 3026
}


3027
static __be32
3028
nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
L
Linus Torvalds 已提交
3029
{
3030
	struct xdr_stream *xdr = &resp->xdr;
3031
	__be32 *p;
L
Linus Torvalds 已提交
3032 3033

	if (!nfserr) {
3034 3035 3036
		p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3037 3038
		p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
						NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
3039
	}
3040
	return nfserr;
L
Linus Torvalds 已提交
3041 3042
}

3043
static __be32
3044
nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
L
Linus Torvalds 已提交
3045
{
3046
	struct xdr_stream *xdr = &resp->xdr;
3047
	__be32 *p;
L
Linus Torvalds 已提交
3048 3049

	if (!nfserr) {
3050 3051 3052
		p = xdr_reserve_space(xdr, 32);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3053
		p = encode_cinfo(p, &create->cr_cinfo);
J
J. Bruce Fields 已提交
3054 3055 3056
		*p++ = cpu_to_be32(2);
		*p++ = cpu_to_be32(create->cr_bmval[0]);
		*p++ = cpu_to_be32(create->cr_bmval[1]);
L
Linus Torvalds 已提交
3057
	}
3058
	return nfserr;
L
Linus Torvalds 已提交
3059 3060
}

3061 3062
static __be32
nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
L
Linus Torvalds 已提交
3063 3064
{
	struct svc_fh *fhp = getattr->ga_fhp;
3065
	struct xdr_stream *xdr = &resp->xdr;
L
Linus Torvalds 已提交
3066 3067 3068 3069

	if (nfserr)
		return nfserr;

3070 3071
	nfserr = nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
				    getattr->ga_bmval,
3072
				    resp->rqstp, 0);
L
Linus Torvalds 已提交
3073 3074 3075
	return nfserr;
}

3076 3077
static __be32
nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
L
Linus Torvalds 已提交
3078
{
3079
	struct xdr_stream *xdr = &resp->xdr;
3080
	struct svc_fh *fhp = *fhpp;
L
Linus Torvalds 已提交
3081
	unsigned int len;
3082
	__be32 *p;
L
Linus Torvalds 已提交
3083 3084 3085

	if (!nfserr) {
		len = fhp->fh_handle.fh_size;
3086 3087 3088
		p = xdr_reserve_space(xdr, len + 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3089
		p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
L
Linus Torvalds 已提交
3090
	}
3091
	return nfserr;
L
Linus Torvalds 已提交
3092 3093 3094 3095 3096 3097
}

/*
* Including all fields other than the name, a LOCK4denied structure requires
*   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
*/
3098 3099
static __be32
nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
L
Linus Torvalds 已提交
3100
{
3101
	struct xdr_netobj *conf = &ld->ld_owner;
3102
	__be32 *p;
L
Linus Torvalds 已提交
3103

3104
again:
3105
	p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
3106 3107 3108 3109 3110 3111
	if (!p) {
		/*
		 * Don't fail to return the result just because we can't
		 * return the conflicting open:
		 */
		if (conf->len) {
3112
			kfree(conf->data);
3113 3114 3115 3116
			conf->len = 0;
			conf->data = NULL;
			goto again;
		}
3117
		return nfserr_resource;
3118
	}
J
J. Bruce Fields 已提交
3119 3120
	p = xdr_encode_hyper(p, ld->ld_start);
	p = xdr_encode_hyper(p, ld->ld_length);
J
J. Bruce Fields 已提交
3121
	*p++ = cpu_to_be32(ld->ld_type);
3122
	if (conf->len) {
J
J. Bruce Fields 已提交
3123 3124
		p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
		p = xdr_encode_opaque(p, conf->data, conf->len);
3125
		kfree(conf->data);
L
Linus Torvalds 已提交
3126
	}  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
J
J. Bruce Fields 已提交
3127
		p = xdr_encode_hyper(p, (u64)0); /* clientid */
J
J. Bruce Fields 已提交
3128
		*p++ = cpu_to_be32(0); /* length of owner name */
L
Linus Torvalds 已提交
3129
	}
3130
	return nfserr_denied;
L
Linus Torvalds 已提交
3131 3132
}

3133
static __be32
3134
nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
L
Linus Torvalds 已提交
3135
{
3136 3137
	struct xdr_stream *xdr = &resp->xdr;

3138
	if (!nfserr)
3139
		nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
3140
	else if (nfserr == nfserr_denied)
3141
		nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
3142

3143
	return nfserr;
L
Linus Torvalds 已提交
3144 3145
}

3146
static __be32
3147
nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
L
Linus Torvalds 已提交
3148
{
3149 3150
	struct xdr_stream *xdr = &resp->xdr;

L
Linus Torvalds 已提交
3151
	if (nfserr == nfserr_denied)
3152
		nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
3153
	return nfserr;
L
Linus Torvalds 已提交
3154 3155
}

3156
static __be32
3157
nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
L
Linus Torvalds 已提交
3158
{
3159 3160
	struct xdr_stream *xdr = &resp->xdr;

3161
	if (!nfserr)
3162
		nfserr = nfsd4_encode_stateid(xdr, &locku->lu_stateid);
3163

3164
	return nfserr;
L
Linus Torvalds 已提交
3165 3166 3167
}


3168
static __be32
3169
nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
L
Linus Torvalds 已提交
3170
{
3171
	struct xdr_stream *xdr = &resp->xdr;
3172
	__be32 *p;
L
Linus Torvalds 已提交
3173 3174

	if (!nfserr) {
3175 3176 3177
		p = xdr_reserve_space(xdr, 20);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3178
		p = encode_cinfo(p, &link->li_cinfo);
L
Linus Torvalds 已提交
3179
	}
3180
	return nfserr;
L
Linus Torvalds 已提交
3181 3182 3183
}


3184
static __be32
3185
nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
L
Linus Torvalds 已提交
3186
{
3187
	struct xdr_stream *xdr = &resp->xdr;
3188
	__be32 *p;
L
Linus Torvalds 已提交
3189 3190 3191 3192

	if (nfserr)
		goto out;

3193 3194 3195 3196 3197 3198
	nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
	if (nfserr)
		goto out;
	p = xdr_reserve_space(xdr, 40);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3199
	p = encode_cinfo(p, &open->op_cinfo);
J
J. Bruce Fields 已提交
3200 3201 3202 3203 3204
	*p++ = cpu_to_be32(open->op_rflags);
	*p++ = cpu_to_be32(2);
	*p++ = cpu_to_be32(open->op_bmval[0]);
	*p++ = cpu_to_be32(open->op_bmval[1]);
	*p++ = cpu_to_be32(open->op_delegate_type);
L
Linus Torvalds 已提交
3205 3206 3207 3208 3209

	switch (open->op_delegate_type) {
	case NFS4_OPEN_DELEGATE_NONE:
		break;
	case NFS4_OPEN_DELEGATE_READ:
3210 3211 3212 3213 3214 3215
		nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
		if (nfserr)
			return nfserr;
		p = xdr_reserve_space(xdr, 20);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3216
		*p++ = cpu_to_be32(open->op_recall);
L
Linus Torvalds 已提交
3217 3218 3219 3220

		/*
		 * TODO: ACE's in delegations
		 */
J
J. Bruce Fields 已提交
3221 3222 3223 3224
		*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
L
Linus Torvalds 已提交
3225 3226
		break;
	case NFS4_OPEN_DELEGATE_WRITE:
3227 3228 3229 3230 3231 3232
		nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
		if (nfserr)
			return nfserr;
		p = xdr_reserve_space(xdr, 32);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3233
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3234 3235 3236 3237

		/*
		 * TODO: space_limit's in delegations
		 */
J
J. Bruce Fields 已提交
3238 3239 3240
		*p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
		*p++ = cpu_to_be32(~(u32)0);
		*p++ = cpu_to_be32(~(u32)0);
L
Linus Torvalds 已提交
3241 3242 3243 3244

		/*
		 * TODO: ACE's in delegations
		 */
J
J. Bruce Fields 已提交
3245 3246 3247 3248
		*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
L
Linus Torvalds 已提交
3249
		break;
3250 3251 3252 3253
	case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
		switch (open->op_why_no_deleg) {
		case WND4_CONTENTION:
		case WND4_RESOURCE:
3254 3255 3256
			p = xdr_reserve_space(xdr, 8);
			if (!p)
				return nfserr_resource;
J
J. Bruce Fields 已提交
3257 3258 3259
			*p++ = cpu_to_be32(open->op_why_no_deleg);
			/* deleg signaling not supported yet: */
			*p++ = cpu_to_be32(0);
3260 3261
			break;
		default:
3262 3263 3264
			p = xdr_reserve_space(xdr, 4);
			if (!p)
				return nfserr_resource;
J
J. Bruce Fields 已提交
3265
			*p++ = cpu_to_be32(open->op_why_no_deleg);
3266 3267
		}
		break;
L
Linus Torvalds 已提交
3268 3269 3270 3271 3272
	default:
		BUG();
	}
	/* XXX save filehandle here */
out:
3273
	return nfserr;
L
Linus Torvalds 已提交
3274 3275
}

3276
static __be32
3277
nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
L
Linus Torvalds 已提交
3278
{
3279 3280
	struct xdr_stream *xdr = &resp->xdr;

3281
	if (!nfserr)
3282
		nfserr = nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
L
Linus Torvalds 已提交
3283

3284
	return nfserr;
L
Linus Torvalds 已提交
3285 3286
}

3287
static __be32
3288
nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
L
Linus Torvalds 已提交
3289
{
3290 3291
	struct xdr_stream *xdr = &resp->xdr;

3292
	if (!nfserr)
3293
		nfserr = nfsd4_encode_stateid(xdr, &od->od_stateid);
L
Linus Torvalds 已提交
3294

3295
	return nfserr;
L
Linus Torvalds 已提交
3296 3297
}

3298 3299 3300 3301
static __be32 nfsd4_encode_splice_read(
				struct nfsd4_compoundres *resp,
				struct nfsd4_read *read,
				struct file *file, unsigned long maxcount)
L
Linus Torvalds 已提交
3302
{
3303
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3304
	struct xdr_buf *buf = xdr->buf;
3305
	u32 eof;
3306
	int space_left;
3307
	__be32 nfserr;
3308
	__be32 *p = xdr->p - 2;
L
Linus Torvalds 已提交
3309

3310 3311
	/* Make sure there will be room for padding if needed */
	if (xdr->end - xdr->p < 1)
3312
		return nfserr_resource;
3313 3314 3315 3316 3317 3318 3319 3320 3321

	nfserr = nfsd_splice_read(read->rd_rqstp, file,
				  read->rd_offset, &maxcount);
	if (nfserr) {
		/*
		 * nfsd_splice_actor may have already messed with the
		 * page length; reset it so as not to confuse
		 * xdr_truncate_encode:
		 */
J
J. Bruce Fields 已提交
3322
		buf->page_len = 0;
3323
		return nfserr;
3324
	}
L
Linus Torvalds 已提交
3325

3326 3327
	eof = (read->rd_offset + maxcount >=
	       read->rd_fhp->fh_dentry->d_inode->i_size);
3328

3329 3330
	*(p++) = htonl(eof);
	*(p++) = htonl(maxcount);
3331

J
J. Bruce Fields 已提交
3332 3333
	buf->page_len = maxcount;
	buf->len += maxcount;
3334 3335
	xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
							/ PAGE_SIZE;
3336 3337

	/* Use rest of head for padding and remaining ops: */
J
J. Bruce Fields 已提交
3338 3339
	buf->tail[0].iov_base = xdr->p;
	buf->tail[0].iov_len = 0;
3340
	xdr->iov = buf->tail;
3341
	if (maxcount&3) {
3342 3343 3344 3345
		int pad = 4 - (maxcount&3);

		*(xdr->p++) = 0;

J
J. Bruce Fields 已提交
3346
		buf->tail[0].iov_base += maxcount&3;
3347 3348
		buf->tail[0].iov_len = pad;
		buf->len += pad;
3349
	}
3350

3351
	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
J
J. Bruce Fields 已提交
3352 3353
				buf->buflen - buf->len);
	buf->buflen = buf->len + space_left;
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367
	xdr->end = (__be32 *)((void *)xdr->end + space_left);

	return 0;
}

static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
				 struct nfsd4_read *read,
				 struct file *file, unsigned long maxcount)
{
	struct xdr_stream *xdr = &resp->xdr;
	u32 eof;
	int v;
	int starting_len = xdr->buf->len - 8;
	long len;
3368
	int thislen;
3369 3370 3371
	__be32 nfserr;
	__be32 tmp;
	__be32 *p;
3372 3373
	u32 zzz = 0;
	int pad;
L
Linus Torvalds 已提交
3374 3375 3376

	len = maxcount;
	v = 0;
3377

3378
	thislen = min_t(long, len, ((void *)xdr->end - (void *)xdr->p));
3379 3380 3381 3382 3383 3384 3385 3386
	p = xdr_reserve_space(xdr, (thislen+3)&~3);
	WARN_ON_ONCE(!p);
	resp->rqstp->rq_vec[v].iov_base = p;
	resp->rqstp->rq_vec[v].iov_len = thislen;
	v++;
	len -= thislen;

	while (len) {
3387
		thislen = min_t(long, len, PAGE_SIZE);
3388 3389 3390
		p = xdr_reserve_space(xdr, (thislen+3)&~3);
		WARN_ON_ONCE(!p);
		resp->rqstp->rq_vec[v].iov_base = p;
3391
		resp->rqstp->rq_vec[v].iov_len = thislen;
L
Linus Torvalds 已提交
3392
		v++;
3393
		len -= thislen;
L
Linus Torvalds 已提交
3394 3395 3396
	}
	read->rd_vlen = v;

3397 3398 3399
	nfserr = nfsd_readv(file, read->rd_offset, resp->rqstp->rq_vec,
			read->rd_vlen, &maxcount);
	if (nfserr)
L
Linus Torvalds 已提交
3400
		return nfserr;
3401
	xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
3402

3403 3404
	eof = (read->rd_offset + maxcount >=
	       read->rd_fhp->fh_dentry->d_inode->i_size);
L
Linus Torvalds 已提交
3405

3406 3407 3408 3409 3410
	tmp = htonl(eof);
	write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
	tmp = htonl(maxcount);
	write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);

3411 3412 3413
	pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
	write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
								&zzz, pad);
L
Linus Torvalds 已提交
3414
	return 0;
3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434

}

static __be32
nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
		  struct nfsd4_read *read)
{
	unsigned long maxcount;
	struct xdr_stream *xdr = &resp->xdr;
	struct file *file = read->rd_filp;
	int starting_len = xdr->buf->len;
	struct raparms *ra;
	__be32 *p;
	__be32 err;

	if (nfserr)
		return nfserr;

	p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
	if (!p) {
3435
		WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
3436 3437
		return nfserr_resource;
	}
3438
	if (resp->xdr.buf->page_len && test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
3439
		WARN_ON_ONCE(1);
3440 3441 3442 3443 3444
		return nfserr_resource;
	}
	xdr_commit_encode(xdr);

	maxcount = svc_max_payload(resp->rqstp);
3445 3446
	maxcount = min_t(unsigned long, maxcount, (xdr->buf->buflen - xdr->buf->len));
	maxcount = min_t(unsigned long, maxcount, read->rd_length);
3447 3448 3449 3450 3451 3452 3453 3454

	if (!read->rd_filp) {
		err = nfsd_get_tmp_read_open(resp->rqstp, read->rd_fhp,
						&file, &ra);
		if (err)
			goto err_truncate;
	}

3455
	if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466
		err = nfsd4_encode_splice_read(resp, read, file, maxcount);
	else
		err = nfsd4_encode_readv(resp, read, file, maxcount);

	if (!read->rd_filp)
		nfsd_put_tmp_read_open(file, ra);

err_truncate:
	if (err)
		xdr_truncate_encode(xdr, starting_len);
	return err;
L
Linus Torvalds 已提交
3467 3468
}

3469 3470
static __be32
nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
L
Linus Torvalds 已提交
3471 3472
{
	int maxcount;
3473 3474
	__be32 wire_count;
	int zero = 0;
3475
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3476
	int length_offset = xdr->buf->len;
3477
	__be32 *p;
L
Linus Torvalds 已提交
3478 3479 3480

	if (nfserr)
		return nfserr;
3481 3482 3483 3484

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return nfserr_resource;
L
Linus Torvalds 已提交
3485
	maxcount = PAGE_SIZE;
3486

3487 3488
	p = xdr_reserve_space(xdr, maxcount);
	if (!p)
3489
		return nfserr_resource;
L
Linus Torvalds 已提交
3490 3491 3492 3493 3494 3495
	/*
	 * XXX: By default, the ->readlink() VFS op will truncate symlinks
	 * if they would overflow the buffer.  Is this kosher in NFSv4?  If
	 * not, one easy fix is: if ->readlink() precisely fills the buffer,
	 * assume that truncation occurred, and return NFS4ERR_RESOURCE.
	 */
3496 3497
	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
						(char *)p, &maxcount);
L
Linus Torvalds 已提交
3498
	if (nfserr == nfserr_isdir)
3499 3500
		nfserr = nfserr_inval;
	if (nfserr) {
J
J. Bruce Fields 已提交
3501
		xdr_truncate_encode(xdr, length_offset);
L
Linus Torvalds 已提交
3502
		return nfserr;
3503
	}
L
Linus Torvalds 已提交
3504

3505 3506
	wire_count = htonl(maxcount);
	write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
3507
	xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
3508 3509 3510
	if (maxcount & 3)
		write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
						&zero, 4 - (maxcount&3));
L
Linus Torvalds 已提交
3511 3512 3513
	return 0;
}

3514 3515
static __be32
nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
L
Linus Torvalds 已提交
3516 3517
{
	int maxcount;
J
J. Bruce Fields 已提交
3518
	int bytes_left;
L
Linus Torvalds 已提交
3519
	loff_t offset;
J
J. Bruce Fields 已提交
3520
	__be64 wire_offset;
3521
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3522
	int starting_len = xdr->buf->len;
3523
	__be32 *p;
L
Linus Torvalds 已提交
3524 3525 3526 3527

	if (nfserr)
		return nfserr;

3528 3529 3530
	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
	if (!p)
		return nfserr_resource;
L
Linus Torvalds 已提交
3531 3532

	/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
J
J. Bruce Fields 已提交
3533 3534
	*p++ = cpu_to_be32(0);
	*p++ = cpu_to_be32(0);
3535 3536
	resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
				- (char *)resp->xdr.buf->head[0].iov_base;
L
Linus Torvalds 已提交
3537 3538

	/*
J
J. Bruce Fields 已提交
3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552
	 * Number of bytes left for directory entries allowing for the
	 * final 8 bytes of the readdir and a following failed op:
	 */
	bytes_left = xdr->buf->buflen - xdr->buf->len
			- COMPOUND_ERR_SLACK_SPACE - 8;
	if (bytes_left < 0) {
		nfserr = nfserr_resource;
		goto err_no_verf;
	}
	maxcount = min_t(u32, readdir->rd_maxcount, INT_MAX);
	/*
	 * Note the rfc defines rd_maxcount as the size of the
	 * READDIR4resok structure, which includes the verifier above
	 * and the 8 bytes encoded at the end of this function:
L
Linus Torvalds 已提交
3553
	 */
J
J. Bruce Fields 已提交
3554 3555
	if (maxcount < 16) {
		nfserr = nfserr_toosmall;
L
Linus Torvalds 已提交
3556 3557
		goto err_no_verf;
	}
J
J. Bruce Fields 已提交
3558
	maxcount = min_t(int, maxcount-16, bytes_left);
L
Linus Torvalds 已提交
3559

3560 3561 3562 3563
	/* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
	if (!readdir->rd_dircount)
		readdir->rd_dircount = INT_MAX;

J
J. Bruce Fields 已提交
3564 3565
	readdir->xdr = xdr;
	readdir->rd_maxcount = maxcount;
L
Linus Torvalds 已提交
3566
	readdir->common.err = 0;
J
J. Bruce Fields 已提交
3567
	readdir->cookie_offset = 0;
L
Linus Torvalds 已提交
3568 3569 3570 3571 3572 3573 3574

	offset = readdir->rd_cookie;
	nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
			      &offset,
			      &readdir->common, nfsd4_encode_dirent);
	if (nfserr == nfs_ok &&
	    readdir->common.err == nfserr_toosmall &&
J
J. Bruce Fields 已提交
3575 3576 3577 3578 3579 3580 3581 3582 3583
	    xdr->buf->len == starting_len + 8) {
		/* nothing encoded; which limit did we hit?: */
		if (maxcount - 16 < bytes_left)
			/* It was the fault of rd_maxcount: */
			nfserr = nfserr_toosmall;
		else
			/* We ran out of buffer space: */
			nfserr = nfserr_resource;
	}
L
Linus Torvalds 已提交
3584 3585 3586
	if (nfserr)
		goto err_no_verf;

J
J. Bruce Fields 已提交
3587 3588 3589 3590 3591
	if (readdir->cookie_offset) {
		wire_offset = cpu_to_be64(offset);
		write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
							&wire_offset, 8);
	}
L
Linus Torvalds 已提交
3592

J
J. Bruce Fields 已提交
3593 3594 3595 3596 3597
	p = xdr_reserve_space(xdr, 8);
	if (!p) {
		WARN_ON_ONCE(1);
		goto err_no_verf;
	}
L
Linus Torvalds 已提交
3598 3599 3600 3601 3602
	*p++ = 0;	/* no more entries */
	*p++ = htonl(readdir->common.err == nfserr_eof);

	return 0;
err_no_verf:
J
J. Bruce Fields 已提交
3603
	xdr_truncate_encode(xdr, starting_len);
L
Linus Torvalds 已提交
3604 3605 3606
	return nfserr;
}

3607
static __be32
3608
nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
L
Linus Torvalds 已提交
3609
{
3610
	struct xdr_stream *xdr = &resp->xdr;
3611
	__be32 *p;
L
Linus Torvalds 已提交
3612 3613

	if (!nfserr) {
3614 3615 3616
		p = xdr_reserve_space(xdr, 20);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3617
		p = encode_cinfo(p, &remove->rm_cinfo);
L
Linus Torvalds 已提交
3618
	}
3619
	return nfserr;
L
Linus Torvalds 已提交
3620 3621
}

3622
static __be32
3623
nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
L
Linus Torvalds 已提交
3624
{
3625
	struct xdr_stream *xdr = &resp->xdr;
3626
	__be32 *p;
L
Linus Torvalds 已提交
3627 3628

	if (!nfserr) {
3629 3630 3631
		p = xdr_reserve_space(xdr, 40);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3632 3633
		p = encode_cinfo(p, &rename->rn_sinfo);
		p = encode_cinfo(p, &rename->rn_tinfo);
L
Linus Torvalds 已提交
3634
	}
3635
	return nfserr;
L
Linus Torvalds 已提交
3636 3637
}

3638
static __be32
3639
nfsd4_do_encode_secinfo(struct xdr_stream *xdr,
3640
			 __be32 nfserr, struct svc_export *exp)
A
Andy Adamson 已提交
3641
{
3642
	u32 i, nflavs, supported;
3643 3644
	struct exp_flavor_info *flavs;
	struct exp_flavor_info def_flavs[2];
3645 3646
	__be32 *p, *flavorsp;
	static bool report = true;
A
Andy Adamson 已提交
3647 3648 3649

	if (nfserr)
		goto out;
3650
	nfserr = nfserr_resource;
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
	if (exp->ex_nflavors) {
		flavs = exp->ex_flavors;
		nflavs = exp->ex_nflavors;
	} else { /* Handling of some defaults in absence of real secinfo: */
		flavs = def_flavs;
		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
			nflavs = 2;
			flavs[0].pseudoflavor = RPC_AUTH_UNIX;
			flavs[1].pseudoflavor = RPC_AUTH_NULL;
		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
			nflavs = 1;
			flavs[0].pseudoflavor
					= svcauth_gss_flavor(exp->ex_client);
		} else {
			nflavs = 1;
			flavs[0].pseudoflavor
					= exp->ex_client->flavour->flavour;
		}
	}

3671
	supported = 0;
3672 3673 3674
	p = xdr_reserve_space(xdr, 4);
	if (!p)
		goto out;
3675 3676
	flavorsp = p++;		/* to be backfilled later */

3677
	for (i = 0; i < nflavs; i++) {
3678
		rpc_authflavor_t pf = flavs[i].pseudoflavor;
3679
		struct rpcsec_gss_info info;
A
Andy Adamson 已提交
3680

3681 3682
		if (rpcauth_get_gssinfo(pf, &info) == 0) {
			supported++;
3683 3684 3685 3686
			p = xdr_reserve_space(xdr, 4 + 4 +
					      XDR_LEN(info.oid.len) + 4 + 4);
			if (!p)
				goto out;
J
J. Bruce Fields 已提交
3687
			*p++ = cpu_to_be32(RPC_AUTH_GSS);
J
J. Bruce Fields 已提交
3688
			p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
J
J. Bruce Fields 已提交
3689 3690
			*p++ = cpu_to_be32(info.qop);
			*p++ = cpu_to_be32(info.service);
3691 3692
		} else if (pf < RPC_AUTH_MAXFLAVOR) {
			supported++;
3693 3694 3695
			p = xdr_reserve_space(xdr, 4);
			if (!p)
				goto out;
J
J. Bruce Fields 已提交
3696
			*p++ = cpu_to_be32(pf);
3697 3698 3699 3700
		} else {
			if (report)
				pr_warn("NFS: SECINFO: security flavor %u "
					"is not supported\n", pf);
A
Andy Adamson 已提交
3701 3702
		}
	}
3703

3704 3705 3706
	if (nflavs != supported)
		report = false;
	*flavorsp = htonl(supported);
3707
	nfserr = 0;
A
Andy Adamson 已提交
3708 3709 3710
out:
	if (exp)
		exp_put(exp);
3711
	return nfserr;
A
Andy Adamson 已提交
3712 3713
}

3714 3715 3716 3717
static __be32
nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
		     struct nfsd4_secinfo *secinfo)
{
3718 3719 3720
	struct xdr_stream *xdr = &resp->xdr;

	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->si_exp);
3721 3722 3723 3724 3725 3726
}

static __be32
nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
		     struct nfsd4_secinfo_no_name *secinfo)
{
3727 3728 3729
	struct xdr_stream *xdr = &resp->xdr;

	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->sin_exp);
3730 3731
}

L
Linus Torvalds 已提交
3732 3733 3734 3735
/*
 * The SETATTR encode routine is special -- it always encodes a bitmap,
 * regardless of the error status.
 */
3736
static __be32
3737
nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
L
Linus Torvalds 已提交
3738
{
3739
	struct xdr_stream *xdr = &resp->xdr;
3740
	__be32 *p;
L
Linus Torvalds 已提交
3741

3742 3743 3744
	p = xdr_reserve_space(xdr, 16);
	if (!p)
		return nfserr_resource;
L
Linus Torvalds 已提交
3745
	if (nfserr) {
J
J. Bruce Fields 已提交
3746 3747 3748 3749
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3750 3751
	}
	else {
J
J. Bruce Fields 已提交
3752 3753 3754 3755
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(setattr->sa_bmval[0]);
		*p++ = cpu_to_be32(setattr->sa_bmval[1]);
		*p++ = cpu_to_be32(setattr->sa_bmval[2]);
L
Linus Torvalds 已提交
3756
	}
3757
	return nfserr;
L
Linus Torvalds 已提交
3758 3759
}

3760
static __be32
3761
nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
L
Linus Torvalds 已提交
3762
{
3763
	struct xdr_stream *xdr = &resp->xdr;
3764
	__be32 *p;
L
Linus Torvalds 已提交
3765 3766

	if (!nfserr) {
3767 3768 3769
		p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3770 3771 3772
		p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
		p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
						NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
3773 3774
	}
	else if (nfserr == nfserr_clid_inuse) {
3775 3776 3777
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3778 3779
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3780
	}
3781
	return nfserr;
L
Linus Torvalds 已提交
3782 3783
}

3784
static __be32
3785
nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
L
Linus Torvalds 已提交
3786
{
3787
	struct xdr_stream *xdr = &resp->xdr;
3788
	__be32 *p;
L
Linus Torvalds 已提交
3789 3790

	if (!nfserr) {
3791 3792 3793
		p = xdr_reserve_space(xdr, 16);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3794 3795
		*p++ = cpu_to_be32(write->wr_bytes_written);
		*p++ = cpu_to_be32(write->wr_how_written);
J
J. Bruce Fields 已提交
3796 3797
		p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
							NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
3798
	}
3799
	return nfserr;
L
Linus Torvalds 已提交
3800 3801
}

3802 3803 3804 3805 3806 3807 3808 3809
static const u32 nfs4_minimal_spo_must_enforce[2] = {
	[1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
	      1 << (OP_EXCHANGE_ID - 32) |
	      1 << (OP_CREATE_SESSION - 32) |
	      1 << (OP_DESTROY_SESSION - 32) |
	      1 << (OP_DESTROY_CLIENTID - 32)
};

A
Andy Adamson 已提交
3810
static __be32
J
J. Bruce Fields 已提交
3811
nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
3812 3813
			 struct nfsd4_exchange_id *exid)
{
3814
	struct xdr_stream *xdr = &resp->xdr;
3815
	__be32 *p;
A
Andy Adamson 已提交
3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829
	char *major_id;
	char *server_scope;
	int major_id_sz;
	int server_scope_sz;
	uint64_t minor_id = 0;

	if (nfserr)
		return nfserr;

	major_id = utsname()->nodename;
	major_id_sz = strlen(major_id);
	server_scope = utsname()->nodename;
	server_scope_sz = strlen(server_scope);

3830
	p = xdr_reserve_space(xdr,
A
Andy Adamson 已提交
3831 3832 3833
		8 /* eir_clientid */ +
		4 /* eir_sequenceid */ +
		4 /* eir_flags */ +
3834
		4 /* spr_how */);
3835 3836
	if (!p)
		return nfserr_resource;
A
Andy Adamson 已提交
3837

J
J. Bruce Fields 已提交
3838
	p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
J
J. Bruce Fields 已提交
3839 3840
	*p++ = cpu_to_be32(exid->seqid);
	*p++ = cpu_to_be32(exid->flags);
A
Andy Adamson 已提交
3841

J
J. Bruce Fields 已提交
3842
	*p++ = cpu_to_be32(exid->spa_how);
3843

3844 3845 3846 3847
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
	case SP4_MACH_CRED:
3848
		/* spo_must_enforce, spo_must_allow */
3849 3850 3851
		p = xdr_reserve_space(xdr, 16);
		if (!p)
			return nfserr_resource;
3852

3853
		/* spo_must_enforce bitmap: */
J
J. Bruce Fields 已提交
3854 3855 3856
		*p++ = cpu_to_be32(2);
		*p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[0]);
		*p++ = cpu_to_be32(nfs4_minimal_spo_must_enforce[1]);
3857
		/* empty spo_must_allow bitmap: */
J
J. Bruce Fields 已提交
3858
		*p++ = cpu_to_be32(0);
3859

3860 3861 3862 3863
		break;
	default:
		WARN_ON_ONCE(1);
	}
A
Andy Adamson 已提交
3864

3865
	p = xdr_reserve_space(xdr,
3866 3867 3868 3869 3870 3871
		8 /* so_minor_id */ +
		4 /* so_major_id.len */ +
		(XDR_QUADLEN(major_id_sz) * 4) +
		4 /* eir_server_scope.len */ +
		(XDR_QUADLEN(server_scope_sz) * 4) +
		4 /* eir_server_impl_id.count (0) */);
3872 3873
	if (!p)
		return nfserr_resource;
3874

A
Andy Adamson 已提交
3875
	/* The server_owner struct */
J
J. Bruce Fields 已提交
3876
	p = xdr_encode_hyper(p, minor_id);      /* Minor id */
A
Andy Adamson 已提交
3877
	/* major id */
J
J. Bruce Fields 已提交
3878
	p = xdr_encode_opaque(p, major_id, major_id_sz);
A
Andy Adamson 已提交
3879 3880

	/* Server scope */
J
J. Bruce Fields 已提交
3881
	p = xdr_encode_opaque(p, server_scope, server_scope_sz);
A
Andy Adamson 已提交
3882 3883

	/* Implementation id */
J
J. Bruce Fields 已提交
3884
	*p++ = cpu_to_be32(0);	/* zero length nfs_impl_id4 array */
A
Andy Adamson 已提交
3885
	return 0;
A
Andy Adamson 已提交
3886 3887 3888
}

static __be32
J
J. Bruce Fields 已提交
3889
nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
3890 3891
			    struct nfsd4_create_session *sess)
{
3892
	struct xdr_stream *xdr = &resp->xdr;
3893
	__be32 *p;
A
Andy Adamson 已提交
3894 3895 3896 3897

	if (nfserr)
		return nfserr;

3898 3899 3900
	p = xdr_reserve_space(xdr, 24);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3901 3902
	p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
					NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
3903 3904
	*p++ = cpu_to_be32(sess->seqid);
	*p++ = cpu_to_be32(sess->flags);
A
Andy Adamson 已提交
3905

3906 3907 3908
	p = xdr_reserve_space(xdr, 28);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3909 3910 3911 3912 3913 3914 3915
	*p++ = cpu_to_be32(0); /* headerpadsz */
	*p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
	*p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
	*p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
	*p++ = cpu_to_be32(sess->fore_channel.maxops);
	*p++ = cpu_to_be32(sess->fore_channel.maxreqs);
	*p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
A
Andy Adamson 已提交
3916 3917

	if (sess->fore_channel.nr_rdma_attrs) {
3918 3919 3920
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3921
		*p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
A
Andy Adamson 已提交
3922 3923
	}

3924 3925 3926
	p = xdr_reserve_space(xdr, 28);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3927 3928 3929 3930 3931 3932 3933
	*p++ = cpu_to_be32(0); /* headerpadsz */
	*p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
	*p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
	*p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
	*p++ = cpu_to_be32(sess->back_channel.maxops);
	*p++ = cpu_to_be32(sess->back_channel.maxreqs);
	*p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
A
Andy Adamson 已提交
3934 3935

	if (sess->back_channel.nr_rdma_attrs) {
3936 3937 3938
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3939
		*p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
A
Andy Adamson 已提交
3940 3941
	}
	return 0;
A
Andy Adamson 已提交
3942 3943
}

D
Daniel Mack 已提交
3944
static __be32
J
J. Bruce Fields 已提交
3945
nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
3946 3947
		      struct nfsd4_sequence *seq)
{
3948
	struct xdr_stream *xdr = &resp->xdr;
3949
	__be32 *p;
B
Benny Halevy 已提交
3950 3951 3952 3953

	if (nfserr)
		return nfserr;

3954 3955 3956
	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3957 3958
	p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
					NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
3959 3960
	*p++ = cpu_to_be32(seq->seqid);
	*p++ = cpu_to_be32(seq->slotid);
3961
	/* Note slotid's are numbered from zero: */
J
J. Bruce Fields 已提交
3962 3963 3964
	*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
	*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
	*p++ = cpu_to_be32(seq->status_flags);
B
Benny Halevy 已提交
3965

3966
	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
B
Benny Halevy 已提交
3967
	return 0;
A
Andy Adamson 已提交
3968 3969
}

J
J. Bruce Fields 已提交
3970
static __be32
J
J. Bruce Fields 已提交
3971
nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
3972 3973
			  struct nfsd4_test_stateid *test_stateid)
{
3974
	struct xdr_stream *xdr = &resp->xdr;
3975
	struct nfsd4_test_stateid_id *stateid, *next;
3976 3977
	__be32 *p;

3978 3979 3980
	if (nfserr)
		return nfserr;

3981 3982 3983
	p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
	if (!p)
		return nfserr_resource;
3984 3985
	*p++ = htonl(test_stateid->ts_num_ids);

3986
	list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
3987
		*p++ = stateid->ts_id_status;
3988 3989 3990 3991 3992
	}

	return nfserr;
}

3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142
#ifdef CONFIG_NFSD_PNFS
static __be32
nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
		struct nfsd4_getdeviceinfo *gdev)
{
	struct xdr_stream *xdr = &resp->xdr;
	const struct nfsd4_layout_ops *ops =
		nfsd4_layout_ops[gdev->gd_layout_type];
	u32 starting_len = xdr->buf->len, needed_len;
	__be32 *p;

	dprintk("%s: err %d\n", __func__, nfserr);
	if (nfserr)
		goto out;

	nfserr = nfserr_resource;
	p = xdr_reserve_space(xdr, 4);
	if (!p)
		goto out;

	*p++ = cpu_to_be32(gdev->gd_layout_type);

	/* If maxcount is 0 then just update notifications */
	if (gdev->gd_maxcount != 0) {
		nfserr = ops->encode_getdeviceinfo(xdr, gdev);
		if (nfserr) {
			/*
			 * We don't bother to burden the layout drivers with
			 * enforcing gd_maxcount, just tell the client to
			 * come back with a bigger buffer if it's not enough.
			 */
			if (xdr->buf->len + 4 > gdev->gd_maxcount)
				goto toosmall;
			goto out;
		}
	}

	nfserr = nfserr_resource;
	if (gdev->gd_notify_types) {
		p = xdr_reserve_space(xdr, 4 + 4);
		if (!p)
			goto out;
		*p++ = cpu_to_be32(1);			/* bitmap length */
		*p++ = cpu_to_be32(gdev->gd_notify_types);
	} else {
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			goto out;
		*p++ = 0;
	}

	nfserr = 0;
out:
	kfree(gdev->gd_device);
	dprintk("%s: done: %d\n", __func__, be32_to_cpu(nfserr));
	return nfserr;

toosmall:
	dprintk("%s: maxcount too small\n", __func__);
	needed_len = xdr->buf->len + 4 /* notifications */;
	xdr_truncate_encode(xdr, starting_len);
	p = xdr_reserve_space(xdr, 4);
	if (!p) {
		nfserr = nfserr_resource;
	} else {
		*p++ = cpu_to_be32(needed_len);
		nfserr = nfserr_toosmall;
	}
	goto out;
}

static __be32
nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
		struct nfsd4_layoutget *lgp)
{
	struct xdr_stream *xdr = &resp->xdr;
	const struct nfsd4_layout_ops *ops =
		nfsd4_layout_ops[lgp->lg_layout_type];
	__be32 *p;

	dprintk("%s: err %d\n", __func__, nfserr);
	if (nfserr)
		goto out;

	nfserr = nfserr_resource;
	p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));
	if (!p)
		goto out;

	*p++ = cpu_to_be32(1);	/* we always set return-on-close */
	*p++ = cpu_to_be32(lgp->lg_sid.si_generation);
	p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque,
				    sizeof(stateid_opaque_t));

	*p++ = cpu_to_be32(1);	/* we always return a single layout */
	p = xdr_encode_hyper(p, lgp->lg_seg.offset);
	p = xdr_encode_hyper(p, lgp->lg_seg.length);
	*p++ = cpu_to_be32(lgp->lg_seg.iomode);
	*p++ = cpu_to_be32(lgp->lg_layout_type);

	nfserr = ops->encode_layoutget(xdr, lgp);
out:
	kfree(lgp->lg_content);
	return nfserr;
}

static __be32
nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
			  struct nfsd4_layoutcommit *lcp)
{
	struct xdr_stream *xdr = &resp->xdr;
	__be32 *p;

	if (nfserr)
		return nfserr;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return nfserr_resource;
	*p++ = cpu_to_be32(lcp->lc_size_chg);
	if (lcp->lc_size_chg) {
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			return nfserr_resource;
		p = xdr_encode_hyper(p, lcp->lc_newsize);
	}

	return nfs_ok;
}

static __be32
nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
		struct nfsd4_layoutreturn *lrp)
{
	struct xdr_stream *xdr = &resp->xdr;
	__be32 *p;

	if (nfserr)
		return nfserr;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return nfserr_resource;
	*p++ = cpu_to_be32(lrp->lrs_present);
	if (lrp->lrs_present)
		nfsd4_encode_stateid(xdr, &lrp->lr_sid);
	return nfs_ok;
}
#endif /* CONFIG_NFSD_PNFS */

A
Anna Schumaker 已提交
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
static __be32
nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
		  struct nfsd4_seek *seek)
{
	__be32 *p;

	if (nfserr)
		return nfserr;

	p = xdr_reserve_space(&resp->xdr, 4 + 8);
	*p++ = cpu_to_be32(seek->seek_eof);
	p = xdr_encode_hyper(p, seek->seek_pos);

	return nfserr;
}

4159 4160 4161 4162 4163 4164 4165 4166
static __be32
nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
{
	return nfserr;
}

typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);

A
Andy Adamson 已提交
4167 4168 4169 4170 4171
/*
 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
 * since we don't need to filter out obsolete ops as this is
 * done in the decoding phase.
 */
4172
static nfsd4_enc nfsd4_enc_ops[] = {
4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188
	[OP_ACCESS]		= (nfsd4_enc)nfsd4_encode_access,
	[OP_CLOSE]		= (nfsd4_enc)nfsd4_encode_close,
	[OP_COMMIT]		= (nfsd4_enc)nfsd4_encode_commit,
	[OP_CREATE]		= (nfsd4_enc)nfsd4_encode_create,
	[OP_DELEGPURGE]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_DELEGRETURN]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_GETATTR]		= (nfsd4_enc)nfsd4_encode_getattr,
	[OP_GETFH]		= (nfsd4_enc)nfsd4_encode_getfh,
	[OP_LINK]		= (nfsd4_enc)nfsd4_encode_link,
	[OP_LOCK]		= (nfsd4_enc)nfsd4_encode_lock,
	[OP_LOCKT]		= (nfsd4_enc)nfsd4_encode_lockt,
	[OP_LOCKU]		= (nfsd4_enc)nfsd4_encode_locku,
	[OP_LOOKUP]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LOOKUPP]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_NVERIFY]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_OPEN]		= (nfsd4_enc)nfsd4_encode_open,
4189
	[OP_OPENATTR]		= (nfsd4_enc)nfsd4_encode_noop,
4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209
	[OP_OPEN_CONFIRM]	= (nfsd4_enc)nfsd4_encode_open_confirm,
	[OP_OPEN_DOWNGRADE]	= (nfsd4_enc)nfsd4_encode_open_downgrade,
	[OP_PUTFH]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_PUTPUBFH]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_PUTROOTFH]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_READ]		= (nfsd4_enc)nfsd4_encode_read,
	[OP_READDIR]		= (nfsd4_enc)nfsd4_encode_readdir,
	[OP_READLINK]		= (nfsd4_enc)nfsd4_encode_readlink,
	[OP_REMOVE]		= (nfsd4_enc)nfsd4_encode_remove,
	[OP_RENAME]		= (nfsd4_enc)nfsd4_encode_rename,
	[OP_RENEW]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_RESTOREFH]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_SAVEFH]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_SECINFO]		= (nfsd4_enc)nfsd4_encode_secinfo,
	[OP_SETATTR]		= (nfsd4_enc)nfsd4_encode_setattr,
	[OP_SETCLIENTID]	= (nfsd4_enc)nfsd4_encode_setclientid,
	[OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
	[OP_VERIFY]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_WRITE]		= (nfsd4_enc)nfsd4_encode_write,
	[OP_RELEASE_LOCKOWNER]	= (nfsd4_enc)nfsd4_encode_noop,
A
Andy Adamson 已提交
4210 4211 4212

	/* NFSv4.1 operations */
	[OP_BACKCHANNEL_CTL]	= (nfsd4_enc)nfsd4_encode_noop,
4213
	[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
A
Andy Adamson 已提交
4214 4215
	[OP_EXCHANGE_ID]	= (nfsd4_enc)nfsd4_encode_exchange_id,
	[OP_CREATE_SESSION]	= (nfsd4_enc)nfsd4_encode_create_session,
4216 4217
	[OP_DESTROY_SESSION]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_FREE_STATEID]	= (nfsd4_enc)nfsd4_encode_noop,
A
Andy Adamson 已提交
4218
	[OP_GET_DIR_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
4219 4220 4221 4222 4223 4224 4225
#ifdef CONFIG_NFSD_PNFS
	[OP_GETDEVICEINFO]	= (nfsd4_enc)nfsd4_encode_getdeviceinfo,
	[OP_GETDEVICELIST]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTCOMMIT]	= (nfsd4_enc)nfsd4_encode_layoutcommit,
	[OP_LAYOUTGET]		= (nfsd4_enc)nfsd4_encode_layoutget,
	[OP_LAYOUTRETURN]	= (nfsd4_enc)nfsd4_encode_layoutreturn,
#else
A
Andy Adamson 已提交
4226 4227 4228 4229 4230
	[OP_GETDEVICEINFO]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_GETDEVICELIST]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTCOMMIT]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTGET]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTRETURN]	= (nfsd4_enc)nfsd4_encode_noop,
4231
#endif
4232
	[OP_SECINFO_NO_NAME]	= (nfsd4_enc)nfsd4_encode_secinfo_no_name,
A
Andy Adamson 已提交
4233 4234
	[OP_SEQUENCE]		= (nfsd4_enc)nfsd4_encode_sequence,
	[OP_SET_SSV]		= (nfsd4_enc)nfsd4_encode_noop,
4235
	[OP_TEST_STATEID]	= (nfsd4_enc)nfsd4_encode_test_stateid,
A
Andy Adamson 已提交
4236 4237 4238
	[OP_WANT_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_DESTROY_CLIENTID]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_RECLAIM_COMPLETE]	= (nfsd4_enc)nfsd4_encode_noop,
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250

	/* NFSv4.2 operations */
	[OP_ALLOCATE]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_COPY]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_COPY_NOTIFY]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_DEALLOCATE]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_IO_ADVISE]		= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTERROR]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_LAYOUTSTATS]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_OFFLOAD_CANCEL]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_OFFLOAD_STATUS]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_READ_PLUS]		= (nfsd4_enc)nfsd4_encode_noop,
A
Anna Schumaker 已提交
4251
	[OP_SEEK]		= (nfsd4_enc)nfsd4_encode_seek,
4252
	[OP_WRITE_SAME]		= (nfsd4_enc)nfsd4_encode_noop,
4253 4254
};

4255
/*
J
J. Bruce Fields 已提交
4256 4257 4258 4259 4260 4261
 * Calculate whether we still have space to encode repsize bytes.
 * There are two considerations:
 *     - For NFS versions >=4.1, the size of the reply must stay within
 *       session limits
 *     - For all NFS versions, we must stay within limited preallocated
 *       buffer space.
4262
 *
J
J. Bruce Fields 已提交
4263 4264 4265 4266
 * This is called before the operation is processed, so can only provide
 * an upper estimate.  For some nonidempotent operations (such as
 * getattr), it's not necessarily a problem if that estimate is wrong,
 * as we can fail it after processing without significant side effects.
4267
 */
J
J. Bruce Fields 已提交
4268
__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
4269
{
4270
	struct xdr_buf *buf = &resp->rqstp->rq_res;
4271
	struct nfsd4_slot *slot = resp->cstate.slot;
4272

4273 4274 4275
	if (buf->len + respsize <= buf->buflen)
		return nfs_ok;
	if (!nfsd4_has_session(&resp->cstate))
4276
		return nfserr_resource;
4277 4278 4279
	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
		WARN_ON_ONCE(1);
		return nfserr_rep_too_big_to_cache;
4280
	}
4281
	return nfserr_rep_too_big;
4282 4283
}

L
Linus Torvalds 已提交
4284 4285 4286
void
nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
{
4287
	struct xdr_stream *xdr = &resp->xdr;
4288
	struct nfs4_stateowner *so = resp->cstate.replay_owner;
4289
	struct svc_rqst *rqstp = resp->rqstp;
4290
	int post_err_offset;
4291
	nfsd4_enc encoder;
4292
	__be32 *p;
L
Linus Torvalds 已提交
4293

4294 4295 4296 4297 4298
	p = xdr_reserve_space(xdr, 8);
	if (!p) {
		WARN_ON_ONCE(1);
		return;
	}
J
J. Bruce Fields 已提交
4299
	*p++ = cpu_to_be32(op->opnum);
4300
	post_err_offset = xdr->buf->len;
L
Linus Torvalds 已提交
4301

4302 4303 4304 4305
	if (op->opnum == OP_ILLEGAL)
		goto status;
	BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
	       !nfsd4_enc_ops[op->opnum]);
4306 4307
	encoder = nfsd4_enc_ops[op->opnum];
	op->status = encoder(resp, op->status, &op->u);
4308 4309
	xdr_commit_encode(xdr);

4310
	/* nfsd4_check_resp_size guarantees enough room for error status */
4311 4312 4313 4314 4315 4316
	if (!op->status) {
		int space_needed = 0;
		if (!nfsd4_last_compound_op(rqstp))
			space_needed = COMPOUND_ERR_SLACK_SPACE;
		op->status = nfsd4_check_resp_size(resp, space_needed);
	}
4317 4318 4319 4320 4321 4322 4323 4324
	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
		struct nfsd4_slot *slot = resp->cstate.slot;

		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
			op->status = nfserr_rep_too_big_to_cache;
		else
			op->status = nfserr_rep_too_big;
	}
4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335
	if (op->status == nfserr_resource ||
	    op->status == nfserr_rep_too_big ||
	    op->status == nfserr_rep_too_big_to_cache) {
		/*
		 * The operation may have already been encoded or
		 * partially encoded.  No op returns anything additional
		 * in the case of one of these three errors, so we can
		 * just truncate back to after the status.  But it's a
		 * bug if we had to do this on a non-idempotent op:
		 */
		warn_on_nonidempotent_op(op);
4336
		xdr_truncate_encode(xdr, post_err_offset);
4337
	}
4338
	if (so) {
4339 4340
		int len = xdr->buf->len - post_err_offset;

4341
		so->so_replay.rp_status = op->status;
4342 4343 4344
		so->so_replay.rp_buflen = len;
		read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
						so->so_replay.rp_buf, len);
4345
	}
4346
status:
4347 4348
	/* Note that op->status is already in network byte order: */
	write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
L
Linus Torvalds 已提交
4349 4350 4351 4352 4353 4354 4355 4356 4357
}

/* 
 * Encode the reply stored in the stateowner reply cache 
 * 
 * XDR note: do not encode rp->rp_buflen: the buffer contains the
 * previously sent already encoded operation.
 */
void
4358
nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
L
Linus Torvalds 已提交
4359
{
4360
	__be32 *p;
L
Linus Torvalds 已提交
4361 4362 4363 4364
	struct nfs4_replay *rp = op->replay;

	BUG_ON(!rp);

4365 4366 4367 4368 4369
	p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
	if (!p) {
		WARN_ON_ONCE(1);
		return;
	}
J
J. Bruce Fields 已提交
4370
	*p++ = cpu_to_be32(op->opnum);
L
Linus Torvalds 已提交
4371 4372
	*p++ = rp->rp_status;  /* already xdr'ed */

J
J. Bruce Fields 已提交
4373
	p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
L
Linus Torvalds 已提交
4374 4375 4376
}

int
A
Al Viro 已提交
4377
nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
L
Linus Torvalds 已提交
4378 4379 4380 4381
{
        return xdr_ressize_check(rqstp, p);
}

4382
int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp)
L
Linus Torvalds 已提交
4383
{
4384 4385 4386
	struct svc_rqst *rqstp = rq;
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

L
Linus Torvalds 已提交
4387 4388 4389 4390
	if (args->ops != args->iops) {
		kfree(args->ops);
		args->ops = args->iops;
	}
J
Jesper Juhl 已提交
4391 4392
	kfree(args->tmpp);
	args->tmpp = NULL;
L
Linus Torvalds 已提交
4393
	while (args->to_free) {
4394
		struct svcxdr_tmpbuf *tb = args->to_free;
L
Linus Torvalds 已提交
4395 4396 4397
		args->to_free = tb->next;
		kfree(tb);
	}
4398
	return 1;
L
Linus Torvalds 已提交
4399 4400 4401
}

int
A
Al Viro 已提交
4402
nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args)
L
Linus Torvalds 已提交
4403
{
4404 4405 4406 4407 4408 4409
	if (rqstp->rq_arg.head[0].iov_len % 4) {
		/* client is nuts */
		dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)",
			__func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid));
		return 0;
	}
L
Linus Torvalds 已提交
4410 4411 4412 4413 4414 4415 4416 4417 4418
	args->p = p;
	args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len;
	args->pagelist = rqstp->rq_arg.pages;
	args->pagelen = rqstp->rq_arg.page_len;
	args->tmpp = NULL;
	args->to_free = NULL;
	args->ops = args->iops;
	args->rqstp = rqstp;

4419
	return !nfsd4_decode_compound(args);
L
Linus Torvalds 已提交
4420 4421 4422
}

int
A
Al Viro 已提交
4423
nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp)
L
Linus Torvalds 已提交
4424 4425 4426 4427
{
	/*
	 * All that remains is to write the tag and operation count...
	 */
4428 4429 4430 4431
	struct xdr_buf *buf = resp->xdr.buf;

	WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
				 buf->tail[0].iov_len);
4432

4433 4434
	rqstp->rq_next_page = resp->xdr.page_ptr + 1;

L
Linus Torvalds 已提交
4435 4436 4437 4438 4439 4440
	p = resp->tagp;
	*p++ = htonl(resp->taglen);
	memcpy(p, resp->tag, resp->taglen);
	p += XDR_QUADLEN(resp->taglen);
	*p++ = htonl(resp->opcnt);

4441
	nfsd4_sequence_done(resp);
L
Linus Torvalds 已提交
4442 4443 4444 4445 4446 4447 4448 4449
	return 1;
}

/*
 * Local variables:
 *  c-basic-offset: 8
 * End:
 */