nfs4xdr.c 115.0 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/fs_struct.h>
37
#include <linux/file.h>
38
#include <linux/slab.h>
L
Linus Torvalds 已提交
39
#include <linux/namei.h>
40
#include <linux/statfs.h>
A
Andy Adamson 已提交
41
#include <linux/utsname.h>
42
#include <linux/pagemap.h>
43
#include <linux/sunrpc/svcauth_gss.h>
44

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

54 55 56 57 58
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
#include <linux/security.h>
#endif


L
Linus Torvalds 已提交
59 60
#define NFSDDBG_FACILITY		NFSDDBG_XDR

J
J. Bruce Fields 已提交
61
const u32 nfsd_suppattrs[3][3] = {
62 63 64 65 66 67 68 69 70 71 72 73 74
	{NFSD4_SUPPORTED_ATTRS_WORD0,
	 NFSD4_SUPPORTED_ATTRS_WORD1,
	 NFSD4_SUPPORTED_ATTRS_WORD2},

	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
	 NFSD4_1_SUPPORTED_ATTRS_WORD2},

	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
	 NFSD4_2_SUPPORTED_ATTRS_WORD2},
};

75 76 77 78 79 80 81 82
/*
 * 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

83
static __be32
84
check_filename(char *str, int len)
L
Linus Torvalds 已提交
85 86 87 88 89 90
{
	int i;

	if (len == 0)
		return nfserr_inval;
	if (isdotent(str, len))
91
		return nfserr_badname;
L
Linus Torvalds 已提交
92 93
	for (i = 0; i < len; i++)
		if (str[i] == '/')
94
			return nfserr_badname;
L
Linus Torvalds 已提交
95 96 97 98
	return 0;
}

#define DECODE_HEAD				\
A
Al Viro 已提交
99
	__be32 *p;				\
100
	__be32 status
L
Linus Torvalds 已提交
101 102 103 104 105
#define DECODE_TAIL				\
	status = 0;				\
out:						\
	return status;				\
xdr_error:					\
106 107
	dprintk("NFSD: xdr error (%s:%d)\n",	\
			__FILE__, __LINE__);	\
L
Linus Torvalds 已提交
108 109 110 111 112 113 114 115 116 117 118
	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)) {			\
119 120
		dprintk("NFSD: xdr error (%s:%d)\n", \
				__FILE__, __LINE__); \
L
Linus Torvalds 已提交
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
		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))) { \
136 137
		dprintk("NFSD: xdr error (%s:%d)\n", \
				__FILE__, __LINE__); \
L
Linus Torvalds 已提交
138 139 140 141
		goto xdr_error;			\
	}					\
} while (0)

J
J. Bruce Fields 已提交
142 143 144
static void next_decode_page(struct nfsd4_compoundargs *argp)
{
	argp->p = page_address(argp->pagelist[0]);
145
	argp->pagelist++;
J
J. Bruce Fields 已提交
146
	if (argp->pagelen < PAGE_SIZE) {
147
		argp->end = argp->p + XDR_QUADLEN(argp->pagelen);
J
J. Bruce Fields 已提交
148 149 150 151 152 153 154
		argp->pagelen = 0;
	} else {
		argp->end = argp->p + (PAGE_SIZE>>2);
		argp->pagelen -= PAGE_SIZE;
	}
}

155
static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes)
L
Linus Torvalds 已提交
156 157 158 159
{
	/* We want more bytes than seem to be available.
	 * Maybe we need a new page, maybe we have just run out
	 */
160
	unsigned int avail = (char *)argp->end - (char *)argp->p;
A
Al Viro 已提交
161
	__be32 *p;
L
Linus Torvalds 已提交
162 163 164 165 166 167 168 169
	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 已提交
170
		kfree(argp->tmpp);
L
Linus Torvalds 已提交
171 172 173 174 175
		p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL);
		if (!p)
			return NULL;
		
	}
176 177 178 179 180
	/*
	 * 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 已提交
181
	memcpy(p, argp->p, avail);
J
J. Bruce Fields 已提交
182
	next_decode_page(argp);
L
Linus Torvalds 已提交
183 184 185 186 187
	memcpy(((char*)p)+avail, argp->p, (nbytes - avail));
	argp->p += XDR_QUADLEN(nbytes - avail);
	return p;
}

A
Andy Adamson 已提交
188 189 190 191 192
static int zero_clientid(clientid_t *clid)
{
	return (clid->cl_boot == 0) && (clid->cl_id == 0);
}

193
/**
194
 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
195 196
 * @argp: NFSv4 compound argument structure
 * @p: pointer to be freed (with kfree())
197 198 199 200
 *
 * Marks @p to be freed when processing the compound operation
 * described in @argp finishes.
 */
201 202
static void *
svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
L
Linus Torvalds 已提交
203
{
204
	struct svcxdr_tmpbuf *tb;
L
Linus Torvalds 已提交
205

206
	tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
L
Linus Torvalds 已提交
207
	if (!tb)
208
		return NULL;
L
Linus Torvalds 已提交
209 210
	tb->next = argp->to_free;
	argp->to_free = tb;
211
	return tb->buf;
L
Linus Torvalds 已提交
212 213
}

214 215 216 217 218 219 220 221 222 223
/*
 * 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)
{
224
	char *p = svcxdr_tmpalloc(argp, len + 1);
225 226 227 228 229 230

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

233 234 235 236 237 238 239 240 241 242
/**
 * 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 已提交
243
static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes)
L
Linus Torvalds 已提交
244
{
245 246 247 248
	void *ret;

	ret = svcxdr_tmpalloc(argp, nbytes);
	if (!ret)
L
Linus Torvalds 已提交
249
		return NULL;
250 251
	memcpy(ret, p, nbytes);
	return ret;
L
Linus Torvalds 已提交
252 253
}

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
/*
 * 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;
}

274
static __be32
L
Linus Torvalds 已提交
275 276 277 278 279 280 281
nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval)
{
	u32 bmlen;
	DECODE_HEAD;

	bmval[0] = 0;
	bmval[1] = 0;
282
	bmval[2] = 0;
L
Linus Torvalds 已提交
283 284

	READ_BUF(4);
J
J. Bruce Fields 已提交
285
	bmlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
286 287 288 289 290
	if (bmlen > 1000)
		goto xdr_error;

	READ_BUF(bmlen << 2);
	if (bmlen > 0)
J
J. Bruce Fields 已提交
291
		bmval[0] = be32_to_cpup(p++);
L
Linus Torvalds 已提交
292
	if (bmlen > 1)
J
J. Bruce Fields 已提交
293
		bmval[1] = be32_to_cpup(p++);
294
	if (bmlen > 2)
J
J. Bruce Fields 已提交
295
		bmval[2] = be32_to_cpup(p++);
L
Linus Torvalds 已提交
296 297 298 299

	DECODE_TAIL;
}

300
static __be32
301
nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval,
302
		   struct iattr *iattr, struct nfs4_acl **acl,
303
		   struct xdr_netobj *label, int *umask)
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313
{
	int expected_len, len = 0;
	u32 dummy32;
	char *buf;

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

314 315 316 317 318 319 320 321
	if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
	    || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
	    || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) {
		if (nfsd_attrs_supported(argp->minorversion, bmval))
			return nfserr_inval;
		return nfserr_attrnotsupp;
	}

L
Linus Torvalds 已提交
322
	READ_BUF(4);
J
J. Bruce Fields 已提交
323
	expected_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
324 325 326 327

	if (bmval[0] & FATTR4_WORD0_SIZE) {
		READ_BUF(8);
		len += 8;
J
J. Bruce Fields 已提交
328
		p = xdr_decode_hyper(p, &iattr->ia_size);
L
Linus Torvalds 已提交
329 330 331
		iattr->ia_valid |= ATTR_SIZE;
	}
	if (bmval[0] & FATTR4_WORD0_ACL) {
332
		u32 nace;
333
		struct nfs4_ace *ace;
L
Linus Torvalds 已提交
334 335

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

338
		if (nace > NFS4_ACL_MAX)
339
			return nfserr_fbig;
340

341
		*acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace));
342 343 344
		if (*acl == NULL)
			return nfserr_jukebox;

345 346
		(*acl)->naces = nace;
		for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) {
L
Linus Torvalds 已提交
347
			READ_BUF(16); len += 16;
J
J. Bruce Fields 已提交
348 349 350 351
			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 已提交
352 353 354
			READ_BUF(dummy32);
			len += XDR_QUADLEN(dummy32) << 2;
			READMEM(buf, dummy32);
355
			ace->whotype = nfs4_acl_get_whotype(buf, dummy32);
356
			status = nfs_ok;
357
			if (ace->whotype != NFS4_ACL_WHO_NAMED)
358
				;
359
			else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
360
				status = nfsd_map_name_to_gid(argp->rqstp,
361
						buf, dummy32, &ace->who_gid);
L
Linus Torvalds 已提交
362
			else
363
				status = nfsd_map_name_to_uid(argp->rqstp,
364
						buf, dummy32, &ace->who_uid);
365 366
			if (status)
				return status;
L
Linus Torvalds 已提交
367 368 369 370 371 372
		}
	} else
		*acl = NULL;
	if (bmval[1] & FATTR4_WORD1_MODE) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
373
		iattr->ia_mode = be32_to_cpup(p++);
L
Linus Torvalds 已提交
374 375 376 377 378 379
		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 已提交
380
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
381 382 383
		READ_BUF(dummy32);
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
384 385
		if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid)))
			return status;
L
Linus Torvalds 已提交
386 387 388 389 390
		iattr->ia_valid |= ATTR_UID;
	}
	if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
391
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
392 393 394
		READ_BUF(dummy32);
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
395 396
		if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid)))
			return status;
L
Linus Torvalds 已提交
397 398 399 400 401
		iattr->ia_valid |= ATTR_GID;
	}
	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
402
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
403 404 405
		switch (dummy32) {
		case NFS4_SET_TO_CLIENT_TIME:
			len += 12;
406 407 408
			status = nfsd4_decode_time(argp, &iattr->ia_atime);
			if (status)
				return status;
L
Linus Torvalds 已提交
409 410 411 412 413 414 415 416 417 418 419 420
			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 已提交
421
		dummy32 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
422 423 424
		switch (dummy32) {
		case NFS4_SET_TO_CLIENT_TIME:
			len += 12;
425 426 427
			status = nfsd4_decode_time(argp, &iattr->ia_mtime);
			if (status)
				return status;
L
Linus Torvalds 已提交
428 429 430 431 432 433 434 435 436
			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;
		}
	}
437 438 439 440 441 442

	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 已提交
443
		dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */
444 445
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
446
		dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */
447 448
		READ_BUF(4);
		len += 4;
J
J. Bruce Fields 已提交
449
		dummy32 = be32_to_cpup(p++);
450
		READ_BUF(dummy32);
451
		if (dummy32 > NFS4_MAXLABELLEN)
452 453 454
			return nfserr_badlabel;
		len += (XDR_QUADLEN(dummy32) << 2);
		READMEM(buf, dummy32);
455 456
		label->len = dummy32;
		label->data = svcxdr_dupstr(argp, buf, dummy32);
457 458 459 460
		if (!label->data)
			return nfserr_jukebox;
	}
#endif
461 462 463 464 465 466 467 468 469 470 471
	if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
		if (!umask)
			goto xdr_error;
		READ_BUF(8);
		len += 8;
		dummy32 = be32_to_cpup(p++);
		iattr->ia_mode = dummy32 & (S_IFMT | S_IALLUGO);
		dummy32 = be32_to_cpup(p++);
		*umask = dummy32 & S_IRWXUGO;
		iattr->ia_valid |= ATTR_MODE;
	}
472
	if (len != expected_len)
L
Linus Torvalds 已提交
473 474 475 476 477
		goto xdr_error;

	DECODE_TAIL;
}

478 479 480 481 482 483
static __be32
nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid)
{
	DECODE_HEAD;

	READ_BUF(sizeof(stateid_t));
J
J. Bruce Fields 已提交
484
	sid->si_generation = be32_to_cpup(p++);
485 486 487 488 489
	COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t));

	DECODE_TAIL;
}

490
static __be32
L
Linus Torvalds 已提交
491 492 493 494 495
nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
496
	access->ac_req_access = be32_to_cpup(p++);
L
Linus Torvalds 已提交
497 498 499 500

	DECODE_TAIL;
}

501 502 503
static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
{
	DECODE_HEAD;
504
	u32 dummy, uid, gid;
505 506 507 508 509 510
	char *machine_name;
	int i;
	int nr_secflavs;

	/* callback_sec_params4 */
	READ_BUF(4);
J
J. Bruce Fields 已提交
511
	nr_secflavs = be32_to_cpup(p++);
512 513 514 515 516
	if (nr_secflavs)
		cbs->flavor = (u32)(-1);
	else
		/* Is this legal? Be generous, take it to mean AUTH_NONE: */
		cbs->flavor = 0;
517 518
	for (i = 0; i < nr_secflavs; ++i) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
519
		dummy = be32_to_cpup(p++);
520 521 522
		switch (dummy) {
		case RPC_AUTH_NULL:
			/* Nothing to read */
523 524
			if (cbs->flavor == (u32)(-1))
				cbs->flavor = RPC_AUTH_NULL;
525 526 527 528
			break;
		case RPC_AUTH_UNIX:
			READ_BUF(8);
			/* stamp */
J
J. Bruce Fields 已提交
529
			dummy = be32_to_cpup(p++);
530 531

			/* machine name */
J
J. Bruce Fields 已提交
532
			dummy = be32_to_cpup(p++);
533 534 535 536 537
			READ_BUF(dummy);
			SAVEMEM(machine_name, dummy);

			/* uid, gid */
			READ_BUF(8);
J
J. Bruce Fields 已提交
538 539
			uid = be32_to_cpup(p++);
			gid = be32_to_cpup(p++);
540 541 542

			/* more gids */
			READ_BUF(4);
J
J. Bruce Fields 已提交
543
			dummy = be32_to_cpup(p++);
544
			READ_BUF(dummy * 4);
545
			if (cbs->flavor == (u32)(-1)) {
546 547 548 549 550 551 552 553 554 555
				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");
				}
556
			}
557 558 559 560 561 562
			break;
		case RPC_AUTH_GSS:
			dprintk("RPC_AUTH_GSS callback secflavor "
				"not supported!\n");
			READ_BUF(8);
			/* gcbp_service */
J
J. Bruce Fields 已提交
563
			dummy = be32_to_cpup(p++);
564
			/* gcbp_handle_from_server */
J
J. Bruce Fields 已提交
565
			dummy = be32_to_cpup(p++);
566 567 568 569
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
			/* gcbp_handle_from_client */
			READ_BUF(4);
J
J. Bruce Fields 已提交
570
			dummy = be32_to_cpup(p++);
571 572 573 574 575 576 577 578 579 580
			READ_BUF(dummy);
			break;
		default:
			dprintk("Illegal callback secflavor\n");
			return nfserr_inval;
		}
	}
	DECODE_TAIL;
}

581 582 583 584 585
static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
586
	bc->bc_cb_program = be32_to_cpup(p++);
587 588 589 590 591
	nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);

	DECODE_TAIL;
}

592 593 594 595 596 597
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 已提交
598
	bcts->dir = be32_to_cpup(p++);
599 600
	/* XXX: skipping ctsa_use_conn_in_rdma_mode.  Perhaps Tom Tucker
	 * could help us figure out we should be using it. */
601 602 603
	DECODE_TAIL;
}

604
static __be32
L
Linus Torvalds 已提交
605 606 607 608
nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
{
	DECODE_HEAD;

609
	READ_BUF(4);
J
J. Bruce Fields 已提交
610
	close->cl_seqid = be32_to_cpup(p++);
611
	return nfsd4_decode_stateid(argp, &close->cl_stateid);
L
Linus Torvalds 已提交
612 613 614 615 616

	DECODE_TAIL;
}


617
static __be32
L
Linus Torvalds 已提交
618 619 620 621 622
nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
{
	DECODE_HEAD;

	READ_BUF(12);
J
J. Bruce Fields 已提交
623
	p = xdr_decode_hyper(p, &commit->co_offset);
J
J. Bruce Fields 已提交
624
	commit->co_count = be32_to_cpup(p++);
L
Linus Torvalds 已提交
625 626 627 628

	DECODE_TAIL;
}

