File Index
Files and directories
Sign in
FILE

nfs3xdr.c

File preview with syntax highlighting.

linux-6.19.14/fs/nfs/nfs3xdr.c C 
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * linux/fs/nfs/nfs3xdr.c
   4 *
   5 * XDR functions to encode/decode NFSv3 RPC arguments and results.
   6 *
   7 * Copyright (C) 1996, 1997 Olaf Kirch
   8 */
   9
  10#include <linux/param.h>
  11#include <linux/time.h>
  12#include <linux/mm.h>
  13#include <linux/errno.h>
  14#include <linux/string.h>
  15#include <linux/in.h>
  16#include <linux/pagemap.h>
  17#include <linux/proc_fs.h>
  18#include <linux/kdev_t.h>
  19#include <linux/sunrpc/clnt.h>
  20#include <linux/nfs.h>
  21#include <linux/nfs3.h>
  22#include <linux/nfs_fs.h>
  23#include <linux/nfsacl.h>
  24#include <linux/nfs_common.h>
  25
  26#include "internal.h"
  27#include "nfstrace.h"
  28
  29#define NFSDBG_FACILITY		NFSDBG_XDR
  30
  31/*
  32 * Declare the space requirements for NFS arguments and replies as
  33 * number of 32bit-words
  34 */
  35#define NFS3_pagepad_sz		(1) /* Page padding */
  36#define NFS3_fhandle_sz		(1+16)
  37#define NFS3_fh_sz		(NFS3_fhandle_sz)	/* shorthand */
  38#define NFS3_post_op_fh_sz	(1+NFS3_fh_sz)
  39#define NFS3_sattr_sz		(15)
  40#define NFS3_filename_sz	(1+(NFS3_MAXNAMLEN>>2))
  41#define NFS3_path_sz		(1+(NFS3_MAXPATHLEN>>2))
  42#define NFS3_fattr_sz		(21)
  43#define NFS3_cookieverf_sz	(NFS3_COOKIEVERFSIZE>>2)
  44#define NFS3_wcc_attr_sz	(6)
  45#define NFS3_pre_op_attr_sz	(1+NFS3_wcc_attr_sz)
  46#define NFS3_post_op_attr_sz	(1+NFS3_fattr_sz)
  47#define NFS3_wcc_data_sz	(NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
  48#define NFS3_diropargs_sz	(NFS3_fh_sz+NFS3_filename_sz)
  49
  50#define NFS3_getattrargs_sz	(NFS3_fh_sz)
  51#define NFS3_setattrargs_sz	(NFS3_fh_sz+NFS3_sattr_sz+3)
  52#define NFS3_lookupargs_sz	(NFS3_fh_sz+NFS3_filename_sz)
  53#define NFS3_accessargs_sz	(NFS3_fh_sz+1)
  54#define NFS3_readlinkargs_sz	(NFS3_fh_sz)
  55#define NFS3_readargs_sz	(NFS3_fh_sz+3)
  56#define NFS3_writeargs_sz	(NFS3_fh_sz+5)
  57#define NFS3_createargs_sz	(NFS3_diropargs_sz+NFS3_sattr_sz)
  58#define NFS3_mkdirargs_sz	(NFS3_diropargs_sz+NFS3_sattr_sz)
  59#define NFS3_symlinkargs_sz	(NFS3_diropargs_sz+1+NFS3_sattr_sz)
  60#define NFS3_mknodargs_sz	(NFS3_diropargs_sz+2+NFS3_sattr_sz)
  61#define NFS3_removeargs_sz	(NFS3_fh_sz+NFS3_filename_sz)
  62#define NFS3_renameargs_sz	(NFS3_diropargs_sz+NFS3_diropargs_sz)
  63#define NFS3_linkargs_sz		(NFS3_fh_sz+NFS3_diropargs_sz)
  64#define NFS3_readdirargs_sz	(NFS3_fh_sz+NFS3_cookieverf_sz+3)
  65#define NFS3_readdirplusargs_sz	(NFS3_fh_sz+NFS3_cookieverf_sz+4)
  66#define NFS3_commitargs_sz	(NFS3_fh_sz+3)
  67
  68#define NFS3_getattrres_sz	(1+NFS3_fattr_sz)
  69#define NFS3_setattrres_sz	(1+NFS3_wcc_data_sz)
  70#define NFS3_removeres_sz	(NFS3_setattrres_sz)
  71#define NFS3_lookupres_sz	(1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
  72#define NFS3_accessres_sz	(1+NFS3_post_op_attr_sz+1)
  73#define NFS3_readlinkres_sz	(1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
  74#define NFS3_readres_sz		(1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
  75#define NFS3_writeres_sz	(1+NFS3_wcc_data_sz+4)
  76#define NFS3_createres_sz	(1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  77#define NFS3_renameres_sz	(1+(2 * NFS3_wcc_data_sz))
  78#define NFS3_linkres_sz		(1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
  79#define NFS3_readdirres_sz	(1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)
  80#define NFS3_fsstatres_sz	(1+NFS3_post_op_attr_sz+13)
  81#define NFS3_fsinfores_sz	(1+NFS3_post_op_attr_sz+12)
  82#define NFS3_pathconfres_sz	(1+NFS3_post_op_attr_sz+6)
  83#define NFS3_commitres_sz	(1+NFS3_wcc_data_sz+2)
  84
  85#define ACL3_getaclargs_sz	(NFS3_fh_sz+1)
  86#define ACL3_setaclargs_sz	(NFS3_fh_sz+1+ \
  87				XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
  88#define ACL3_getaclres_sz	(1+NFS3_post_op_attr_sz+1+ \
  89				XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+\
  90				NFS3_pagepad_sz)
  91#define ACL3_setaclres_sz	(1+NFS3_post_op_attr_sz)
  92
  93/*
  94 * Map file type to S_IFMT bits
  95 */
  96static const umode_t nfs_type2fmt[] = {
  97	[NF3BAD] = 0,
  98	[NF3REG] = S_IFREG,
  99	[NF3DIR] = S_IFDIR,
 100	[NF3BLK] = S_IFBLK,
 101	[NF3CHR] = S_IFCHR,
 102	[NF3LNK] = S_IFLNK,
 103	[NF3SOCK] = S_IFSOCK,
 104	[NF3FIFO] = S_IFIFO,
 105};
 106
 107static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt)
 108{
 109	if (clnt && clnt->cl_cred)
 110		return clnt->cl_cred->user_ns;
 111	return &init_user_ns;
 112}
 113
 114static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp)
 115{
 116	if (rqstp->rq_task)
 117		return rpc_userns(rqstp->rq_task->tk_client);
 118	return &init_user_ns;
 119}
 120
 121/*
 122 * Encode/decode NFSv3 basic data types
 123 *
 124 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
 125 * "NFS Version 3 Protocol Specification".
 126 *
 127 * Not all basic data types have their own encoding and decoding
 128 * functions.  For run-time efficiency, some data types are encoded
 129 * or decoded inline.
 130 */
 131
 132static void encode_uint32(struct xdr_stream *xdr, u32 value)
 133{
 134	__be32 *p = xdr_reserve_space(xdr, 4);
 135	*p = cpu_to_be32(value);
 136}
 137
 138static int decode_uint32(struct xdr_stream *xdr, u32 *value)
 139{
 140	__be32 *p;
 141
 142	p = xdr_inline_decode(xdr, 4);
 143	if (unlikely(!p))
 144		return -EIO;
 145	*value = be32_to_cpup(p);
 146	return 0;
 147}
 148
 149static int decode_uint64(struct xdr_stream *xdr, u64 *value)
 150{
 151	__be32 *p;
 152
 153	p = xdr_inline_decode(xdr, 8);
 154	if (unlikely(!p))
 155		return -EIO;
 156	xdr_decode_hyper(p, value);
 157	return 0;
 158}
 159
 160/*
 161 * fileid3
 162 *
 163 *	typedef uint64 fileid3;
 164 */
 165static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
 166{
 167	return xdr_decode_hyper(p, fileid);
 168}
 169
 170static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
 171{
 172	return decode_uint64(xdr, fileid);
 173}
 174
 175/*
 176 * filename3
 177 *
 178 *	typedef string filename3<>;
 179 */
 180static void encode_filename3(struct xdr_stream *xdr,
 181			     const char *name, u32 length)
 182{
 183	__be32 *p;
 184
 185	WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
 186	p = xdr_reserve_space(xdr, 4 + length);
 187	xdr_encode_opaque(p, name, length);
 188}
 189
 190static int decode_inline_filename3(struct xdr_stream *xdr,
 191				   const char **name, u32 *length)
 192{
 193	__be32 *p;
 194	u32 count;
 195
 196	p = xdr_inline_decode(xdr, 4);
 197	if (unlikely(!p))
 198		return -EIO;
 199	count = be32_to_cpup(p);
 200	if (count > NFS3_MAXNAMLEN)
 201		goto out_nametoolong;
 202	p = xdr_inline_decode(xdr, count);
 203	if (unlikely(!p))
 204		return -EIO;
 205	*name = (const char *)p;
 206	*length = count;
 207	return 0;
 208
 209out_nametoolong:
 210	dprintk("NFS: returned filename too long: %u\n", count);
 211	return -ENAMETOOLONG;
 212}
 213
 214/*
 215 * nfspath3
 216 *
 217 *	typedef string nfspath3<>;
 218 */
 219static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
 220			    const u32 length)
 221{
 222	encode_uint32(xdr, length);
 223	xdr_write_pages(xdr, pages, 0, length);
 224}
 225
 226static int decode_nfspath3(struct xdr_stream *xdr)
 227{
 228	u32 recvd, count;
 229	__be32 *p;
 230
 231	p = xdr_inline_decode(xdr, 4);
 232	if (unlikely(!p))
 233		return -EIO;
 234	count = be32_to_cpup(p);
 235	if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
 236		goto out_nametoolong;
 237	recvd = xdr_read_pages(xdr, count);
 238	if (unlikely(count > recvd))
 239		goto out_cheating;
 240	xdr_terminate_string(xdr->buf, count);
 241	return 0;
 242
 243out_nametoolong:
 244	dprintk("NFS: returned pathname too long: %u\n", count);
 245	return -ENAMETOOLONG;
 246out_cheating:
 247	dprintk("NFS: server cheating in pathname result: "
 248		"count %u > recvd %u\n", count, recvd);
 249	return -EIO;
 250}
 251
 252/*
 253 * cookie3
 254 *
 255 *	typedef uint64 cookie3
 256 */
 257static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
 258{
 259	return xdr_encode_hyper(p, cookie);
 260}
 261
 262static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
 263{
 264	return decode_uint64(xdr, cookie);
 265}
 266
 267/*
 268 * cookieverf3
 269 *
 270 *	typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
 271 */
 272static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
 273{
 274	memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
 275	return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
 276}
 277
 278static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
 279{
 280	__be32 *p;
 281
 282	p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
 283	if (unlikely(!p))
 284		return -EIO;
 285	memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
 286	return 0;
 287}
 288
 289/*
 290 * createverf3
 291 *
 292 *	typedef opaque createverf3[NFS3_CREATEVERFSIZE];
 293 */
 294static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
 295{
 296	__be32 *p;
 297
 298	p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
 299	memcpy(p, verifier, NFS3_CREATEVERFSIZE);
 300}
 301
 302static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
 303{
 304	__be32 *p;
 305
 306	p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
 307	if (unlikely(!p))
 308		return -EIO;
 309	memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
 310	return 0;
 311}
 312
 313/*
 314 * size3
 315 *
 316 *	typedef uint64 size3;
 317 */
 318static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
 319{
 320	return xdr_decode_hyper(p, size);
 321}
 322
 323/*
 324 * nfsstat3
 325 *
 326 *	enum nfsstat3 {
 327 *		NFS3_OK = 0,
 328 *		...
 329 *	}
 330 */
 331#define NFS3_OK		NFS_OK
 332
 333static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
 334{
 335	__be32 *p;
 336
 337	p = xdr_inline_decode(xdr, 4);
 338	if (unlikely(!p))
 339		return -EIO;
 340	if (unlikely(*p != cpu_to_be32(NFS3_OK)))
 341		goto out_status;
 342	*status = 0;
 343	return 0;
 344out_status:
 345	*status = be32_to_cpup(p);
 346	trace_nfs_xdr_status(xdr, (int)*status);
 347	return 0;
 348}
 349
 350/*
 351 * ftype3
 352 *
 353 *	enum ftype3 {
 354 *		NF3REG	= 1,
 355 *		NF3DIR	= 2,
 356 *		NF3BLK	= 3,
 357 *		NF3CHR	= 4,
 358 *		NF3LNK	= 5,
 359 *		NF3SOCK	= 6,
 360 *		NF3FIFO	= 7
 361 *	};
 362 */
 363static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
 364{
 365	encode_uint32(xdr, type);
 366}
 367
 368static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
 369{
 370	u32 type;
 371
 372	type = be32_to_cpup(p++);
 373	if (type > NF3FIFO)
 374		type = NF3NON;
 375	*mode = nfs_type2fmt[type];
 376	return p;
 377}
 378
 379/*
 380 * specdata3
 381 *
 382 *     struct specdata3 {
 383 *             uint32  specdata1;
 384 *             uint32  specdata2;
 385 *     };
 386 */
 387static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
 388{
 389	__be32 *p;
 390
 391	p = xdr_reserve_space(xdr, 8);
 392	*p++ = cpu_to_be32(MAJOR(rdev));
 393	*p = cpu_to_be32(MINOR(rdev));
 394}
 395
 396static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
 397{
 398	unsigned int major, minor;
 399
 400	major = be32_to_cpup(p++);
 401	minor = be32_to_cpup(p++);
 402	*rdev = MKDEV(major, minor);
 403	if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
 404		*rdev = 0;
 405	return p;
 406}
 407
 408/*
 409 * nfs_fh3
 410 *
 411 *	struct nfs_fh3 {
 412 *		opaque       data<NFS3_FHSIZE>;
 413 *	};
 414 */
 415static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
 416{
 417	__be32 *p;
 418
 419	WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
 420	p = xdr_reserve_space(xdr, 4 + fh->size);
 421	xdr_encode_opaque(p, fh->data, fh->size);
 422}
 423
 424static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 425{
 426	u32 length;
 427	__be32 *p;
 428
 429	p = xdr_inline_decode(xdr, 4);
 430	if (unlikely(!p))
 431		return -EIO;
 432	length = be32_to_cpup(p++);
 433	if (unlikely(length > NFS3_FHSIZE || length == 0))
 434		goto out_toobig;
 435	p = xdr_inline_decode(xdr, length);
 436	if (unlikely(!p))
 437		return -EIO;
 438	fh->size = length;
 439	memcpy(fh->data, p, length);
 440	return 0;
 441out_toobig:
 442	trace_nfs_xdr_bad_filehandle(xdr, NFSERR_BADHANDLE);
 443	return -E2BIG;
 444}
 445
 446static void zero_nfs_fh3(struct nfs_fh *fh)
 447{
 448	memset(fh, 0, sizeof(*fh));
 449}
 450
 451/*
 452 * nfstime3
 453 *
 454 *	struct nfstime3 {
 455 *		uint32	seconds;
 456 *		uint32	nseconds;
 457 *	};
 458 */
 459static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec64 *timep)
 460{
 461	*p++ = cpu_to_be32((u32)timep->tv_sec);
 462	*p++ = cpu_to_be32(timep->tv_nsec);
 463	return p;
 464}
 465
 466static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec64 *timep)
 467{
 468	timep->tv_sec = be32_to_cpup(p++);
 469	timep->tv_nsec = be32_to_cpup(p++);
 470	return p;
 471}
 472
 473/*
 474 * sattr3
 475 *
 476 *	enum time_how {
 477 *		DONT_CHANGE		= 0,
 478 *		SET_TO_SERVER_TIME	= 1,
 479 *		SET_TO_CLIENT_TIME	= 2
 480 *	};
 481 *
 482 *	union set_mode3 switch (bool set_it) {
 483 *	case TRUE:
 484 *		mode3	mode;
 485 *	default:
 486 *		void;
 487 *	};
 488 *
 489 *	union set_uid3 switch (bool set_it) {
 490 *	case TRUE:
 491 *		uid3	uid;
 492 *	default:
 493 *		void;
 494 *	};
 495 *
 496 *	union set_gid3 switch (bool set_it) {
 497 *	case TRUE:
 498 *		gid3	gid;
 499 *	default:
 500 *		void;
 501 *	};
 502 *
 503 *	union set_size3 switch (bool set_it) {
 504 *	case TRUE:
 505 *		size3	size;
 506 *	default:
 507 *		void;
 508 *	};
 509 *
 510 *	union set_atime switch (time_how set_it) {
 511 *	case SET_TO_CLIENT_TIME:
 512 *		nfstime3	atime;
 513 *	default:
 514 *		void;
 515 *	};
 516 *
 517 *	union set_mtime switch (time_how set_it) {
 518 *	case SET_TO_CLIENT_TIME:
 519 *		nfstime3  mtime;
 520 *	default:
 521 *		void;
 522 *	};
 523 *
 524 *	struct sattr3 {
 525 *		set_mode3	mode;
 526 *		set_uid3	uid;
 527 *		set_gid3	gid;
 528 *		set_size3	size;
 529 *		set_atime	atime;
 530 *		set_mtime	mtime;
 531 *	};
 532 */
 533static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr,
 534		struct user_namespace *userns)
 535{
 536	u32 nbytes;
 537	__be32 *p;
 538
 539	/*
 540	 * In order to make only a single xdr_reserve_space() call,
 541	 * pre-compute the total number of bytes to be reserved.
 542	 * Six boolean values, one for each set_foo field, are always
 543	 * present in the encoded result, so start there.
 544	 */
 545	nbytes = 6 * 4;
 546	if (attr->ia_valid & ATTR_MODE)
 547		nbytes += 4;
 548	if (attr->ia_valid & ATTR_UID)
 549		nbytes += 4;
 550	if (attr->ia_valid & ATTR_GID)
 551		nbytes += 4;
 552	if (attr->ia_valid & ATTR_SIZE)
 553		nbytes += 8;
 554	if (attr->ia_valid & ATTR_ATIME_SET)
 555		nbytes += 8;
 556	if (attr->ia_valid & ATTR_MTIME_SET)
 557		nbytes += 8;
 558	p = xdr_reserve_space(xdr, nbytes);
 559
 560	if (attr->ia_valid & ATTR_MODE) {
 561		*p++ = xdr_one;
 562		*p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
 563	} else
 564		*p++ = xdr_zero;
 565
 566	if (attr->ia_valid & ATTR_UID) {
 567		*p++ = xdr_one;
 568		*p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid));
 569	} else
 570		*p++ = xdr_zero;
 571
 572	if (attr->ia_valid & ATTR_GID) {
 573		*p++ = xdr_one;
 574		*p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid));
 575	} else
 576		*p++ = xdr_zero;
 577
 578	if (attr->ia_valid & ATTR_SIZE) {
 579		*p++ = xdr_one;
 580		p = xdr_encode_hyper(p, (u64)attr->ia_size);
 581	} else
 582		*p++ = xdr_zero;
 583
 584	if (attr->ia_valid & ATTR_ATIME_SET) {
 585		*p++ = xdr_two;
 586		p = xdr_encode_nfstime3(p, &attr->ia_atime);
 587	} else if (attr->ia_valid & ATTR_ATIME) {
 588		*p++ = xdr_one;
 589	} else
 590		*p++ = xdr_zero;
 591
 592	if (attr->ia_valid & ATTR_MTIME_SET) {
 593		*p++ = xdr_two;
 594		xdr_encode_nfstime3(p, &attr->ia_mtime);
 595	} else if (attr->ia_valid & ATTR_MTIME) {
 596		*p = xdr_one;
 597	} else
 598		*p = xdr_zero;
 599}
 600
 601/*
 602 * fattr3
 603 *
 604 *	struct fattr3 {
 605 *		ftype3		type;
 606 *		mode3		mode;
 607 *		uint32		nlink;
 608 *		uid3		uid;
 609 *		gid3		gid;
 610 *		size3		size;
 611 *		size3		used;
 612 *		specdata3	rdev;
 613 *		uint64		fsid;
 614 *		fileid3		fileid;
 615 *		nfstime3	atime;
 616 *		nfstime3	mtime;
 617 *		nfstime3	ctime;
 618 *	};
 619 */
 620static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 621		struct user_namespace *userns)
 622{
 623	umode_t fmode;
 624	__be32 *p;
 625
 626	p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
 627	if (unlikely(!p))
 628		return -EIO;
 629
 630	p = xdr_decode_ftype3(p, &fmode);
 631
 632	fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
 633	fattr->nlink = be32_to_cpup(p++);
 634	fattr->uid = make_kuid(userns, be32_to_cpup(p++));
 635	if (!uid_valid(fattr->uid))
 636		goto out_uid;
 637	fattr->gid = make_kgid(userns, be32_to_cpup(p++));
 638	if (!gid_valid(fattr->gid))
 639		goto out_gid;
 640
 641	p = xdr_decode_size3(p, &fattr->size);
 642	p = xdr_decode_size3(p, &fattr->du.nfs3.used);
 643	p = xdr_decode_specdata3(p, &fattr->rdev);
 644
 645	p = xdr_decode_hyper(p, &fattr->fsid.major);
 646	fattr->fsid.minor = 0;
 647
 648	p = xdr_decode_fileid3(p, &fattr->fileid);
 649	p = xdr_decode_nfstime3(p, &fattr->atime);
 650	p = xdr_decode_nfstime3(p, &fattr->mtime);
 651	xdr_decode_nfstime3(p, &fattr->ctime);
 652	fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
 653
 654	fattr->valid |= NFS_ATTR_FATTR_V3;
 655	return 0;
 656out_uid:
 657	dprintk("NFS: returned invalid uid\n");
 658	return -EINVAL;
 659out_gid:
 660	dprintk("NFS: returned invalid gid\n");
 661	return -EINVAL;
 662}
 663
 664/*
 665 * post_op_attr
 666 *
 667 *	union post_op_attr switch (bool attributes_follow) {
 668 *	case TRUE:
 669 *		fattr3	attributes;
 670 *	case FALSE:
 671 *		void;
 672 *	};
 673 */
 674static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 675		struct user_namespace *userns)
 676{
 677	__be32 *p;
 678
 679	p = xdr_inline_decode(xdr, 4);
 680	if (unlikely(!p))
 681		return -EIO;
 682	if (*p != xdr_zero)
 683		return decode_fattr3(xdr, fattr, userns);
 684	return 0;
 685}
 686
 687/*
 688 * wcc_attr
 689 *	struct wcc_attr {
 690 *		size3		size;
 691 *		nfstime3	mtime;
 692 *		nfstime3	ctime;
 693 *	};
 694 */
 695static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 696{
 697	__be32 *p;
 698
 699	p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
 700	if (unlikely(!p))
 701		return -EIO;
 702
 703	fattr->valid |= NFS_ATTR_FATTR_PRESIZE
 704		| NFS_ATTR_FATTR_PRECHANGE
 705		| NFS_ATTR_FATTR_PREMTIME
 706		| NFS_ATTR_FATTR_PRECTIME;
 707
 708	p = xdr_decode_size3(p, &fattr->pre_size);
 709	p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
 710	xdr_decode_nfstime3(p, &fattr->pre_ctime);
 711	fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
 712
 713	return 0;
 714}
 715
 716/*
 717 * pre_op_attr
 718 *	union pre_op_attr switch (bool attributes_follow) {
 719 *	case TRUE:
 720 *		wcc_attr	attributes;
 721 *	case FALSE:
 722 *		void;
 723 *	};
 724 *
 725 * wcc_data
 726 *
 727 *	struct wcc_data {
 728 *		pre_op_attr	before;
 729 *		post_op_attr	after;
 730 *	};
 731 */
 732static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
 733{
 734	__be32 *p;
 735
 736	p = xdr_inline_decode(xdr, 4);
 737	if (unlikely(!p))
 738		return -EIO;
 739	if (*p != xdr_zero)
 740		return decode_wcc_attr(xdr, fattr);
 741	return 0;
 742}
 743
 744static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr,
 745		struct user_namespace *userns)
 746{
 747	int error;
 748
 749	error = decode_pre_op_attr(xdr, fattr);
 750	if (unlikely(error))
 751		goto out;
 752	error = decode_post_op_attr(xdr, fattr, userns);
 753out:
 754	return error;
 755}
 756
 757/*
 758 * post_op_fh3
 759 *
 760 *	union post_op_fh3 switch (bool handle_follows) {
 761 *	case TRUE:
 762 *		nfs_fh3  handle;
 763 *	case FALSE:
 764 *		void;
 765 *	};
 766 */
 767static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
 768{
 769	__be32 *p = xdr_inline_decode(xdr, 4);
 770	if (unlikely(!p))
 771		return -EIO;
 772	if (*p != xdr_zero)
 773		return decode_nfs_fh3(xdr, fh);
 774	zero_nfs_fh3(fh);
 775	return 0;
 776}
 777
 778/*
 779 * diropargs3
 780 *
 781 *	struct diropargs3 {
 782 *		nfs_fh3		dir;
 783 *		filename3	name;
 784 *	};
 785 */
 786static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
 787			      const char *name, u32 length)
 788{
 789	encode_nfs_fh3(xdr, fh);
 790	encode_filename3(xdr, name, length);
 791}
 792
 793
 794/*
 795 * NFSv3 XDR encode functions
 796 *
 797 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
 798 * "NFS Version 3 Protocol Specification".
 799 */
 800
 801/*
 802 * 3.3.1  GETATTR3args
 803 *
 804 *	struct GETATTR3args {
 805 *		nfs_fh3  object;
 806 *	};
 807 */
 808static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
 809				      struct xdr_stream *xdr,
 810				      const void *data)
 811{
 812	const struct nfs_fh *fh = data;
 813
 814	encode_nfs_fh3(xdr, fh);
 815}
 816
 817/*
 818 * 3.3.2  SETATTR3args
 819 *
 820 *	union sattrguard3 switch (bool check) {
 821 *	case TRUE:
 822 *		nfstime3  obj_ctime;
 823 *	case FALSE:
 824 *		void;
 825 *	};
 826 *
 827 *	struct SETATTR3args {
 828 *		nfs_fh3		object;
 829 *		sattr3		new_attributes;
 830 *		sattrguard3	guard;
 831 *	};
 832 */
 833static void encode_sattrguard3(struct xdr_stream *xdr,
 834			       const struct nfs3_sattrargs *args)
 835{
 836	__be32 *p;
 837
 838	if (args->guard) {
 839		p = xdr_reserve_space(xdr, 4 + 8);
 840		*p++ = xdr_one;
 841		xdr_encode_nfstime3(p, &args->guardtime);
 842	} else {
 843		p = xdr_reserve_space(xdr, 4);
 844		*p = xdr_zero;
 845	}
 846}
 847
 848static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
 849				      struct xdr_stream *xdr,
 850				      const void *data)
 851{
 852	const struct nfs3_sattrargs *args = data;
 853	encode_nfs_fh3(xdr, args->fh);
 854	encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
 855	encode_sattrguard3(xdr, args);
 856}
 857
 858/*
 859 * 3.3.3  LOOKUP3args
 860 *
 861 *	struct LOOKUP3args {
 862 *		diropargs3  what;
 863 *	};
 864 */
 865static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
 866				     struct xdr_stream *xdr,
 867				     const void *data)
 868{
 869	const struct nfs3_diropargs *args = data;
 870
 871	encode_diropargs3(xdr, args->fh, args->name, args->len);
 872}
 873
 874/*
 875 * 3.3.4  ACCESS3args
 876 *
 877 *	struct ACCESS3args {
 878 *		nfs_fh3		object;
 879 *		uint32		access;
 880 *	};
 881 */
 882static void encode_access3args(struct xdr_stream *xdr,
 883			       const struct nfs3_accessargs *args)
 884{
 885	encode_nfs_fh3(xdr, args->fh);
 886	encode_uint32(xdr, args->access);
 887}
 888
 889static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
 890				     struct xdr_stream *xdr,
 891				     const void *data)
 892{
 893	const struct nfs3_accessargs *args = data;
 894
 895	encode_access3args(xdr, args);
 896}
 897
 898/*
 899 * 3.3.5  READLINK3args
 900 *
 901 *	struct READLINK3args {
 902 *		nfs_fh3	symlink;
 903 *	};
 904 */
 905static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
 906				       struct xdr_stream *xdr,
 907				       const void *data)
 908{
 909	const struct nfs3_readlinkargs *args = data;
 910
 911	encode_nfs_fh3(xdr, args->fh);
 912	rpc_prepare_reply_pages(req, args->pages, args->pgbase, args->pglen,
 913				NFS3_readlinkres_sz - NFS3_pagepad_sz);
 914}
 915
 916/*
 917 * 3.3.6  READ3args
 918 *
 919 *	struct READ3args {
 920 *		nfs_fh3		file;
 921 *		offset3		offset;
 922 *		count3		count;
 923 *	};
 924 */
 925static void encode_read3args(struct xdr_stream *xdr,
 926			     const struct nfs_pgio_args *args)
 927{
 928	__be32 *p;
 929
 930	encode_nfs_fh3(xdr, args->fh);
 931
 932	p = xdr_reserve_space(xdr, 8 + 4);
 933	p = xdr_encode_hyper(p, args->offset);
 934	*p = cpu_to_be32(args->count);
 935}
 936
 937static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
 938				   struct xdr_stream *xdr,
 939				   const void *data)
 940{
 941	const struct nfs_pgio_args *args = data;
 942	unsigned int replen = args->replen ? args->replen :
 943					     NFS3_readres_sz - NFS3_pagepad_sz;
 944
 945	encode_read3args(xdr, args);
 946	rpc_prepare_reply_pages(req, args->pages, args->pgbase,
 947				args->count, replen);
 948	req->rq_rcv_buf.flags |= XDRBUF_READ;
 949}
 950
 951/*
 952 * 3.3.7  WRITE3args
 953 *
 954 *	enum stable_how {
 955 *		UNSTABLE  = 0,
 956 *		DATA_SYNC = 1,
 957 *		FILE_SYNC = 2
 958 *	};
 959 *
 960 *	struct WRITE3args {
 961 *		nfs_fh3		file;
 962 *		offset3		offset;
 963 *		count3		count;
 964 *		stable_how	stable;
 965 *		opaque		data<>;
 966 *	};
 967 */
 968static void encode_write3args(struct xdr_stream *xdr,
 969			      const struct nfs_pgio_args *args)
 970{
 971	__be32 *p;
 972
 973	encode_nfs_fh3(xdr, args->fh);
 974
 975	p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
 976	p = xdr_encode_hyper(p, args->offset);
 977	*p++ = cpu_to_be32(args->count);
 978	*p++ = cpu_to_be32(args->stable);
 979	*p = cpu_to_be32(args->count);
 980	xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
 981}
 982
 983static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
 984				    struct xdr_stream *xdr,
 985				    const void *data)
 986{
 987	const struct nfs_pgio_args *args = data;
 988
 989	encode_write3args(xdr, args);
 990	xdr->buf->flags |= XDRBUF_WRITE;
 991}
 992
 993/*
 994 * 3.3.8  CREATE3args
 995 *
 996 *	enum createmode3 {
 997 *		UNCHECKED = 0,
 998 *		GUARDED   = 1,
 999 *		EXCLUSIVE = 2
1000 *	};
1001 *
1002 *	union createhow3 switch (createmode3 mode) {
1003 *	case UNCHECKED:
1004 *	case GUARDED:
1005 *		sattr3       obj_attributes;
1006 *	case EXCLUSIVE:
1007 *		createverf3  verf;
1008 *	};
1009 *
1010 *	struct CREATE3args {
1011 *		diropargs3	where;
1012 *		createhow3	how;
1013 *	};
1014 */
1015static void encode_createhow3(struct xdr_stream *xdr,
1016			      const struct nfs3_createargs *args,
1017			      struct user_namespace *userns)
1018{
1019	encode_uint32(xdr, args->createmode);
1020	switch (args->createmode) {
1021	case NFS3_CREATE_UNCHECKED:
1022	case NFS3_CREATE_GUARDED:
1023		encode_sattr3(xdr, args->sattr, userns);
1024		break;
1025	case NFS3_CREATE_EXCLUSIVE:
1026		encode_createverf3(xdr, args->verifier);
1027		break;
1028	default:
1029		BUG();
1030	}
1031}
1032
1033static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1034				     struct xdr_stream *xdr,
1035				     const void *data)
1036{
1037	const struct nfs3_createargs *args = data;
1038
1039	encode_diropargs3(xdr, args->fh, args->name, args->len);
1040	encode_createhow3(xdr, args, rpc_rqst_userns(req));
1041}
1042
1043/*
1044 * 3.3.9  MKDIR3args
1045 *
1046 *	struct MKDIR3args {
1047 *		diropargs3	where;
1048 *		sattr3		attributes;
1049 *	};
1050 */
1051static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1052				    struct xdr_stream *xdr,
1053				    const void *data)
1054{
1055	const struct nfs3_mkdirargs *args = data;
1056
1057	encode_diropargs3(xdr, args->fh, args->name, args->len);
1058	encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
1059}
1060
1061/*
1062 * 3.3.10  SYMLINK3args
1063 *
1064 *	struct symlinkdata3 {
1065 *		sattr3		symlink_attributes;
1066 *		nfspath3	symlink_data;
1067 *	};
1068 *
1069 *	struct SYMLINK3args {
1070 *		diropargs3	where;
1071 *		symlinkdata3	symlink;
1072 *	};
1073 */
1074static void encode_symlinkdata3(struct xdr_stream *xdr,
1075				const void *data,
1076				struct user_namespace *userns)
1077{
1078	const struct nfs3_symlinkargs *args = data;
1079
1080	encode_sattr3(xdr, args->sattr, userns);
1081	encode_nfspath3(xdr, args->pages, args->pathlen);
1082}
1083
1084static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1085				      struct xdr_stream *xdr,
1086				      const void *data)
1087{
1088	const struct nfs3_symlinkargs *args = data;
1089
1090	encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1091	encode_symlinkdata3(xdr, args, rpc_rqst_userns(req));
1092	xdr->buf->flags |= XDRBUF_WRITE;
1093}
1094
1095/*
1096 * 3.3.11  MKNOD3args
1097 *
1098 *	struct devicedata3 {
1099 *		sattr3		dev_attributes;
1100 *		specdata3	spec;
1101 *	};
1102 *
1103 *	union mknoddata3 switch (ftype3 type) {
1104 *	case NF3CHR:
1105 *	case NF3BLK:
1106 *		devicedata3	device;
1107 *	case NF3SOCK:
1108 *	case NF3FIFO:
1109 *		sattr3		pipe_attributes;
1110 *	default:
1111 *		void;
1112 *	};
1113 *
1114 *	struct MKNOD3args {
1115 *		diropargs3	where;
1116 *		mknoddata3	what;
1117 *	};
1118 */
1119static void encode_devicedata3(struct xdr_stream *xdr,
1120			       const struct nfs3_mknodargs *args,
1121			       struct user_namespace *userns)
1122{
1123	encode_sattr3(xdr, args->sattr, userns);
1124	encode_specdata3(xdr, args->rdev);
1125}
1126
1127static void encode_mknoddata3(struct xdr_stream *xdr,
1128			      const struct nfs3_mknodargs *args,
1129			      struct user_namespace *userns)
1130{
1131	encode_ftype3(xdr, args->type);
1132	switch (args->type) {
1133	case NF3CHR:
1134	case NF3BLK:
1135		encode_devicedata3(xdr, args, userns);
1136		break;
1137	case NF3SOCK:
1138	case NF3FIFO:
1139		encode_sattr3(xdr, args->sattr, userns);
1140		break;
1141	case NF3REG:
1142	case NF3DIR:
1143		break;
1144	default:
1145		BUG();
1146	}
1147}
1148
1149static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1150				    struct xdr_stream *xdr,
1151				    const void *data)
1152{
1153	const struct nfs3_mknodargs *args = data;
1154
1155	encode_diropargs3(xdr, args->fh, args->name, args->len);
1156	encode_mknoddata3(xdr, args, rpc_rqst_userns(req));
1157}
1158
1159/*
1160 * 3.3.12  REMOVE3args
1161 *
1162 *	struct REMOVE3args {
1163 *		diropargs3  object;
1164 *	};
1165 */
1166static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1167				     struct xdr_stream *xdr,
1168				     const void *data)
1169{
1170	const struct nfs_removeargs *args = data;
1171
1172	encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1173}
1174
1175/*
1176 * 3.3.14  RENAME3args
1177 *
1178 *	struct RENAME3args {
1179 *		diropargs3	from;
1180 *		diropargs3	to;
1181 *	};
1182 */
1183static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1184				     struct xdr_stream *xdr,
1185				     const void *data)
1186{
1187	const struct nfs_renameargs *args = data;
1188	const struct qstr *old = args->old_name;
1189	const struct qstr *new = args->new_name;
1190
1191	encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1192	encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1193}
1194
1195/*
1196 * 3.3.15  LINK3args
1197 *
1198 *	struct LINK3args {
1199 *		nfs_fh3		file;
1200 *		diropargs3	link;
1201 *	};
1202 */
1203static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1204				   struct xdr_stream *xdr,
1205				   const void *data)
1206{
1207	const struct nfs3_linkargs *args = data;
1208
1209	encode_nfs_fh3(xdr, args->fromfh);
1210	encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1211}
1212
1213/*
1214 * 3.3.16  READDIR3args
1215 *
1216 *	struct READDIR3args {
1217 *		nfs_fh3		dir;
1218 *		cookie3		cookie;
1219 *		cookieverf3	cookieverf;
1220 *		count3		count;
1221 *	};
1222 */
1223static void encode_readdir3args(struct xdr_stream *xdr,
1224				const struct nfs3_readdirargs *args)
1225{
1226	__be32 *p;
1227
1228	encode_nfs_fh3(xdr, args->fh);
1229
1230	p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1231	p = xdr_encode_cookie3(p, args->cookie);
1232	p = xdr_encode_cookieverf3(p, args->verf);
1233	*p = cpu_to_be32(args->count);
1234}
1235
1236static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1237				      struct xdr_stream *xdr,
1238				      const void *data)
1239{
1240	const struct nfs3_readdirargs *args = data;
1241
1242	encode_readdir3args(xdr, args);
1243	rpc_prepare_reply_pages(req, args->pages, 0, args->count,
1244				NFS3_readdirres_sz - NFS3_pagepad_sz);
1245}
1246
1247/*
1248 * 3.3.17  READDIRPLUS3args
1249 *
1250 *	struct READDIRPLUS3args {
1251 *		nfs_fh3		dir;
1252 *		cookie3		cookie;
1253 *		cookieverf3	cookieverf;
1254 *		count3		dircount;
1255 *		count3		maxcount;
1256 *	};
1257 */
1258static void encode_readdirplus3args(struct xdr_stream *xdr,
1259				    const struct nfs3_readdirargs *args)
1260{
1261	uint32_t dircount = args->count;
1262	uint32_t maxcount = args->count;
1263	__be32 *p;
1264
1265	encode_nfs_fh3(xdr, args->fh);
1266
1267	p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1268	p = xdr_encode_cookie3(p, args->cookie);
1269	p = xdr_encode_cookieverf3(p, args->verf);
1270
1271	/*
1272	 * readdirplus: need dircount + buffer size.
1273	 * We just make sure we make dircount big enough
1274	 */
1275	*p++ = cpu_to_be32(dircount);
1276	*p = cpu_to_be32(maxcount);
1277}
1278
1279static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1280					  struct xdr_stream *xdr,
1281					  const void *data)
1282{
1283	const struct nfs3_readdirargs *args = data;
1284
1285	encode_readdirplus3args(xdr, args);
1286	rpc_prepare_reply_pages(req, args->pages, 0, args->count,
1287				NFS3_readdirres_sz - NFS3_pagepad_sz);
1288}
1289
1290/*
1291 * 3.3.21  COMMIT3args
1292 *
1293 *	struct COMMIT3args {
1294 *		nfs_fh3		file;
1295 *		offset3		offset;
1296 *		count3		count;
1297 *	};
1298 */
1299static void encode_commit3args(struct xdr_stream *xdr,
1300			       const struct nfs_commitargs *args)
1301{
1302	__be32 *p;
1303
1304	encode_nfs_fh3(xdr, args->fh);
1305
1306	p = xdr_reserve_space(xdr, 8 + 4);
1307	p = xdr_encode_hyper(p, args->offset);
1308	*p = cpu_to_be32(args->count);
1309}
1310
1311static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1312				     struct xdr_stream *xdr,
1313				     const void *data)
1314{
1315	const struct nfs_commitargs *args = data;
1316
1317	encode_commit3args(xdr, args);
1318}
1319
1320#ifdef CONFIG_NFS_V3_ACL
1321
1322static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1323				     struct xdr_stream *xdr,
1324				     const void *data)
1325{
1326	const struct nfs3_getaclargs *args = data;
1327
1328	encode_nfs_fh3(xdr, args->fh);
1329	encode_uint32(xdr, args->mask);
1330	if (args->mask & (NFS_ACL | NFS_DFACL)) {
1331		rpc_prepare_reply_pages(req, args->pages, 0,
1332					NFSACL_MAXPAGES << PAGE_SHIFT,
1333					ACL3_getaclres_sz - NFS3_pagepad_sz);
1334		req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
1335	}
1336}
1337
1338static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1339				     struct xdr_stream *xdr,
1340				     const void *data)
1341{
1342	const struct nfs3_setaclargs *args = data;
1343	unsigned int base;
1344	int error;
1345
1346	encode_nfs_fh3(xdr, NFS_FH(args->inode));
1347	encode_uint32(xdr, args->mask);
1348
1349	base = req->rq_slen;
1350	if (args->npages != 0)
1351		xdr_write_pages(xdr, args->pages, 0, args->len);
1352	else
1353		xdr_reserve_space(xdr, args->len);
1354
1355	error = nfsacl_encode(xdr->buf, base, args->inode,
1356			    (args->mask & NFS_ACL) ?
1357			    args->acl_access : NULL, 1, 0);
1358	/* FIXME: this is just broken */
1359	BUG_ON(error < 0);
1360	error = nfsacl_encode(xdr->buf, base + error, args->inode,
1361			    (args->mask & NFS_DFACL) ?
1362			    args->acl_default : NULL, 1,
1363			    NFS_ACL_DEFAULT);
1364	BUG_ON(error < 0);
1365}
1366
1367#endif  /* CONFIG_NFS_V3_ACL */
1368
1369/*
1370 * NFSv3 XDR decode functions
1371 *
1372 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1373 * "NFS Version 3 Protocol Specification".
1374 */
1375
1376/*
1377 * 3.3.1  GETATTR3res
1378 *
1379 *	struct GETATTR3resok {
1380 *		fattr3		obj_attributes;
1381 *	};
1382 *
1383 *	union GETATTR3res switch (nfsstat3 status) {
1384 *	case NFS3_OK:
1385 *		GETATTR3resok  resok;
1386 *	default:
1387 *		void;
1388 *	};
1389 */
1390static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1391				    struct xdr_stream *xdr,
1392				    void *result)
1393{
1394	enum nfs_stat status;
1395	int error;
1396
1397	error = decode_nfsstat3(xdr, &status);
1398	if (unlikely(error))
1399		goto out;
1400	if (status != NFS3_OK)
1401		goto out_default;
1402	error = decode_fattr3(xdr, result, rpc_rqst_userns(req));
1403out:
1404	return error;
1405out_default:
1406	return nfs_stat_to_errno(status);
1407}
1408
1409/*
1410 * 3.3.2  SETATTR3res
1411 *
1412 *	struct SETATTR3resok {
1413 *		wcc_data  obj_wcc;
1414 *	};
1415 *
1416 *	struct SETATTR3resfail {
1417 *		wcc_data  obj_wcc;
1418 *	};
1419 *
1420 *	union SETATTR3res switch (nfsstat3 status) {
1421 *	case NFS3_OK:
1422 *		SETATTR3resok   resok;
1423 *	default:
1424 *		SETATTR3resfail resfail;
1425 *	};
1426 */
1427static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1428				    struct xdr_stream *xdr,
1429				    void *result)
1430{
1431	enum nfs_stat status;
1432	int error;
1433
1434	error = decode_nfsstat3(xdr, &status);
1435	if (unlikely(error))
1436		goto out;
1437	error = decode_wcc_data(xdr, result, rpc_rqst_userns(req));
1438	if (unlikely(error))
1439		goto out;
1440	if (status != NFS3_OK)
1441		goto out_status;
1442out:
1443	return error;
1444out_status:
1445	return nfs_stat_to_errno(status);
1446}
1447
1448/*
1449 * 3.3.3  LOOKUP3res
1450 *
1451 *	struct LOOKUP3resok {
1452 *		nfs_fh3		object;
1453 *		post_op_attr	obj_attributes;
1454 *		post_op_attr	dir_attributes;
1455 *	};
1456 *
1457 *	struct LOOKUP3resfail {
1458 *		post_op_attr	dir_attributes;
1459 *	};
1460 *
1461 *	union LOOKUP3res switch (nfsstat3 status) {
1462 *	case NFS3_OK:
1463 *		LOOKUP3resok	resok;
1464 *	default:
1465 *		LOOKUP3resfail	resfail;
1466 *	};
1467 */
1468static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1469				   struct xdr_stream *xdr,
1470				   void *data)
1471{
1472	struct user_namespace *userns = rpc_rqst_userns(req);
1473	struct nfs3_diropres *result = data;
1474	enum nfs_stat status;
1475	int error;
1476
1477	error = decode_nfsstat3(xdr, &status);
1478	if (unlikely(error))
1479		goto out;
1480	if (status != NFS3_OK)
1481		goto out_default;
1482	error = decode_nfs_fh3(xdr, result->fh);
1483	if (unlikely(error))
1484		goto out;
1485	error = decode_post_op_attr(xdr, result->fattr, userns);
1486	if (unlikely(error))
1487		goto out;
1488	error = decode_post_op_attr(xdr, result->dir_attr, userns);
1489out:
1490	return error;
1491out_default:
1492	error = decode_post_op_attr(xdr, result->dir_attr, userns);
1493	if (unlikely(error))
1494		goto out;
1495	return nfs_stat_to_errno(status);
1496}
1497
1498/*
1499 * 3.3.4  ACCESS3res
1500 *
1501 *	struct ACCESS3resok {
1502 *		post_op_attr	obj_attributes;
1503 *		uint32		access;
1504 *	};
1505 *
1506 *	struct ACCESS3resfail {
1507 *		post_op_attr	obj_attributes;
1508 *	};
1509 *
1510 *	union ACCESS3res switch (nfsstat3 status) {
1511 *	case NFS3_OK:
1512 *		ACCESS3resok	resok;
1513 *	default:
1514 *		ACCESS3resfail	resfail;
1515 *	};
1516 */
1517static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1518				   struct xdr_stream *xdr,
1519				   void *data)
1520{
1521	struct nfs3_accessres *result = data;
1522	enum nfs_stat status;
1523	int error;
1524
1525	error = decode_nfsstat3(xdr, &status);
1526	if (unlikely(error))
1527		goto out;
1528	error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1529	if (unlikely(error))
1530		goto out;
1531	if (status != NFS3_OK)
1532		goto out_default;
1533	error = decode_uint32(xdr, &result->access);
1534out:
1535	return error;
1536out_default:
1537	return nfs_stat_to_errno(status);
1538}
1539
1540/*
1541 * 3.3.5  READLINK3res
1542 *
1543 *	struct READLINK3resok {
1544 *		post_op_attr	symlink_attributes;
1545 *		nfspath3	data;
1546 *	};
1547 *
1548 *	struct READLINK3resfail {
1549 *		post_op_attr	symlink_attributes;
1550 *	};
1551 *
1552 *	union READLINK3res switch (nfsstat3 status) {
1553 *	case NFS3_OK:
1554 *		READLINK3resok	resok;
1555 *	default:
1556 *		READLINK3resfail resfail;
1557 *	};
1558 */
1559static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1560				     struct xdr_stream *xdr,
1561				     void *result)
1562{
1563	enum nfs_stat status;
1564	int error;
1565
1566	error = decode_nfsstat3(xdr, &status);
1567	if (unlikely(error))
1568		goto out;
1569	error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
1570	if (unlikely(error))
1571		goto out;
1572	if (status != NFS3_OK)
1573		goto out_default;
1574	error = decode_nfspath3(xdr);
1575out:
1576	return error;
1577out_default:
1578	return nfs_stat_to_errno(status);
1579}
1580
1581/*
1582 * 3.3.6  READ3res
1583 *
1584 *	struct READ3resok {
1585 *		post_op_attr	file_attributes;
1586 *		count3		count;
1587 *		bool		eof;
1588 *		opaque		data<>;
1589 *	};
1590 *
1591 *	struct READ3resfail {
1592 *		post_op_attr	file_attributes;
1593 *	};
1594 *
1595 *	union READ3res switch (nfsstat3 status) {
1596 *	case NFS3_OK:
1597 *		READ3resok	resok;
1598 *	default:
1599 *		READ3resfail	resfail;
1600 *	};
1601 */
1602static int decode_read3resok(struct xdr_stream *xdr,
1603			     struct nfs_pgio_res *result)
1604{
1605	u32 eof, count, ocount, recvd;
1606	__be32 *p;
1607
1608	p = xdr_inline_decode(xdr, 4 + 4 + 4);
1609	if (unlikely(!p))
1610		return -EIO;
1611	count = be32_to_cpup(p++);
1612	eof = be32_to_cpup(p++);
1613	ocount = be32_to_cpup(p++);
1614	if (unlikely(ocount != count))
1615		goto out_mismatch;
1616	recvd = xdr_read_pages(xdr, count);
1617	if (unlikely(count > recvd))
1618		goto out_cheating;
1619out:
1620	result->eof = eof;
1621	result->count = count;
1622	return count;
1623out_mismatch:
1624	dprintk("NFS: READ count doesn't match length of opaque: "
1625		"count %u != ocount %u\n", count, ocount);
1626	return -EIO;
1627out_cheating:
1628	dprintk("NFS: server cheating in read result: "
1629		"count %u > recvd %u\n", count, recvd);
1630	count = recvd;
1631	eof = 0;
1632	goto out;
1633}
1634
1635static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1636				 void *data)
1637{
1638	struct nfs_pgio_res *result = data;
1639	unsigned int pos;
1640	enum nfs_stat status;
1641	int error;
1642
1643	pos = xdr_stream_pos(xdr);
1644	error = decode_nfsstat3(xdr, &status);
1645	if (unlikely(error))
1646		goto out;
1647	error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1648	if (unlikely(error))
1649		goto out;
1650	result->op_status = status;
1651	if (status != NFS3_OK)
1652		goto out_status;
1653	result->replen = 3 + ((xdr_stream_pos(xdr) - pos) >> 2);
1654	error = decode_read3resok(xdr, result);
1655out:
1656	return error;
1657out_status:
1658	return nfs_stat_to_errno(status);
1659}
1660
1661/*
1662 * 3.3.7  WRITE3res
1663 *
1664 *	enum stable_how {
1665 *		UNSTABLE  = 0,
1666 *		DATA_SYNC = 1,
1667 *		FILE_SYNC = 2
1668 *	};
1669 *
1670 *	struct WRITE3resok {
1671 *		wcc_data	file_wcc;
1672 *		count3		count;
1673 *		stable_how	committed;
1674 *		writeverf3	verf;
1675 *	};
1676 *
1677 *	struct WRITE3resfail {
1678 *		wcc_data	file_wcc;
1679 *	};
1680 *
1681 *	union WRITE3res switch (nfsstat3 status) {
1682 *	case NFS3_OK:
1683 *		WRITE3resok	resok;
1684 *	default:
1685 *		WRITE3resfail	resfail;
1686 *	};
1687 */
1688static int decode_write3resok(struct xdr_stream *xdr,
1689			      struct nfs_pgio_res *result)
1690{
1691	__be32 *p;
1692
1693	p = xdr_inline_decode(xdr, 4 + 4);
1694	if (unlikely(!p))
1695		return -EIO;
1696	result->count = be32_to_cpup(p++);
1697	result->verf->committed = be32_to_cpup(p++);
1698	if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1699		goto out_badvalue;
1700	if (decode_writeverf3(xdr, &result->verf->verifier))
1701		return -EIO;
1702	return result->count;
1703out_badvalue:
1704	dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1705	return -EIO;
1706}
1707
1708static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1709				  void *data)
1710{
1711	struct nfs_pgio_res *result = data;
1712	enum nfs_stat status;
1713	int error;
1714
1715	error = decode_nfsstat3(xdr, &status);
1716	if (unlikely(error))
1717		goto out;
1718	error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
1719	if (unlikely(error))
1720		goto out;
1721	result->op_status = status;
1722	if (status != NFS3_OK)
1723		goto out_status;
1724	error = decode_write3resok(xdr, result);
1725out:
1726	return error;
1727out_status:
1728	return nfs_stat_to_errno(status);
1729}
1730
1731/*
1732 * 3.3.8  CREATE3res
1733 *
1734 *	struct CREATE3resok {
1735 *		post_op_fh3	obj;
1736 *		post_op_attr	obj_attributes;
1737 *		wcc_data	dir_wcc;
1738 *	};
1739 *
1740 *	struct CREATE3resfail {
1741 *		wcc_data	dir_wcc;
1742 *	};
1743 *
1744 *	union CREATE3res switch (nfsstat3 status) {
1745 *	case NFS3_OK:
1746 *		CREATE3resok	resok;
1747 *	default:
1748 *		CREATE3resfail	resfail;
1749 *	};
1750 */
1751static int decode_create3resok(struct xdr_stream *xdr,
1752			       struct nfs3_diropres *result,
1753			       struct user_namespace *userns)
1754{
1755	int error;
1756
1757	error = decode_post_op_fh3(xdr, result->fh);
1758	if (unlikely(error))
1759		goto out;
1760	error = decode_post_op_attr(xdr, result->fattr, userns);
1761	if (unlikely(error))
1762		goto out;
1763	/* The server isn't required to return a file handle.
1764	 * If it didn't, force the client to perform a LOOKUP
1765	 * to determine the correct file handle and attribute
1766	 * values for the new object. */
1767	if (result->fh->size == 0)
1768		result->fattr->valid = 0;
1769	error = decode_wcc_data(xdr, result->dir_attr, userns);
1770out:
1771	return error;
1772}
1773
1774static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1775				   struct xdr_stream *xdr,
1776				   void *data)
1777{
1778	struct user_namespace *userns = rpc_rqst_userns(req);
1779	struct nfs3_diropres *result = data;
1780	enum nfs_stat status;
1781	int error;
1782
1783	error = decode_nfsstat3(xdr, &status);
1784	if (unlikely(error))
1785		goto out;
1786	if (status != NFS3_OK)
1787		goto out_default;
1788	error = decode_create3resok(xdr, result, userns);
1789out:
1790	return error;
1791out_default:
1792	error = decode_wcc_data(xdr, result->dir_attr, userns);
1793	if (unlikely(error))
1794		goto out;
1795	return nfs_stat_to_errno(status);
1796}
1797
1798/*
1799 * 3.3.12  REMOVE3res
1800 *
1801 *	struct REMOVE3resok {
1802 *		wcc_data    dir_wcc;
1803 *	};
1804 *
1805 *	struct REMOVE3resfail {
1806 *		wcc_data    dir_wcc;
1807 *	};
1808 *
1809 *	union REMOVE3res switch (nfsstat3 status) {
1810 *	case NFS3_OK:
1811 *		REMOVE3resok   resok;
1812 *	default:
1813 *		REMOVE3resfail resfail;
1814 *	};
1815 */
1816static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1817				   struct xdr_stream *xdr,
1818				   void *data)
1819{
1820	struct nfs_removeres *result = data;
1821	enum nfs_stat status;
1822	int error;
1823
1824	error = decode_nfsstat3(xdr, &status);
1825	if (unlikely(error))
1826		goto out;
1827	error = decode_wcc_data(xdr, result->dir_attr, rpc_rqst_userns(req));
1828	if (unlikely(error))
1829		goto out;
1830	if (status != NFS3_OK)
1831		goto out_status;
1832out:
1833	return error;
1834out_status:
1835	return nfs_stat_to_errno(status);
1836}
1837
1838/*
1839 * 3.3.14  RENAME3res
1840 *
1841 *	struct RENAME3resok {
1842 *		wcc_data	fromdir_wcc;
1843 *		wcc_data	todir_wcc;
1844 *	};
1845 *
1846 *	struct RENAME3resfail {
1847 *		wcc_data	fromdir_wcc;
1848 *		wcc_data	todir_wcc;
1849 *	};
1850 *
1851 *	union RENAME3res switch (nfsstat3 status) {
1852 *	case NFS3_OK:
1853 *		RENAME3resok   resok;
1854 *	default:
1855 *		RENAME3resfail resfail;
1856 *	};
1857 */
1858static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1859				   struct xdr_stream *xdr,
1860				   void *data)
1861{
1862	struct user_namespace *userns = rpc_rqst_userns(req);
1863	struct nfs_renameres *result = data;
1864	enum nfs_stat status;
1865	int error;
1866
1867	error = decode_nfsstat3(xdr, &status);
1868	if (unlikely(error))
1869		goto out;
1870	error = decode_wcc_data(xdr, result->old_fattr, userns);
1871	if (unlikely(error))
1872		goto out;
1873	error = decode_wcc_data(xdr, result->new_fattr, userns);
1874	if (unlikely(error))
1875		goto out;
1876	if (status != NFS3_OK)
1877		goto out_status;
1878out:
1879	return error;
1880out_status:
1881	return nfs_stat_to_errno(status);
1882}
1883
1884/*
1885 * 3.3.15  LINK3res
1886 *
1887 *	struct LINK3resok {
1888 *		post_op_attr	file_attributes;
1889 *		wcc_data	linkdir_wcc;
1890 *	};
1891 *
1892 *	struct LINK3resfail {
1893 *		post_op_attr	file_attributes;
1894 *		wcc_data	linkdir_wcc;
1895 *	};
1896 *
1897 *	union LINK3res switch (nfsstat3 status) {
1898 *	case NFS3_OK:
1899 *		LINK3resok	resok;
1900 *	default:
1901 *		LINK3resfail	resfail;
1902 *	};
1903 */
1904static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1905				 void *data)
1906{
1907	struct user_namespace *userns = rpc_rqst_userns(req);
1908	struct nfs3_linkres *result = data;
1909	enum nfs_stat status;
1910	int error;
1911
1912	error = decode_nfsstat3(xdr, &status);
1913	if (unlikely(error))
1914		goto out;
1915	error = decode_post_op_attr(xdr, result->fattr, userns);
1916	if (unlikely(error))
1917		goto out;
1918	error = decode_wcc_data(xdr, result->dir_attr, userns);
1919	if (unlikely(error))
1920		goto out;
1921	if (status != NFS3_OK)
1922		goto out_status;
1923out:
1924	return error;
1925out_status:
1926	return nfs_stat_to_errno(status);
1927}
1928
1929/**
1930 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1931 *			the local page cache
1932 * @xdr: XDR stream where entry resides
1933 * @entry: buffer to fill in with entry data
1934 * @plus: boolean indicating whether this should be a readdirplus entry
1935 *
1936 * Returns zero if successful, otherwise a negative errno value is
1937 * returned.
1938 *
1939 * This function is not invoked during READDIR reply decoding, but
1940 * rather whenever an application invokes the getdents(2) system call
1941 * on a directory already in our cache.
1942 *
1943 * 3.3.16  entry3
1944 *
1945 *	struct entry3 {
1946 *		fileid3		fileid;
1947 *		filename3	name;
1948 *		cookie3		cookie;
1949 *		fhandle3	filehandle;
1950 *		post_op_attr3	attributes;
1951 *		entry3		*nextentry;
1952 *	};
1953 *
1954 * 3.3.17  entryplus3
1955 *	struct entryplus3 {
1956 *		fileid3		fileid;
1957 *		filename3	name;
1958 *		cookie3		cookie;
1959 *		post_op_attr	name_attributes;
1960 *		post_op_fh3	name_handle;
1961 *		entryplus3	*nextentry;
1962 *	};
1963 */
1964int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1965		       bool plus)
1966{
1967	struct user_namespace *userns = rpc_userns(entry->server->client);
1968	__be32 *p;
1969	int error;
1970	u64 new_cookie;
1971
1972	p = xdr_inline_decode(xdr, 4);
1973	if (unlikely(!p))
1974		return -EAGAIN;
1975	if (*p == xdr_zero) {
1976		p = xdr_inline_decode(xdr, 4);
1977		if (unlikely(!p))
1978			return -EAGAIN;
1979		if (*p == xdr_zero)
1980			return -EAGAIN;
1981		entry->eof = 1;
1982		return -EBADCOOKIE;
1983	}
1984
1985	error = decode_fileid3(xdr, &entry->ino);
1986	if (unlikely(error))
1987		return -EAGAIN;
1988
1989	error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1990	if (unlikely(error))
1991		return error == -ENAMETOOLONG ? -ENAMETOOLONG : -EAGAIN;
1992
1993	error = decode_cookie3(xdr, &new_cookie);
1994	if (unlikely(error))
1995		return -EAGAIN;
1996
1997	entry->d_type = DT_UNKNOWN;
1998
1999	if (plus) {
2000		entry->fattr->valid = 0;
2001		error = decode_post_op_attr(xdr, entry->fattr, userns);
2002		if (unlikely(error))
2003			return -EAGAIN;
2004		if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
2005			entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
2006
2007		if (entry->fattr->fileid != entry->ino) {
2008			entry->fattr->mounted_on_fileid = entry->ino;
2009			entry->fattr->valid |= NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
2010		}
2011
2012		/* In fact, a post_op_fh3: */
2013		p = xdr_inline_decode(xdr, 4);
2014		if (unlikely(!p))
2015			return -EAGAIN;
2016		if (*p != xdr_zero) {
2017			error = decode_nfs_fh3(xdr, entry->fh);
2018			if (unlikely(error))
2019				return -EAGAIN;
2020		} else
2021			zero_nfs_fh3(entry->fh);
2022	}
2023
2024	entry->cookie = new_cookie;
2025
2026	return 0;
2027}
2028
2029/*
2030 * 3.3.16  READDIR3res
2031 *
2032 *	struct dirlist3 {
2033 *		entry3		*entries;
2034 *		bool		eof;
2035 *	};
2036 *
2037 *	struct READDIR3resok {
2038 *		post_op_attr	dir_attributes;
2039 *		cookieverf3	cookieverf;
2040 *		dirlist3	reply;
2041 *	};
2042 *
2043 *	struct READDIR3resfail {
2044 *		post_op_attr	dir_attributes;
2045 *	};
2046 *
2047 *	union READDIR3res switch (nfsstat3 status) {
2048 *	case NFS3_OK:
2049 *		READDIR3resok	resok;
2050 *	default:
2051 *		READDIR3resfail	resfail;
2052 *	};
2053 *
2054 * Read the directory contents into the page cache, but otherwise
2055 * don't touch them.  The actual decoding is done by nfs3_decode_entry()
2056 * during subsequent nfs_readdir() calls.
2057 */
2058static int decode_dirlist3(struct xdr_stream *xdr)
2059{
2060	return xdr_read_pages(xdr, xdr->buf->page_len);
2061}
2062
2063static int decode_readdir3resok(struct xdr_stream *xdr,
2064				struct nfs3_readdirres *result,
2065				struct user_namespace *userns)
2066{
2067	int error;
2068
2069	error = decode_post_op_attr(xdr, result->dir_attr, userns);
2070	if (unlikely(error))
2071		goto out;
2072	/* XXX: do we need to check if result->verf != NULL ? */
2073	error = decode_cookieverf3(xdr, result->verf);
2074	if (unlikely(error))
2075		goto out;
2076	error = decode_dirlist3(xdr);
2077out:
2078	return error;
2079}
2080
2081static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2082				    struct xdr_stream *xdr,
2083				    void *data)
2084{
2085	struct nfs3_readdirres *result = data;
2086	enum nfs_stat status;
2087	int error;
2088
2089	error = decode_nfsstat3(xdr, &status);
2090	if (unlikely(error))
2091		goto out;
2092	if (status != NFS3_OK)
2093		goto out_default;
2094	error = decode_readdir3resok(xdr, result, rpc_rqst_userns(req));
2095out:
2096	return error;
2097out_default:
2098	error = decode_post_op_attr(xdr, result->dir_attr, rpc_rqst_userns(req));
2099	if (unlikely(error))
2100		goto out;
2101	return nfs_stat_to_errno(status);
2102}
2103
2104/*
2105 * 3.3.18  FSSTAT3res
2106 *
2107 *	struct FSSTAT3resok {
2108 *		post_op_attr	obj_attributes;
2109 *		size3		tbytes;
2110 *		size3		fbytes;
2111 *		size3		abytes;
2112 *		size3		tfiles;
2113 *		size3		ffiles;
2114 *		size3		afiles;
2115 *		uint32		invarsec;
2116 *	};
2117 *
2118 *	struct FSSTAT3resfail {
2119 *		post_op_attr	obj_attributes;
2120 *	};
2121 *
2122 *	union FSSTAT3res switch (nfsstat3 status) {
2123 *	case NFS3_OK:
2124 *		FSSTAT3resok	resok;
2125 *	default:
2126 *		FSSTAT3resfail	resfail;
2127 *	};
2128 */
2129static int decode_fsstat3resok(struct xdr_stream *xdr,
2130			       struct nfs_fsstat *result)
2131{
2132	__be32 *p;
2133
2134	p = xdr_inline_decode(xdr, 8 * 6 + 4);
2135	if (unlikely(!p))
2136		return -EIO;
2137	p = xdr_decode_size3(p, &result->tbytes);
2138	p = xdr_decode_size3(p, &result->fbytes);
2139	p = xdr_decode_size3(p, &result->abytes);
2140	p = xdr_decode_size3(p, &result->tfiles);
2141	p = xdr_decode_size3(p, &result->ffiles);
2142	xdr_decode_size3(p, &result->afiles);
2143	/* ignore invarsec */
2144	return 0;
2145}
2146
2147static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2148				   struct xdr_stream *xdr,
2149				   void *data)
2150{
2151	struct nfs_fsstat *result = data;
2152	enum nfs_stat status;
2153	int error;
2154
2155	error = decode_nfsstat3(xdr, &status);
2156	if (unlikely(error))
2157		goto out;
2158	error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2159	if (unlikely(error))
2160		goto out;
2161	if (status != NFS3_OK)
2162		goto out_status;
2163	error = decode_fsstat3resok(xdr, result);
2164out:
2165	return error;
2166out_status:
2167	return nfs_stat_to_errno(status);
2168}
2169
2170/*
2171 * 3.3.19  FSINFO3res
2172 *
2173 *	struct FSINFO3resok {
2174 *		post_op_attr	obj_attributes;
2175 *		uint32		rtmax;
2176 *		uint32		rtpref;
2177 *		uint32		rtmult;
2178 *		uint32		wtmax;
2179 *		uint32		wtpref;
2180 *		uint32		wtmult;
2181 *		uint32		dtpref;
2182 *		size3		maxfilesize;
2183 *		nfstime3	time_delta;
2184 *		uint32		properties;
2185 *	};
2186 *
2187 *	struct FSINFO3resfail {
2188 *		post_op_attr	obj_attributes;
2189 *	};
2190 *
2191 *	union FSINFO3res switch (nfsstat3 status) {
2192 *	case NFS3_OK:
2193 *		FSINFO3resok	resok;
2194 *	default:
2195 *		FSINFO3resfail	resfail;
2196 *	};
2197 */
2198static int decode_fsinfo3resok(struct xdr_stream *xdr,
2199			       struct nfs_fsinfo *result)
2200{
2201	__be32 *p;
2202
2203	p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2204	if (unlikely(!p))
2205		return -EIO;
2206	result->rtmax  = be32_to_cpup(p++);
2207	result->rtpref = be32_to_cpup(p++);
2208	result->rtmult = be32_to_cpup(p++);
2209	result->wtmax  = be32_to_cpup(p++);
2210	result->wtpref = be32_to_cpup(p++);
2211	result->wtmult = be32_to_cpup(p++);
2212	result->dtpref = be32_to_cpup(p++);
2213	p = xdr_decode_size3(p, &result->maxfilesize);
2214	xdr_decode_nfstime3(p, &result->time_delta);
2215
2216	/* ignore properties */
2217	result->lease_time = 0;
2218	result->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;
2219	result->xattr_support = 0;
2220	return 0;
2221}
2222
2223static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2224				   struct xdr_stream *xdr,
2225				   void *data)
2226{
2227	struct nfs_fsinfo *result = data;
2228	enum nfs_stat status;
2229	int error;
2230
2231	error = decode_nfsstat3(xdr, &status);
2232	if (unlikely(error))
2233		goto out;
2234	error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2235	if (unlikely(error))
2236		goto out;
2237	if (status != NFS3_OK)
2238		goto out_status;
2239	error = decode_fsinfo3resok(xdr, result);
2240out:
2241	return error;
2242out_status:
2243	return nfs_stat_to_errno(status);
2244}
2245
2246/*
2247 * 3.3.20  PATHCONF3res
2248 *
2249 *	struct PATHCONF3resok {
2250 *		post_op_attr	obj_attributes;
2251 *		uint32		linkmax;
2252 *		uint32		name_max;
2253 *		bool		no_trunc;
2254 *		bool		chown_restricted;
2255 *		bool		case_insensitive;
2256 *		bool		case_preserving;
2257 *	};
2258 *
2259 *	struct PATHCONF3resfail {
2260 *		post_op_attr	obj_attributes;
2261 *	};
2262 *
2263 *	union PATHCONF3res switch (nfsstat3 status) {
2264 *	case NFS3_OK:
2265 *		PATHCONF3resok	resok;
2266 *	default:
2267 *		PATHCONF3resfail resfail;
2268 *	};
2269 */
2270static int decode_pathconf3resok(struct xdr_stream *xdr,
2271				 struct nfs_pathconf *result)
2272{
2273	__be32 *p;
2274
2275	p = xdr_inline_decode(xdr, 4 * 6);
2276	if (unlikely(!p))
2277		return -EIO;
2278	result->max_link = be32_to_cpup(p++);
2279	result->max_namelen = be32_to_cpup(p);
2280	/* ignore remaining fields */
2281	return 0;
2282}
2283
2284static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2285				     struct xdr_stream *xdr,
2286				     void *data)
2287{
2288	struct nfs_pathconf *result = data;
2289	enum nfs_stat status;
2290	int error;
2291
2292	error = decode_nfsstat3(xdr, &status);
2293	if (unlikely(error))
2294		goto out;
2295	error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2296	if (unlikely(error))
2297		goto out;
2298	if (status != NFS3_OK)
2299		goto out_status;
2300	error = decode_pathconf3resok(xdr, result);
2301out:
2302	return error;
2303out_status:
2304	return nfs_stat_to_errno(status);
2305}
2306
2307/*
2308 * 3.3.21  COMMIT3res
2309 *
2310 *	struct COMMIT3resok {
2311 *		wcc_data	file_wcc;
2312 *		writeverf3	verf;
2313 *	};
2314 *
2315 *	struct COMMIT3resfail {
2316 *		wcc_data	file_wcc;
2317 *	};
2318 *
2319 *	union COMMIT3res switch (nfsstat3 status) {
2320 *	case NFS3_OK:
2321 *		COMMIT3resok	resok;
2322 *	default:
2323 *		COMMIT3resfail	resfail;
2324 *	};
2325 */
2326static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2327				   struct xdr_stream *xdr,
2328				   void *data)
2329{
2330	struct nfs_commitres *result = data;
2331	struct nfs_writeverf *verf = result->verf;
2332	enum nfs_stat status;
2333	int error;
2334
2335	error = decode_nfsstat3(xdr, &status);
2336	if (unlikely(error))
2337		goto out;
2338	error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
2339	if (unlikely(error))
2340		goto out;
2341	result->op_status = status;
2342	if (status != NFS3_OK)
2343		goto out_status;
2344	error = decode_writeverf3(xdr, &verf->verifier);
2345	if (!error)
2346		verf->committed = NFS_FILE_SYNC;
2347out:
2348	return error;
2349out_status:
2350	return nfs_stat_to_errno(status);
2351}
2352
2353#ifdef CONFIG_NFS_V3_ACL
2354
2355static inline int decode_getacl3resok(struct xdr_stream *xdr,
2356				      struct nfs3_getaclres *result,
2357				      struct user_namespace *userns)
2358{
2359	struct posix_acl **acl;
2360	unsigned int *aclcnt;
2361	size_t hdrlen;
2362	int error;
2363
2364	error = decode_post_op_attr(xdr, result->fattr, userns);
2365	if (unlikely(error))
2366		goto out;
2367	error = decode_uint32(xdr, &result->mask);
2368	if (unlikely(error))
2369		goto out;
2370	error = -EINVAL;
2371	if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2372		goto out;
2373
2374	hdrlen = xdr_stream_pos(xdr);
2375
2376	acl = NULL;
2377	if (result->mask & NFS_ACL)
2378		acl = &result->acl_access;
2379	aclcnt = NULL;
2380	if (result->mask & NFS_ACLCNT)
2381		aclcnt = &result->acl_access_count;
2382	error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2383	if (unlikely(error <= 0))
2384		goto out;
2385
2386	acl = NULL;
2387	if (result->mask & NFS_DFACL)
2388		acl = &result->acl_default;
2389	aclcnt = NULL;
2390	if (result->mask & NFS_DFACLCNT)
2391		aclcnt = &result->acl_default_count;
2392	error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2393	if (unlikely(error <= 0))
2394		return error;
2395	error = 0;
2396out:
2397	return error;
2398}
2399
2400static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2401				   struct xdr_stream *xdr,
2402				   void *result)
2403{
2404	enum nfs_stat status;
2405	int error;
2406
2407	error = decode_nfsstat3(xdr, &status);
2408	if (unlikely(error))
2409		goto out;
2410	if (status != NFS3_OK)
2411		goto out_default;
2412	error = decode_getacl3resok(xdr, result, rpc_rqst_userns(req));
2413out:
2414	return error;
2415out_default:
2416	return nfs_stat_to_errno(status);
2417}
2418
2419static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2420				   struct xdr_stream *xdr,
2421				   void *result)
2422{
2423	enum nfs_stat status;
2424	int error;
2425
2426	error = decode_nfsstat3(xdr, &status);
2427	if (unlikely(error))
2428		goto out;
2429	if (status != NFS3_OK)
2430		goto out_default;
2431	error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
2432out:
2433	return error;
2434out_default:
2435	return nfs_stat_to_errno(status);
2436}
2437
2438#endif  /* CONFIG_NFS_V3_ACL */
2439
2440#define PROC(proc, argtype, restype, timer)				\
2441[NFS3PROC_##proc] = {							\
2442	.p_proc      = NFS3PROC_##proc,					\
2443	.p_encode    = nfs3_xdr_enc_##argtype##3args,			\
2444	.p_decode    = nfs3_xdr_dec_##restype##3res,			\
2445	.p_arglen    = NFS3_##argtype##args_sz,				\
2446	.p_replen    = NFS3_##restype##res_sz,				\
2447	.p_timer     = timer,						\
2448	.p_statidx   = NFS3PROC_##proc,					\
2449	.p_name      = #proc,						\
2450	}
2451
2452const struct rpc_procinfo nfs3_procedures[] = {
2453	PROC(GETATTR,		getattr,	getattr,	1),
2454	PROC(SETATTR,		setattr,	setattr,	0),
2455	PROC(LOOKUP,		lookup,		lookup,		2),
2456	PROC(ACCESS,		access,		access,		1),
2457	PROC(READLINK,		readlink,	readlink,	3),
2458	PROC(READ,		read,		read,		3),
2459	PROC(WRITE,		write,		write,		4),
2460	PROC(CREATE,		create,		create,		0),
2461	PROC(MKDIR,		mkdir,		create,		0),
2462	PROC(SYMLINK,		symlink,	create,		0),
2463	PROC(MKNOD,		mknod,		create,		0),
2464	PROC(REMOVE,		remove,		remove,		0),
2465	PROC(RMDIR,		lookup,		setattr,	0),
2466	PROC(RENAME,		rename,		rename,		0),
2467	PROC(LINK,		link,		link,		0),
2468	PROC(READDIR,		readdir,	readdir,	3),
2469	PROC(READDIRPLUS,	readdirplus,	readdir,	3),
2470	PROC(FSSTAT,		getattr,	fsstat,		0),
2471	PROC(FSINFO,		getattr,	fsinfo,		0),
2472	PROC(PATHCONF,		getattr,	pathconf,	0),
2473	PROC(COMMIT,		commit,		commit,		5),
2474};
2475
2476static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
2477const struct rpc_version nfs_version3 = {
2478	.number			= 3,
2479	.nrprocs		= ARRAY_SIZE(nfs3_procedures),
2480	.procs			= nfs3_procedures,
2481	.counts			= nfs_version3_counts,
2482};
2483
2484#ifdef CONFIG_NFS_V3_ACL
2485static const struct rpc_procinfo nfs3_acl_procedures[] = {
2486	[ACLPROC3_GETACL] = {
2487		.p_proc = ACLPROC3_GETACL,
2488		.p_encode = nfs3_xdr_enc_getacl3args,
2489		.p_decode = nfs3_xdr_dec_getacl3res,
2490		.p_arglen = ACL3_getaclargs_sz,
2491		.p_replen = ACL3_getaclres_sz,
2492		.p_timer = 1,
2493		.p_name = "GETACL",
2494	},
2495	[ACLPROC3_SETACL] = {
2496		.p_proc = ACLPROC3_SETACL,
2497		.p_encode = nfs3_xdr_enc_setacl3args,
2498		.p_decode = nfs3_xdr_dec_setacl3res,
2499		.p_arglen = ACL3_setaclargs_sz,
2500		.p_replen = ACL3_setaclres_sz,
2501		.p_timer = 0,
2502		.p_name = "SETACL",
2503	},
2504};
2505
2506static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
2507const struct rpc_version nfsacl_version3 = {
2508	.number			= 3,
2509	.nrprocs		= ARRAY_SIZE(nfs3_acl_procedures),
2510	.procs			= nfs3_acl_procedures,
2511	.counts			= nfs3_acl_counts,
2512};
2513#endif  /* CONFIG_NFS_V3_ACL */
~/ Read-only file preview.