629
static __be32
L
Linus Torvalds 已提交
630 631 632 633 634
nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
635
	create->cr_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
636 637 638
	switch (create->cr_type) {
	case NF4LNK:
		READ_BUF(4);
639 640
		create->cr_datalen = be32_to_cpup(p++);
		READ_BUF(create->cr_datalen);
641
		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
642
		if (!create->cr_data)
643
			return nfserr_jukebox;
L
Linus Torvalds 已提交
644 645 646 647
		break;
	case NF4BLK:
	case NF4CHR:
		READ_BUF(8);
J
J. Bruce Fields 已提交
648 649
		create->cr_specdata1 = be32_to_cpup(p++);
		create->cr_specdata2 = be32_to_cpup(p++);
L
Linus Torvalds 已提交
650 651 652 653 654 655 656 657 658
		break;
	case NF4SOCK:
	case NF4FIFO:
	case NF4DIR:
	default:
		break;
	}

	READ_BUF(4);
J
J. Bruce Fields 已提交
659
	create->cr_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
660 661
	READ_BUF(create->cr_namelen);
	SAVEMEM(create->cr_name, create->cr_namelen);
662
	if ((status = check_filename(create->cr_name, create->cr_namelen)))
L
Linus Torvalds 已提交
663 664
		return status;

665
	status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr,
666 667
				    &create->cr_acl, &create->cr_label,
				    &current->fs->umask);
668
	if (status)
L
Linus Torvalds 已提交
669 670 671 672 673
		goto out;

	DECODE_TAIL;
}

674
static inline __be32
L
Linus Torvalds 已提交
675 676
nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
{
677
	return nfsd4_decode_stateid(argp, &dr->dr_stateid);
L
Linus Torvalds 已提交
678 679
}

680
static inline __be32
L
Linus Torvalds 已提交
681 682 683 684 685
nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
{
	return nfsd4_decode_bitmap(argp, getattr->ga_bmval);
}

686
static __be32
L
Linus Torvalds 已提交
687 688 689 690 691
nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
692
	link->li_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
693 694
	READ_BUF(link->li_namelen);
	SAVEMEM(link->li_name, link->li_namelen);
695
	if ((status = check_filename(link->li_name, link->li_namelen)))
L
Linus Torvalds 已提交
696 697 698 699 700
		return status;

	DECODE_TAIL;
}

701
static __be32
L
Linus Torvalds 已提交
702 703 704 705 706 707 708 709
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 已提交
710
	lock->lk_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
711 712
	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
713
	lock->lk_reclaim = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
714 715
	p = xdr_decode_hyper(p, &lock->lk_offset);
	p = xdr_decode_hyper(p, &lock->lk_length);
J
J. Bruce Fields 已提交
716
	lock->lk_is_new = be32_to_cpup(p++);
L
Linus Torvalds 已提交
717 718

	if (lock->lk_is_new) {
719
		READ_BUF(4);
J
J. Bruce Fields 已提交
720
		lock->lk_new_open_seqid = be32_to_cpup(p++);
721 722 723 724
		status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid);
		if (status)
			return status;
		READ_BUF(8 + sizeof(clientid_t));
J
J. Bruce Fields 已提交
725
		lock->lk_new_lock_seqid = be32_to_cpup(p++);
L
Linus Torvalds 已提交
726
		COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t));
J
J. Bruce Fields 已提交
727
		lock->lk_new_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
728 729 730
		READ_BUF(lock->lk_new_owner.len);
		READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len);
	} else {
731 732 733 734
		status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid);
		if (status)
			return status;
		READ_BUF(4);
J
J. Bruce Fields 已提交
735
		lock->lk_old_lock_seqid = be32_to_cpup(p++);
L
Linus Torvalds 已提交
736 737 738 739 740
	}

	DECODE_TAIL;
}

741
static __be32
L
Linus Torvalds 已提交
742 743 744 745 746
nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
{
	DECODE_HEAD;
		        
	READ_BUF(32);
J
J. Bruce Fields 已提交
747
	lockt->lt_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
748 749
	if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
750 751
	p = xdr_decode_hyper(p, &lockt->lt_offset);
	p = xdr_decode_hyper(p, &lockt->lt_length);
L
Linus Torvalds 已提交
752
	COPYMEM(&lockt->lt_clientid, 8);
J
J. Bruce Fields 已提交
753
	lockt->lt_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
754 755 756 757 758 759
	READ_BUF(lockt->lt_owner.len);
	READMEM(lockt->lt_owner.data, lockt->lt_owner.len);

	DECODE_TAIL;
}

760
static __be32
L
Linus Torvalds 已提交
761 762 763 764
nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
{
	DECODE_HEAD;

765
	READ_BUF(8);
J
J. Bruce Fields 已提交
766
	locku->lu_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
767 768
	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
		goto xdr_error;
J
J. Bruce Fields 已提交
769
	locku->lu_seqid = be32_to_cpup(p++);
770 771 772 773
	status = nfsd4_decode_stateid(argp, &locku->lu_stateid);
	if (status)
		return status;
	READ_BUF(16);
J
J. Bruce Fields 已提交
774 775
	p = xdr_decode_hyper(p, &locku->lu_offset);
	p = xdr_decode_hyper(p, &locku->lu_length);
L
Linus Torvalds 已提交
776 777 778 779

	DECODE_TAIL;
}

780
static __be32
L
Linus Torvalds 已提交
781 782 783 784 785
nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
786
	lookup->lo_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
787 788
	READ_BUF(lookup->lo_len);
	SAVEMEM(lookup->lo_name, lookup->lo_len);
789
	if ((status = check_filename(lookup->lo_name, lookup->lo_len)))
L
Linus Torvalds 已提交
790 791 792 793 794
		return status;

	DECODE_TAIL;
}

795
static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
796 797 798 799 800
{
	__be32 *p;
	u32 w;

	READ_BUF(4);
J
J. Bruce Fields 已提交
801
	w = be32_to_cpup(p++);
802 803 804 805 806
	*share_access = w & NFS4_SHARE_ACCESS_MASK;
	*deleg_want = w & NFS4_SHARE_WANT_MASK;
	if (deleg_when)
		*deleg_when = w & NFS4_SHARE_WHEN_MASK;

807 808 809 810 811 812 813 814
	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;
	}
815
	w &= ~NFS4_SHARE_ACCESS_MASK;
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
	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;
	}
831
	w &= ~NFS4_SHARE_WANT_MASK;
832 833
	if (!w)
		return nfs_ok;
834 835 836

	if (!deleg_when)	/* open_downgrade */
		return nfserr_inval;
837 838 839
	switch (w) {
	case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
	case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
840 841
	case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
	      NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
842 843 844 845 846 847 848 849 850 851 852
		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 已提交
853
	*x = be32_to_cpup(p++);
854
	/* Note: unlinke access bits, deny bits may be zero. */
855
	if (*x & ~NFS4_SHARE_DENY_BOTH)
856 857 858 859 860 861
		return nfserr_bad_xdr;
	return nfs_ok;
xdr_error:
	return nfserr_bad_xdr;
}

862 863 864 865 866
static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
{
	__be32 *p;

	READ_BUF(4);
J
J. Bruce Fields 已提交
867
	o->len = be32_to_cpup(p++);
868 869 870 871 872 873 874 875 876 877 878

	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;
}

879
static __be32
L
Linus Torvalds 已提交
880 881 882
nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
{
	DECODE_HEAD;
883
	u32 dummy;
L
Linus Torvalds 已提交
884 885 886

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

889
	open->op_xdr_error = 0;
L
Linus Torvalds 已提交
890
	/* seqid, share_access, share_deny, clientid, ownerlen */
891
	READ_BUF(4);
J
J. Bruce Fields 已提交
892
	open->op_seqid = be32_to_cpup(p++);
893 894 895
	/* decode, yet ignore deleg_when until supported */
	status = nfsd4_decode_share_access(argp, &open->op_share_access,
					   &open->op_deleg_want, &dummy);
896 897 898 899 900
	if (status)
		goto xdr_error;
	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
	if (status)
		goto xdr_error;
901
	READ_BUF(sizeof(clientid_t));
L
Linus Torvalds 已提交
902
	COPYMEM(&open->op_clientid, sizeof(clientid_t));
903 904 905 906
	status = nfsd4_decode_opaque(argp, &open->op_owner);
	if (status)
		goto xdr_error;
	READ_BUF(4);
J
J. Bruce Fields 已提交
907
	open->op_create = be32_to_cpup(p++);
L
Linus Torvalds 已提交
908 909 910 911
	switch (open->op_create) {
	case NFS4_OPEN_NOCREATE:
		break;
	case NFS4_OPEN_CREATE:
912
		current->fs->umask = 0;
L
Linus Torvalds 已提交
913
		READ_BUF(4);
J
J. Bruce Fields 已提交
914
		open->op_createmode = be32_to_cpup(p++);
L
Linus Torvalds 已提交
915 916 917
		switch (open->op_createmode) {
		case NFS4_CREATE_UNCHECKED:
		case NFS4_CREATE_GUARDED:
918
			status = nfsd4_decode_fattr(argp, open->op_bmval,
919 920
				&open->op_iattr, &open->op_acl, &open->op_label,
				&current->fs->umask);
921
			if (status)
L
Linus Torvalds 已提交
922 923 924
				goto out;
			break;
		case NFS4_CREATE_EXCLUSIVE:
925 926
			READ_BUF(NFS4_VERIFIER_SIZE);
			COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
927
			break;
B
Benny Halevy 已提交
928 929 930
		case NFS4_CREATE_EXCLUSIVE4_1:
			if (argp->minorversion < 1)
				goto xdr_error;
931 932
			READ_BUF(NFS4_VERIFIER_SIZE);
			COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE);
B
Benny Halevy 已提交
933
			status = nfsd4_decode_fattr(argp, open->op_bmval,
934 935
				&open->op_iattr, &open->op_acl, &open->op_label,
				&current->fs->umask);
B
Benny Halevy 已提交
936 937 938
			if (status)
				goto out;
			break;
L
Linus Torvalds 已提交
939 940 941 942 943 944 945 946 947 948
		default:
			goto xdr_error;
		}
		break;
	default:
		goto xdr_error;
	}

	/* open_claim */
	READ_BUF(4);
J
J. Bruce Fields 已提交
949
	open->op_claim_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
950 951 952 953
	switch (open->op_claim_type) {
	case NFS4_OPEN_CLAIM_NULL:
	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
		READ_BUF(4);
J
J. Bruce Fields 已提交
954
		open->op_fname.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
955 956
		READ_BUF(open->op_fname.len);
		SAVEMEM(open->op_fname.data, open->op_fname.len);
957
		if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
L
Linus Torvalds 已提交
958 959 960 961
			return status;
		break;
	case NFS4_OPEN_CLAIM_PREVIOUS:
		READ_BUF(4);
J
J. Bruce Fields 已提交
962
		open->op_delegate_type = be32_to_cpup(p++);
L
Linus Torvalds 已提交
963 964
		break;
	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
965 966 967 968
		status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid);
		if (status)
			return status;
		READ_BUF(4);
J
J. Bruce Fields 已提交
969
		open->op_fname.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
970 971
		READ_BUF(open->op_fname.len);
		SAVEMEM(open->op_fname.data, open->op_fname.len);
972
		if ((status = check_filename(open->op_fname.data, open->op_fname.len)))
L
Linus Torvalds 已提交
973 974
			return status;
		break;
975 976 977 978 979 980 981 982 983 984 985 986 987
	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 已提交
988 989 990 991 992 993 994
	default:
		goto xdr_error;
	}

	DECODE_TAIL;
}

995
static __be32
L
Linus Torvalds 已提交
996 997 998
nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
{
	DECODE_HEAD;
999 1000 1001 1002

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

1003 1004 1005 1006
	status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid);
	if (status)
		return status;
	READ_BUF(4);
J
J. Bruce Fields 已提交
1007
	open_conf->oc_seqid = be32_to_cpup(p++);
1008

L
Linus Torvalds 已提交
1009 1010 1011
	DECODE_TAIL;
}

1012
static __be32
L
Linus Torvalds 已提交
1013 1014 1015 1016
nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
{
	DECODE_HEAD;
		    
1017 1018 1019
	status = nfsd4_decode_stateid(argp, &open_down->od_stateid);
	if (status)
		return status;
1020
	READ_BUF(4);
J
J. Bruce Fields 已提交
1021
	open_down->od_seqid = be32_to_cpup(p++);
1022 1023
	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
					   &open_down->od_deleg_want, NULL);
1024 1025 1026 1027 1028
	if (status)
		return status;
	status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
	if (status)
		return status;
L
Linus Torvalds 已提交
1029 1030 1031
	DECODE_TAIL;
}

1032
static __be32
L
Linus Torvalds 已提交
1033 1034 1035 1036 1037
nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1038
	putfh->pf_fhlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1039 1040 1041 1042 1043 1044 1045 1046
	if (putfh->pf_fhlen > NFS4_FHSIZE)
		goto xdr_error;
	READ_BUF(putfh->pf_fhlen);
	SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen);

	DECODE_TAIL;
}

1047 1048 1049 1050 1051 1052 1053 1054
static __be32
nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p)
{
	if (argp->minorversion == 0)
		return nfs_ok;
	return nfserr_notsupp;
}

1055
static __be32
L
Linus Torvalds 已提交
1056 1057 1058 1059
nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
{
	DECODE_HEAD;

1060 1061 1062 1063
	status = nfsd4_decode_stateid(argp, &read->rd_stateid);
	if (status)
		return status;
	READ_BUF(12);
J
J. Bruce Fields 已提交
1064
	p = xdr_decode_hyper(p, &read->rd_offset);
J
J. Bruce Fields 已提交
1065
	read->rd_length = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1066 1067 1068 1069

	DECODE_TAIL;
}

1070
static __be32
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075
nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
{
	DECODE_HEAD;

	READ_BUF(24);
J
J. Bruce Fields 已提交
1076
	p = xdr_decode_hyper(p, &readdir->rd_cookie);
L
Linus Torvalds 已提交
1077
	COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data));
J
J. Bruce Fields 已提交
1078 1079
	readdir->rd_dircount = be32_to_cpup(p++);
	readdir->rd_maxcount = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1080 1081 1082 1083 1084 1085
	if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval)))
		goto out;

	DECODE_TAIL;
}

1086
static __be32
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091
nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1092
	remove->rm_namelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1093 1094
	READ_BUF(remove->rm_namelen);
	SAVEMEM(remove->rm_name, remove->rm_namelen);
1095
	if ((status = check_filename(remove->rm_name, remove->rm_namelen)))
L
Linus Torvalds 已提交
1096 1097 1098 1099 1100
		return status;

	DECODE_TAIL;
}

1101
static __be32
L
Linus Torvalds 已提交
1102 1103 1104 1105 1106
nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1107
	rename->rn_snamelen = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
1108
	READ_BUF(rename->rn_snamelen);
L
Linus Torvalds 已提交
1109
	SAVEMEM(rename->rn_sname, rename->rn_snamelen);
J
J. Bruce Fields 已提交
1110
	READ_BUF(4);
J
J. Bruce Fields 已提交
1111
	rename->rn_tnamelen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1112 1113
	READ_BUF(rename->rn_tnamelen);
	SAVEMEM(rename->rn_tname, rename->rn_tnamelen);
1114
	if ((status = check_filename(rename->rn_sname, rename->rn_snamelen)))
L
Linus Torvalds 已提交
1115
		return status;
1116
	if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen)))
L
Linus Torvalds 已提交
1117 1118 1119 1120 1121
		return status;

	DECODE_TAIL;
}

1122
static __be32
L
Linus Torvalds 已提交
1123 1124 1125 1126
nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
{
	DECODE_HEAD;

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

L
Linus Torvalds 已提交
1130 1131 1132 1133 1134 1135
	READ_BUF(sizeof(clientid_t));
	COPYMEM(clientid, sizeof(clientid_t));

	DECODE_TAIL;
}

A
Andy Adamson 已提交
1136 1137 1138 1139 1140 1141 1142
static __be32
nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
		     struct nfsd4_secinfo *secinfo)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1143
	secinfo->si_namelen = be32_to_cpup(p++);
A
Andy Adamson 已提交
1144 1145
	READ_BUF(secinfo->si_namelen);
	SAVEMEM(secinfo->si_name, secinfo->si_namelen);
1146
	status = check_filename(secinfo->si_name, secinfo->si_namelen);
A
Andy Adamson 已提交
1147 1148 1149 1150 1151
	if (status)
		return status;
	DECODE_TAIL;
}

J
J. Bruce Fields 已提交
1152 1153 1154 1155 1156 1157 1158
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 已提交
1159
	sin->sin_style = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
1160 1161 1162
	DECODE_TAIL;
}

1163
static __be32
L
Linus Torvalds 已提交
1164 1165
nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
{
1166
	__be32 status;
L
Linus Torvalds 已提交
1167

1168 1169 1170
	status = nfsd4_decode_stateid(argp, &setattr->sa_stateid);
	if (status)
		return status;
1171
	return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr,
1172
				  &setattr->sa_acl, &setattr->sa_label, NULL);
L
Linus Torvalds 已提交
1173 1174
}

1175
static __be32
L
Linus Torvalds 已提交
1176 1177 1178 1179
nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
{
	DECODE_HEAD;

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

1183 1184
	READ_BUF(NFS4_VERIFIER_SIZE);
	COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1185

1186 1187 1188 1189
	status = nfsd4_decode_opaque(argp, &setclientid->se_name);
	if (status)
		return nfserr_bad_xdr;
	READ_BUF(8);
J
J. Bruce Fields 已提交
1190 1191
	setclientid->se_callback_prog = be32_to_cpup(p++);
	setclientid->se_callback_netid_len = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
1192
	READ_BUF(setclientid->se_callback_netid_len);
L
Linus Torvalds 已提交
1193
	SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len);
J
J. Bruce Fields 已提交
1194
	READ_BUF(4);
J
J. Bruce Fields 已提交
1195
	setclientid->se_callback_addr_len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1196

J
J. Bruce Fields 已提交
1197
	READ_BUF(setclientid->se_callback_addr_len);
L
Linus Torvalds 已提交
1198
	SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len);
J
J. Bruce Fields 已提交
1199
	READ_BUF(4);
J
J. Bruce Fields 已提交
1200
	setclientid->se_callback_ident = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1201 1202 1203 1204

	DECODE_TAIL;
}

1205
static __be32
L
Linus Torvalds 已提交
1206 1207 1208 1209
nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
{
	DECODE_HEAD;

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

1213
	READ_BUF(8 + NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1214
	COPYMEM(&scd_c->sc_clientid, 8);
1215
	COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
1216 1217 1218 1219 1220

	DECODE_TAIL;
}

/* Also used for NVERIFY */
1221
static __be32
L
Linus Torvalds 已提交
1222 1223 1224 1225 1226 1227 1228 1229
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
1230 1231
	 * nfsd4_proc_verify */

L
Linus Torvalds 已提交
1232
	READ_BUF(4);
J
J. Bruce Fields 已提交
1233
	verify->ve_attrlen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239
	READ_BUF(verify->ve_attrlen);
	SAVEMEM(verify->ve_attrval, verify->ve_attrlen);

	DECODE_TAIL;
}

1240
static __be32
L
Linus Torvalds 已提交
1241 1242 1243 1244 1245 1246
nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
{
	int avail;
	int len;
	DECODE_HEAD;

1247 1248 1249 1250
	status = nfsd4_decode_stateid(argp, &write->wr_stateid);
	if (status)
		return status;
	READ_BUF(16);
J
J. Bruce Fields 已提交
1251
	p = xdr_decode_hyper(p, &write->wr_offset);
J
J. Bruce Fields 已提交
1252
	write->wr_stable_how = be32_to_cpup(p++);
1253
	if (write->wr_stable_how > NFS_FILE_SYNC)
L
Linus Torvalds 已提交
1254
		goto xdr_error;
J
J. Bruce Fields 已提交
1255
	write->wr_buflen = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261 1262

	/* 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) {
1263 1264
		dprintk("NFSD: xdr error (%s:%d)\n",
				__FILE__, __LINE__);
L
Linus Torvalds 已提交
1265 1266
		goto xdr_error;
	}
1267 1268 1269
	write->wr_head.iov_base = p;
	write->wr_head.iov_len = avail;
	write->wr_pagelist = argp->pagelist;
J
J. Bruce Fields 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281

	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;

1282
		next_decode_page(argp);
L
Linus Torvalds 已提交
1283
	}
J
J. Bruce Fields 已提交
1284
	argp->p += XDR_QUADLEN(len);
L
Linus Torvalds 已提交
1285 1286 1287 1288

	DECODE_TAIL;
}

1289
static __be32
L
Linus Torvalds 已提交
1290 1291 1292 1293
nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
{
	DECODE_HEAD;

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

L
Linus Torvalds 已提交
1297 1298
	READ_BUF(12);
	COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t));
J
J. Bruce Fields 已提交
1299
	rlockowner->rl_owner.len = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1300 1301 1302
	READ_BUF(rlockowner->rl_owner.len);
	READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len);

A
Andy Adamson 已提交
1303 1304
	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
		return nfserr_inval;
L
Linus Torvalds 已提交
1305 1306 1307
	DECODE_TAIL;
}

A
Andy Adamson 已提交
1308 1309
static __be32
nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
A
Andy Adamson 已提交
1310
			 struct nfsd4_exchange_id *exid)
A
Andy Adamson 已提交
1311
{
1312
	int dummy, tmp;
A
Andy Adamson 已提交
1313 1314 1315 1316 1317
	DECODE_HEAD;

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

1318 1319 1320
	status = nfsd4_decode_opaque(argp, &exid->clname);
	if (status)
		return nfserr_bad_xdr;
A
Andy Adamson 已提交
1321 1322

	READ_BUF(4);
J
J. Bruce Fields 已提交
1323
	exid->flags = be32_to_cpup(p++);
A
Andy Adamson 已提交
1324 1325 1326

	/* Ignore state_protect4_a */
	READ_BUF(4);
J
J. Bruce Fields 已提交
1327
	exid->spa_how = be32_to_cpup(p++);
A
Andy Adamson 已提交
1328 1329 1330 1331 1332
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
	case SP4_MACH_CRED:
		/* spo_must_enforce */
1333 1334 1335 1336
		status = nfsd4_decode_bitmap(argp,
					exid->spo_must_enforce);
		if (status)
			goto out;
A
Andy Adamson 已提交
1337
		/* spo_must_allow */
1338 1339 1340
		status = nfsd4_decode_bitmap(argp, exid->spo_must_allow);
		if (status)
			goto out;
A
Andy Adamson 已提交
1341 1342 1343 1344
		break;
	case SP4_SSV:
		/* ssp_ops */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1345
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1346 1347 1348 1349
		READ_BUF(dummy * 4);
		p += dummy;

		READ_BUF(4);
J
J. Bruce Fields 已提交
1350
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1351 1352 1353 1354 1355
		READ_BUF(dummy * 4);
		p += dummy;

		/* ssp_hash_algs<> */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1356
		tmp = be32_to_cpup(p++);
1357 1358
		while (tmp--) {
			READ_BUF(4);
J
J. Bruce Fields 已提交
1359
			dummy = be32_to_cpup(p++);
1360 1361 1362
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
		}
A
Andy Adamson 已提交
1363 1364 1365

		/* ssp_encr_algs<> */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1366
		tmp = be32_to_cpup(p++);
1367 1368
		while (tmp--) {
			READ_BUF(4);
J
J. Bruce Fields 已提交
1369
			dummy = be32_to_cpup(p++);
1370 1371 1372
			READ_BUF(dummy);
			p += XDR_QUADLEN(dummy);
		}
A
Andy Adamson 已提交
1373 1374 1375

		/* ssp_window and ssp_num_gss_handles */
		READ_BUF(8);
J
J. Bruce Fields 已提交
1376 1377
		dummy = be32_to_cpup(p++);
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1378 1379 1380 1381 1382 1383 1384
		break;
	default:
		goto xdr_error;
	}

	/* Ignore Implementation ID */
	READ_BUF(4);    /* nfs_impl_id4 array length */
J
J. Bruce Fields 已提交
1385
	dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1386 1387 1388 1389 1390 1391 1392

	if (dummy > 1)
		goto xdr_error;

	if (dummy == 1) {
		/* nii_domain */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1393
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1394 1395 1396 1397 1398
		READ_BUF(dummy);
		p += XDR_QUADLEN(dummy);

		/* nii_name */
		READ_BUF(4);
J
J. Bruce Fields 已提交
1399
		dummy = be32_to_cpup(p++);
A
Andy Adamson 已提交
1400 1401 1402 1403 1404 1405 1406 1407
		READ_BUF(dummy);
		p += XDR_QUADLEN(dummy);

		/* nii_date */
		READ_BUF(12);
		p += 3;
	}
	DECODE_TAIL;
A
Andy Adamson 已提交
1408 1409 1410 1411 1412 1413
}

static __be32
nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
			    struct nfsd4_create_session *sess)
{
A
Andy Adamson 已提交
1414 1415 1416 1417 1418
	DECODE_HEAD;
	u32 dummy;

	READ_BUF(16);
	COPYMEM(&sess->clientid, 8);
J
J. Bruce Fields 已提交
1419 1420
	sess->seqid = be32_to_cpup(p++);
	sess->flags = be32_to_cpup(p++);
A
Andy Adamson 已提交
1421 1422 1423

	/* Fore channel attrs */
	READ_BUF(28);
J
J. Bruce Fields 已提交
1424 1425 1426 1427 1428 1429 1430
	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 已提交
1431 1432
	if (sess->fore_channel.nr_rdma_attrs == 1) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
1433
		sess->fore_channel.rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1434 1435 1436 1437 1438 1439 1440
	} 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 已提交
1441 1442 1443 1444 1445 1446 1447
	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 已提交
1448 1449
	if (sess->back_channel.nr_rdma_attrs == 1) {
		READ_BUF(4);
J
J. Bruce Fields 已提交
1450
		sess->back_channel.rdma_attrs = be32_to_cpup(p++);
A
Andy Adamson 已提交
1451 1452 1453 1454 1455
	} else if (sess->back_channel.nr_rdma_attrs > 1) {
		dprintk("Too many back channel attr bitmaps!\n");
		goto xdr_error;
	}

1456
	READ_BUF(4);
J
J. Bruce Fields 已提交
1457
	sess->callback_prog = be32_to_cpup(p++);
1458
	nfsd4_decode_cb_sec(argp, &sess->cb_sec);
A
Andy Adamson 已提交
1459
	DECODE_TAIL;
A
Andy Adamson 已提交
1460 1461 1462 1463 1464 1465
}

static __be32
nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
			     struct nfsd4_destroy_session *destroy_session)
{
B
Benny Halevy 已提交
1466 1467 1468 1469 1470
	DECODE_HEAD;
	READ_BUF(NFS4_MAX_SESSIONID_LEN);
	COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN);

	DECODE_TAIL;
A
Andy Adamson 已提交
1471 1472
}

1473 1474 1475 1476 1477 1478 1479
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 已提交
1480
	free_stateid->fr_stateid.si_generation = be32_to_cpup(p++);
1481 1482 1483 1484 1485
	COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t));

	DECODE_TAIL;
}

A
Andy Adamson 已提交
1486 1487 1488 1489
static __be32
nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
		      struct nfsd4_sequence *seq)
{
B
Benny Halevy 已提交
1490 1491 1492 1493
	DECODE_HEAD;

	READ_BUF(NFS4_MAX_SESSIONID_LEN + 16);
	COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
1494 1495 1496 1497
	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 已提交
1498 1499

	DECODE_TAIL;
A
Andy Adamson 已提交
1500 1501
}

1502 1503 1504 1505
static __be32
nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
{
	int i;
1506 1507
	__be32 *p, status;
	struct nfsd4_test_stateid_id *stateid;
1508 1509 1510 1511

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

1512
	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
1513 1514

	for (i = 0; i < test_stateid->ts_num_ids; i++) {
1515
		stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
1516
		if (!stateid) {
1517
			status = nfserrno(-ENOMEM);
1518 1519 1520 1521 1522 1523 1524
			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);
1525
		if (status)
1526
			goto out;
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
	}

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

1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
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;
}

1548 1549 1550 1551 1552
static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc)
{
	DECODE_HEAD;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1553
	rc->rca_one_fs = be32_to_cpup(p++);
1554 1555 1556 1557

	DECODE_TAIL;
}

1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
#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);
1597 1598 1599 1600 1601

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

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
	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++);
1619 1620 1621 1622 1623

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

1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
	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);
1671 1672 1673 1674 1675

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

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
		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 已提交
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
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;
}

1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
static __be32
nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone)
{
	DECODE_HEAD;

	status = nfsd4_decode_stateid(argp, &clone->cl_src_stateid);
	if (status)
		return status;
	status = nfsd4_decode_stateid(argp, &clone->cl_dst_stateid);
	if (status)
		return status;

	READ_BUF(8 + 8 + 8);
	p = xdr_decode_hyper(p, &clone->cl_src_pos);
	p = xdr_decode_hyper(p, &clone->cl_dst_pos);
	p = xdr_decode_hyper(p, &clone->cl_count);
	DECODE_TAIL;
}

A
Anna Schumaker 已提交
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
static __be32
nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)
{
	DECODE_HEAD;
	unsigned int tmp;

	status = nfsd4_decode_stateid(argp, &copy->cp_src_stateid);
	if (status)
		return status;
	status = nfsd4_decode_stateid(argp, &copy->cp_dst_stateid);
	if (status)
		return status;

	READ_BUF(8 + 8 + 8 + 4 + 4 + 4);
	p = xdr_decode_hyper(p, &copy->cp_src_pos);
	p = xdr_decode_hyper(p, &copy->cp_dst_pos);
	p = xdr_decode_hyper(p, &copy->cp_count);
	copy->cp_consecutive = be32_to_cpup(p++);
	copy->cp_synchronous = be32_to_cpup(p++);
	tmp = be32_to_cpup(p); /* Source server list not supported */

	DECODE_TAIL;
}

A
Anna Schumaker 已提交
1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
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;
}

1767 1768 1769 1770 1771 1772
static __be32
nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
{
	return nfs_ok;
}

1773 1774 1775
static __be32
nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
{
1776
	return nfserr_notsupp;
1777 1778
}

1779 1780 1781
typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);

static nfsd4_dec nfsd4_dec_ops[] = {
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
	[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,
1802
	[OP_PUTPUBFH]		= (nfsd4_dec)nfsd4_decode_putpubfh,
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
	[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 已提交
1819 1820

	/* new operations for NFSv4.1 */
1821
	[OP_BACKCHANNEL_CTL]	= (nfsd4_dec)nfsd4_decode_backchannel_ctl,
1822
	[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
R
Randy Dunlap 已提交
1823 1824 1825
	[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,
1826
	[OP_FREE_STATEID]	= (nfsd4_dec)nfsd4_decode_free_stateid,
R
Randy Dunlap 已提交
1827
	[OP_GET_DIR_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
1828 1829 1830 1831 1832 1833 1834
#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 已提交
1835 1836 1837 1838 1839
	[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,
1840
#endif
J
J. Bruce Fields 已提交
1841
	[OP_SECINFO_NO_NAME]	= (nfsd4_dec)nfsd4_decode_secinfo_no_name,
R
Randy Dunlap 已提交
1842 1843
	[OP_SEQUENCE]		= (nfsd4_dec)nfsd4_decode_sequence,
	[OP_SET_SSV]		= (nfsd4_dec)nfsd4_decode_notsupp,
1844
	[OP_TEST_STATEID]	= (nfsd4_dec)nfsd4_decode_test_stateid,
R
Randy Dunlap 已提交
1845
	[OP_WANT_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
1846
	[OP_DESTROY_CLIENTID]	= (nfsd4_dec)nfsd4_decode_destroy_clientid,
1847
	[OP_RECLAIM_COMPLETE]	= (nfsd4_dec)nfsd4_decode_reclaim_complete,
1848 1849

	/* new operations for NFSv4.2 */
A
Anna Schumaker 已提交
1850
	[OP_ALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
A
Anna Schumaker 已提交
1851
	[OP_COPY]		= (nfsd4_dec)nfsd4_decode_copy,
1852
	[OP_COPY_NOTIFY]	= (nfsd4_dec)nfsd4_decode_notsupp,
A
Anna Schumaker 已提交
1853
	[OP_DEALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
1854 1855 1856 1857 1858 1859
	[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 已提交
1860
	[OP_SEEK]		= (nfsd4_dec)nfsd4_decode_seek,
1861
	[OP_WRITE_SAME]		= (nfsd4_dec)nfsd4_decode_notsupp,
1862
	[OP_CLONE]		= (nfsd4_dec)nfsd4_decode_clone,
A
Andy Adamson 已提交
1863 1864
};

1865 1866 1867
static inline bool
nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
{
1868
	if (op->opnum < FIRST_NFS4_OP)
1869
		return false;
1870
	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
1871
		return false;
1872 1873 1874
	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
		return false;
	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
1875 1876 1877
		return false;
	return true;
}
1878

1879
static __be32
L
Linus Torvalds 已提交
1880 1881 1882 1883
nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
{
	DECODE_HEAD;
	struct nfsd4_op *op;
1884
	bool cachethis = false;
1885 1886
	int auth_slack= argp->rqstp->rq_auth_slack;
	int max_reply = auth_slack + 8; /* opcnt, status */
1887 1888
	int readcount = 0;
	int readbytes = 0;
L
Linus Torvalds 已提交
1889 1890 1891
	int i;

	READ_BUF(4);
J
J. Bruce Fields 已提交
1892
	argp->taglen = be32_to_cpup(p++);
J
J. Bruce Fields 已提交
1893
	READ_BUF(argp->taglen);
L
Linus Torvalds 已提交
1894
	SAVEMEM(argp->tag, argp->taglen);
J
J. Bruce Fields 已提交
1895
	READ_BUF(8);
J
J. Bruce Fields 已提交
1896 1897
	argp->minorversion = be32_to_cpup(p++);
	argp->opcnt = be32_to_cpup(p++);
1898
	max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2);
L
Linus Torvalds 已提交
1899 1900 1901 1902 1903 1904

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

1905
	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
1906
		argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
L
Linus Torvalds 已提交
1907 1908
		if (!argp->ops) {
			argp->ops = argp->iops;
1909
			dprintk("nfsd: couldn't allocate room for COMPOUND\n");
L
Linus Torvalds 已提交
1910 1911 1912 1913
			goto xdr_error;
		}
	}

1914
	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
1915 1916
		argp->opcnt = 0;

L
Linus Torvalds 已提交
1917 1918 1919 1920
	for (i = 0; i < argp->opcnt; i++) {
		op = &argp->ops[i];
		op->replay = NULL;

J
J. Bruce Fields 已提交
1921
		READ_BUF(4);
J
J. Bruce Fields 已提交
1922
		op->opnum = be32_to_cpup(p++);
L
Linus Torvalds 已提交
1923

1924 1925
		if (nfsd4_opnum_in_range(argp, op))
			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
1926
		else {
L
Linus Torvalds 已提交
1927 1928 1929
			op->opnum = OP_ILLEGAL;
			op->status = nfserr_op_illegal;
		}
1930 1931 1932 1933 1934
		/*
		 * 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);
1935

1936 1937 1938 1939 1940
		if (op->opnum == OP_READ) {
			readcount++;
			readbytes += nfsd4_max_reply(argp->rqstp, op);
		} else
			max_reply += nfsd4_max_reply(argp->rqstp, op);
1941
		/*
1942 1943 1944 1945
		 * OP_LOCK and OP_LOCKT 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.)
1946
		 */
1947
		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
1948
			max_reply += NFS4_OPAQUE_LIMIT;
1949 1950 1951 1952 1953

		if (op->status) {
			argp->opcnt = i+1;
			break;
		}
L
Linus Torvalds 已提交
1954
	}
1955 1956 1957
	/* Sessions make the DRC unnecessary: */
	if (argp->minorversion)
		cachethis = false;
1958
	svc_reserve(argp->rqstp, max_reply + readbytes);
1959
	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
L
Linus Torvalds 已提交
1960

1961
	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
1962
		clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
1963

L
Linus Torvalds 已提交
1964 1965 1966
	DECODE_TAIL;
}

1967 1968
static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
			     struct svc_export *exp)
J
J. Bruce Fields 已提交
1969
{
1970 1971 1972 1973
	if (exp->ex_flags & NFSEXP_V4ROOT) {
		*p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time));
		*p++ = 0;
	} else if (IS_I_VERSION(inode)) {
1974
		p = xdr_encode_hyper(p, nfsd4_change_attribute(inode));
J
J. Bruce Fields 已提交
1975
	} else {
J
J. Bruce Fields 已提交
1976 1977
		*p++ = cpu_to_be32(stat->ctime.tv_sec);
		*p++ = cpu_to_be32(stat->ctime.tv_nsec);
J
J. Bruce Fields 已提交
1978
	}
J
J. Bruce Fields 已提交
1979
	return p;
J
J. Bruce Fields 已提交
1980 1981
}

J
J. Bruce Fields 已提交
1982
static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
J
J. Bruce Fields 已提交
1983
{
J
J. Bruce Fields 已提交
1984
	*p++ = cpu_to_be32(c->atomic);
J
J. Bruce Fields 已提交
1985
	if (c->change_supported) {
J
J. Bruce Fields 已提交
1986 1987
		p = xdr_encode_hyper(p, c->before_change);
		p = xdr_encode_hyper(p, c->after_change);
J
J. Bruce Fields 已提交
1988
	} else {
J
J. Bruce Fields 已提交
1989 1990 1991 1992
		*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 已提交
1993
	}
J
J. Bruce Fields 已提交
1994
	return p;
J
J. Bruce Fields 已提交
1995
}
L
Linus Torvalds 已提交
1996

1997
/* Encode as an array of strings the string given with components
1998
 * separated @sep, escaped with esc_enter and esc_exit.
1999
 */
2000 2001 2002
static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
					  char *components, char esc_enter,
					  char esc_exit)
2003
{
2004
	__be32 *p;
2005 2006
	__be32 pathlen;
	int pathlen_offset;
2007
	int strlen, count=0;
2008
	char *str, *end, *next;
2009 2010

	dprintk("nfsd4_encode_components(%s)\n", components);
2011 2012

	pathlen_offset = xdr->buf->len;
2013 2014
	p = xdr_reserve_space(xdr, 4);
	if (!p)
2015
		return nfserr_resource;
2016 2017
	p++; /* We will fill this in with @count later */

2018 2019
	end = str = components;
	while (*end) {
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
		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 */;

2037 2038
		strlen = end - str;
		if (strlen) {
2039 2040
			p = xdr_reserve_space(xdr, strlen + 4);
			if (!p)
2041
				return nfserr_resource;
J
J. Bruce Fields 已提交
2042
			p = xdr_encode_opaque(p, str, strlen);
2043 2044 2045 2046
			count++;
		}
		else
			end++;
2047 2048 2049
		if (found_esc)
			end = next;

2050 2051
		str = end;
	}
2052
	pathlen = htonl(count);
2053
	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
2054 2055 2056
	return 0;
}

2057 2058 2059
/* Encode as an array of strings the string given with components
 * separated @sep.
 */
2060 2061
static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
				      char *components)
2062
{
2063
	return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
2064 2065
}

2066 2067 2068
/*
 * encode a location element of a fs_locations structure
 */
2069 2070
static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
					struct nfsd4_fs_location *location)
2071
{
2072
	__be32 status;
2073

2074
	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
2075
						'[', ']');
2076 2077
	if (status)
		return status;
2078
	status = nfsd4_encode_components(xdr, '/', location->path);
2079 2080 2081 2082 2083 2084
	if (status)
		return status;
	return 0;
}

/*
T
Trond Myklebust 已提交
2085
 * Encode a path in RFC3530 'pathname4' format
2086
 */
2087 2088 2089
static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
				const struct path *root,
				const struct path *path)
2090
{
2091
	struct path cur = *path;
2092
	__be32 *p;
T
Trond Myklebust 已提交
2093 2094 2095
	struct dentry **components = NULL;
	unsigned int ncomponents = 0;
	__be32 err = nfserr_jukebox;
2096

T
Trond Myklebust 已提交
2097
	dprintk("nfsd4_encode_components(");
2098

T
Trond Myklebust 已提交
2099 2100 2101 2102 2103
	path_get(&cur);
	/* First walk the path up to the nfsd root, and store the
	 * dentries/path components in an array.
	 */
	for (;;) {
2104
		if (path_equal(&cur, root))
T
Trond Myklebust 已提交
2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
			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);
	}
2123 2124 2125
	err = nfserr_resource;
	p = xdr_reserve_space(xdr, 4);
	if (!p)
T
Trond Myklebust 已提交
2126
		goto out_free;
J
J. Bruce Fields 已提交
2127
	*p++ = cpu_to_be32(ncomponents);
T
Trond Myklebust 已提交
2128 2129 2130

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

2133 2134
		spin_lock(&dentry->d_lock);
		len = dentry->d_name.len;
2135 2136
		p = xdr_reserve_space(xdr, len + 4);
		if (!p) {
2137
			spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
2138
			goto out_free;
2139
		}
J
J. Bruce Fields 已提交
2140
		p = xdr_encode_opaque(p, dentry->d_name.name, len);
A
Al Viro 已提交
2141
		dprintk("/%pd", dentry);
2142
		spin_unlock(&dentry->d_lock);
T
Trond Myklebust 已提交
2143 2144
		dput(dentry);
		ncomponents--;
2145
	}
T
Trond Myklebust 已提交
2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156

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

2157 2158
static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
			struct svc_rqst *rqstp, const struct path *path)
T
Trond Myklebust 已提交
2159 2160 2161 2162 2163 2164 2165
{
	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));
2166
	res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
T
Trond Myklebust 已提交
2167 2168
	exp_put(exp_ps);
	return res;
2169 2170 2171 2172 2173
}

/*
 *  encode a fs_locations structure
 */
2174 2175
static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
			struct svc_rqst *rqstp, struct svc_export *exp)
2176
{
2177
	__be32 status;
2178
	int i;
2179
	__be32 *p;
2180 2181
	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;

2182
	status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
2183 2184
	if (status)
		return status;
2185 2186
	p = xdr_reserve_space(xdr, 4);
	if (!p)
2187
		return nfserr_resource;
J
J. Bruce Fields 已提交
2188
	*p++ = cpu_to_be32(fslocs->locations_count);
2189
	for (i=0; i<fslocs->locations_count; i++) {
2190
		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2191 2192 2193 2194 2195
		if (status)
			return status;
	}
	return 0;
}
L
Linus Torvalds 已提交
2196

2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209
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 已提交
2210

2211
static inline __be32
2212 2213
nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
		     struct nfs4_ace *ace)
L
Linus Torvalds 已提交
2214
{
2215
	if (ace->whotype != NFS4_ACL_WHO_NAMED)
2216
		return nfs4_acl_write_who(xdr, ace->whotype);
2217
	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2218
		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2219
	else
2220
		return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
L
Linus Torvalds 已提交
2221 2222
}

2223
static inline __be32
2224
nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types)
2225
{
2226 2227
	__be32		*p;
	unsigned long	i = hweight_long(layout_types);
2228

2229 2230 2231 2232 2233 2234 2235 2236 2237
	p = xdr_reserve_space(xdr, 4 + 4 * i);
	if (!p)
		return nfserr_resource;

	*p++ = cpu_to_be32(i);

	for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
		if (layout_types & (1 << i))
			*p++ = cpu_to_be32(i);
2238 2239 2240 2241

	return 0;
}

2242 2243 2244
#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
2245
#define WORD2_ABSENT_FS_ATTRS 0
2246

2247 2248
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
static inline __be32
2249 2250
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
			    void *context, int len)
2251
{
2252
	__be32 *p;
2253

2254 2255
	p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
	if (!p)
2256 2257 2258 2259 2260 2261
		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 已提交
2262 2263
	*p++ = cpu_to_be32(0); /* lfs */
	*p++ = cpu_to_be32(0); /* pi */
2264 2265 2266 2267 2268
	p = xdr_encode_opaque(p, context, len);
	return 0;
}
#else
static inline __be32
2269 2270
nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
			    void *context, int len)
2271 2272 2273
{ return 0; }
#endif

2274
static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
{
	/* 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;
2287
	*bmval2 &= WORD2_ABSENT_FS_ATTRS;
2288 2289
	return 0;
}
L
Linus Torvalds 已提交
2290

2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301

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;
	}
2302
	err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2303 2304 2305 2306
	path_put(&path);
	return err;
}

2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
static __be32
nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
{
	__be32 *p;

	if (bmval2) {
		p = xdr_reserve_space(xdr, 16);
		if (!p)
			goto out_resource;
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(bmval0);
		*p++ = cpu_to_be32(bmval1);
		*p++ = cpu_to_be32(bmval2);
	} else if (bmval1) {
		p = xdr_reserve_space(xdr, 12);
		if (!p)
			goto out_resource;
		*p++ = cpu_to_be32(2);
		*p++ = cpu_to_be32(bmval0);
		*p++ = cpu_to_be32(bmval1);
	} else {
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			goto out_resource;
		*p++ = cpu_to_be32(1);
		*p++ = cpu_to_be32(bmval0);
	}

	return 0;
out_resource:
	return nfserr_resource;
}

L
Linus Torvalds 已提交
2340 2341 2342 2343
/*
 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
 * ourselves.
 */
2344
static __be32
2345 2346 2347
nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
		struct svc_export *exp,
		struct dentry *dentry, u32 *bmval,
2348
		struct svc_rqst *rqstp, int ignore_crossmnt)
L
Linus Torvalds 已提交
2349 2350 2351
{
	u32 bmval0 = bmval[0];
	u32 bmval1 = bmval[1];
2352
	u32 bmval2 = bmval[2];
L
Linus Torvalds 已提交
2353
	struct kstat stat;
2354
	struct svc_fh *tempfh = NULL;
L
Linus Torvalds 已提交
2355
	struct kstatfs statfs;
2356
	__be32 *p;
J
J. Bruce Fields 已提交
2357
	int starting_len = xdr->buf->len;
2358 2359
	int attrlen_offset;
	__be32 attrlen;
L
Linus Torvalds 已提交
2360 2361
	u32 dummy;
	u64 dummy64;
2362
	u32 rdattr_err = 0;
2363
	__be32 status;
2364
	int err;
L
Linus Torvalds 已提交
2365
	struct nfs4_acl *acl = NULL;
2366 2367 2368
	void *context = NULL;
	int contextlen;
	bool contextsupport = false;
2369 2370
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
	u32 minorversion = resp->cstate.minorversion;
2371 2372 2373 2374
	struct path path = {
		.mnt	= exp->ex_path.mnt,
		.dentry	= dentry,
	};
2375
	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
L
Linus Torvalds 已提交
2376 2377

	BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
2378
	BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
L
Linus Torvalds 已提交
2379

2380
	if (exp->ex_fslocs.migrated) {
2381
		status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err);
2382 2383 2384 2385
		if (status)
			goto out;
	}

2386
	err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2387
	if (err)
L
Linus Torvalds 已提交
2388
		goto out_nfserr;
2389 2390
	if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
			FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
L
Linus Torvalds 已提交
2391 2392
	    (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
		       FATTR4_WORD1_SPACE_TOTAL))) {
2393
		err = vfs_statfs(&path, &statfs);
2394
		if (err)
L
Linus Torvalds 已提交
2395 2396 2397
			goto out_nfserr;
	}
	if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
2398 2399 2400 2401 2402 2403
		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 已提交
2404 2405
		if (status)
			goto out;
2406
		fhp = tempfh;
L
Linus Torvalds 已提交
2407
	}
2408
	if (bmval0 & FATTR4_WORD0_ACL) {
2409
		err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
2410 2411 2412 2413 2414 2415 2416
		if (err == -EOPNOTSUPP)
			bmval0 &= ~FATTR4_WORD0_ACL;
		else if (err == -EINVAL) {
			status = nfserr_attrnotsupp;
			goto out;
		} else if (err != 0)
			goto out_nfserr;
L
Linus Torvalds 已提交
2417 2418
	}

2419
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2420 2421
	if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) ||
	     bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2422 2423
		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
			err = security_inode_getsecctx(d_inode(dentry),
2424
						&context, &contextlen);
2425 2426
		else
			err = -EOPNOTSUPP;
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
		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 */

2437 2438 2439
	status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2);
	if (status)
		goto out;
2440 2441

	attrlen_offset = xdr->buf->len;
2442 2443 2444
	p = xdr_reserve_space(xdr, 4);
	if (!p)
		goto out_resource;
2445
	p++;                /* to be backfilled later */
L
Linus Torvalds 已提交
2446 2447

	if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2448 2449 2450
		u32 supp[3];

		memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2451

2452
		if (!IS_POSIXACL(dentry->d_inode))
2453
			supp[0] &= ~FATTR4_WORD0_ACL;
2454
		if (!contextsupport)
2455 2456
			supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
		if (!supp[2]) {
2457 2458
			p = xdr_reserve_space(xdr, 12);
			if (!p)
2459
				goto out_resource;
J
J. Bruce Fields 已提交
2460
			*p++ = cpu_to_be32(2);
2461 2462
			*p++ = cpu_to_be32(supp[0]);
			*p++ = cpu_to_be32(supp[1]);
2463
		} else {
2464 2465
			p = xdr_reserve_space(xdr, 16);
			if (!p)
2466
				goto out_resource;
J
J. Bruce Fields 已提交
2467
			*p++ = cpu_to_be32(3);
2468 2469 2470
			*p++ = cpu_to_be32(supp[0]);
			*p++ = cpu_to_be32(supp[1]);
			*p++ = cpu_to_be32(supp[2]);
2471
		}
L
Linus Torvalds 已提交
2472 2473
	}
	if (bmval0 & FATTR4_WORD0_TYPE) {
2474 2475
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2476
			goto out_resource;
2477
		dummy = nfs4_file_type(stat.mode);
2478 2479 2480 2481
		if (dummy == NF4BAD) {
			status = nfserr_serverfault;
			goto out;
		}
J
J. Bruce Fields 已提交
2482
		*p++ = cpu_to_be32(dummy);
L
Linus Torvalds 已提交
2483 2484
	}
	if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2485 2486
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2487
			goto out_resource;
N
NeilBrown 已提交
2488
		if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
J
J. Bruce Fields 已提交
2489
			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
N
NeilBrown 已提交
2490
		else
J
J. Bruce Fields 已提交
2491 2492
			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
						NFS4_FH_VOL_RENAME);
L
Linus Torvalds 已提交
2493 2494
	}
	if (bmval0 & FATTR4_WORD0_CHANGE) {
2495 2496
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2497
			goto out_resource;
2498
		p = encode_change(p, &stat, d_inode(dentry), exp);
L
Linus Torvalds 已提交
2499 2500
	}
	if (bmval0 & FATTR4_WORD0_SIZE) {
2501 2502
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2503
			goto out_resource;
J
J. Bruce Fields 已提交
2504
		p = xdr_encode_hyper(p, stat.size);
L
Linus Torvalds 已提交
2505 2506
	}
	if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2507 2508
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2509
			goto out_resource;
J
J. Bruce Fields 已提交
2510
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2511 2512
	}
	if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2513 2514
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2515
			goto out_resource;
J
J. Bruce Fields 已提交
2516
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2517 2518
	}
	if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2519 2520
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2521
			goto out_resource;
J
J. Bruce Fields 已提交
2522
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2523 2524
	}
	if (bmval0 & FATTR4_WORD0_FSID) {
2525 2526
		p = xdr_reserve_space(xdr, 16);
		if (!p)
L
Linus Torvalds 已提交
2527
			goto out_resource;
2528
		if (exp->ex_fslocs.migrated) {
J
J. Bruce Fields 已提交
2529 2530
			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
2531 2532
		} else switch(fsid_source(fhp)) {
		case FSIDSOURCE_FSID:
J
J. Bruce Fields 已提交
2533 2534
			p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
			p = xdr_encode_hyper(p, (u64)0);
2535 2536
			break;
		case FSIDSOURCE_DEV:
J
J. Bruce Fields 已提交
2537 2538 2539 2540
			*p++ = cpu_to_be32(0);
			*p++ = cpu_to_be32(MAJOR(stat.dev));
			*p++ = cpu_to_be32(0);
			*p++ = cpu_to_be32(MINOR(stat.dev));
2541 2542
			break;
		case FSIDSOURCE_UUID:
2543 2544
			p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
								EX_UUID_LEN);
2545
			break;
L
Linus Torvalds 已提交
2546 2547 2548
		}
	}
	if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
2549 2550
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2551
			goto out_resource;
J
J. Bruce Fields 已提交
2552
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2553 2554
	}
	if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
2555 2556
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2557
			goto out_resource;
J
J. Bruce Fields 已提交
2558
		*p++ = cpu_to_be32(nn->nfsd4_lease);
L
Linus Torvalds 已提交
2559 2560
	}
	if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
2561 2562
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2563
			goto out_resource;
J
J. Bruce Fields 已提交
2564
		*p++ = cpu_to_be32(rdattr_err);
L
Linus Torvalds 已提交
2565 2566 2567 2568 2569
	}
	if (bmval0 & FATTR4_WORD0_ACL) {
		struct nfs4_ace *ace;

		if (acl == NULL) {
2570 2571
			p = xdr_reserve_space(xdr, 4);
			if (!p)
L
Linus Torvalds 已提交
2572 2573
				goto out_resource;

J
J. Bruce Fields 已提交
2574
			*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2575 2576
			goto out_acl;
		}
2577 2578
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2579
			goto out_resource;
J
J. Bruce Fields 已提交
2580
		*p++ = cpu_to_be32(acl->naces);
L
Linus Torvalds 已提交
2581

2582
		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
2583 2584
			p = xdr_reserve_space(xdr, 4*3);
			if (!p)
L
Linus Torvalds 已提交
2585
				goto out_resource;
J
J. Bruce Fields 已提交
2586 2587 2588 2589
			*p++ = cpu_to_be32(ace->type);
			*p++ = cpu_to_be32(ace->flag);
			*p++ = cpu_to_be32(ace->access_mask &
							NFS4_ACE_MASK_ALL);
2590
			status = nfsd4_encode_aclname(xdr, rqstp, ace);
L
Linus Torvalds 已提交
2591 2592 2593 2594 2595 2596
			if (status)
				goto out;
		}
	}
out_acl:
	if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
2597 2598
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2599
			goto out_resource;
2600
		*p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
L
Linus Torvalds 已提交
2601 2602 2603
			ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
	}
	if (bmval0 & FATTR4_WORD0_CANSETTIME) {
2604 2605
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2606
			goto out_resource;
J
J. Bruce Fields 已提交
2607
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2608 2609
	}
	if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
2610 2611
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2612
			goto out_resource;
J
J. Bruce Fields 已提交
2613
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2614 2615
	}
	if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
2616 2617
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2618
			goto out_resource;
J
J. Bruce Fields 已提交
2619
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2620 2621
	}
	if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
2622 2623
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2624
			goto out_resource;
J
J. Bruce Fields 已提交
2625
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2626 2627
	}
	if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
2628 2629
		p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
		if (!p)
L
Linus Torvalds 已提交
2630
			goto out_resource;
J
J. Bruce Fields 已提交
2631 2632
		p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base,
					fhp->fh_handle.fh_size);
L
Linus Torvalds 已提交
2633 2634
	}
	if (bmval0 & FATTR4_WORD0_FILEID) {
2635 2636
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2637
			goto out_resource;
J
J. Bruce Fields 已提交
2638
		p = xdr_encode_hyper(p, stat.ino);
L
Linus Torvalds 已提交
2639 2640
	}
	if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
2641 2642
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2643
			goto out_resource;
J
J. Bruce Fields 已提交
2644
		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
L
Linus Torvalds 已提交
2645 2646
	}
	if (bmval0 & FATTR4_WORD0_FILES_FREE) {
2647 2648
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2649
			goto out_resource;
J
J. Bruce Fields 已提交
2650
		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
L
Linus Torvalds 已提交
2651 2652
	}
	if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
2653 2654
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2655
			goto out_resource;
J
J. Bruce Fields 已提交
2656
		p = xdr_encode_hyper(p, (u64) statfs.f_files);
L
Linus Torvalds 已提交
2657
	}
2658
	if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
2659
		status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
2660 2661 2662
		if (status)
			goto out;
	}
L
Linus Torvalds 已提交
2663
	if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
2664 2665
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2666
			goto out_resource;
J
J. Bruce Fields 已提交
2667
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2668 2669
	}
	if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
2670 2671
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2672
			goto out_resource;
J
J. Bruce Fields 已提交
2673
		p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
L
Linus Torvalds 已提交
2674 2675
	}
	if (bmval0 & FATTR4_WORD0_MAXLINK) {
2676 2677
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2678
			goto out_resource;
J
J. Bruce Fields 已提交
2679
		*p++ = cpu_to_be32(255);
L
Linus Torvalds 已提交
2680 2681
	}
	if (bmval0 & FATTR4_WORD0_MAXNAME) {
2682 2683
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2684
			goto out_resource;
J
J. Bruce Fields 已提交
2685
		*p++ = cpu_to_be32(statfs.f_namelen);
L
Linus Torvalds 已提交
2686 2687
	}
	if (bmval0 & FATTR4_WORD0_MAXREAD) {
2688 2689
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2690
			goto out_resource;
J
J. Bruce Fields 已提交
2691
		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
L
Linus Torvalds 已提交
2692 2693
	}
	if (bmval0 & FATTR4_WORD0_MAXWRITE) {
2694 2695
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2696
			goto out_resource;
J
J. Bruce Fields 已提交
2697
		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
L
Linus Torvalds 已提交
2698 2699
	}
	if (bmval1 & FATTR4_WORD1_MODE) {
2700 2701
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2702
			goto out_resource;
J
J. Bruce Fields 已提交
2703
		*p++ = cpu_to_be32(stat.mode & S_IALLUGO);
L
Linus Torvalds 已提交
2704 2705
	}
	if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
2706 2707
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2708
			goto out_resource;
J
J. Bruce Fields 已提交
2709
		*p++ = cpu_to_be32(1);
L
Linus Torvalds 已提交
2710 2711
	}
	if (bmval1 & FATTR4_WORD1_NUMLINKS) {
2712 2713
		p = xdr_reserve_space(xdr, 4);
		if (!p)
L
Linus Torvalds 已提交
2714
			goto out_resource;
J
J. Bruce Fields 已提交
2715
		*p++ = cpu_to_be32(stat.nlink);
L
Linus Torvalds 已提交
2716 2717
	}
	if (bmval1 & FATTR4_WORD1_OWNER) {
2718
		status = nfsd4_encode_user(xdr, rqstp, stat.uid);
L
Linus Torvalds 已提交
2719 2720 2721 2722
		if (status)
			goto out;
	}
	if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
2723
		status = nfsd4_encode_group(xdr, rqstp, stat.gid);
L
Linus Torvalds 已提交
2724 2725 2726 2727
		if (status)
			goto out;
	}
	if (bmval1 & FATTR4_WORD1_RAWDEV) {
2728 2729
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2730
			goto out_resource;
J
J. Bruce Fields 已提交
2731 2732
		*p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
		*p++ = cpu_to_be32((u32) MINOR(stat.rdev));
L
Linus Torvalds 已提交
2733 2734
	}
	if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
2735 2736
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2737 2738
			goto out_resource;
		dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2739
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2740 2741
	}
	if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
2742 2743
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2744 2745
			goto out_resource;
		dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2746
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2747 2748
	}
	if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
2749 2750
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2751 2752
			goto out_resource;
		dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
J
J. Bruce Fields 已提交
2753
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2754 2755
	}
	if (bmval1 & FATTR4_WORD1_SPACE_USED) {
2756 2757
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2758 2759
			goto out_resource;
		dummy64 = (u64)stat.blocks << 9;
J
J. Bruce Fields 已提交
2760
		p = xdr_encode_hyper(p, dummy64);
L
Linus Torvalds 已提交
2761 2762
	}
	if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
2763 2764
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2765
			goto out_resource;
J
J. Bruce Fields 已提交
2766
		p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
J
J. Bruce Fields 已提交
2767
		*p++ = cpu_to_be32(stat.atime.tv_nsec);
L
Linus Torvalds 已提交
2768 2769
	}
	if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
2770 2771
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2772
			goto out_resource;
J
J. Bruce Fields 已提交
2773 2774 2775
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(1);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
2776 2777
	}
	if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
2778 2779
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2780
			goto out_resource;
J
J. Bruce Fields 已提交
2781
		p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
J
J. Bruce Fields 已提交
2782
		*p++ = cpu_to_be32(stat.ctime.tv_nsec);
L
Linus Torvalds 已提交
2783 2784
	}
	if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
2785 2786
		p = xdr_reserve_space(xdr, 12);
		if (!p)
L
Linus Torvalds 已提交
2787
			goto out_resource;
J
J. Bruce Fields 已提交
2788
		p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
J
J. Bruce Fields 已提交
2789
		*p++ = cpu_to_be32(stat.mtime.tv_nsec);
L
Linus Torvalds 已提交
2790 2791
	}
	if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
2792 2793 2794
		struct kstat parent_stat;
		u64 ino = stat.ino;

2795 2796
		p = xdr_reserve_space(xdr, 8);
		if (!p)
L
Linus Torvalds 已提交
2797
                	goto out_resource;
2798 2799 2800 2801 2802
		/*
		 * Get parent's attributes if not ignoring crossmount
		 * and this is the root of a cross-mounted filesystem.
		 */
		if (ignore_crossmnt == 0 &&
2803 2804 2805 2806 2807 2808 2809
		    dentry == exp->ex_path.mnt->mnt_root) {
			err = get_parent_attributes(exp, &parent_stat);
			if (err)
				goto out_nfserr;
			ino = parent_stat.ino;
		}
		p = xdr_encode_hyper(p, ino);
L
Linus Torvalds 已提交
2810
	}
2811
#ifdef CONFIG_NFSD_PNFS
2812
	if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) {
2813
		status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
2814 2815 2816 2817 2818
		if (status)
			goto out;
	}

	if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) {
2819
		status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
2820 2821
		if (status)
			goto out;
2822 2823 2824 2825 2826 2827 2828 2829 2830
	}

	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 */
2831
	if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
2832 2833 2834 2835 2836 2837 2838 2839
		u32 supp[3];

		memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
		supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
		supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
		supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;

		status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]);
2840 2841
		if (status)
			goto out;
2842
	}
2843

2844 2845 2846 2847 2848 2849 2850
	if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
		status = nfsd4_encode_security_label(xdr, rqstp, context,
								contextlen);
		if (status)
			goto out;
	}

2851 2852
	attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
	write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
L
Linus Torvalds 已提交
2853 2854 2855
	status = nfs_ok;

out:
2856
#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2857 2858
	if (context)
		security_release_secctx(context, contextlen);
2859
#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2860
	kfree(acl);
2861
	if (tempfh) {
2862
		fh_put(tempfh);
2863 2864
		kfree(tempfh);
	}
J
J. Bruce Fields 已提交
2865 2866
	if (status)
		xdr_truncate_encode(xdr, starting_len);
L
Linus Torvalds 已提交
2867 2868
	return status;
out_nfserr:
2869
	status = nfserrno(err);
L
Linus Torvalds 已提交
2870 2871 2872 2873 2874 2875
	goto out;
out_resource:
	status = nfserr_resource;
	goto out;
}

2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
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;
}

2891 2892 2893 2894 2895
__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)
{
2896
	struct xdr_buf dummy;
2897 2898 2899
	struct xdr_stream xdr;
	__be32 ret;

2900
	svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
2901 2902 2903 2904 2905 2906
	ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
							ignore_crossmnt);
	*p = xdr.p;
	return ret;
}

2907 2908 2909 2910 2911 2912 2913 2914 2915
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;
}

2916
static __be32
J
J. Bruce Fields 已提交
2917 2918
nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
			const char *name, int namlen)
L
Linus Torvalds 已提交
2919 2920 2921
{
	struct svc_export *exp = cd->rd_fhp->fh_export;
	struct dentry *dentry;
2922
	__be32 nfserr;
2923
	int ignore_crossmnt = 0;
L
Linus Torvalds 已提交
2924

2925
	dentry = lookup_one_len_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
L
Linus Torvalds 已提交
2926 2927
	if (IS_ERR(dentry))
		return nfserrno(PTR_ERR(dentry));
2928
	if (d_really_is_negative(dentry)) {
2929
		/*
2930 2931 2932
		 * we're not holding the i_mutex here, so there's
		 * a window where this directory entry could have gone
		 * away.
2933 2934 2935 2936
		 */
		dput(dentry);
		return nfserr_noent;
	}
L
Linus Torvalds 已提交
2937 2938

	exp_get(exp);
2939 2940 2941 2942 2943 2944 2945
	/*
	 * 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.
	 */
2946
	if (nfsd_mountpoint(dentry, exp)) {
2947 2948
		int err;

2949 2950 2951 2952 2953
		if (!(exp->ex_flags & NFSEXP_V4ROOT)
				&& !attributes_need_mount(cd->rd_bmval)) {
			ignore_crossmnt = 1;
			goto out_encode;
		}
A
Andy Adamson 已提交
2954 2955 2956 2957 2958
		/*
		 * Why the heck aren't we just using nfsd_lookup??
		 * Different "."/".." handling?  Something else?
		 * At least, add a comment here to explain....
		 */
2959 2960 2961
		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
		if (err) {
			nfserr = nfserrno(err);
L
Linus Torvalds 已提交
2962 2963
			goto out_put;
		}
A
Andy Adamson 已提交
2964 2965 2966
		nfserr = check_nfsd_access(exp, cd->rd_rqstp);
		if (nfserr)
			goto out_put;
L
Linus Torvalds 已提交
2967 2968

	}
2969
out_encode:
J
J. Bruce Fields 已提交
2970
	nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
2971
					cd->rd_rqstp, ignore_crossmnt);
L
Linus Torvalds 已提交
2972 2973 2974 2975 2976 2977
out_put:
	dput(dentry);
	exp_put(exp);
	return nfserr;
}

A
Al Viro 已提交
2978
static __be32 *
J
J. Bruce Fields 已提交
2979
nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
L
Linus Torvalds 已提交
2980
{
J
J. Bruce Fields 已提交
2981 2982
	__be32 *p;

2983
	p = xdr_reserve_space(xdr, 20);
J
J. Bruce Fields 已提交
2984
	if (!p)
L
Linus Torvalds 已提交
2985 2986 2987 2988 2989
		return NULL;
	*p++ = htonl(2);
	*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
	*p++ = htonl(0);			 /* bmval1 */

2990
	*p++ = htonl(4);     /* attribute length */
L
Linus Torvalds 已提交
2991 2992 2993 2994 2995
	*p++ = nfserr;       /* no htonl */
	return p;
}

static int
2996 2997
nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
		    loff_t offset, u64 ino, unsigned int d_type)
L
Linus Torvalds 已提交
2998
{
2999
	struct readdir_cd *ccd = ccdv;
L
Linus Torvalds 已提交
3000
	struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
J
J. Bruce Fields 已提交
3001 3002 3003
	struct xdr_stream *xdr = cd->xdr;
	int start_offset = xdr->buf->len;
	int cookie_offset;
3004
	u32 name_and_cookie;
J
J. Bruce Fields 已提交
3005
	int entry_bytes;
3006
	__be32 nfserr = nfserr_toosmall;
J
J. Bruce Fields 已提交
3007 3008
	__be64 wire_offset;
	__be32 *p;
L
Linus Torvalds 已提交
3009 3010 3011 3012 3013 3014 3015

	/* 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 已提交
3016 3017 3018 3019 3020
	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 已提交
3021

J
J. Bruce Fields 已提交
3022 3023
	p = xdr_reserve_space(xdr, 4);
	if (!p)
L
Linus Torvalds 已提交
3024 3025
		goto fail;
	*p++ = xdr_one;                             /* mark entry present */
J
J. Bruce Fields 已提交
3026 3027 3028 3029
	cookie_offset = xdr->buf->len;
	p = xdr_reserve_space(xdr, 3*4 + namlen);
	if (!p)
		goto fail;
L
Linus Torvalds 已提交
3030 3031 3032
	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 已提交
3033
	nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
L
Linus Torvalds 已提交
3034 3035 3036 3037 3038 3039
	switch (nfserr) {
	case nfs_ok:
		break;
	case nfserr_resource:
		nfserr = nfserr_toosmall;
		goto fail;
3040
	case nfserr_noent:
3041
		xdr_truncate_encode(xdr, start_offset);
3042
		goto skip_entry;
L
Linus Torvalds 已提交
3043 3044 3045 3046 3047 3048 3049 3050 3051 3052
	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 已提交
3053
		p = nfsd4_encode_rdattr_error(xdr, nfserr);
3054 3055
		if (p == NULL) {
			nfserr = nfserr_toosmall;
L
Linus Torvalds 已提交
3056
			goto fail;
3057
		}
L
Linus Torvalds 已提交
3058
	}
J
J. Bruce Fields 已提交
3059 3060 3061 3062 3063
	nfserr = nfserr_toosmall;
	entry_bytes = xdr->buf->len - start_offset;
	if (entry_bytes > cd->rd_maxcount)
		goto fail;
	cd->rd_maxcount -= entry_bytes;
3064 3065 3066 3067
	/*
	 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
	 * let's always let through the first entry, at least:
	 */
3068 3069 3070
	if (!cd->rd_dircount)
		goto fail;
	name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
3071 3072 3073
	if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
		goto fail;
	cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
3074

J
J. Bruce Fields 已提交
3075
	cd->cookie_offset = cookie_offset;
3076
skip_entry:
L
Linus Torvalds 已提交
3077 3078 3079
	cd->common.err = nfs_ok;
	return 0;
fail:
J
J. Bruce Fields 已提交
3080
	xdr_truncate_encode(xdr, start_offset);
L
Linus Torvalds 已提交
3081 3082 3083 3084
	cd->common.err = nfserr;
	return -EINVAL;
}

3085 3086
static __be32
nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
3087
{
3088
	__be32 *p;
3089

3090 3091 3092
	p = xdr_reserve_space(xdr, sizeof(stateid_t));
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3093
	*p++ = cpu_to_be32(sid->si_generation);
J
J. Bruce Fields 已提交
3094 3095
	p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
					sizeof(stateid_opaque_t));
3096
	return 0;
3097 3098
}

3099
static __be32
3100
nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
L
Linus Torvalds 已提交
3101
{
3102
	struct xdr_stream *xdr = &resp->xdr;
3103
	__be32 *p;
L
Linus Torvalds 已提交
3104 3105

	if (!nfserr) {
3106 3107 3108
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3109 3110
		*p++ = cpu_to_be32(access->ac_supported);
		*p++ = cpu_to_be32(access->ac_resp_access);
L
Linus Torvalds 已提交
3111
	}
3112
	return nfserr;
L
Linus Torvalds 已提交
3113 3114
}

3115 3116
static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
{
3117
	struct xdr_stream *xdr = &resp->xdr;
3118 3119 3120
	__be32 *p;

	if (!nfserr) {
3121 3122 3123
		p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3124 3125
		p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
						NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
3126
		*p++ = cpu_to_be32(bcts->dir);
3127
		/* Upshifting from TCP to RDMA is not supported */
J
J. Bruce Fields 已提交
3128
		*p++ = cpu_to_be32(0);
3129 3130 3131 3132
	}
	return nfserr;
}

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

3138
	if (!nfserr)
3139
		nfserr = nfsd4_encode_stateid(xdr, &close->cl_stateid);
3140

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


3145
static __be32
3146
nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
L
Linus Torvalds 已提交
3147
{
3148
	struct xdr_stream *xdr = &resp->xdr;
3149
	__be32 *p;
L
Linus Torvalds 已提交
3150 3151

	if (!nfserr) {
3152 3153 3154
		p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3155 3156
		p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
						NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
3157
	}
3158
	return nfserr;
L
Linus Torvalds 已提交
3159 3160
}

3161
static __be32
3162
nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
L
Linus Torvalds 已提交
3163
{
3164
	struct xdr_stream *xdr = &resp->xdr;
3165
	__be32 *p;
L
Linus Torvalds 已提交
3166 3167

	if (!nfserr) {
3168
		p = xdr_reserve_space(xdr, 20);
3169 3170
		if (!p)
			return nfserr_resource;
3171 3172 3173
		encode_cinfo(p, &create->cr_cinfo);
		nfserr = nfsd4_encode_bitmap(xdr, create->cr_bmval[0],
				create->cr_bmval[1], create->cr_bmval[2]);
L
Linus Torvalds 已提交
3174
	}
3175
	return nfserr;
L
Linus Torvalds 已提交
3176 3177
}

3178 3179
static __be32
nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
L
Linus Torvalds 已提交
3180 3181
{
	struct svc_fh *fhp = getattr->ga_fhp;
3182
	struct xdr_stream *xdr = &resp->xdr;
L
Linus Torvalds 已提交
3183 3184 3185 3186

	if (nfserr)
		return nfserr;

3187 3188
	nfserr = nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
				    getattr->ga_bmval,
3189
				    resp->rqstp, 0);
L
Linus Torvalds 已提交
3190 3191 3192
	return nfserr;
}

3193 3194
static __be32
nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
L
Linus Torvalds 已提交
3195
{
3196
	struct xdr_stream *xdr = &resp->xdr;
3197
	struct svc_fh *fhp = *fhpp;
L
Linus Torvalds 已提交
3198
	unsigned int len;
3199
	__be32 *p;
L
Linus Torvalds 已提交
3200 3201 3202

	if (!nfserr) {
		len = fhp->fh_handle.fh_size;
3203 3204 3205
		p = xdr_reserve_space(xdr, len + 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3206
		p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len);
L
Linus Torvalds 已提交
3207
	}
3208
	return nfserr;
L
Linus Torvalds 已提交
3209 3210 3211 3212 3213 3214
}

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

3221
again:
3222
	p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
3223 3224 3225 3226 3227 3228
	if (!p) {
		/*
		 * Don't fail to return the result just because we can't
		 * return the conflicting open:
		 */
		if (conf->len) {
3229
			kfree(conf->data);
3230 3231 3232 3233
			conf->len = 0;
			conf->data = NULL;
			goto again;
		}
3234
		return nfserr_resource;
3235
	}
J
J. Bruce Fields 已提交
3236 3237
	p = xdr_encode_hyper(p, ld->ld_start);
	p = xdr_encode_hyper(p, ld->ld_length);
J
J. Bruce Fields 已提交
3238
	*p++ = cpu_to_be32(ld->ld_type);
3239
	if (conf->len) {
J
J. Bruce Fields 已提交
3240 3241
		p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
		p = xdr_encode_opaque(p, conf->data, conf->len);
3242
		kfree(conf->data);
L
Linus Torvalds 已提交
3243
	}  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
J
J. Bruce Fields 已提交
3244
		p = xdr_encode_hyper(p, (u64)0); /* clientid */
J
J. Bruce Fields 已提交
3245
		*p++ = cpu_to_be32(0); /* length of owner name */
L
Linus Torvalds 已提交
3246
	}
3247
	return nfserr_denied;
L
Linus Torvalds 已提交
3248 3249
}

3250
static __be32
3251
nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
L
Linus Torvalds 已提交
3252
{
3253 3254
	struct xdr_stream *xdr = &resp->xdr;

3255
	if (!nfserr)
3256
		nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
3257
	else if (nfserr == nfserr_denied)
3258
		nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
3259

3260
	return nfserr;
L
Linus Torvalds 已提交
3261 3262
}

3263
static __be32
3264
nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
L
Linus Torvalds 已提交
3265
{
3266 3267
	struct xdr_stream *xdr = &resp->xdr;

L
Linus Torvalds 已提交
3268
	if (nfserr == nfserr_denied)
3269
		nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
3270
	return nfserr;
L
Linus Torvalds 已提交
3271 3272
}

3273
static __be32
3274
nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
L
Linus Torvalds 已提交
3275
{
3276 3277
	struct xdr_stream *xdr = &resp->xdr;

3278
	if (!nfserr)
3279
		nfserr = nfsd4_encode_stateid(xdr, &locku->lu_stateid);
3280

3281
	return nfserr;
L
Linus Torvalds 已提交
3282 3283 3284
}


3285
static __be32
3286
nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
L
Linus Torvalds 已提交
3287
{
3288
	struct xdr_stream *xdr = &resp->xdr;
3289
	__be32 *p;
L
Linus Torvalds 已提交
3290 3291

	if (!nfserr) {
3292 3293 3294
		p = xdr_reserve_space(xdr, 20);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3295
		p = encode_cinfo(p, &link->li_cinfo);
L
Linus Torvalds 已提交
3296
	}
3297
	return nfserr;
L
Linus Torvalds 已提交
3298 3299 3300
}


3301
static __be32
3302
nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
L
Linus Torvalds 已提交
3303
{
3304
	struct xdr_stream *xdr = &resp->xdr;
3305
	__be32 *p;
L
Linus Torvalds 已提交
3306 3307 3308 3309

	if (nfserr)
		goto out;

3310 3311 3312
	nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
	if (nfserr)
		goto out;
3313
	p = xdr_reserve_space(xdr, 24);
3314 3315
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
3316
	p = encode_cinfo(p, &open->op_cinfo);
J
J. Bruce Fields 已提交
3317
	*p++ = cpu_to_be32(open->op_rflags);
L
Linus Torvalds 已提交
3318

3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],
					open->op_bmval[2]);
	if (nfserr)
		goto out;

	p = xdr_reserve_space(xdr, 4);
	if (!p)
		return nfserr_resource;

	*p++ = cpu_to_be32(open->op_delegate_type);
L
Linus Torvalds 已提交
3329 3330 3331 3332
	switch (open->op_delegate_type) {
	case NFS4_OPEN_DELEGATE_NONE:
		break;
	case NFS4_OPEN_DELEGATE_READ:
3333 3334 3335 3336 3337 3338
		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 已提交
3339
		*p++ = cpu_to_be32(open->op_recall);
L
Linus Torvalds 已提交
3340 3341 3342 3343

		/*
		 * TODO: ACE's in delegations
		 */
J
J. Bruce Fields 已提交
3344 3345 3346 3347
		*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 已提交
3348 3349
		break;
	case NFS4_OPEN_DELEGATE_WRITE:
3350 3351 3352 3353 3354 3355
		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 已提交
3356
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3357 3358 3359 3360

		/*
		 * TODO: space_limit's in delegations
		 */
J
J. Bruce Fields 已提交
3361 3362 3363
		*p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
		*p++ = cpu_to_be32(~(u32)0);
		*p++ = cpu_to_be32(~(u32)0);
L
Linus Torvalds 已提交
3364 3365 3366 3367

		/*
		 * TODO: ACE's in delegations
		 */
J
J. Bruce Fields 已提交
3368 3369 3370 3371
		*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 已提交
3372
		break;
3373 3374 3375 3376
	case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
		switch (open->op_why_no_deleg) {
		case WND4_CONTENTION:
		case WND4_RESOURCE:
3377 3378 3379
			p = xdr_reserve_space(xdr, 8);
			if (!p)
				return nfserr_resource;
J
J. Bruce Fields 已提交
3380 3381 3382
			*p++ = cpu_to_be32(open->op_why_no_deleg);
			/* deleg signaling not supported yet: */
			*p++ = cpu_to_be32(0);
3383 3384
			break;
		default:
3385 3386 3387
			p = xdr_reserve_space(xdr, 4);
			if (!p)
				return nfserr_resource;
J
J. Bruce Fields 已提交
3388
			*p++ = cpu_to_be32(open->op_why_no_deleg);
3389 3390
		}
		break;
L
Linus Torvalds 已提交
3391 3392 3393 3394 3395
	default:
		BUG();
	}
	/* XXX save filehandle here */
out:
3396
	return nfserr;
L
Linus Torvalds 已提交
3397 3398
}

3399
static __be32
3400
nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
L
Linus Torvalds 已提交
3401
{
3402 3403
	struct xdr_stream *xdr = &resp->xdr;

3404
	if (!nfserr)
3405
		nfserr = nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
L
Linus Torvalds 已提交
3406

3407
	return nfserr;
L
Linus Torvalds 已提交
3408 3409
}

3410
static __be32
3411
nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
L
Linus Torvalds 已提交
3412
{
3413 3414
	struct xdr_stream *xdr = &resp->xdr;

3415
	if (!nfserr)
3416
		nfserr = nfsd4_encode_stateid(xdr, &od->od_stateid);
L
Linus Torvalds 已提交
3417

3418
	return nfserr;
L
Linus Torvalds 已提交
3419 3420
}

3421 3422 3423 3424
static __be32 nfsd4_encode_splice_read(
				struct nfsd4_compoundres *resp,
				struct nfsd4_read *read,
				struct file *file, unsigned long maxcount)
L
Linus Torvalds 已提交
3425
{
3426
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3427
	struct xdr_buf *buf = xdr->buf;
3428
	u32 eof;
3429
	long len;
3430
	int space_left;
3431
	__be32 nfserr;
3432
	__be32 *p = xdr->p - 2;
L
Linus Torvalds 已提交
3433

3434 3435
	/* Make sure there will be room for padding if needed */
	if (xdr->end - xdr->p < 1)
3436
		return nfserr_resource;
3437

3438
	len = maxcount;
3439 3440 3441 3442 3443 3444 3445 3446
	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 已提交
3447
		buf->page_len = 0;
3448
		return nfserr;
3449
	}
L
Linus Torvalds 已提交
3450

3451 3452
	eof = nfsd_eof_on_read(len, maxcount, read->rd_offset,
				d_inode(read->rd_fhp->fh_dentry)->i_size);
3453

3454 3455
	*(p++) = htonl(eof);
	*(p++) = htonl(maxcount);
3456

J
J. Bruce Fields 已提交
3457 3458
	buf->page_len = maxcount;
	buf->len += maxcount;
3459 3460
	xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
							/ PAGE_SIZE;
3461 3462

	/* Use rest of head for padding and remaining ops: */
J
J. Bruce Fields 已提交
3463 3464
	buf->tail[0].iov_base = xdr->p;
	buf->tail[0].iov_len = 0;
3465
	xdr->iov = buf->tail;
3466
	if (maxcount&3) {
3467 3468 3469 3470
		int pad = 4 - (maxcount&3);

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

J
J. Bruce Fields 已提交
3471
		buf->tail[0].iov_base += maxcount&3;
3472 3473
		buf->tail[0].iov_len = pad;
		buf->len += pad;
3474
	}
3475

3476
	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
J
J. Bruce Fields 已提交
3477 3478
				buf->buflen - buf->len);
	buf->buflen = buf->len + space_left;
3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492
	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;
3493
	int thislen;
3494 3495 3496
	__be32 nfserr;
	__be32 tmp;
	__be32 *p;
3497 3498
	u32 zzz = 0;
	int pad;
L
Linus Torvalds 已提交
3499 3500 3501

	len = maxcount;
	v = 0;
3502

3503
	thislen = min_t(long, len, ((void *)xdr->end - (void *)xdr->p));
3504 3505 3506 3507 3508 3509 3510 3511
	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) {
3512
		thislen = min_t(long, len, PAGE_SIZE);
3513 3514 3515
		p = xdr_reserve_space(xdr, (thislen+3)&~3);
		WARN_ON_ONCE(!p);
		resp->rqstp->rq_vec[v].iov_base = p;
3516
		resp->rqstp->rq_vec[v].iov_len = thislen;
L
Linus Torvalds 已提交
3517
		v++;
3518
		len -= thislen;
L
Linus Torvalds 已提交
3519 3520 3521
	}
	read->rd_vlen = v;

3522
	len = maxcount;
3523 3524 3525
	nfserr = nfsd_readv(file, read->rd_offset, resp->rqstp->rq_vec,
			read->rd_vlen, &maxcount);
	if (nfserr)
L
Linus Torvalds 已提交
3526
		return nfserr;
3527
	xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3));
3528

3529 3530
	eof = nfsd_eof_on_read(len, maxcount, read->rd_offset,
				d_inode(read->rd_fhp->fh_dentry)->i_size);
L
Linus Torvalds 已提交
3531

3532 3533 3534 3535 3536
	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);

3537 3538 3539
	pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
	write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
								&zzz, pad);
L
Linus Torvalds 已提交
3540
	return 0;
3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551

}

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;
3552
	struct raparms *ra = NULL;
3553 3554 3555
	__be32 *p;

	if (nfserr)
3556
		goto out;
3557 3558 3559

	p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
	if (!p) {
3560
		WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
3561 3562
		nfserr = nfserr_resource;
		goto out;
3563
	}
3564 3565
	if (resp->xdr.buf->page_len &&
	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
3566
		WARN_ON_ONCE(1);
3567 3568
		nfserr = nfserr_resource;
		goto out;
3569 3570 3571 3572
	}
	xdr_commit_encode(xdr);

	maxcount = svc_max_payload(resp->rqstp);
3573 3574
	maxcount = min_t(unsigned long, maxcount,
			 (xdr->buf->buflen - xdr->buf->len));
3575
	maxcount = min_t(unsigned long, maxcount, read->rd_length);
3576

3577
	if (read->rd_tmp_file)
3578
		ra = nfsd_init_raparms(file);
3579

3580 3581
	if (file->f_op->splice_read &&
	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
3582
		nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
3583
	else
3584
		nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
3585

3586 3587
	if (ra)
		nfsd_put_raparams(file, ra);
3588

3589
	if (nfserr)
3590
		xdr_truncate_encode(xdr, starting_len);
3591 3592 3593 3594 3595

out:
	if (file)
		fput(file);
	return nfserr;
L
Linus Torvalds 已提交
3596 3597
}

3598 3599
static __be32
nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
L
Linus Torvalds 已提交
3600 3601
{
	int maxcount;
3602 3603
	__be32 wire_count;
	int zero = 0;
3604
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3605
	int length_offset = xdr->buf->len;
3606
	__be32 *p;
L
Linus Torvalds 已提交
3607 3608 3609

	if (nfserr)
		return nfserr;
3610 3611 3612 3613

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

3616 3617
	p = xdr_reserve_space(xdr, maxcount);
	if (!p)
3618
		return nfserr_resource;
L
Linus Torvalds 已提交
3619
	/*
3620 3621 3622 3623
	 * XXX: By default, vfs_readlink() will truncate symlinks if they
	 * would overflow the buffer.  Is this kosher in NFSv4?  If not, one
	 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
	 * that truncation occurred, and return NFS4ERR_RESOURCE.
L
Linus Torvalds 已提交
3624
	 */
3625 3626
	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
						(char *)p, &maxcount);
L
Linus Torvalds 已提交
3627
	if (nfserr == nfserr_isdir)
3628 3629
		nfserr = nfserr_inval;
	if (nfserr) {
J
J. Bruce Fields 已提交
3630
		xdr_truncate_encode(xdr, length_offset);
L
Linus Torvalds 已提交
3631
		return nfserr;
3632
	}
L
Linus Torvalds 已提交
3633

3634 3635
	wire_count = htonl(maxcount);
	write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
3636
	xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
3637 3638 3639
	if (maxcount & 3)
		write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
						&zero, 4 - (maxcount&3));
L
Linus Torvalds 已提交
3640 3641 3642
	return 0;
}

3643 3644
static __be32
nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
L
Linus Torvalds 已提交
3645 3646
{
	int maxcount;
J
J. Bruce Fields 已提交
3647
	int bytes_left;
L
Linus Torvalds 已提交
3648
	loff_t offset;
J
J. Bruce Fields 已提交
3649
	__be64 wire_offset;
3650
	struct xdr_stream *xdr = &resp->xdr;
J
J. Bruce Fields 已提交
3651
	int starting_len = xdr->buf->len;
3652
	__be32 *p;
L
Linus Torvalds 已提交
3653 3654 3655 3656

	if (nfserr)
		return nfserr;

3657 3658 3659
	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
	if (!p)
		return nfserr_resource;
L
Linus Torvalds 已提交
3660 3661

	/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
J
J. Bruce Fields 已提交
3662 3663
	*p++ = cpu_to_be32(0);
	*p++ = cpu_to_be32(0);
3664 3665
	resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p)
				- (char *)resp->xdr.buf->head[0].iov_base;
L
Linus Torvalds 已提交
3666 3667

	/*
J
J. Bruce Fields 已提交
3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
	 * 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 已提交
3682
	 */
J
J. Bruce Fields 已提交
3683 3684
	if (maxcount < 16) {
		nfserr = nfserr_toosmall;
L
Linus Torvalds 已提交
3685 3686
		goto err_no_verf;
	}
J
J. Bruce Fields 已提交
3687
	maxcount = min_t(int, maxcount-16, bytes_left);
L
Linus Torvalds 已提交
3688

3689 3690 3691 3692
	/* 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 已提交
3693 3694
	readdir->xdr = xdr;
	readdir->rd_maxcount = maxcount;
L
Linus Torvalds 已提交
3695
	readdir->common.err = 0;
J
J. Bruce Fields 已提交
3696
	readdir->cookie_offset = 0;
L
Linus Torvalds 已提交
3697 3698 3699 3700 3701 3702 3703

	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 已提交
3704 3705 3706 3707 3708 3709 3710 3711 3712
	    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 已提交
3713 3714 3715
	if (nfserr)
		goto err_no_verf;

J
J. Bruce Fields 已提交
3716 3717 3718 3719 3720
	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 已提交
3721

J
J. Bruce Fields 已提交
3722 3723 3724 3725 3726
	p = xdr_reserve_space(xdr, 8);
	if (!p) {
		WARN_ON_ONCE(1);
		goto err_no_verf;
	}
L
Linus Torvalds 已提交
3727 3728 3729 3730 3731
	*p++ = 0;	/* no more entries */
	*p++ = htonl(readdir->common.err == nfserr_eof);

	return 0;
err_no_verf:
J
J. Bruce Fields 已提交
3732
	xdr_truncate_encode(xdr, starting_len);
L
Linus Torvalds 已提交
3733 3734 3735
	return nfserr;
}

3736
static __be32
3737
nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
L
Linus Torvalds 已提交
3738
{
3739
	struct xdr_stream *xdr = &resp->xdr;
3740
	__be32 *p;
L
Linus Torvalds 已提交
3741 3742

	if (!nfserr) {
3743 3744 3745
		p = xdr_reserve_space(xdr, 20);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3746
		p = encode_cinfo(p, &remove->rm_cinfo);
L
Linus Torvalds 已提交
3747
	}
3748
	return nfserr;
L
Linus Torvalds 已提交
3749 3750
}

3751
static __be32
3752
nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
L
Linus Torvalds 已提交
3753
{
3754
	struct xdr_stream *xdr = &resp->xdr;
3755
	__be32 *p;
L
Linus Torvalds 已提交
3756 3757

	if (!nfserr) {
3758 3759 3760
		p = xdr_reserve_space(xdr, 40);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3761 3762
		p = encode_cinfo(p, &rename->rn_sinfo);
		p = encode_cinfo(p, &rename->rn_tinfo);
L
Linus Torvalds 已提交
3763
	}
3764
	return nfserr;
L
Linus Torvalds 已提交
3765 3766
}

3767
static __be32
3768
nfsd4_do_encode_secinfo(struct xdr_stream *xdr,
3769
			 __be32 nfserr, struct svc_export *exp)
A
Andy Adamson 已提交
3770
{
3771
	u32 i, nflavs, supported;
3772 3773
	struct exp_flavor_info *flavs;
	struct exp_flavor_info def_flavs[2];
3774 3775
	__be32 *p, *flavorsp;
	static bool report = true;
A
Andy Adamson 已提交
3776 3777 3778

	if (nfserr)
		goto out;
3779
	nfserr = nfserr_resource;
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799
	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;
		}
	}

3800
	supported = 0;
3801 3802 3803
	p = xdr_reserve_space(xdr, 4);
	if (!p)
		goto out;
3804 3805
	flavorsp = p++;		/* to be backfilled later */

3806
	for (i = 0; i < nflavs; i++) {
3807
		rpc_authflavor_t pf = flavs[i].pseudoflavor;
3808
		struct rpcsec_gss_info info;
A
Andy Adamson 已提交
3809

3810 3811
		if (rpcauth_get_gssinfo(pf, &info) == 0) {
			supported++;
3812 3813 3814 3815
			p = xdr_reserve_space(xdr, 4 + 4 +
					      XDR_LEN(info.oid.len) + 4 + 4);
			if (!p)
				goto out;
J
J. Bruce Fields 已提交
3816
			*p++ = cpu_to_be32(RPC_AUTH_GSS);
J
J. Bruce Fields 已提交
3817
			p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
J
J. Bruce Fields 已提交
3818 3819
			*p++ = cpu_to_be32(info.qop);
			*p++ = cpu_to_be32(info.service);
3820 3821
		} else if (pf < RPC_AUTH_MAXFLAVOR) {
			supported++;
3822 3823 3824
			p = xdr_reserve_space(xdr, 4);
			if (!p)
				goto out;
J
J. Bruce Fields 已提交
3825
			*p++ = cpu_to_be32(pf);
3826 3827 3828 3829
		} else {
			if (report)
				pr_warn("NFS: SECINFO: security flavor %u "
					"is not supported\n", pf);
A
Andy Adamson 已提交
3830 3831
		}
	}
3832

3833 3834 3835
	if (nflavs != supported)
		report = false;
	*flavorsp = htonl(supported);
3836
	nfserr = 0;
A
Andy Adamson 已提交
3837 3838 3839
out:
	if (exp)
		exp_put(exp);
3840
	return nfserr;
A
Andy Adamson 已提交
3841 3842
}

3843 3844 3845 3846
static __be32
nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
		     struct nfsd4_secinfo *secinfo)
{
3847 3848 3849
	struct xdr_stream *xdr = &resp->xdr;

	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->si_exp);
3850 3851 3852 3853 3854 3855
}

static __be32
nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
		     struct nfsd4_secinfo_no_name *secinfo)
{
3856 3857 3858
	struct xdr_stream *xdr = &resp->xdr;

	return nfsd4_do_encode_secinfo(xdr, nfserr, secinfo->sin_exp);
3859 3860
}

L
Linus Torvalds 已提交
3861 3862 3863 3864
/*
 * The SETATTR encode routine is special -- it always encodes a bitmap,
 * regardless of the error status.
 */
3865
static __be32
3866
nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
L
Linus Torvalds 已提交
3867
{
3868
	struct xdr_stream *xdr = &resp->xdr;
3869
	__be32 *p;
L
Linus Torvalds 已提交
3870

3871 3872 3873
	p = xdr_reserve_space(xdr, 16);
	if (!p)
		return nfserr_resource;
L
Linus Torvalds 已提交
3874
	if (nfserr) {
J
J. Bruce Fields 已提交
3875 3876 3877 3878
		*p++ = cpu_to_be32(3);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3879 3880
	}
	else {
J
J. Bruce Fields 已提交
3881 3882 3883 3884
		*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 已提交
3885
	}
3886
	return nfserr;
L
Linus Torvalds 已提交
3887 3888
}

3889
static __be32
3890
nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
L
Linus Torvalds 已提交
3891
{
3892
	struct xdr_stream *xdr = &resp->xdr;
3893
	__be32 *p;
L
Linus Torvalds 已提交
3894 3895

	if (!nfserr) {
3896 3897 3898
		p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3899 3900 3901
		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 已提交
3902 3903
	}
	else if (nfserr == nfserr_clid_inuse) {
3904 3905 3906
		p = xdr_reserve_space(xdr, 8);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3907 3908
		*p++ = cpu_to_be32(0);
		*p++ = cpu_to_be32(0);
L
Linus Torvalds 已提交
3909
	}
3910
	return nfserr;
L
Linus Torvalds 已提交
3911 3912
}

3913
static __be32
3914
nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
L
Linus Torvalds 已提交
3915
{
3916
	struct xdr_stream *xdr = &resp->xdr;
3917
	__be32 *p;
L
Linus Torvalds 已提交
3918 3919

	if (!nfserr) {
3920 3921 3922
		p = xdr_reserve_space(xdr, 16);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
3923 3924
		*p++ = cpu_to_be32(write->wr_bytes_written);
		*p++ = cpu_to_be32(write->wr_how_written);
J
J. Bruce Fields 已提交
3925 3926
		p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
							NFS4_VERIFIER_SIZE);
L
Linus Torvalds 已提交
3927
	}
3928
	return nfserr;
L
Linus Torvalds 已提交
3929 3930
}

A
Andy Adamson 已提交
3931
static __be32
J
J. Bruce Fields 已提交
3932
nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
3933 3934
			 struct nfsd4_exchange_id *exid)
{
3935
	struct xdr_stream *xdr = &resp->xdr;
3936
	__be32 *p;
A
Andy Adamson 已提交
3937 3938 3939 3940
	char *major_id;
	char *server_scope;
	int major_id_sz;
	int server_scope_sz;
3941
	int status = 0;
A
Andy Adamson 已提交
3942 3943 3944 3945 3946 3947 3948 3949 3950 3951
	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);

3952
	p = xdr_reserve_space(xdr,
A
Andy Adamson 已提交
3953 3954 3955
		8 /* eir_clientid */ +
		4 /* eir_sequenceid */ +
		4 /* eir_flags */ +
3956
		4 /* spr_how */);
3957 3958
	if (!p)
		return nfserr_resource;
A
Andy Adamson 已提交
3959

J
J. Bruce Fields 已提交
3960
	p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
J
J. Bruce Fields 已提交
3961 3962
	*p++ = cpu_to_be32(exid->seqid);
	*p++ = cpu_to_be32(exid->flags);
A
Andy Adamson 已提交
3963

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

3966 3967 3968 3969 3970
	switch (exid->spa_how) {
	case SP4_NONE:
		break;
	case SP4_MACH_CRED:
		/* spo_must_enforce bitmap: */
3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983
		status = nfsd4_encode_bitmap(xdr,
					exid->spo_must_enforce[0],
					exid->spo_must_enforce[1],
					exid->spo_must_enforce[2]);
		if (status)
			goto out;
		/* spo_must_allow bitmap: */
		status = nfsd4_encode_bitmap(xdr,
					exid->spo_must_allow[0],
					exid->spo_must_allow[1],
					exid->spo_must_allow[2]);
		if (status)
			goto out;
3984 3985 3986 3987
		break;
	default:
		WARN_ON_ONCE(1);
	}
A
Andy Adamson 已提交
3988

3989
	p = xdr_reserve_space(xdr,
3990 3991 3992 3993 3994 3995
		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) */);
3996 3997
	if (!p)
		return nfserr_resource;
3998

A
Andy Adamson 已提交
3999
	/* The server_owner struct */
J
J. Bruce Fields 已提交
4000
	p = xdr_encode_hyper(p, minor_id);      /* Minor id */
A
Andy Adamson 已提交
4001
	/* major id */
J
J. Bruce Fields 已提交
4002
	p = xdr_encode_opaque(p, major_id, major_id_sz);
A
Andy Adamson 已提交
4003 4004

	/* Server scope */
J
J. Bruce Fields 已提交
4005
	p = xdr_encode_opaque(p, server_scope, server_scope_sz);
A
Andy Adamson 已提交
4006 4007

	/* Implementation id */
J
J. Bruce Fields 已提交
4008
	*p++ = cpu_to_be32(0);	/* zero length nfs_impl_id4 array */
A
Andy Adamson 已提交
4009
	return 0;
4010 4011
out:
	return status;
A
Andy Adamson 已提交
4012 4013 4014
}

static __be32
J
J. Bruce Fields 已提交
4015
nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
4016 4017
			    struct nfsd4_create_session *sess)
{
4018
	struct xdr_stream *xdr = &resp->xdr;
4019
	__be32 *p;
A
Andy Adamson 已提交
4020 4021 4022 4023

	if (nfserr)
		return nfserr;

4024 4025 4026
	p = xdr_reserve_space(xdr, 24);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
4027 4028
	p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
					NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
4029 4030
	*p++ = cpu_to_be32(sess->seqid);
	*p++ = cpu_to_be32(sess->flags);
A
Andy Adamson 已提交
4031

4032 4033 4034
	p = xdr_reserve_space(xdr, 28);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
4035 4036 4037 4038 4039 4040 4041
	*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 已提交
4042 4043

	if (sess->fore_channel.nr_rdma_attrs) {
4044 4045 4046
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
4047
		*p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
A
Andy Adamson 已提交
4048 4049
	}

4050 4051 4052
	p = xdr_reserve_space(xdr, 28);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
4053 4054 4055 4056 4057 4058 4059
	*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 已提交
4060 4061

	if (sess->back_channel.nr_rdma_attrs) {
4062 4063 4064
		p = xdr_reserve_space(xdr, 4);
		if (!p)
			return nfserr_resource;
J
J. Bruce Fields 已提交
4065
		*p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
A
Andy Adamson 已提交
4066 4067
	}
	return 0;
A
Andy Adamson 已提交
4068 4069
}

D
Daniel Mack 已提交
4070
static __be32
J
J. Bruce Fields 已提交
4071
nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
A
Andy Adamson 已提交
4072 4073
		      struct nfsd4_sequence *seq)
{
4074
	struct xdr_stream *xdr = &resp->xdr;
4075
	__be32 *p;
B
Benny Halevy 已提交
4076 4077 4078 4079

	if (nfserr)
		return nfserr;

4080 4081 4082
	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
	if (!p)
		return nfserr_resource;
J
J. Bruce Fields 已提交
4083 4084
	p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
					NFS4_MAX_SESSIONID_LEN);
J
J. Bruce Fields 已提交
4085 4086
	*p++ = cpu_to_be32(seq->seqid);
	*p++ = cpu_to_be32(seq->slotid);
4087
	/* Note slotid's are numbered from zero: */
J
J. Bruce Fields 已提交
4088 4089 4090
	*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 已提交
4091

4092
	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
B
Benny Halevy 已提交
4093
	return 0;
A
Andy Adamson 已提交
4094 4095
}

J
J. Bruce Fields 已提交
4096
static __be32
J
J. Bruce Fields 已提交
4097
nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
4098 4099
			  struct nfsd4_test_stateid *test_stateid)
{
4100
	struct xdr_stream *xdr = &resp->xdr;
4101
	struct nfsd4_test_stateid_id *stateid, *next;
4102 4103
	__be32 *p;

4104 4105 4106
	if (nfserr)
		return nfserr;

4107 4108 4109
	p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
	if (!p)
		return nfserr_resource;
4110 4111
	*p++ = htonl(test_stateid->ts_num_ids);

4112
	list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
4113
		*p++ = stateid->ts_id_status;
4114 4115 4116 4117 4118
	}

	return nfserr;
}

4119 4120 4121 4122 4123 4124
#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;
4125
	const struct nfsd4_layout_ops *ops;
4126 4127 4128
	u32 starting_len = xdr->buf->len, needed_len;
	__be32 *p;

4129
	dprintk("%s: err %d\n", __func__, be32_to_cpu(nfserr));
4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141
	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) {
4142
		ops = nfsd4_layout_ops[gdev->gd_layout_type];
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
		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;
4195
	const struct nfsd4_layout_ops *ops;
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217
	__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);

4218
	ops = nfsd4_layout_ops[lgp->lg_layout_type];
4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263
	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)
4264
		return nfsd4_encode_stateid(xdr, &lrp->lr_sid);
4265 4266 4267 4268
	return nfs_ok;
}
#endif /* CONFIG_NFSD_PNFS */

A
Anna Schumaker 已提交
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303
static __be32
nfsd42_encode_write_res(struct nfsd4_compoundres *resp, struct nfsd42_write_res *write)
{
	__be32 *p;

	p = xdr_reserve_space(&resp->xdr, 4 + 8 + 4 + NFS4_VERIFIER_SIZE);
	if (!p)
		return nfserr_resource;

	*p++ = cpu_to_be32(0);
	p = xdr_encode_hyper(p, write->wr_bytes_written);
	*p++ = cpu_to_be32(write->wr_stable_how);
	p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
				    NFS4_VERIFIER_SIZE);
	return nfs_ok;
}

static __be32
nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
		  struct nfsd4_copy *copy)
{
	__be32 *p;

	if (!nfserr) {
		nfserr = nfsd42_encode_write_res(resp, &copy->cp_res);
		if (nfserr)
			return nfserr;

		p = xdr_reserve_space(&resp->xdr, 4 + 4);
		*p++ = cpu_to_be32(copy->cp_consecutive);
		*p++ = cpu_to_be32(copy->cp_synchronous);
	}
	return nfserr;
}

A
Anna Schumaker 已提交
4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
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;
}

4320 4321 4322 4323 4324 4325 4326 4327
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 已提交
4328 4329 4330 4331 4332
/*
 * 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.
 */
4333
static nfsd4_enc nfsd4_enc_ops[] = {
4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349
	[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,
4350
	[OP_OPENATTR]		= (nfsd4_enc)nfsd4_encode_noop,
4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370
	[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 已提交
4371 4372 4373

	/* NFSv4.1 operations */
	[OP_BACKCHANNEL_CTL]	= (nfsd4_enc)nfsd4_encode_noop,
4374
	[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
A
Andy Adamson 已提交
4375 4376
	[OP_EXCHANGE_ID]	= (nfsd4_enc)nfsd4_encode_exchange_id,
	[OP_CREATE_SESSION]	= (nfsd4_enc)nfsd4_encode_create_session,
4377 4378
	[OP_DESTROY_SESSION]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_FREE_STATEID]	= (nfsd4_enc)nfsd4_encode_noop,
A
Andy Adamson 已提交
4379
	[OP_GET_DIR_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
4380 4381 4382 4383 4384 4385 4386
#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 已提交
4387 4388 4389 4390 4391
	[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,
4392
#endif
4393
	[OP_SECINFO_NO_NAME]	= (nfsd4_enc)nfsd4_encode_secinfo_no_name,
A
Andy Adamson 已提交
4394 4395
	[OP_SEQUENCE]		= (nfsd4_enc)nfsd4_encode_sequence,
	[OP_SET_SSV]		= (nfsd4_enc)nfsd4_encode_noop,
4396
	[OP_TEST_STATEID]	= (nfsd4_enc)nfsd4_encode_test_stateid,
A
Andy Adamson 已提交
4397 4398 4399
	[OP_WANT_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_DESTROY_CLIENTID]	= (nfsd4_enc)nfsd4_encode_noop,
	[OP_RECLAIM_COMPLETE]	= (nfsd4_enc)nfsd4_encode_noop,
4400 4401 4402

	/* NFSv4.2 operations */
	[OP_ALLOCATE]		= (nfsd4_enc)nfsd4_encode_noop,
A
Anna Schumaker 已提交
4403
	[OP_COPY]		= (nfsd4_enc)nfsd4_encode_copy,
4404 4405 4406 4407 4408 4409 4410 4411
	[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 已提交
4412
	[OP_SEEK]		= (nfsd4_enc)nfsd4_encode_seek,
4413
	[OP_WRITE_SAME]		= (nfsd4_enc)nfsd4_encode_noop,
4414
	[OP_CLONE]		= (nfsd4_enc)nfsd4_encode_noop,
4415 4416
};

4417
/*
J
J. Bruce Fields 已提交
4418 4419 4420 4421 4422 4423
 * 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.
4424
 *
J
J. Bruce Fields 已提交
4425 4426 4427 4428
 * 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.
4429
 */
J
J. Bruce Fields 已提交
4430
__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
4431
{
4432
	struct xdr_buf *buf = &resp->rqstp->rq_res;
4433
	struct nfsd4_slot *slot = resp->cstate.slot;
4434

4435 4436 4437
	if (buf->len + respsize <= buf->buflen)
		return nfs_ok;
	if (!nfsd4_has_session(&resp->cstate))
4438
		return nfserr_resource;
4439 4440 4441
	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
		WARN_ON_ONCE(1);
		return nfserr_rep_too_big_to_cache;
4442
	}
4443
	return nfserr_rep_too_big;
4444 4445
}

L
Linus Torvalds 已提交
4446 4447 4448
void
nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
{
4449
	struct xdr_stream *xdr = &resp->xdr;
4450
	struct nfs4_stateowner *so = resp->cstate.replay_owner;
4451
	struct svc_rqst *rqstp = resp->rqstp;
4452
	int post_err_offset;
4453
	nfsd4_enc encoder;
4454
	__be32 *p;
L
Linus Torvalds 已提交
4455

4456 4457 4458 4459 4460
	p = xdr_reserve_space(xdr, 8);
	if (!p) {
		WARN_ON_ONCE(1);
		return;
	}
J
J. Bruce Fields 已提交
4461
	*p++ = cpu_to_be32(op->opnum);
4462
	post_err_offset = xdr->buf->len;
L
Linus Torvalds 已提交
4463

4464 4465 4466 4467
	if (op->opnum == OP_ILLEGAL)
		goto status;
	BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
	       !nfsd4_enc_ops[op->opnum]);
4468 4469
	encoder = nfsd4_enc_ops[op->opnum];
	op->status = encoder(resp, op->status, &op->u);
4470 4471
	xdr_commit_encode(xdr);

4472
	/* nfsd4_check_resp_size guarantees enough room for error status */
4473 4474 4475 4476 4477 4478
	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);
	}
4479 4480 4481 4482 4483 4484 4485 4486
	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;
	}
4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497
	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);
4498
		xdr_truncate_encode(xdr, post_err_offset);
4499
	}
4500
	if (so) {
4501 4502
		int len = xdr->buf->len - post_err_offset;

4503
		so->so_replay.rp_status = op->status;
4504 4505 4506
		so->so_replay.rp_buflen = len;
		read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
						so->so_replay.rp_buf, len);
4507
	}
4508
status:
4509 4510
	/* 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 已提交
4511 4512 4513 4514 4515 4516 4517 4518 4519
}

/* 
 * 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
4520
nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
L
Linus Torvalds 已提交
4521
{
4522
	__be32 *p;
L
Linus Torvalds 已提交
4523 4524 4525 4526
	struct nfs4_replay *rp = op->replay;

	BUG_ON(!rp);

4527 4528 4529 4530 4531
	p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
	if (!p) {
		WARN_ON_ONCE(1);
		return;
	}
J
J. Bruce Fields 已提交
4532
	*p++ = cpu_to_be32(op->opnum);
L
Linus Torvalds 已提交
4533 4534
	*p++ = rp->rp_status;  /* already xdr'ed */

J
J. Bruce Fields 已提交
4535
	p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
L
Linus Torvalds 已提交
4536 4537 4538
}

int
4539
nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p)
L
Linus Torvalds 已提交
4540 4541 4542 4543
{
        return xdr_ressize_check(rqstp, p);
}

4544
void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
L
Linus Torvalds 已提交
4545
{
4546 4547
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

L
Linus Torvalds 已提交
4548 4549 4550 4551
	if (args->ops != args->iops) {
		kfree(args->ops);
		args->ops = args->iops;
	}
J
Jesper Juhl 已提交
4552 4553
	kfree(args->tmpp);
	args->tmpp = NULL;
L
Linus Torvalds 已提交
4554
	while (args->to_free) {
4555
		struct svcxdr_tmpbuf *tb = args->to_free;
L
Linus Torvalds 已提交
4556 4557 4558 4559 4560 4561
		args->to_free = tb->next;
		kfree(tb);
	}
}

int
4562
nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p)
L
Linus Torvalds 已提交
4563
{
4564 4565
	struct nfsd4_compoundargs *args = rqstp->rq_argp;

4566 4567 4568 4569 4570 4571
	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 已提交
4572 4573 4574 4575 4576 4577 4578 4579 4580
	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;

4581
	return !nfsd4_decode_compound(args);
L
Linus Torvalds 已提交
4582 4583 4584
}

int
4585
nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p)
L
Linus Torvalds 已提交
4586 4587 4588 4589
{
	/*
	 * All that remains is to write the tag and operation count...
	 */
4590
	struct nfsd4_compoundres *resp = rqstp->rq_resp;
4591 4592 4593 4594
	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);
4595

4596 4597
	rqstp->rq_next_page = resp->xdr.page_ptr + 1;

L
Linus Torvalds 已提交
4598 4599 4600 4601 4602 4603
	p = resp->tagp;
	*p++ = htonl(resp->taglen);
	memcpy(p, resp->tag, resp->taglen);
	p += XDR_QUADLEN(resp->taglen);
	*p++ = htonl(resp->opcnt);

4604
	nfsd4_sequence_done(resp);
L
Linus Torvalds 已提交
4605 4606 4607 4608 4609 4610 4611 4612
	return 1;
}

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