1/*
   2 *  Server-side XDR for NFSv4
   3 *
   4 *  Copyright (c) 2002 The Regents of the University of Michigan.
   5 *  All rights reserved.
   6 *
   7 *  Kendrick Smith <kmsmith@umich.edu>
   8 *  Andy Adamson   <andros@umich.edu>
   9 *
  10 *  Redistribution and use in source and binary forms, with or without
  11 *  modification, are permitted provided that the following conditions
  12 *  are met:
  13 *
  14 *  1. Redistributions of source code must retain the above copyright
  15 *     notice, this list of conditions and the following disclaimer.
  16 *  2. Redistributions in binary form must reproduce the above copyright
  17 *     notice, this list of conditions and the following disclaimer in the
  18 *     documentation and/or other materials provided with the distribution.
  19 *  3. Neither the name of the University nor the names of its
  20 *     contributors may be used to endorse or promote products derived
  21 *     from this software without specific prior written permission.
  22 *
  23 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  24 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34 */
  35
  36#include <linux/file.h>
  37#include <linux/slab.h>
  38#include <linux/namei.h>
  39#include <linux/statfs.h>
  40#include <linux/utsname.h>
  41#include <linux/pagemap.h>
  42#include <linux/sunrpc/svcauth_gss.h>
  43#include <linux/sunrpc/addr.h>
  44#include <linux/xattr.h>
  45#include <linux/vmalloc.h>
  46
  47#include <uapi/linux/xattr.h>
  48
  49#include "idmap.h"
  50#include "acl.h"
  51#include "xdr4.h"
  52#include "vfs.h"
  53#include "state.h"
  54#include "cache.h"
  55#include "netns.h"
  56#include "pnfs.h"
  57#include "filecache.h"
  58
  59#include "trace.h"
  60
  61#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
  62#include <linux/security.h>
  63#endif
  64
  65
  66#define NFSDDBG_FACILITY		NFSDDBG_XDR
  67
  68const u32 nfsd_suppattrs[3][3] = {
  69	{NFSD4_SUPPORTED_ATTRS_WORD0,
  70	 NFSD4_SUPPORTED_ATTRS_WORD1,
  71	 NFSD4_SUPPORTED_ATTRS_WORD2},
  72
  73	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
  74	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
  75	 NFSD4_1_SUPPORTED_ATTRS_WORD2},
  76
  77	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
  78	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
  79	 NFSD4_2_SUPPORTED_ATTRS_WORD2},
  80};
  81
  82/*
  83 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
  84 * directory in order to indicate to the client that a filesystem boundary is present
  85 * We use a fixed fsid for a referral
  86 */
  87#define NFS4_REFERRAL_FSID_MAJOR	0x8000000ULL
  88#define NFS4_REFERRAL_FSID_MINOR	0x8000000ULL
  89
  90static __be32
  91check_filename(char *str, int len)
  92{
  93	int i;
  94
  95	if (len == 0)
  96		return nfserr_inval;
  97	if (len > NFS4_MAXNAMLEN)
  98		return nfserr_nametoolong;
  99	if (isdotent(str, len))
 100		return nfserr_badname;
 101	for (i = 0; i < len; i++)
 102		if (str[i] == '/')
 103			return nfserr_badname;
 104	return 0;
 105}
 106
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 107static int zero_clientid(clientid_t *clid)
 108{
 109	return (clid->cl_boot == 0) && (clid->cl_id == 0);
 110}
 111
 112/**
 113 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
 114 * @argp: NFSv4 compound argument structure
 115 * @len: length of buffer to allocate
 116 *
 117 * Allocates a buffer of size @len to be freed when processing the compound
 118 * operation described in @argp finishes.
 119 */
 120static void *
 121svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
 122{
 123	struct svcxdr_tmpbuf *tb;
 124
 125	tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
 126	if (!tb)
 127		return NULL;
 128	tb->next = argp->to_free;
 129	argp->to_free = tb;
 130	return tb->buf;
 131}
 132
 133/*
 134 * For xdr strings that need to be passed to other kernel api's
 135 * as null-terminated strings.
 136 *
 137 * Note null-terminating in place usually isn't safe since the
 138 * buffer might end on a page boundary.
 139 */
 140static char *
 141svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)
 142{
 143	char *p = svcxdr_tmpalloc(argp, len + 1);
 144
 145	if (!p)
 146		return NULL;
 147	memcpy(p, buf, len);
 148	p[len] = '\0';
 149	return p;
 150}
 151
 152static void *
 153svcxdr_savemem(struct nfsd4_compoundargs *argp, __be32 *p, u32 len)
 
 
 
 
 
 
 
 
 
 154{
 155	__be32 *tmp;
 156
 157	/*
 158	 * The location of the decoded data item is stable,
 159	 * so @p is OK to use. This is the common case.
 160	 */
 161	if (p != argp->xdr->scratch.iov_base)
 162		return p;
 163
 164	tmp = svcxdr_tmpalloc(argp, len);
 165	if (!tmp)
 166		return NULL;
 167	memcpy(tmp, p, len);
 168	return tmp;
 169}
 170
 171/*
 172 * NFSv4 basic data type decoders
 
 173 */
 174
 175/*
 176 * This helper handles variable-length opaques which belong to protocol
 177 * elements that this implementation does not support.
 178 */
 179static __be32
 180nfsd4_decode_ignored_string(struct nfsd4_compoundargs *argp, u32 maxlen)
 181{
 182	u32 len;
 183
 184	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)
 185		return nfserr_bad_xdr;
 186	if (maxlen && len > maxlen)
 187		return nfserr_bad_xdr;
 188	if (!xdr_inline_decode(argp->xdr, len))
 189		return nfserr_bad_xdr;
 190
 191	return nfs_ok;
 192}
 193
 194static __be32
 195nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
 196{
 197	__be32 *p;
 198	u32 len;
 199
 200	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)
 201		return nfserr_bad_xdr;
 202	if (len == 0 || len > NFS4_OPAQUE_LIMIT)
 203		return nfserr_bad_xdr;
 204	p = xdr_inline_decode(argp->xdr, len);
 205	if (!p)
 206		return nfserr_bad_xdr;
 207	o->data = svcxdr_savemem(argp, p, len);
 208	if (!o->data)
 209		return nfserr_jukebox;
 210	o->len = len;
 211
 212	return nfs_ok;
 213}
 214
 215static __be32
 216nfsd4_decode_component4(struct nfsd4_compoundargs *argp, char **namp, u32 *lenp)
 217{
 218	__be32 *p, status;
 219
 220	if (xdr_stream_decode_u32(argp->xdr, lenp) < 0)
 221		return nfserr_bad_xdr;
 222	p = xdr_inline_decode(argp->xdr, *lenp);
 223	if (!p)
 224		return nfserr_bad_xdr;
 225	status = check_filename((char *)p, *lenp);
 226	if (status)
 227		return status;
 228	*namp = svcxdr_savemem(argp, p, *lenp);
 229	if (!*namp)
 230		return nfserr_jukebox;
 231
 232	return nfs_ok;
 233}
 234
 235static __be32
 236nfsd4_decode_nfstime4(struct nfsd4_compoundargs *argp, struct timespec64 *tv)
 237{
 238	__be32 *p;
 
 239
 240	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 3);
 241	if (!p)
 242		return nfserr_bad_xdr;
 243	p = xdr_decode_hyper(p, &tv->tv_sec);
 244	tv->tv_nsec = be32_to_cpup(p++);
 245	if (tv->tv_nsec >= (u32)1000000000)
 246		return nfserr_inval;
 247	return nfs_ok;
 248}
 249
 250static __be32
 251nfsd4_decode_verifier4(struct nfsd4_compoundargs *argp, nfs4_verifier *verf)
 252{
 253	__be32 *p;
 254
 255	p = xdr_inline_decode(argp->xdr, NFS4_VERIFIER_SIZE);
 256	if (!p)
 257		return nfserr_bad_xdr;
 258	memcpy(verf->data, p, sizeof(verf->data));
 259	return nfs_ok;
 260}
 261
 262/**
 263 * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
 264 * @argp: NFSv4 compound argument structure
 265 * @bmval: pointer to an array of u32's to decode into
 266 * @bmlen: size of the @bmval array
 267 *
 268 * The server needs to return nfs_ok rather than nfserr_bad_xdr when
 269 * encountering bitmaps containing bits it does not recognize. This
 270 * includes bits in bitmap words past WORDn, where WORDn is the last
 271 * bitmap WORD the implementation currently supports. Thus we are
 272 * careful here to simply ignore bits in bitmap words that this
 273 * implementation has yet to support explicitly.
 274 *
 275 * Return values:
 276 *   %nfs_ok: @bmval populated successfully
 277 *   %nfserr_bad_xdr: the encoded bitmap was invalid
 278 */
 279static __be32
 280nfsd4_decode_bitmap4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen)
 281{
 282	ssize_t status;
 
 283
 284	status = xdr_stream_decode_uint32_array(argp->xdr, bmval, bmlen);
 285	return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok;
 286}
 287
 288static __be32
 289nfsd4_decode_nfsace4(struct nfsd4_compoundargs *argp, struct nfs4_ace *ace)
 290{
 291	__be32 *p, status;
 292	u32 length;
 293
 294	if (xdr_stream_decode_u32(argp->xdr, &ace->type) < 0)
 295		return nfserr_bad_xdr;
 296	if (xdr_stream_decode_u32(argp->xdr, &ace->flag) < 0)
 297		return nfserr_bad_xdr;
 298	if (xdr_stream_decode_u32(argp->xdr, &ace->access_mask) < 0)
 299		return nfserr_bad_xdr;
 300
 301	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
 302		return nfserr_bad_xdr;
 303	p = xdr_inline_decode(argp->xdr, length);
 304	if (!p)
 305		return nfserr_bad_xdr;
 306	ace->whotype = nfs4_acl_get_whotype((char *)p, length);
 307	if (ace->whotype != NFS4_ACL_WHO_NAMED)
 308		status = nfs_ok;
 309	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
 310		status = nfsd_map_name_to_gid(argp->rqstp,
 311				(char *)p, length, &ace->who_gid);
 312	else
 313		status = nfsd_map_name_to_uid(argp->rqstp,
 314				(char *)p, length, &ace->who_uid);
 315
 316	return status;
 317}
 318
 319/* A counted array of nfsace4's */
 320static noinline __be32
 321nfsd4_decode_acl(struct nfsd4_compoundargs *argp, struct nfs4_acl **acl)
 322{
 323	struct nfs4_ace *ace;
 324	__be32 status;
 325	u32 count;
 326
 327	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
 328		return nfserr_bad_xdr;
 329
 330	if (count > xdr_stream_remaining(argp->xdr) / 20)
 331		/*
 332		 * Even with 4-byte names there wouldn't be
 333		 * space for that many aces; something fishy is
 334		 * going on:
 335		 */
 336		return nfserr_fbig;
 337
 338	*acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(count));
 339	if (*acl == NULL)
 340		return nfserr_jukebox;
 341
 342	(*acl)->naces = count;
 343	for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) {
 344		status = nfsd4_decode_nfsace4(argp, ace);
 345		if (status)
 346			return status;
 347	}
 348
 349	return nfs_ok;
 350}
 351
 352static noinline __be32
 353nfsd4_decode_security_label(struct nfsd4_compoundargs *argp,
 354			    struct xdr_netobj *label)
 355{
 356	u32 lfs, pi, length;
 357	__be32 *p;
 358
 359	if (xdr_stream_decode_u32(argp->xdr, &lfs) < 0)
 360		return nfserr_bad_xdr;
 361	if (xdr_stream_decode_u32(argp->xdr, &pi) < 0)
 362		return nfserr_bad_xdr;
 363
 364	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
 365		return nfserr_bad_xdr;
 366	if (length > NFS4_MAXLABELLEN)
 367		return nfserr_badlabel;
 368	p = xdr_inline_decode(argp->xdr, length);
 369	if (!p)
 370		return nfserr_bad_xdr;
 371	label->len = length;
 372	label->data = svcxdr_dupstr(argp, p, length);
 373	if (!label->data)
 374		return nfserr_jukebox;
 375
 376	return nfs_ok;
 377}
 378
 379static __be32
 380nfsd4_decode_fattr4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen,
 381		    struct iattr *iattr, struct nfs4_acl **acl,
 382		    struct xdr_netobj *label, int *umask)
 383{
 384	unsigned int starting_pos;
 385	u32 attrlist4_count;
 386	__be32 *p, status;
 387
 
 388	iattr->ia_valid = 0;
 389	status = nfsd4_decode_bitmap4(argp, bmval, bmlen);
 390	if (status)
 391		return nfserr_bad_xdr;
 392
 393	if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
 394	    || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
 395	    || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) {
 396		if (nfsd_attrs_supported(argp->minorversion, bmval))
 397			return nfserr_inval;
 398		return nfserr_attrnotsupp;
 399	}
 400
 401	if (xdr_stream_decode_u32(argp->xdr, &attrlist4_count) < 0)
 402		return nfserr_bad_xdr;
 403	starting_pos = xdr_stream_pos(argp->xdr);
 404
 405	if (bmval[0] & FATTR4_WORD0_SIZE) {
 406		u64 size;
 407
 408		if (xdr_stream_decode_u64(argp->xdr, &size) < 0)
 409			return nfserr_bad_xdr;
 410		iattr->ia_size = size;
 411		iattr->ia_valid |= ATTR_SIZE;
 412	}
 413	if (bmval[0] & FATTR4_WORD0_ACL) {
 414		status = nfsd4_decode_acl(argp, acl);
 415		if (status)
 416			return status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 417	} else
 418		*acl = NULL;
 419	if (bmval[1] & FATTR4_WORD1_MODE) {
 420		u32 mode;
 421
 422		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)
 423			return nfserr_bad_xdr;
 424		iattr->ia_mode = mode;
 425		iattr->ia_mode &= (S_IFMT | S_IALLUGO);
 426		iattr->ia_valid |= ATTR_MODE;
 427	}
 428	if (bmval[1] & FATTR4_WORD1_OWNER) {
 429		u32 length;
 430
 431		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
 432			return nfserr_bad_xdr;
 433		p = xdr_inline_decode(argp->xdr, length);
 434		if (!p)
 435			return nfserr_bad_xdr;
 436		status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length,
 437					      &iattr->ia_uid);
 438		if (status)
 439			return status;
 440		iattr->ia_valid |= ATTR_UID;
 441	}
 442	if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
 443		u32 length;
 444
 445		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
 446			return nfserr_bad_xdr;
 447		p = xdr_inline_decode(argp->xdr, length);
 448		if (!p)
 449			return nfserr_bad_xdr;
 450		status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length,
 451					      &iattr->ia_gid);
 452		if (status)
 453			return status;
 454		iattr->ia_valid |= ATTR_GID;
 455	}
 456	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
 457		u32 set_it;
 458
 459		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)
 460			return nfserr_bad_xdr;
 461		switch (set_it) {
 462		case NFS4_SET_TO_CLIENT_TIME:
 463			status = nfsd4_decode_nfstime4(argp, &iattr->ia_atime);
 
 464			if (status)
 465				return status;
 466			iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
 467			break;
 468		case NFS4_SET_TO_SERVER_TIME:
 469			iattr->ia_valid |= ATTR_ATIME;
 470			break;
 471		default:
 472			return nfserr_bad_xdr;
 473		}
 474	}
 475	if (bmval[1] & FATTR4_WORD1_TIME_CREATE) {
 476		struct timespec64 ts;
 477
 478		/* No Linux filesystem supports setting this attribute. */
 479		bmval[1] &= ~FATTR4_WORD1_TIME_CREATE;
 480		status = nfsd4_decode_nfstime4(argp, &ts);
 481		if (status)
 482			return status;
 483	}
 484	if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
 485		u32 set_it;
 486
 487		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)
 488			return nfserr_bad_xdr;
 489		switch (set_it) {
 490		case NFS4_SET_TO_CLIENT_TIME:
 491			status = nfsd4_decode_nfstime4(argp, &iattr->ia_mtime);
 
 492			if (status)
 493				return status;
 494			iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
 495			break;
 496		case NFS4_SET_TO_SERVER_TIME:
 497			iattr->ia_valid |= ATTR_MTIME;
 498			break;
 499		default:
 500			return nfserr_bad_xdr;
 501		}
 502	}
 
 503	label->len = 0;
 504	if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) &&
 505	    bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
 506		status = nfsd4_decode_security_label(argp, label);
 507		if (status)
 508			return status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 509	}
 510	if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
 511		u32 mode, mask;
 512
 513		if (!umask)
 514			return nfserr_bad_xdr;
 515		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)
 516			return nfserr_bad_xdr;
 517		iattr->ia_mode = mode & (S_IFMT | S_IALLUGO);
 518		if (xdr_stream_decode_u32(argp->xdr, &mask) < 0)
 519			return nfserr_bad_xdr;
 520		*umask = mask & S_IRWXUGO;
 521		iattr->ia_valid |= ATTR_MODE;
 522	}
 
 
 523
 524	/* request sanity: did attrlist4 contain the expected number of words? */
 525	if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos)
 526		return nfserr_bad_xdr;
 527
 528	return nfs_ok;
 529}
 530
 531static __be32
 532nfsd4_decode_stateid4(struct nfsd4_compoundargs *argp, stateid_t *sid)
 533{
 534	__be32 *p;
 535
 536	p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE);
 537	if (!p)
 538		return nfserr_bad_xdr;
 539	sid->si_generation = be32_to_cpup(p++);
 540	memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque));
 541	return nfs_ok;
 542}
 543
 544static __be32
 545nfsd4_decode_clientid4(struct nfsd4_compoundargs *argp, clientid_t *clientid)
 546{
 547	__be32 *p;
 548
 549	p = xdr_inline_decode(argp->xdr, sizeof(__be64));
 550	if (!p)
 551		return nfserr_bad_xdr;
 552	memcpy(clientid, p, sizeof(*clientid));
 553	return nfs_ok;
 554}
 555
 556static __be32
 557nfsd4_decode_state_owner4(struct nfsd4_compoundargs *argp,
 558			  clientid_t *clientid, struct xdr_netobj *owner)
 559{
 560	__be32 status;
 561
 562	status = nfsd4_decode_clientid4(argp, clientid);
 563	if (status)
 564		return status;
 565	return nfsd4_decode_opaque(argp, owner);
 566}
 567
 568#ifdef CONFIG_NFSD_PNFS
 569static __be32
 570nfsd4_decode_deviceid4(struct nfsd4_compoundargs *argp,
 571		       struct nfsd4_deviceid *devid)
 572{
 573	__be32 *p;
 574
 575	p = xdr_inline_decode(argp->xdr, NFS4_DEVICEID4_SIZE);
 576	if (!p)
 577		return nfserr_bad_xdr;
 578	memcpy(devid, p, sizeof(*devid));
 579	return nfs_ok;
 580}
 581
 582static __be32
 583nfsd4_decode_layoutupdate4(struct nfsd4_compoundargs *argp,
 584			   struct nfsd4_layoutcommit *lcp)
 585{
 586	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0)
 587		return nfserr_bad_xdr;
 588	if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES)
 589		return nfserr_bad_xdr;
 590	if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX)
 591		return nfserr_bad_xdr;
 592
 593	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_up_len) < 0)
 594		return nfserr_bad_xdr;
 595	if (lcp->lc_up_len > 0) {
 596		lcp->lc_up_layout = xdr_inline_decode(argp->xdr, lcp->lc_up_len);
 597		if (!lcp->lc_up_layout)
 598			return nfserr_bad_xdr;
 599	}
 600
 601	return nfs_ok;
 602}
 603
 604static __be32
 605nfsd4_decode_layoutreturn4(struct nfsd4_compoundargs *argp,
 606			   struct nfsd4_layoutreturn *lrp)
 607{
 608	__be32 status;
 609
 610	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0)
 611		return nfserr_bad_xdr;
 612	switch (lrp->lr_return_type) {
 613	case RETURN_FILE:
 614		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0)
 615			return nfserr_bad_xdr;
 616		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0)
 617			return nfserr_bad_xdr;
 618		status = nfsd4_decode_stateid4(argp, &lrp->lr_sid);
 619		if (status)
 620			return status;
 621		if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0)
 622			return nfserr_bad_xdr;
 623		if (lrp->lrf_body_len > 0) {
 624			lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len);
 625			if (!lrp->lrf_body)
 626				return nfserr_bad_xdr;
 627		}
 628		break;
 629	case RETURN_FSID:
 630	case RETURN_ALL:
 631		lrp->lr_seg.offset = 0;
 632		lrp->lr_seg.length = NFS4_MAX_UINT64;
 633		break;
 634	default:
 635		return nfserr_bad_xdr;
 636	}
 637
 638	return nfs_ok;
 639}
 640
 641#endif /* CONFIG_NFSD_PNFS */
 642
 643static __be32
 644nfsd4_decode_sessionid4(struct nfsd4_compoundargs *argp,
 645			struct nfs4_sessionid *sessionid)
 646{
 647	__be32 *p;
 648
 649	p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN);
 650	if (!p)
 651		return nfserr_bad_xdr;
 652	memcpy(sessionid->data, p, sizeof(sessionid->data));
 653	return nfs_ok;
 654}
 655
 656/* Defined in Appendix A of RFC 5531 */
 657static __be32
 658nfsd4_decode_authsys_parms(struct nfsd4_compoundargs *argp,
 659			   struct nfsd4_cb_sec *cbs)
 660{
 661	u32 stamp, gidcount, uid, gid;
 662	__be32 *p, status;
 663
 664	if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0)
 665		return nfserr_bad_xdr;
 666	/* machine name */
 667	status = nfsd4_decode_ignored_string(argp, 255);
 668	if (status)
 669		return status;
 670	if (xdr_stream_decode_u32(argp->xdr, &uid) < 0)
 671		return nfserr_bad_xdr;
 672	if (xdr_stream_decode_u32(argp->xdr, &gid) < 0)
 673		return nfserr_bad_xdr;
 674	if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0)
 675		return nfserr_bad_xdr;
 676	if (gidcount > 16)
 677		return nfserr_bad_xdr;
 678	p = xdr_inline_decode(argp->xdr, gidcount << 2);
 679	if (!p)
 680		return nfserr_bad_xdr;
 681	if (cbs->flavor == (u32)(-1)) {
 682		struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);
 683
 684		kuid_t kuid = make_kuid(userns, uid);
 685		kgid_t kgid = make_kgid(userns, gid);
 686		if (uid_valid(kuid) && gid_valid(kgid)) {
 687			cbs->uid = kuid;
 688			cbs->gid = kgid;
 689			cbs->flavor = RPC_AUTH_UNIX;
 690		} else {
 691			dprintk("RPC_AUTH_UNIX with invalid uid or gid, ignoring!\n");
 692		}
 693	}
 694
 695	return nfs_ok;
 696}
 697
 698static __be32
 699nfsd4_decode_gss_cb_handles4(struct nfsd4_compoundargs *argp,
 700			     struct nfsd4_cb_sec *cbs)
 701{
 702	__be32 status;
 703	u32 service;
 704
 705	dprintk("RPC_AUTH_GSS callback secflavor not supported!\n");
 706
 707	if (xdr_stream_decode_u32(argp->xdr, &service) < 0)
 708		return nfserr_bad_xdr;
 709	if (service < RPC_GSS_SVC_NONE || service > RPC_GSS_SVC_PRIVACY)
 710		return nfserr_bad_xdr;
 711	/* gcbp_handle_from_server */
 712	status = nfsd4_decode_ignored_string(argp, 0);
 713	if (status)
 714		return status;
 715	/* gcbp_handle_from_client */
 716	status = nfsd4_decode_ignored_string(argp, 0);
 717	if (status)
 718		return status;
 719
 720	return nfs_ok;
 721}
 722
 723/* a counted array of callback_sec_parms4 items */
 724static __be32
 725nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
 726{
 727	u32 i, secflavor, nr_secflavs;
 728	__be32 status;
 729
 730	/* callback_sec_params4 */
 731	if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0)
 732		return nfserr_bad_xdr;
 733	if (nr_secflavs)
 734		cbs->flavor = (u32)(-1);
 735	else
 736		/* Is this legal? Be generous, take it to mean AUTH_NONE: */
 737		cbs->flavor = 0;
 738
 739	for (i = 0; i < nr_secflavs; ++i) {
 740		if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0)
 741			return nfserr_bad_xdr;
 742		switch (secflavor) {
 743		case RPC_AUTH_NULL:
 744			/* void */
 745			if (cbs->flavor == (u32)(-1))
 746				cbs->flavor = RPC_AUTH_NULL;
 747			break;
 748		case RPC_AUTH_UNIX:
 749			status = nfsd4_decode_authsys_parms(argp, cbs);
 750			if (status)
 751				return status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 752			break;
 753		case RPC_AUTH_GSS:
 754			status = nfsd4_decode_gss_cb_handles4(argp, cbs);
 755			if (status)
 756				return status;
 
 
 
 
 
 
 
 
 
 
 757			break;
 758		default:
 
 759			return nfserr_inval;
 760		}
 761	}
 762
 763	return nfs_ok;
 764}
 765
 
 
 
 
 
 
 
 766
 767/*
 768 * NFSv4 operation argument decoders
 769 */
 770
 771static __be32
 772nfsd4_decode_access(struct nfsd4_compoundargs *argp,
 773		    union nfsd4_op_u *u)
 774{
 775	struct nfsd4_access *access = &u->access;
 776	if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0)
 777		return nfserr_bad_xdr;
 778	return nfs_ok;
 
 
 
 
 779}
 780
 781static __be32
 782nfsd4_decode_close(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 783{
 784	struct nfsd4_close *close = &u->close;
 785	if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0)
 786		return nfserr_bad_xdr;
 787	return nfsd4_decode_stateid4(argp, &close->cl_stateid);
 
 
 
 788}
 789
 790
 791static __be32
 792nfsd4_decode_commit(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 793{
 794	struct nfsd4_commit *commit = &u->commit;
 795	if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0)
 796		return nfserr_bad_xdr;
 797	if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0)
 798		return nfserr_bad_xdr;
 799	memset(&commit->co_verf, 0, sizeof(commit->co_verf));
 800	return nfs_ok;
 801}
 802
 803static __be32
 804nfsd4_decode_create(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 805{
 806	struct nfsd4_create *create = &u->create;
 807	__be32 *p, status;
 808
 809	memset(create, 0, sizeof(*create));
 810	if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0)
 811		return nfserr_bad_xdr;
 812	switch (create->cr_type) {
 813	case NF4LNK:
 814		if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0)
 815			return nfserr_bad_xdr;
 816		p = xdr_inline_decode(argp->xdr, create->cr_datalen);
 817		if (!p)
 818			return nfserr_bad_xdr;
 819		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
 820		if (!create->cr_data)
 821			return nfserr_jukebox;
 822		break;
 823	case NF4BLK:
 824	case NF4CHR:
 825		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0)
 826			return nfserr_bad_xdr;
 827		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0)
 828			return nfserr_bad_xdr;
 829		break;
 830	case NF4SOCK:
 831	case NF4FIFO:
 832	case NF4DIR:
 833	default:
 834		break;
 835	}
 836	status = nfsd4_decode_component4(argp, &create->cr_name,
 837					 &create->cr_namelen);
 838	if (status)
 
 
 
 839		return status;
 840	status = nfsd4_decode_fattr4(argp, create->cr_bmval,
 841				    ARRAY_SIZE(create->cr_bmval),
 842				    &create->cr_iattr, &create->cr_acl,
 843				    &create->cr_label, &create->cr_umask);
 844	if (status)
 845		return status;
 846
 847	return nfs_ok;
 848}
 849
 850static inline __be32
 851nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 852{
 853	struct nfsd4_delegreturn *dr = &u->delegreturn;
 854	return nfsd4_decode_stateid4(argp, &dr->dr_stateid);
 855}
 856
 857static inline __be32
 858nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 859{
 860	struct nfsd4_getattr *getattr = &u->getattr;
 861	memset(getattr, 0, sizeof(*getattr));
 862	return nfsd4_decode_bitmap4(argp, getattr->ga_bmval,
 863				    ARRAY_SIZE(getattr->ga_bmval));
 864}
 865
 866static __be32
 867nfsd4_decode_link(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 868{
 869	struct nfsd4_link *link = &u->link;
 870	memset(link, 0, sizeof(*link));
 871	return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen);
 872}
 873
 874static __be32
 875nfsd4_decode_open_to_lock_owner4(struct nfsd4_compoundargs *argp,
 876				 struct nfsd4_lock *lock)
 877{
 878	__be32 status;
 879
 880	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0)
 881		return nfserr_bad_xdr;
 882	status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid);
 883	if (status)
 884		return status;
 885	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0)
 886		return nfserr_bad_xdr;
 887	return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid,
 888					 &lock->lk_new_owner);
 889}
 890
 891static __be32
 892nfsd4_decode_exist_lock_owner4(struct nfsd4_compoundargs *argp,
 893			       struct nfsd4_lock *lock)
 894{
 895	__be32 status;
 896
 897	status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid);
 898	if (status)
 899		return status;
 900	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0)
 901		return nfserr_bad_xdr;
 902
 903	return nfs_ok;
 904}
 905
 906static __be32
 907nfsd4_decode_locker4(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
 908{
 909	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0)
 910		return nfserr_bad_xdr;
 911	if (lock->lk_is_new)
 912		return nfsd4_decode_open_to_lock_owner4(argp, lock);
 913	return nfsd4_decode_exist_lock_owner4(argp, lock);
 914}
 915
 916static __be32
 917nfsd4_decode_lock(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 918{
 919	struct nfsd4_lock *lock = &u->lock;
 920	memset(lock, 0, sizeof(*lock));
 921	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0)
 922		return nfserr_bad_xdr;
 923	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
 924		return nfserr_bad_xdr;
 925	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0)
 926		return nfserr_bad_xdr;
 927	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0)
 928		return nfserr_bad_xdr;
 929	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0)
 930		return nfserr_bad_xdr;
 931	return nfsd4_decode_locker4(argp, lock);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 932}
 933
 934static __be32
 935nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 936{
 937	struct nfsd4_lockt *lockt = &u->lockt;
 938	memset(lockt, 0, sizeof(*lockt));
 939	if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0)
 940		return nfserr_bad_xdr;
 941	if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
 942		return nfserr_bad_xdr;
 943	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0)
 944		return nfserr_bad_xdr;
 945	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0)
 946		return nfserr_bad_xdr;
 947	return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid,
 948					 &lockt->lt_owner);
 
 
 949}
 950
 951static __be32
 952nfsd4_decode_locku(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 953{
 954	struct nfsd4_locku *locku = &u->locku;
 955	__be32 status;
 956
 957	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0)
 958		return nfserr_bad_xdr;
 959	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
 960		return nfserr_bad_xdr;
 961	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0)
 962		return nfserr_bad_xdr;
 963	status = nfsd4_decode_stateid4(argp, &locku->lu_stateid);
 964	if (status)
 965		return status;
 966	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0)
 967		return nfserr_bad_xdr;
 968	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0)
 969		return nfserr_bad_xdr;
 970
 971	return nfs_ok;
 972}
 973
 974static __be32
 975nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 976{
 977	struct nfsd4_lookup *lookup = &u->lookup;
 978	return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len);
 979}
 980
 981static __be32
 982nfsd4_decode_createhow4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
 983{
 984	__be32 status;
 985
 986	if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0)
 987		return nfserr_bad_xdr;
 988	switch (open->op_createmode) {
 989	case NFS4_CREATE_UNCHECKED:
 990	case NFS4_CREATE_GUARDED:
 991		status = nfsd4_decode_fattr4(argp, open->op_bmval,
 992					     ARRAY_SIZE(open->op_bmval),
 993					     &open->op_iattr, &open->op_acl,
 994					     &open->op_label, &open->op_umask);
 995		if (status)
 996			return status;
 997		break;
 998	case NFS4_CREATE_EXCLUSIVE:
 999		status = nfsd4_decode_verifier4(argp, &open->op_verf);
1000		if (status)
1001			return status;
1002		break;
1003	case NFS4_CREATE_EXCLUSIVE4_1:
1004		if (argp->minorversion < 1)
1005			return nfserr_bad_xdr;
1006		status = nfsd4_decode_verifier4(argp, &open->op_verf);
1007		if (status)
1008			return status;
1009		status = nfsd4_decode_fattr4(argp, open->op_bmval,
1010					     ARRAY_SIZE(open->op_bmval),
1011					     &open->op_iattr, &open->op_acl,
1012					     &open->op_label, &open->op_umask);
1013		if (status)
1014			return status;
1015		break;
1016	default:
1017		return nfserr_bad_xdr;
1018	}
1019
1020	return nfs_ok;
1021}
1022
1023static __be32
1024nfsd4_decode_openflag4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
1025{
1026	__be32 status;
1027
1028	if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0)
1029		return nfserr_bad_xdr;
1030	switch (open->op_create) {
1031	case NFS4_OPEN_NOCREATE:
1032		break;
1033	case NFS4_OPEN_CREATE:
1034		status = nfsd4_decode_createhow4(argp, open);
1035		if (status)
1036			return status;
1037		break;
1038	default:
1039		return nfserr_bad_xdr;
1040	}
1041
1042	return nfs_ok;
1043}
1044
1045static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
1046{
 
1047	u32 w;
1048
1049	if (xdr_stream_decode_u32(argp->xdr, &w) < 0)
1050		return nfserr_bad_xdr;
1051	*share_access = w & NFS4_SHARE_ACCESS_MASK;
1052	*deleg_want = w & NFS4_SHARE_WANT_MASK;
1053	if (deleg_when)
1054		*deleg_when = w & NFS4_SHARE_WHEN_MASK;
1055
1056	switch (w & NFS4_SHARE_ACCESS_MASK) {
1057	case NFS4_SHARE_ACCESS_READ:
1058	case NFS4_SHARE_ACCESS_WRITE:
1059	case NFS4_SHARE_ACCESS_BOTH:
1060		break;
1061	default:
1062		return nfserr_bad_xdr;
1063	}
1064	w &= ~NFS4_SHARE_ACCESS_MASK;
1065	if (!w)
1066		return nfs_ok;
1067	if (!argp->minorversion)
1068		return nfserr_bad_xdr;
1069	switch (w & NFS4_SHARE_WANT_MASK) {
1070	case NFS4_SHARE_WANT_NO_PREFERENCE:
1071	case NFS4_SHARE_WANT_READ_DELEG:
1072	case NFS4_SHARE_WANT_WRITE_DELEG:
1073	case NFS4_SHARE_WANT_ANY_DELEG:
1074	case NFS4_SHARE_WANT_NO_DELEG:
1075	case NFS4_SHARE_WANT_CANCEL:
1076		break;
1077	default:
1078		return nfserr_bad_xdr;
1079	}
1080	w &= ~NFS4_SHARE_WANT_MASK;
1081	if (!w)
1082		return nfs_ok;
1083
1084	if (!deleg_when)	/* open_downgrade */
1085		return nfserr_inval;
1086	switch (w) {
1087	case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
1088	case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
1089	case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
1090	      NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
1091		return nfs_ok;
1092	}
 
1093	return nfserr_bad_xdr;
1094}
1095
1096static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)
1097{
1098	if (xdr_stream_decode_u32(argp->xdr, x) < 0)
1099		return nfserr_bad_xdr;
1100	/* Note: unlike access bits, deny bits may be zero. */
 
 
1101	if (*x & ~NFS4_SHARE_DENY_BOTH)
1102		return nfserr_bad_xdr;
 
 
 
 
 
 
 
 
1103
 
 
 
 
 
 
 
 
1104	return nfs_ok;
 
 
1105}
1106
1107static __be32
1108nfsd4_decode_open_claim4(struct nfsd4_compoundargs *argp,
1109			 struct nfsd4_open *open)
1110{
1111	__be32 status;
 
1112
1113	if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0)
1114		return nfserr_bad_xdr;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1115	switch (open->op_claim_type) {
1116	case NFS4_OPEN_CLAIM_NULL:
1117	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1118		status = nfsd4_decode_component4(argp, &open->op_fname,
1119						 &open->op_fnamelen);
1120		if (status)
 
 
1121			return status;
1122		break;
1123	case NFS4_OPEN_CLAIM_PREVIOUS:
1124		if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0)
1125			return nfserr_bad_xdr;
1126		break;
1127	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1128		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);
1129		if (status)
1130			return status;
1131		status = nfsd4_decode_component4(argp, &open->op_fname,
1132						 &open->op_fnamelen);
1133		if (status)
 
 
1134			return status;
1135		break;
1136	case NFS4_OPEN_CLAIM_FH:
1137	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1138		if (argp->minorversion < 1)
1139			return nfserr_bad_xdr;
1140		/* void */
1141		break;
1142	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1143		if (argp->minorversion < 1)
1144			return nfserr_bad_xdr;
1145		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);
1146		if (status)
1147			return status;
1148		break;
1149	default:
1150		return nfserr_bad_xdr;
1151	}
1152
1153	return nfs_ok;
1154}
1155
1156static __be32
1157nfsd4_decode_open(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1158{
1159	struct nfsd4_open *open = &u->open;
1160	__be32 status;
1161	u32 dummy;
1162
1163	memset(open, 0, sizeof(*open));
1164
1165	if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0)
1166		return nfserr_bad_xdr;
1167	/* deleg_want is ignored */
1168	status = nfsd4_decode_share_access(argp, &open->op_share_access,
1169					   &open->op_deleg_want, &dummy);
1170	if (status)
1171		return status;
1172	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
1173	if (status)
1174		return status;
1175	status = nfsd4_decode_state_owner4(argp, &open->op_clientid,
1176					   &open->op_owner);
1177	if (status)
1178		return status;
1179	status = nfsd4_decode_openflag4(argp, open);
1180	if (status)
1181		return status;
1182	return nfsd4_decode_open_claim4(argp, open);
1183}
1184
1185static __be32
1186nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp,
1187			  union nfsd4_op_u *u)
1188{
1189	struct nfsd4_open_confirm *open_conf = &u->open_confirm;
1190	__be32 status;
1191
1192	if (argp->minorversion >= 1)
1193		return nfserr_notsupp;
1194
1195	status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid);
1196	if (status)
1197		return status;
1198	if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0)
1199		return nfserr_bad_xdr;
1200
1201	memset(&open_conf->oc_resp_stateid, 0,
1202	       sizeof(open_conf->oc_resp_stateid));
1203	return nfs_ok;
1204}
1205
1206static __be32
1207nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp,
1208			    union nfsd4_op_u *u)
1209{
1210	struct nfsd4_open_downgrade *open_down = &u->open_downgrade;
1211	__be32 status;
1212
1213	memset(open_down, 0, sizeof(*open_down));
1214	status = nfsd4_decode_stateid4(argp, &open_down->od_stateid);
1215	if (status)
1216		return status;
1217	if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0)
1218		return nfserr_bad_xdr;
1219	/* deleg_want is ignored */
1220	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
1221					   &open_down->od_deleg_want, NULL);
1222	if (status)
1223		return status;
1224	return nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
 
 
 
1225}
1226
1227static __be32
1228nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1229{
1230	struct nfsd4_putfh *putfh = &u->putfh;
1231	__be32 *p;
1232
1233	if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0)
1234		return nfserr_bad_xdr;
1235	if (putfh->pf_fhlen > NFS4_FHSIZE)
1236		return nfserr_bad_xdr;
1237	p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen);
1238	if (!p)
1239		return nfserr_bad_xdr;
1240	putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen);
1241	if (!putfh->pf_fhval)
1242		return nfserr_jukebox;
1243
1244	putfh->no_verify = false;
1245	return nfs_ok;
1246}
1247
1248static __be32
1249nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p)
1250{
1251	if (argp->minorversion == 0)
1252		return nfs_ok;
1253	return nfserr_notsupp;
1254}
1255
1256static __be32
1257nfsd4_decode_read(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1258{
1259	struct nfsd4_read *read = &u->read;
1260	__be32 status;
1261
1262	memset(read, 0, sizeof(*read));
1263	status = nfsd4_decode_stateid4(argp, &read->rd_stateid);
1264	if (status)
1265		return status;
1266	if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0)
1267		return nfserr_bad_xdr;
1268	if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0)
1269		return nfserr_bad_xdr;
1270
1271	return nfs_ok;
1272}
1273
1274static __be32
1275nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1276{
1277	struct nfsd4_readdir *readdir = &u->readdir;
1278	__be32 status;
1279
1280	memset(readdir, 0, sizeof(*readdir));
1281	if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0)
1282		return nfserr_bad_xdr;
1283	status = nfsd4_decode_verifier4(argp, &readdir->rd_verf);
1284	if (status)
1285		return status;
1286	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0)
1287		return nfserr_bad_xdr;
1288	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0)
1289		return nfserr_bad_xdr;
1290	if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval,
1291					   ARRAY_SIZE(readdir->rd_bmval)) < 0)
1292		return nfserr_bad_xdr;
1293
1294	return nfs_ok;
1295}
1296
1297static __be32
1298nfsd4_decode_remove(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1299{
1300	struct nfsd4_remove *remove = &u->remove;
1301	memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo));
1302	return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen);
 
 
 
 
 
 
 
1303}
1304
1305static __be32
1306nfsd4_decode_rename(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1307{
1308	struct nfsd4_rename *rename = &u->rename;
1309	__be32 status;
1310
1311	memset(rename, 0, sizeof(*rename));
1312	status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen);
1313	if (status)
 
 
 
 
 
 
 
 
1314		return status;
1315	return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen);
 
1316}
1317
1318static __be32
1319nfsd4_decode_renew(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1320{
1321	clientid_t *clientid = &u->renew;
1322	return nfsd4_decode_clientid4(argp, clientid);
 
 
 
 
 
 
 
1323}
1324
1325static __be32
1326nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
1327		     union nfsd4_op_u *u)
1328{
1329	struct nfsd4_secinfo *secinfo = &u->secinfo;
1330	secinfo->si_exp = NULL;
1331	return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen);
 
 
 
 
 
 
 
1332}
1333
1334static __be32
1335nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 
 
 
 
 
 
 
 
 
 
 
1336{
1337	struct nfsd4_setattr *setattr = &u->setattr;
1338	__be32 status;
1339
1340	memset(setattr, 0, sizeof(*setattr));
1341	status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid);
1342	if (status)
1343		return status;
1344	return nfsd4_decode_fattr4(argp, setattr->sa_bmval,
1345				   ARRAY_SIZE(setattr->sa_bmval),
1346				   &setattr->sa_iattr, &setattr->sa_acl,
1347				   &setattr->sa_label, NULL);
1348}
1349
1350static __be32
1351nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1352{
1353	struct nfsd4_setclientid *setclientid = &u->setclientid;
1354	__be32 *p, status;
1355
1356	memset(setclientid, 0, sizeof(*setclientid));
1357
1358	if (argp->minorversion >= 1)
1359		return nfserr_notsupp;
1360
1361	status = nfsd4_decode_verifier4(argp, &setclientid->se_verf);
1362	if (status)
1363		return status;
1364	status = nfsd4_decode_opaque(argp, &setclientid->se_name);
1365	if (status)
1366		return status;
1367	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0)
1368		return nfserr_bad_xdr;
1369	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0)
1370		return nfserr_bad_xdr;
1371	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len);
1372	if (!p)
1373		return nfserr_bad_xdr;
1374	setclientid->se_callback_netid_val = svcxdr_savemem(argp, p,
1375						setclientid->se_callback_netid_len);
1376	if (!setclientid->se_callback_netid_val)
1377		return nfserr_jukebox;
1378
1379	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0)
1380		return nfserr_bad_xdr;
1381	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len);
1382	if (!p)
1383		return nfserr_bad_xdr;
1384	setclientid->se_callback_addr_val = svcxdr_savemem(argp, p,
1385						setclientid->se_callback_addr_len);
1386	if (!setclientid->se_callback_addr_val)
1387		return nfserr_jukebox;
1388	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0)
1389		return nfserr_bad_xdr;
1390
1391	return nfs_ok;
1392}
1393
1394static __be32
1395nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp,
1396				 union nfsd4_op_u *u)
1397{
1398	struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm;
1399	__be32 status;
1400
1401	if (argp->minorversion >= 1)
1402		return nfserr_notsupp;
1403
1404	status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid);
1405	if (status)
1406		return status;
1407	return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm);
 
1408}
1409
1410/* Also used for NVERIFY */
1411static __be32
1412nfsd4_decode_verify(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1413{
1414	struct nfsd4_verify *verify = &u->verify;
1415	__be32 *p, status;
1416
1417	memset(verify, 0, sizeof(*verify));
1418
1419	status = nfsd4_decode_bitmap4(argp, verify->ve_bmval,
1420				      ARRAY_SIZE(verify->ve_bmval));
1421	if (status)
1422		return status;
1423
1424	/* For convenience's sake, we compare raw xdr'd attributes in
1425	 * nfsd4_proc_verify */
1426
1427	if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0)
1428		return nfserr_bad_xdr;
1429	p = xdr_inline_decode(argp->xdr, verify->ve_attrlen);
1430	if (!p)
1431		return nfserr_bad_xdr;
1432	verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen);
1433	if (!verify->ve_attrval)
1434		return nfserr_jukebox;
1435
1436	return nfs_ok;
1437}
1438
1439static __be32
1440nfsd4_decode_write(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
1441{
1442	struct nfsd4_write *write = &u->write;
1443	__be32 status;
 
1444
1445	status = nfsd4_decode_stateid4(argp, &write->wr_stateid);
1446	if (status)
1447		return status;
1448	if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0)
1449		return nfserr_bad_xdr;
1450	if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0)
1451		return nfserr_bad_xdr;
1452	if (write->wr_stable_how > NFS_FILE_SYNC)
1453		return nfserr_bad_xdr;
1454	if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0)
1455		return nfserr_bad_xdr;
1456	if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen))
1457		return nfserr_bad_xdr;
1458
1459	write->wr_bytes_written = 0;
1460	write->wr_how_written = 0;
1461	memset(&write->wr_verifier, 0, sizeof(write->wr_verifier));
1462	return nfs_ok;
1463}
 
 
 
 
 
 
 
 
1464
1465static __be32
1466nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp,
1467			       union nfsd4_op_u *u)
1468{
1469	struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;
1470	__be32 status;
1471
1472	if (argp->minorversion >= 1)
1473		return nfserr_notsupp;
1474
1475	status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid,
1476					   &rlockowner->rl_owner);
1477	if (status)
1478		return status;
1479
1480	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
1481		return nfserr_inval;
 
1482
1483	return nfs_ok;
1484}
1485
1486static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp,
1487					   union nfsd4_op_u *u)
1488{
1489	struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;
1490	memset(bc, 0, sizeof(*bc));
1491	if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0)
1492		return nfserr_bad_xdr;
1493	return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);
1494}
1495
1496static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp,
1497						union nfsd4_op_u *u)
1498{
1499	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
1500	u32 use_conn_in_rdma_mode;
1501	__be32 status;
1502
1503	memset(bcts, 0, sizeof(*bcts));
1504	status = nfsd4_decode_sessionid4(argp, &bcts->sessionid);
1505	if (status)
1506		return status;
1507	if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0)
1508		return nfserr_bad_xdr;
1509	if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0)
1510		return nfserr_bad_xdr;
1511
1512	return nfs_ok;
 
 
1513}
1514
1515static __be32
1516nfsd4_decode_state_protect_ops(struct nfsd4_compoundargs *argp,
1517			       struct nfsd4_exchange_id *exid)
1518{
1519	__be32 status;
 
1520
1521	status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce,
1522				      ARRAY_SIZE(exid->spo_must_enforce));
1523	if (status)
1524		return nfserr_bad_xdr;
1525	status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow,
1526				      ARRAY_SIZE(exid->spo_must_allow));
1527	if (status)
1528		return nfserr_bad_xdr;
1529
1530	return nfs_ok;
1531}
1532
1533/*
1534 * This implementation currently does not support SP4_SSV.
1535 * This decoder simply skips over these arguments.
1536 */
1537static noinline __be32
1538nfsd4_decode_ssv_sp_parms(struct nfsd4_compoundargs *argp,
1539			  struct nfsd4_exchange_id *exid)
1540{
1541	u32 count, window, num_gss_handles;
1542	__be32 status;
1543
1544	/* ssp_ops */
1545	status = nfsd4_decode_state_protect_ops(argp, exid);
1546	if (status)
1547		return status;
1548
1549	/* ssp_hash_algs<> */
1550	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1551		return nfserr_bad_xdr;
1552	while (count--) {
1553		status = nfsd4_decode_ignored_string(argp, 0);
1554		if (status)
1555			return status;
1556	}
1557
1558	/* ssp_encr_algs<> */
1559	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1560		return nfserr_bad_xdr;
1561	while (count--) {
1562		status = nfsd4_decode_ignored_string(argp, 0);
1563		if (status)
1564			return status;
1565	}
1566
1567	if (xdr_stream_decode_u32(argp->xdr, &window) < 0)
1568		return nfserr_bad_xdr;
1569	if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0)
1570		return nfserr_bad_xdr;
1571
1572	return nfs_ok;
1573}
1574
1575static __be32
1576nfsd4_decode_state_protect4_a(struct nfsd4_compoundargs *argp,
1577			      struct nfsd4_exchange_id *exid)
1578{
1579	__be32 status;
1580
1581	if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0)
1582		return nfserr_bad_xdr;
 
1583	switch (exid->spa_how) {
1584	case SP4_NONE:
1585		break;
1586	case SP4_MACH_CRED:
1587		status = nfsd4_decode_state_protect_ops(argp, exid);
 
 
1588		if (status)
1589			return status;
1590		break;
1591	case SP4_SSV:
1592		status = nfsd4_decode_ssv_sp_parms(argp, exid);
1593		if (status)
1594			return status;
1595		break;
1596	default:
1597		return nfserr_bad_xdr;
1598	}
1599
1600	return nfs_ok;
1601}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1602
1603static __be32
1604nfsd4_decode_nfs_impl_id4(struct nfsd4_compoundargs *argp,
1605			  struct nfsd4_exchange_id *exid)
1606{
1607	__be32 status;
1608	u32 count;
 
 
 
1609
1610	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1611		return nfserr_bad_xdr;
1612	switch (count) {
1613	case 0:
1614		break;
1615	case 1:
1616		/* Note that RFC 8881 places no length limit on
1617		 * nii_domain, but this implementation permits no
1618		 * more than NFS4_OPAQUE_LIMIT bytes */
1619		status = nfsd4_decode_opaque(argp, &exid->nii_domain);
1620		if (status)
1621			return status;
1622		/* Note that RFC 8881 places no length limit on
1623		 * nii_name, but this implementation permits no
1624		 * more than NFS4_OPAQUE_LIMIT bytes */
1625		status = nfsd4_decode_opaque(argp, &exid->nii_name);
1626		if (status)
1627			return status;
1628		status = nfsd4_decode_nfstime4(argp, &exid->nii_time);
1629		if (status)
1630			return status;
1631		break;
1632	default:
1633		return nfserr_bad_xdr;
1634	}
1635
1636	return nfs_ok;
1637}
1638
1639static __be32
1640nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
1641			 union nfsd4_op_u *u)
1642{
1643	struct nfsd4_exchange_id *exid = &u->exchange_id;
1644	__be32 status;
1645
1646	memset(exid, 0, sizeof(*exid));
1647	status = nfsd4_decode_verifier4(argp, &exid->verifier);
1648	if (status)
1649		return status;
1650	status = nfsd4_decode_opaque(argp, &exid->clname);
1651	if (status)
1652		return status;
1653	if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0)
1654		return nfserr_bad_xdr;
1655	status = nfsd4_decode_state_protect4_a(argp, exid);
1656	if (status)
1657		return status;
1658	return nfsd4_decode_nfs_impl_id4(argp, exid);
1659}
1660
1661static __be32
1662nfsd4_decode_channel_attrs4(struct nfsd4_compoundargs *argp,
1663			    struct nfsd4_channel_attrs *ca)
1664{
1665	__be32 *p;
1666
1667	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7);
1668	if (!p)
1669		return nfserr_bad_xdr;
1670
1671	/* headerpadsz is ignored */
1672	p++;
1673	ca->maxreq_sz = be32_to_cpup(p++);
1674	ca->maxresp_sz = be32_to_cpup(p++);
1675	ca->maxresp_cached = be32_to_cpup(p++);
1676	ca->maxops = be32_to_cpup(p++);
1677	ca->maxreqs = be32_to_cpup(p++);
1678	ca->nr_rdma_attrs = be32_to_cpup(p);
1679	switch (ca->nr_rdma_attrs) {
1680	case 0:
1681		break;
1682	case 1:
1683		if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0)
1684			return nfserr_bad_xdr;
1685		break;
1686	default:
1687		return nfserr_bad_xdr;
1688	}
1689
1690	return nfs_ok;
1691}
1692
1693static __be32
1694nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
1695			    union nfsd4_op_u *u)
1696{
1697	struct nfsd4_create_session *sess = &u->create_session;
1698	__be32 status;
1699
1700	memset(sess, 0, sizeof(*sess));
1701	status = nfsd4_decode_clientid4(argp, &sess->clientid);
1702	if (status)
1703		return status;
1704	if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0)
1705		return nfserr_bad_xdr;
1706	if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0)
1707		return nfserr_bad_xdr;
1708	status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel);
1709	if (status)
1710		return status;
1711	status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel);
1712	if (status)
1713		return status;
1714	if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0)
1715		return nfserr_bad_xdr;
1716	return nfsd4_decode_cb_sec(argp, &sess->cb_sec);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1717}
1718
1719static __be32
1720nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
1721			     union nfsd4_op_u *u)
1722{
1723	struct nfsd4_destroy_session *destroy_session = &u->destroy_session;
1724	return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid);
1725}
1726
1727static __be32
1728nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
1729			  union nfsd4_op_u *u)
1730{
1731	struct nfsd4_free_stateid *free_stateid = &u->free_stateid;
1732	return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid);
1733}
1734
1735#ifdef CONFIG_NFSD_PNFS
1736static __be32
1737nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp,
1738		union nfsd4_op_u *u)
1739{
1740	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;
1741	__be32 status;
1742
1743	memset(gdev, 0, sizeof(*gdev));
1744	status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid);
1745	if (status)
1746		return status;
1747	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0)
1748		return nfserr_bad_xdr;
1749	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0)
1750		return nfserr_bad_xdr;
1751	if (xdr_stream_decode_uint32_array(argp->xdr,
1752					   &gdev->gd_notify_types, 1) < 0)
1753		return nfserr_bad_xdr;
1754
1755	return nfs_ok;
1756}
1757
1758static __be32
1759nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp,
1760			  union nfsd4_op_u *u)
1761{
1762	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
1763	__be32 *p, status;
 
1764
1765	memset(lcp, 0, sizeof(*lcp));
1766	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0)
1767		return nfserr_bad_xdr;
1768	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0)
1769		return nfserr_bad_xdr;
1770	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0)
1771		return nfserr_bad_xdr;
1772	status = nfsd4_decode_stateid4(argp, &lcp->lc_sid);
1773	if (status)
1774		return status;
1775	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0)
1776		return nfserr_bad_xdr;
1777	if (lcp->lc_newoffset) {
1778		if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0)
1779			return nfserr_bad_xdr;
1780	} else
1781		lcp->lc_last_wr = 0;
1782	p = xdr_inline_decode(argp->xdr, XDR_UNIT);
1783	if (!p)
1784		return nfserr_bad_xdr;
1785	if (xdr_item_is_present(p)) {
1786		status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime);
1787		if (status)
1788			return status;
1789	} else {
1790		lcp->lc_mtime.tv_nsec = UTIME_NOW;
1791	}
1792	return nfsd4_decode_layoutupdate4(argp, lcp);
1793}
1794
1795static __be32
1796nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp,
1797		union nfsd4_op_u *u)
1798{
1799	struct nfsd4_layoutget *lgp = &u->layoutget;
1800	__be32 status;
1801
1802	memset(lgp, 0, sizeof(*lgp));
1803	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0)
1804		return nfserr_bad_xdr;
1805	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0)
1806		return nfserr_bad_xdr;
1807	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0)
1808		return nfserr_bad_xdr;
1809	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0)
1810		return nfserr_bad_xdr;
1811	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0)
1812		return nfserr_bad_xdr;
1813	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0)
1814		return nfserr_bad_xdr;
1815	status = nfsd4_decode_stateid4(argp, &lgp->lg_sid);
1816	if (status)
1817		return status;
1818	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0)
1819		return nfserr_bad_xdr;
1820
1821	return nfs_ok;
1822}
1823
1824static __be32
1825nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp,
1826		union nfsd4_op_u *u)
1827{
1828	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
1829	memset(lrp, 0, sizeof(*lrp));
1830	if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0)
1831		return nfserr_bad_xdr;
1832	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0)
1833		return nfserr_bad_xdr;
1834	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0)
1835		return nfserr_bad_xdr;
1836	return nfsd4_decode_layoutreturn4(argp, lrp);
1837}
1838#endif /* CONFIG_NFSD_PNFS */
1839
1840static __be32 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
1841					   union nfsd4_op_u *u)
1842{
1843	struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name;
1844	if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0)
1845		return nfserr_bad_xdr;
1846
1847	sin->sin_exp = NULL;
1848	return nfs_ok;
1849}
1850
1851static __be32
1852nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
1853		      union nfsd4_op_u *u)
1854{
1855	struct nfsd4_sequence *seq = &u->sequence;
1856	__be32 *p, status;
1857
1858	status = nfsd4_decode_sessionid4(argp, &seq->sessionid);
1859	if (status)
1860		return status;
1861	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4);
1862	if (!p)
1863		return nfserr_bad_xdr;
1864	seq->seqid = be32_to_cpup(p++);
1865	seq->slotid = be32_to_cpup(p++);
1866	seq->maxslots = be32_to_cpup(p++);
1867	seq->cachethis = be32_to_cpup(p);
1868
1869	seq->status_flags = 0;
1870	return nfs_ok;
1871}
1872
1873static __be32
1874nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp,
1875			  union nfsd4_op_u *u)
1876{
1877	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;
 
1878	struct nfsd4_test_stateid_id *stateid;
1879	__be32 status;
1880	u32 i;
1881
1882	memset(test_stateid, 0, sizeof(*test_stateid));
1883	if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0)
1884		return nfserr_bad_xdr;
1885
1886	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
 
1887	for (i = 0; i < test_stateid->ts_num_ids; i++) {
1888		stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
1889		if (!stateid)
1890			return nfserr_jukebox;
 
 
 
1891		INIT_LIST_HEAD(&stateid->ts_id_list);
1892		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);
1893		status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid);
 
1894		if (status)
1895			return status;
1896	}
1897
1898	return nfs_ok;
 
 
 
 
 
 
1899}
1900
1901static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp,
1902					    union nfsd4_op_u *u)
1903{
1904	struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;
1905	return nfsd4_decode_clientid4(argp, &dc->clientid);
1906}
1907
1908static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp,
1909					    union nfsd4_op_u *u)
1910{
1911	struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;
1912	if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0)
1913		return nfserr_bad_xdr;
1914	return nfs_ok;
1915}
1916
1917static __be32
1918nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp,
1919		       union nfsd4_op_u *u)
1920{
1921	struct nfsd4_fallocate *fallocate = &u->allocate;
1922	__be32 status;
1923
1924	status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid);
1925	if (status)
1926		return status;
1927	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0)
1928		return nfserr_bad_xdr;
1929	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0)
1930		return nfserr_bad_xdr;
1931
1932	return nfs_ok;
1933}
1934
1935static __be32 nfsd4_decode_nl4_server(struct nfsd4_compoundargs *argp,
1936				      struct nl4_server *ns)
1937{
1938	struct nfs42_netaddr *naddr;
1939	__be32 *p;
1940
1941	if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0)
1942		return nfserr_bad_xdr;
1943
1944	/* currently support for 1 inter-server source server */
1945	switch (ns->nl4_type) {
1946	case NL4_NETADDR:
1947		naddr = &ns->u.nl4_addr;
1948
1949		if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0)
1950			return nfserr_bad_xdr;
1951		if (naddr->netid_len > RPCBIND_MAXNETIDLEN)
1952			return nfserr_bad_xdr;
1953
1954		p = xdr_inline_decode(argp->xdr, naddr->netid_len);
1955		if (!p)
1956			return nfserr_bad_xdr;
1957		memcpy(naddr->netid, p, naddr->netid_len);
1958
1959		if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0)
1960			return nfserr_bad_xdr;
1961		if (naddr->addr_len > RPCBIND_MAXUADDRLEN)
1962			return nfserr_bad_xdr;
1963
1964		p = xdr_inline_decode(argp->xdr, naddr->addr_len);
1965		if (!p)
1966			return nfserr_bad_xdr;
1967		memcpy(naddr->addr, p, naddr->addr_len);
1968		break;
1969	default:
1970		return nfserr_bad_xdr;
1971	}
1972
1973	return nfs_ok;
1974}
1975
 
1976static __be32
1977nfsd4_decode_copy(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 
1978{
1979	struct nfsd4_copy *copy = &u->copy;
1980	u32 consecutive, i, count, sync;
1981	struct nl4_server *ns_dummy;
1982	__be32 status;
1983
1984	memset(copy, 0, sizeof(*copy));
1985	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);
1986	if (status)
1987		return status;
1988	status = nfsd4_decode_stateid4(argp, &copy->cp_dst_stateid);
1989	if (status)
1990		return status;
1991	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_src_pos) < 0)
1992		return nfserr_bad_xdr;
1993	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_dst_pos) < 0)
1994		return nfserr_bad_xdr;
1995	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_count) < 0)
1996		return nfserr_bad_xdr;
1997	/* ca_consecutive: we always do consecutive copies */
1998	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)
1999		return nfserr_bad_xdr;
2000	if (xdr_stream_decode_bool(argp->xdr, &sync) < 0)
2001		return nfserr_bad_xdr;
2002	nfsd4_copy_set_sync(copy, sync);
2003
2004	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
2005		return nfserr_bad_xdr;
2006	copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src));
2007	if (copy->cp_src == NULL)
2008		return nfserr_jukebox;
2009	if (count == 0) { /* intra-server copy */
2010		__set_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
2011		return nfs_ok;
2012	}
2013
2014	/* decode all the supplied server addresses but use only the first */
2015	status = nfsd4_decode_nl4_server(argp, copy->cp_src);
2016	if (status)
2017		return status;
2018
2019	ns_dummy = kmalloc(sizeof(struct nl4_server), GFP_KERNEL);
2020	if (ns_dummy == NULL)
2021		return nfserr_jukebox;
2022	for (i = 0; i < count - 1; i++) {
2023		status = nfsd4_decode_nl4_server(argp, ns_dummy);
2024		if (status) {
2025			kfree(ns_dummy);
2026			return status;
2027		}
2028	}
2029	kfree(ns_dummy);
2030
2031	return nfs_ok;
2032}
2033
2034static __be32
2035nfsd4_decode_copy_notify(struct nfsd4_compoundargs *argp,
2036			 union nfsd4_op_u *u)
2037{
2038	struct nfsd4_copy_notify *cn = &u->copy_notify;
2039	__be32 status;
2040
2041	memset(cn, 0, sizeof(*cn));
2042	cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src));
2043	if (cn->cpn_src == NULL)
2044		return nfserr_jukebox;
2045	cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst));
2046	if (cn->cpn_dst == NULL)
2047		return nfserr_jukebox;
2048
2049	status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid);
2050	if (status)
2051		return status;
2052	return nfsd4_decode_nl4_server(argp, cn->cpn_dst);
2053}
2054
2055static __be32
2056nfsd4_decode_offload_status(struct nfsd4_compoundargs *argp,
2057			    union nfsd4_op_u *u)
2058{
2059	struct nfsd4_offload_status *os = &u->offload_status;
2060	os->count = 0;
2061	os->status = 0;
2062	return nfsd4_decode_stateid4(argp, &os->stateid);
2063}
2064
2065static __be32
2066nfsd4_decode_seek(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
 
2067{
2068	struct nfsd4_seek *seek = &u->seek;
2069	__be32 status;
2070
2071	status = nfsd4_decode_stateid4(argp, &seek->seek_stateid);
 
 
 
 
 
2072	if (status)
2073		return status;
2074	if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0)
2075		return nfserr_bad_xdr;
2076	if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0)
2077		return nfserr_bad_xdr;
2078
2079	seek->seek_eof = 0;
2080	seek->seek_pos = 0;
2081	return nfs_ok;
2082}
2083
2084static __be32
2085nfsd4_decode_clone(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
2086{
2087	struct nfsd4_clone *clone = &u->clone;
2088	__be32 status;
 
 
 
 
 
 
 
 
2089
2090	status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid);
2091	if (status)
2092		return status;
2093	status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid);
2094	if (status)
2095		return status;
2096	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0)
2097		return nfserr_bad_xdr;
2098	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0)
2099		return nfserr_bad_xdr;
2100	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0)
2101		return nfserr_bad_xdr;
2102
2103	return nfs_ok;
2104}
2105
2106/*
2107 * XDR data that is more than PAGE_SIZE in size is normally part of a
2108 * read or write. However, the size of extended attributes is limited
2109 * by the maximum request size, and then further limited by the underlying
2110 * filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX
2111 * is 64k). Since there is no kvec- or page-based interface to xattrs,
2112 * and we're not dealing with contiguous pages, we need to do some copying.
2113 */
2114
2115/*
2116 * Decode data into buffer.
2117 */
2118static __be32
2119nfsd4_vbuf_from_vector(struct nfsd4_compoundargs *argp, struct xdr_buf *xdr,
2120		       char **bufp, u32 buflen)
2121{
2122	struct page **pages = xdr->pages;
2123	struct kvec *head = xdr->head;
2124	char *tmp, *dp;
2125	u32 len;
2126
2127	if (buflen <= head->iov_len) {
2128		/*
2129		 * We're in luck, the head has enough space. Just return
2130		 * the head, no need for copying.
2131		 */
2132		*bufp = head->iov_base;
2133		return 0;
2134	}
2135
2136	tmp = svcxdr_tmpalloc(argp, buflen);
2137	if (tmp == NULL)
2138		return nfserr_jukebox;
2139
2140	dp = tmp;
2141	memcpy(dp, head->iov_base, head->iov_len);
2142	buflen -= head->iov_len;
2143	dp += head->iov_len;
2144
2145	while (buflen > 0) {
2146		len = min_t(u32, buflen, PAGE_SIZE);
2147		memcpy(dp, page_address(*pages), len);
2148
2149		buflen -= len;
2150		dp += len;
2151		pages++;
 
 
 
 
 
 
2152	}
2153
2154	*bufp = tmp;
2155	return 0;
2156}
 
2157
2158/*
2159 * Get a user extended attribute name from the XDR buffer.
2160 * It will not have the "user." prefix, so prepend it.
2161 * Lastly, check for nul characters in the name.
2162 */
2163static __be32
2164nfsd4_decode_xattr_name(struct nfsd4_compoundargs *argp, char **namep)
 
2165{
2166	char *name, *sp, *dp;
2167	u32 namelen, cnt;
2168	__be32 *p;
2169
2170	if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0)
2171		return nfserr_bad_xdr;
2172	if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))
2173		return nfserr_nametoolong;
2174	if (namelen == 0)
2175		return nfserr_bad_xdr;
2176	p = xdr_inline_decode(argp->xdr, namelen);
2177	if (!p)
2178		return nfserr_bad_xdr;
2179	name = svcxdr_tmpalloc(argp, namelen + XATTR_USER_PREFIX_LEN + 1);
2180	if (!name)
2181		return nfserr_jukebox;
2182	memcpy(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
2183
2184	/*
2185	 * Copy the extended attribute name over while checking for 0
2186	 * characters.
2187	 */
2188	sp = (char *)p;
2189	dp = name + XATTR_USER_PREFIX_LEN;
2190	cnt = namelen;
2191
2192	while (cnt-- > 0) {
2193		if (*sp == '\0')
2194			return nfserr_bad_xdr;
2195		*dp++ = *sp++;
2196	}
2197	*dp = '\0';
2198
2199	*namep = name;
 
 
2200
2201	return nfs_ok;
2202}
2203
2204/*
2205 * A GETXATTR op request comes without a length specifier. We just set the
2206 * maximum length for the reply based on XATTR_SIZE_MAX and the maximum
2207 * channel reply size. nfsd_getxattr will probe the length of the xattr,
2208 * check it against getxa_len, and allocate + return the value.
2209 */
2210static __be32
2211nfsd4_decode_getxattr(struct nfsd4_compoundargs *argp,
2212		      union nfsd4_op_u *u)
2213{
2214	struct nfsd4_getxattr *getxattr = &u->getxattr;
2215	__be32 status;
2216	u32 maxcount;
2217
2218	memset(getxattr, 0, sizeof(*getxattr));
2219	status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);
 
 
2220	if (status)
2221		return status;
2222
2223	maxcount = svc_max_payload(argp->rqstp);
2224	maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
2225
2226	getxattr->getxa_len = maxcount;
2227	return nfs_ok;
2228}
2229
2230static __be32
2231nfsd4_decode_setxattr(struct nfsd4_compoundargs *argp,
2232		      union nfsd4_op_u *u)
2233{
2234	struct nfsd4_setxattr *setxattr = &u->setxattr;
2235	u32 flags, maxcount, size;
2236	__be32 status;
2237
2238	memset(setxattr, 0, sizeof(*setxattr));
2239
2240	if (xdr_stream_decode_u32(argp->xdr, &flags) < 0)
2241		return nfserr_bad_xdr;
2242
2243	if (flags > SETXATTR4_REPLACE)
2244		return nfserr_inval;
2245	setxattr->setxa_flags = flags;
2246
2247	status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);
 
 
 
2248	if (status)
2249		return status;
2250
2251	maxcount = svc_max_payload(argp->rqstp);
2252	maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
 
 
 
 
 
2253
2254	if (xdr_stream_decode_u32(argp->xdr, &size) < 0)
2255		return nfserr_bad_xdr;
2256	if (size > maxcount)
2257		return nfserr_xattr2big;
2258
2259	setxattr->setxa_len = size;
2260	if (size > 0) {
2261		struct xdr_buf payload;
2262
2263		if (!xdr_stream_subsegment(argp->xdr, &payload, size))
2264			return nfserr_bad_xdr;
2265		status = nfsd4_vbuf_from_vector(argp, &payload,
2266						&setxattr->setxa_buf, size);
2267	}
2268
2269	return nfs_ok;
2270}
2271
2272static __be32
2273nfsd4_decode_listxattrs(struct nfsd4_compoundargs *argp,
2274			union nfsd4_op_u *u)
2275{
2276	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;
2277	u32 maxcount;
2278
2279	memset(listxattrs, 0, sizeof(*listxattrs));
2280
2281	if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0)
2282		return nfserr_bad_xdr;
2283
2284	/*
2285	 * If the cookie  is too large to have even one user.x attribute
2286	 * plus trailing '\0' left in a maximum size buffer, it's invalid.
2287	 */
2288	if (listxattrs->lsxa_cookie >=
2289	    (XATTR_LIST_MAX / (XATTR_USER_PREFIX_LEN + 2)))
2290		return nfserr_badcookie;
2291
2292	if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0)
2293		return nfserr_bad_xdr;
2294	if (maxcount < 8)
2295		/* Always need at least 2 words (length and one character) */
2296		return nfserr_inval;
2297
2298	maxcount = min(maxcount, svc_max_payload(argp->rqstp));
2299	listxattrs->lsxa_maxcount = maxcount;
 
2300
2301	return nfs_ok;
2302}
2303
2304static __be32
2305nfsd4_decode_removexattr(struct nfsd4_compoundargs *argp,
2306			 union nfsd4_op_u *u)
2307{
2308	struct nfsd4_removexattr *removexattr = &u->removexattr;
2309	memset(removexattr, 0, sizeof(*removexattr));
2310	return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);
2311}
2312
2313static __be32
2314nfsd4_decode_noop(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p)
2315{
2316	return nfs_ok;
2317}
2318
2319static __be32
2320nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, union nfsd4_op_u *p)
2321{
2322	return nfserr_notsupp;
2323}
2324
2325typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u);
2326
2327static const nfsd4_dec nfsd4_dec_ops[] = {
2328	[OP_ACCESS]		= nfsd4_decode_access,
2329	[OP_CLOSE]		= nfsd4_decode_close,
2330	[OP_COMMIT]		= nfsd4_decode_commit,
2331	[OP_CREATE]		= nfsd4_decode_create,
2332	[OP_DELEGPURGE]		= nfsd4_decode_notsupp,
2333	[OP_DELEGRETURN]	= nfsd4_decode_delegreturn,
2334	[OP_GETATTR]		= nfsd4_decode_getattr,
2335	[OP_GETFH]		= nfsd4_decode_noop,
2336	[OP_LINK]		= nfsd4_decode_link,
2337	[OP_LOCK]		= nfsd4_decode_lock,
2338	[OP_LOCKT]		= nfsd4_decode_lockt,
2339	[OP_LOCKU]		= nfsd4_decode_locku,
2340	[OP_LOOKUP]		= nfsd4_decode_lookup,
2341	[OP_LOOKUPP]		= nfsd4_decode_noop,
2342	[OP_NVERIFY]		= nfsd4_decode_verify,
2343	[OP_OPEN]		= nfsd4_decode_open,
2344	[OP_OPENATTR]		= nfsd4_decode_notsupp,
2345	[OP_OPEN_CONFIRM]	= nfsd4_decode_open_confirm,
2346	[OP_OPEN_DOWNGRADE]	= nfsd4_decode_open_downgrade,
2347	[OP_PUTFH]		= nfsd4_decode_putfh,
2348	[OP_PUTPUBFH]		= nfsd4_decode_putpubfh,
2349	[OP_PUTROOTFH]		= nfsd4_decode_noop,
2350	[OP_READ]		= nfsd4_decode_read,
2351	[OP_READDIR]		= nfsd4_decode_readdir,
2352	[OP_READLINK]		= nfsd4_decode_noop,
2353	[OP_REMOVE]		= nfsd4_decode_remove,
2354	[OP_RENAME]		= nfsd4_decode_rename,
2355	[OP_RENEW]		= nfsd4_decode_renew,
2356	[OP_RESTOREFH]		= nfsd4_decode_noop,
2357	[OP_SAVEFH]		= nfsd4_decode_noop,
2358	[OP_SECINFO]		= nfsd4_decode_secinfo,
2359	[OP_SETATTR]		= nfsd4_decode_setattr,
2360	[OP_SETCLIENTID]	= nfsd4_decode_setclientid,
2361	[OP_SETCLIENTID_CONFIRM] = nfsd4_decode_setclientid_confirm,
2362	[OP_VERIFY]		= nfsd4_decode_verify,
2363	[OP_WRITE]		= nfsd4_decode_write,
2364	[OP_RELEASE_LOCKOWNER]	= nfsd4_decode_release_lockowner,
2365
2366	/* new operations for NFSv4.1 */
2367	[OP_BACKCHANNEL_CTL]	= nfsd4_decode_backchannel_ctl,
2368	[OP_BIND_CONN_TO_SESSION] = nfsd4_decode_bind_conn_to_session,
2369	[OP_EXCHANGE_ID]	= nfsd4_decode_exchange_id,
2370	[OP_CREATE_SESSION]	= nfsd4_decode_create_session,
2371	[OP_DESTROY_SESSION]	= nfsd4_decode_destroy_session,
2372	[OP_FREE_STATEID]	= nfsd4_decode_free_stateid,
2373	[OP_GET_DIR_DELEGATION]	= nfsd4_decode_notsupp,
2374#ifdef CONFIG_NFSD_PNFS
2375	[OP_GETDEVICEINFO]	= nfsd4_decode_getdeviceinfo,
2376	[OP_GETDEVICELIST]	= nfsd4_decode_notsupp,
2377	[OP_LAYOUTCOMMIT]	= nfsd4_decode_layoutcommit,
2378	[OP_LAYOUTGET]		= nfsd4_decode_layoutget,
2379	[OP_LAYOUTRETURN]	= nfsd4_decode_layoutreturn,
2380#else
2381	[OP_GETDEVICEINFO]	= nfsd4_decode_notsupp,
2382	[OP_GETDEVICELIST]	= nfsd4_decode_notsupp,
2383	[OP_LAYOUTCOMMIT]	= nfsd4_decode_notsupp,
2384	[OP_LAYOUTGET]		= nfsd4_decode_notsupp,
2385	[OP_LAYOUTRETURN]	= nfsd4_decode_notsupp,
2386#endif
2387	[OP_SECINFO_NO_NAME]	= nfsd4_decode_secinfo_no_name,
2388	[OP_SEQUENCE]		= nfsd4_decode_sequence,
2389	[OP_SET_SSV]		= nfsd4_decode_notsupp,
2390	[OP_TEST_STATEID]	= nfsd4_decode_test_stateid,
2391	[OP_WANT_DELEGATION]	= nfsd4_decode_notsupp,
2392	[OP_DESTROY_CLIENTID]	= nfsd4_decode_destroy_clientid,
2393	[OP_RECLAIM_COMPLETE]	= nfsd4_decode_reclaim_complete,
2394
2395	/* new operations for NFSv4.2 */
2396	[OP_ALLOCATE]		= nfsd4_decode_fallocate,
2397	[OP_COPY]		= nfsd4_decode_copy,
2398	[OP_COPY_NOTIFY]	= nfsd4_decode_copy_notify,
2399	[OP_DEALLOCATE]		= nfsd4_decode_fallocate,
2400	[OP_IO_ADVISE]		= nfsd4_decode_notsupp,
2401	[OP_LAYOUTERROR]	= nfsd4_decode_notsupp,
2402	[OP_LAYOUTSTATS]	= nfsd4_decode_notsupp,
2403	[OP_OFFLOAD_CANCEL]	= nfsd4_decode_offload_status,
2404	[OP_OFFLOAD_STATUS]	= nfsd4_decode_offload_status,
2405	[OP_READ_PLUS]		= nfsd4_decode_read,
2406	[OP_SEEK]		= nfsd4_decode_seek,
2407	[OP_WRITE_SAME]		= nfsd4_decode_notsupp,
2408	[OP_CLONE]		= nfsd4_decode_clone,
2409	/* RFC 8276 extended atributes operations */
2410	[OP_GETXATTR]		= nfsd4_decode_getxattr,
2411	[OP_SETXATTR]		= nfsd4_decode_setxattr,
2412	[OP_LISTXATTRS]		= nfsd4_decode_listxattrs,
2413	[OP_REMOVEXATTR]	= nfsd4_decode_removexattr,
2414};
2415
2416static inline bool
2417nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
2418{
2419	if (op->opnum < FIRST_NFS4_OP)
2420		return false;
2421	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
2422		return false;
2423	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
2424		return false;
2425	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
2426		return false;
2427	return true;
2428}
2429
2430static bool
2431nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
2432{
 
2433	struct nfsd4_op *op;
2434	bool cachethis = false;
2435	int auth_slack= argp->rqstp->rq_auth_slack;
2436	int max_reply = auth_slack + 8; /* opcnt, status */
2437	int readcount = 0;
2438	int readbytes = 0;
2439	__be32 *p;
2440	int i;
2441
2442	if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0)
2443		return false;
2444	max_reply += XDR_UNIT;
2445	argp->tag = NULL;
2446	if (unlikely(argp->taglen)) {
2447		if (argp->taglen > NFSD4_MAX_TAGLEN)
2448			return false;
2449		p = xdr_inline_decode(argp->xdr, argp->taglen);
2450		if (!p)
2451			return false;
2452		argp->tag = svcxdr_savemem(argp, p, argp->taglen);
2453		if (!argp->tag)
2454			return false;
2455		max_reply += xdr_align_size(argp->taglen);
2456	}
2457
2458	if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)
2459		return false;
2460	if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0)
2461		return false;
2462	argp->opcnt = min_t(u32, argp->client_opcnt,
2463			    NFSD_MAX_OPS_PER_COMPOUND);
 
 
 
2464
2465	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
2466		argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops));
2467		if (!argp->ops) {
2468			argp->ops = argp->iops;
2469			return false;
 
2470		}
2471	}
2472
2473	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
2474		argp->opcnt = 0;
2475
2476	for (i = 0; i < argp->opcnt; i++) {
2477		op = &argp->ops[i];
2478		op->replay = NULL;
2479		op->opdesc = NULL;
2480
2481		if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)
2482			return false;
2483		if (nfsd4_opnum_in_range(argp, op)) {
2484			op->opdesc = OPDESC(op);
2485			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
2486			if (op->status != nfs_ok)
2487				trace_nfsd_compound_decode_err(argp->rqstp,
2488							       argp->opcnt, i,
2489							       op->opnum,
2490							       op->status);
2491		} else {
2492			op->opnum = OP_ILLEGAL;
2493			op->status = nfserr_op_illegal;
2494		}
2495
2496		/*
2497		 * We'll try to cache the result in the DRC if any one
2498		 * op in the compound wants to be cached:
2499		 */
2500		cachethis |= nfsd4_cache_this_op(op);
2501
2502		if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {
2503			readcount++;
2504			readbytes += nfsd4_max_reply(argp->rqstp, op);
2505		} else
2506			max_reply += nfsd4_max_reply(argp->rqstp, op);
2507		/*
2508		 * OP_LOCK and OP_LOCKT may return a conflicting lock.
2509		 * (Special case because it will just skip encoding this
2510		 * if it runs out of xdr buffer space, and it is the only
2511		 * operation that behaves this way.)
2512		 */
2513		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
2514			max_reply += NFS4_OPAQUE_LIMIT;
2515
2516		if (op->status) {
2517			argp->opcnt = i+1;
2518			break;
2519		}
2520	}
2521	/* Sessions make the DRC unnecessary: */
2522	if (argp->minorversion)
2523		cachethis = false;
2524	svc_reserve(argp->rqstp, max_reply + readbytes);
2525	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
2526
2527	argp->splice_ok = nfsd_read_splice_ok(argp->rqstp);
2528	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
2529		argp->splice_ok = false;
2530
2531	return true;
2532}
2533
2534static __be32 nfsd4_encode_nfs_fh4(struct xdr_stream *xdr,
2535				   struct knfsd_fh *fh_handle)
2536{
2537	return nfsd4_encode_opaque(xdr, fh_handle->fh_raw, fh_handle->fh_size);
2538}
2539
2540/* This is a frequently-encoded type; open-coded for speed */
2541static __be32 nfsd4_encode_nfstime4(struct xdr_stream *xdr,
2542				    const struct timespec64 *tv)
2543{
2544	__be32 *p;
2545
2546	p = xdr_reserve_space(xdr, XDR_UNIT * 3);
2547	if (!p)
2548		return nfserr_resource;
2549	p = xdr_encode_hyper(p, tv->tv_sec);
2550	*p = cpu_to_be32(tv->tv_nsec);
2551	return nfs_ok;
2552}
2553
2554static __be32 nfsd4_encode_specdata4(struct xdr_stream *xdr,
2555				     unsigned int major, unsigned int minor)
2556{
2557	__be32 status;
2558
2559	status = nfsd4_encode_uint32_t(xdr, major);
2560	if (status != nfs_ok)
2561		return status;
2562	return nfsd4_encode_uint32_t(xdr, minor);
2563}
2564
2565static __be32
2566nfsd4_encode_change_info4(struct xdr_stream *xdr, const struct nfsd4_change_info *c)
2567{
2568	__be32 status;
2569
2570	status = nfsd4_encode_bool(xdr, c->atomic);
2571	if (status != nfs_ok)
2572		return status;
2573	status = nfsd4_encode_changeid4(xdr, c->before_change);
2574	if (status != nfs_ok)
2575		return status;
2576	return nfsd4_encode_changeid4(xdr, c->after_change);
2577}
2578
2579static __be32 nfsd4_encode_netaddr4(struct xdr_stream *xdr,
2580				    const struct nfs42_netaddr *addr)
2581{
2582	__be32 status;
2583
2584	/* na_r_netid */
2585	status = nfsd4_encode_opaque(xdr, addr->netid, addr->netid_len);
2586	if (status != nfs_ok)
2587		return status;
2588	/* na_r_addr */
2589	return nfsd4_encode_opaque(xdr, addr->addr, addr->addr_len);
 
 
 
2590}
2591
2592/* Encode as an array of strings the string given with components
2593 * separated @sep, escaped with esc_enter and esc_exit.
2594 */
2595static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
2596					  char *components, char esc_enter,
2597					  char esc_exit)
2598{
2599	__be32 *p;
2600	__be32 pathlen;
2601	int pathlen_offset;
2602	int strlen, count=0;
2603	char *str, *end, *next;
2604
2605	dprintk("nfsd4_encode_components(%s)\n", components);
2606
2607	pathlen_offset = xdr->buf->len;
2608	p = xdr_reserve_space(xdr, 4);
2609	if (!p)
2610		return nfserr_resource;
2611	p++; /* We will fill this in with @count later */
2612
2613	end = str = components;
2614	while (*end) {
2615		bool found_esc = false;
2616
2617		/* try to parse as esc_start, ..., esc_end, sep */
2618		if (*str == esc_enter) {
2619			for (; *end && (*end != esc_exit); end++)
2620				/* find esc_exit or end of string */;
2621			next = end + 1;
2622			if (*end && (!*next || *next == sep)) {
2623				str++;
2624				found_esc = true;
2625			}
2626		}
2627
2628		if (!found_esc)
2629			for (; *end && (*end != sep); end++)
2630				/* find sep or end of string */;
2631
2632		strlen = end - str;
2633		if (strlen) {
2634			p = xdr_reserve_space(xdr, strlen + 4);
2635			if (!p)
2636				return nfserr_resource;
2637			p = xdr_encode_opaque(p, str, strlen);
2638			count++;
2639		}
2640		else
2641			end++;
2642		if (found_esc)
2643			end = next;
2644
2645		str = end;
2646	}
2647	pathlen = htonl(count);
2648	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
2649	return 0;
2650}
2651
2652/* Encode as an array of strings the string given with components
2653 * separated @sep.
2654 */
2655static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
2656				      char *components)
2657{
2658	return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
2659}
2660
 
 
 
2661static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
2662					struct nfsd4_fs_location *location)
2663{
2664	__be32 status;
2665
2666	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
2667						'[', ']');
2668	if (status)
2669		return status;
2670	status = nfsd4_encode_components(xdr, '/', location->path);
2671	if (status)
2672		return status;
2673	return nfs_ok;
2674}
2675
2676static __be32 nfsd4_encode_pathname4(struct xdr_stream *xdr,
2677				     const struct path *root,
2678				     const struct path *path)
 
 
 
2679{
2680	struct path cur = *path;
2681	__be32 *p;
2682	struct dentry **components = NULL;
2683	unsigned int ncomponents = 0;
2684	__be32 err = nfserr_jukebox;
2685
2686	dprintk("nfsd4_encode_components(");
2687
2688	path_get(&cur);
2689	/* First walk the path up to the nfsd root, and store the
2690	 * dentries/path components in an array.
2691	 */
2692	for (;;) {
2693		if (path_equal(&cur, root))
2694			break;
2695		if (cur.dentry == cur.mnt->mnt_root) {
2696			if (follow_up(&cur))
2697				continue;
2698			goto out_free;
2699		}
2700		if ((ncomponents & 15) == 0) {
2701			struct dentry **new;
2702			new = krealloc(components,
2703					sizeof(*new) * (ncomponents + 16),
2704					GFP_KERNEL);
2705			if (!new)
2706				goto out_free;
2707			components = new;
2708		}
2709		components[ncomponents++] = cur.dentry;
2710		cur.dentry = dget_parent(cur.dentry);
2711	}
2712	err = nfserr_resource;
2713	p = xdr_reserve_space(xdr, 4);
2714	if (!p)
2715		goto out_free;
2716	*p++ = cpu_to_be32(ncomponents);
2717
2718	while (ncomponents) {
2719		struct dentry *dentry = components[ncomponents - 1];
2720		unsigned int len;
2721
2722		spin_lock(&dentry->d_lock);
2723		len = dentry->d_name.len;
2724		p = xdr_reserve_space(xdr, len + 4);
2725		if (!p) {
2726			spin_unlock(&dentry->d_lock);
2727			goto out_free;
2728		}
2729		p = xdr_encode_opaque(p, dentry->d_name.name, len);
2730		dprintk("/%pd", dentry);
2731		spin_unlock(&dentry->d_lock);
2732		dput(dentry);
2733		ncomponents--;
2734	}
2735
2736	err = 0;
2737out_free:
2738	dprintk(")\n");
2739	while (ncomponents)
2740		dput(components[--ncomponents]);
2741	kfree(components);
2742	path_put(&cur);
2743	return err;
2744}
2745
2746static __be32 nfsd4_encode_fs_locations4(struct xdr_stream *xdr,
2747					 struct svc_rqst *rqstp,
2748					 struct svc_export *exp)
2749{
2750	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
2751	struct svc_export *exp_ps;
2752	unsigned int i;
2753	__be32 status;
2754
2755	/* fs_root */
2756	exp_ps = rqst_find_fsidzero_export(rqstp);
2757	if (IS_ERR(exp_ps))
2758		return nfserrno(PTR_ERR(exp_ps));
2759	status = nfsd4_encode_pathname4(xdr, &exp_ps->ex_path, &exp->ex_path);
2760	exp_put(exp_ps);
2761	if (status != nfs_ok)
2762		return status;
2763
2764	/* locations<> */
2765	if (xdr_stream_encode_u32(xdr, fslocs->locations_count) != XDR_UNIT)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2766		return nfserr_resource;
2767	for (i = 0; i < fslocs->locations_count; i++) {
 
2768		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2769		if (status != nfs_ok)
2770			return status;
2771	}
2772
2773	return nfs_ok;
2774}
2775
2776static __be32 nfsd4_encode_nfsace4(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2777				   struct nfs4_ace *ace)
2778{
2779	__be32 status;
 
 
 
 
 
 
 
 
 
 
2780
2781	/* type */
2782	status = nfsd4_encode_acetype4(xdr, ace->type);
2783	if (status != nfs_ok)
2784		return nfserr_resource;
2785	/* flag */
2786	status = nfsd4_encode_aceflag4(xdr, ace->flag);
2787	if (status != nfs_ok)
2788		return nfserr_resource;
2789	/* access mask */
2790	status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL);
2791	if (status != nfs_ok)
2792		return nfserr_resource;
2793	/* who */
2794	if (ace->whotype != NFS4_ACL_WHO_NAMED)
2795		return nfs4_acl_write_who(xdr, ace->whotype);
2796	if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2797		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2798	return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2799}
2800
2801#define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2802			      FATTR4_WORD0_RDATTR_ERROR)
2803#define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2804#define WORD2_ABSENT_FS_ATTRS 0
2805
2806#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2807static inline __be32
2808nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2809			    void *context, int len)
2810{
2811	__be32 *p;
2812
2813	p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
2814	if (!p)
2815		return nfserr_resource;
2816
2817	/*
2818	 * For now we use a 0 here to indicate the null translation; in
2819	 * the future we may place a call to translation code here.
2820	 */
2821	*p++ = cpu_to_be32(0); /* lfs */
2822	*p++ = cpu_to_be32(0); /* pi */
2823	p = xdr_encode_opaque(p, context, len);
2824	return 0;
2825}
2826#else
2827static inline __be32
2828nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2829			    void *context, int len)
2830{ return 0; }
2831#endif
2832
2833static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
2834{
2835	/* As per referral draft:  */
2836	if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
2837	    *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
2838		if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
2839	            *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
2840			*rdattr_err = NFSERR_MOVED;
2841		else
2842			return nfserr_moved;
2843	}
2844	*bmval0 &= WORD0_ABSENT_FS_ATTRS;
2845	*bmval1 &= WORD1_ABSENT_FS_ATTRS;
2846	*bmval2 &= WORD2_ABSENT_FS_ATTRS;
2847	return 0;
2848}
2849
2850
2851static int nfsd4_get_mounted_on_ino(struct svc_export *exp, u64 *pino)
2852{
2853	struct path path = exp->ex_path;
2854	struct kstat stat;
2855	int err;
2856
2857	path_get(&path);
2858	while (follow_up(&path)) {
2859		if (path.dentry != path.mnt->mnt_root)
2860			break;
2861	}
2862	err = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT);
2863	path_put(&path);
2864	if (!err)
2865		*pino = stat.ino;
2866	return err;
2867}
2868
2869static __be32
2870nfsd4_encode_bitmap4(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
2871{
2872	__be32 *p;
2873
2874	if (bmval2) {
2875		p = xdr_reserve_space(xdr, XDR_UNIT * 4);
2876		if (!p)
2877			goto out_resource;
2878		*p++ = cpu_to_be32(3);
2879		*p++ = cpu_to_be32(bmval0);
2880		*p++ = cpu_to_be32(bmval1);
2881		*p++ = cpu_to_be32(bmval2);
2882	} else if (bmval1) {
2883		p = xdr_reserve_space(xdr, XDR_UNIT * 3);
2884		if (!p)
2885			goto out_resource;
2886		*p++ = cpu_to_be32(2);
2887		*p++ = cpu_to_be32(bmval0);
2888		*p++ = cpu_to_be32(bmval1);
2889	} else {
2890		p = xdr_reserve_space(xdr, XDR_UNIT * 2);
2891		if (!p)
2892			goto out_resource;
2893		*p++ = cpu_to_be32(1);
2894		*p++ = cpu_to_be32(bmval0);
2895	}
2896
2897	return nfs_ok;
2898out_resource:
2899	return nfserr_resource;
2900}
2901
2902struct nfsd4_fattr_args {
2903	struct svc_rqst		*rqstp;
2904	struct svc_fh		*fhp;
2905	struct svc_export	*exp;
2906	struct dentry		*dentry;
2907	struct kstat		stat;
2908	struct kstatfs		statfs;
2909	struct nfs4_acl		*acl;
2910	u64			size;
2911#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2912	void			*context;
2913	int			contextlen;
2914#endif
2915	u32			rdattr_err;
2916	bool			contextsupport;
2917	bool			ignore_crossmnt;
2918};
2919
2920typedef __be32(*nfsd4_enc_attr)(struct xdr_stream *xdr,
2921				const struct nfsd4_fattr_args *args);
2922
2923static __be32 nfsd4_encode_fattr4__noop(struct xdr_stream *xdr,
2924					const struct nfsd4_fattr_args *args)
2925{
2926	return nfs_ok;
2927}
2928
2929static __be32 nfsd4_encode_fattr4__true(struct xdr_stream *xdr,
2930					const struct nfsd4_fattr_args *args)
2931{
2932	return nfsd4_encode_bool(xdr, true);
2933}
2934
2935static __be32 nfsd4_encode_fattr4__false(struct xdr_stream *xdr,
2936					 const struct nfsd4_fattr_args *args)
2937{
2938	return nfsd4_encode_bool(xdr, false);
2939}
2940
2941static __be32 nfsd4_encode_fattr4_supported_attrs(struct xdr_stream *xdr,
2942						  const struct nfsd4_fattr_args *args)
2943{
2944	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;
2945	u32 minorversion = resp->cstate.minorversion;
2946	u32 supp[3];
2947
2948	memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2949	if (!IS_POSIXACL(d_inode(args->dentry)))
2950		supp[0] &= ~FATTR4_WORD0_ACL;
2951	if (!args->contextsupport)
2952		supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
2953
2954	return nfsd4_encode_bitmap4(xdr, supp[0], supp[1], supp[2]);
2955}
2956
2957static __be32 nfsd4_encode_fattr4_type(struct xdr_stream *xdr,
2958				       const struct nfsd4_fattr_args *args)
2959{
2960	__be32 *p;
2961
2962	p = xdr_reserve_space(xdr, XDR_UNIT);
2963	if (!p)
2964		return nfserr_resource;
2965
2966	switch (args->stat.mode & S_IFMT) {
2967	case S_IFIFO:
2968		*p = cpu_to_be32(NF4FIFO);
2969		break;
2970	case S_IFCHR:
2971		*p = cpu_to_be32(NF4CHR);
2972		break;
2973	case S_IFDIR:
2974		*p = cpu_to_be32(NF4DIR);
2975		break;
2976	case S_IFBLK:
2977		*p = cpu_to_be32(NF4BLK);
2978		break;
2979	case S_IFLNK:
2980		*p = cpu_to_be32(NF4LNK);
2981		break;
2982	case S_IFREG:
2983		*p = cpu_to_be32(NF4REG);
2984		break;
2985	case S_IFSOCK:
2986		*p = cpu_to_be32(NF4SOCK);
2987		break;
2988	default:
2989		return nfserr_serverfault;
2990	}
2991
2992	return nfs_ok;
2993}
2994
2995static __be32 nfsd4_encode_fattr4_fh_expire_type(struct xdr_stream *xdr,
2996						 const struct nfsd4_fattr_args *args)
2997{
2998	u32 mask;
2999
3000	mask = NFS4_FH_PERSISTENT;
3001	if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK))
3002		mask |= NFS4_FH_VOL_RENAME;
3003	return nfsd4_encode_uint32_t(xdr, mask);
3004}
3005
3006static __be32 nfsd4_encode_fattr4_change(struct xdr_stream *xdr,
3007					 const struct nfsd4_fattr_args *args)
3008{
3009	const struct svc_export *exp = args->exp;
3010	u64 c;
3011
3012	if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) {
3013		u32 flush_time = convert_to_wallclock(exp->cd->flush_time);
3014
3015		if (xdr_stream_encode_u32(xdr, flush_time) != XDR_UNIT)
3016			return nfserr_resource;
3017		if (xdr_stream_encode_u32(xdr, 0) != XDR_UNIT)
3018			return nfserr_resource;
3019		return nfs_ok;
3020	}
3021
3022	c = nfsd4_change_attribute(&args->stat, d_inode(args->dentry));
3023	return nfsd4_encode_changeid4(xdr, c);
3024}
3025
3026static __be32 nfsd4_encode_fattr4_size(struct xdr_stream *xdr,
3027				       const struct nfsd4_fattr_args *args)
3028{
3029	return nfsd4_encode_uint64_t(xdr, args->size);
3030}
3031
3032static __be32 nfsd4_encode_fattr4_fsid(struct xdr_stream *xdr,
3033				       const struct nfsd4_fattr_args *args)
3034{
3035	__be32 *p;
3036
3037	p = xdr_reserve_space(xdr, XDR_UNIT * 2 + XDR_UNIT * 2);
3038	if (!p)
3039		return nfserr_resource;
3040
3041	if (unlikely(args->exp->ex_fslocs.migrated)) {
3042		p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
3043		xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
3044		return nfs_ok;
3045	}
3046	switch (fsid_source(args->fhp)) {
3047	case FSIDSOURCE_FSID:
3048		p = xdr_encode_hyper(p, (u64)args->exp->ex_fsid);
3049		xdr_encode_hyper(p, (u64)0);
3050		break;
3051	case FSIDSOURCE_DEV:
3052		*p++ = xdr_zero;
3053		*p++ = cpu_to_be32(MAJOR(args->stat.dev));
3054		*p++ = xdr_zero;
3055		*p   = cpu_to_be32(MINOR(args->stat.dev));
3056		break;
3057	case FSIDSOURCE_UUID:
3058		xdr_encode_opaque_fixed(p, args->exp->ex_uuid, EX_UUID_LEN);
3059		break;
3060	}
3061
3062	return nfs_ok;
3063}
3064
3065static __be32 nfsd4_encode_fattr4_lease_time(struct xdr_stream *xdr,
3066					     const struct nfsd4_fattr_args *args)
3067{
3068	struct nfsd_net *nn = net_generic(SVC_NET(args->rqstp), nfsd_net_id);
3069
3070	return nfsd4_encode_nfs_lease4(xdr, nn->nfsd4_lease);
3071}
3072
3073static __be32 nfsd4_encode_fattr4_rdattr_error(struct xdr_stream *xdr,
3074					       const struct nfsd4_fattr_args *args)
3075{
3076	return nfsd4_encode_uint32_t(xdr, args->rdattr_err);
3077}
3078
3079static __be32 nfsd4_encode_fattr4_aclsupport(struct xdr_stream *xdr,
3080					     const struct nfsd4_fattr_args *args)
3081{
3082	u32 mask;
3083
3084	mask = 0;
3085	if (IS_POSIXACL(d_inode(args->dentry)))
3086		mask = ACL4_SUPPORT_ALLOW_ACL | ACL4_SUPPORT_DENY_ACL;
3087	return nfsd4_encode_uint32_t(xdr, mask);
3088}
3089
3090static __be32 nfsd4_encode_fattr4_acl(struct xdr_stream *xdr,
3091				      const struct nfsd4_fattr_args *args)
3092{
3093	struct nfs4_acl *acl = args->acl;
3094	struct nfs4_ace *ace;
3095	__be32 status;
3096
3097	/* nfsace4<> */
3098	if (!acl) {
3099		if (xdr_stream_encode_u32(xdr, 0) != XDR_UNIT)
3100			return nfserr_resource;
3101	} else {
3102		if (xdr_stream_encode_u32(xdr, acl->naces) != XDR_UNIT)
3103			return nfserr_resource;
3104		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
3105			status = nfsd4_encode_nfsace4(xdr, args->rqstp, ace);
3106			if (status != nfs_ok)
3107				return status;
3108		}
3109	}
3110	return nfs_ok;
3111}
3112
3113static __be32 nfsd4_encode_fattr4_filehandle(struct xdr_stream *xdr,
3114					     const struct nfsd4_fattr_args *args)
3115{
3116	return nfsd4_encode_nfs_fh4(xdr, &args->fhp->fh_handle);
3117}
3118
3119static __be32 nfsd4_encode_fattr4_fileid(struct xdr_stream *xdr,
3120					 const struct nfsd4_fattr_args *args)
3121{
3122	return nfsd4_encode_uint64_t(xdr, args->stat.ino);
3123}
3124
3125static __be32 nfsd4_encode_fattr4_files_avail(struct xdr_stream *xdr,
3126					      const struct nfsd4_fattr_args *args)
3127{
3128	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);
3129}
3130
3131static __be32 nfsd4_encode_fattr4_files_free(struct xdr_stream *xdr,
3132					     const struct nfsd4_fattr_args *args)
3133{
3134	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);
3135}
3136
3137static __be32 nfsd4_encode_fattr4_files_total(struct xdr_stream *xdr,
3138					      const struct nfsd4_fattr_args *args)
3139{
3140	return nfsd4_encode_uint64_t(xdr, args->statfs.f_files);
3141}
3142
3143static __be32 nfsd4_encode_fattr4_fs_locations(struct xdr_stream *xdr,
3144					       const struct nfsd4_fattr_args *args)
3145{
3146	return nfsd4_encode_fs_locations4(xdr, args->rqstp, args->exp);
3147}
3148
3149static __be32 nfsd4_encode_fattr4_maxfilesize(struct xdr_stream *xdr,
3150					      const struct nfsd4_fattr_args *args)
3151{
3152	struct super_block *sb = args->exp->ex_path.mnt->mnt_sb;
3153
3154	return nfsd4_encode_uint64_t(xdr, sb->s_maxbytes);
3155}
3156
3157static __be32 nfsd4_encode_fattr4_maxlink(struct xdr_stream *xdr,
3158					  const struct nfsd4_fattr_args *args)
3159{
3160	return nfsd4_encode_uint32_t(xdr, 255);
3161}
3162
3163static __be32 nfsd4_encode_fattr4_maxname(struct xdr_stream *xdr,
3164					  const struct nfsd4_fattr_args *args)
3165{
3166	return nfsd4_encode_uint32_t(xdr, args->statfs.f_namelen);
3167}
3168
3169static __be32 nfsd4_encode_fattr4_maxread(struct xdr_stream *xdr,
3170					  const struct nfsd4_fattr_args *args)
3171{
3172	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));
3173}
3174
3175static __be32 nfsd4_encode_fattr4_maxwrite(struct xdr_stream *xdr,
3176					   const struct nfsd4_fattr_args *args)
3177{
3178	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));
3179}
3180
3181static __be32 nfsd4_encode_fattr4_mode(struct xdr_stream *xdr,
3182				       const struct nfsd4_fattr_args *args)
3183{
3184	return nfsd4_encode_mode4(xdr, args->stat.mode & S_IALLUGO);
3185}
3186
3187static __be32 nfsd4_encode_fattr4_numlinks(struct xdr_stream *xdr,
3188					   const struct nfsd4_fattr_args *args)
3189{
3190	return nfsd4_encode_uint32_t(xdr, args->stat.nlink);
3191}
3192
3193static __be32 nfsd4_encode_fattr4_owner(struct xdr_stream *xdr,
3194					const struct nfsd4_fattr_args *args)
3195{
3196	return nfsd4_encode_user(xdr, args->rqstp, args->stat.uid);
3197}
3198
3199static __be32 nfsd4_encode_fattr4_owner_group(struct xdr_stream *xdr,
3200					      const struct nfsd4_fattr_args *args)
3201{
3202	return nfsd4_encode_group(xdr, args->rqstp, args->stat.gid);
3203}
3204
3205static __be32 nfsd4_encode_fattr4_rawdev(struct xdr_stream *xdr,
3206					 const struct nfsd4_fattr_args *args)
3207{
3208	return nfsd4_encode_specdata4(xdr, MAJOR(args->stat.rdev),
3209				      MINOR(args->stat.rdev));
3210}
3211
3212static __be32 nfsd4_encode_fattr4_space_avail(struct xdr_stream *xdr,
3213					      const struct nfsd4_fattr_args *args)
3214{
3215	u64 avail = (u64)args->statfs.f_bavail * (u64)args->statfs.f_bsize;
3216
3217	return nfsd4_encode_uint64_t(xdr, avail);
3218}
3219
3220static __be32 nfsd4_encode_fattr4_space_free(struct xdr_stream *xdr,
3221					     const struct nfsd4_fattr_args *args)
3222{
3223	u64 free = (u64)args->statfs.f_bfree * (u64)args->statfs.f_bsize;
3224
3225	return nfsd4_encode_uint64_t(xdr, free);
3226}
3227
3228static __be32 nfsd4_encode_fattr4_space_total(struct xdr_stream *xdr,
3229					      const struct nfsd4_fattr_args *args)
3230{
3231	u64 total = (u64)args->statfs.f_blocks * (u64)args->statfs.f_bsize;
3232
3233	return nfsd4_encode_uint64_t(xdr, total);
3234}
3235
3236static __be32 nfsd4_encode_fattr4_space_used(struct xdr_stream *xdr,
3237					     const struct nfsd4_fattr_args *args)
3238{
3239	return nfsd4_encode_uint64_t(xdr, (u64)args->stat.blocks << 9);
3240}
3241
3242static __be32 nfsd4_encode_fattr4_time_access(struct xdr_stream *xdr,
3243					      const struct nfsd4_fattr_args *args)
3244{
3245	return nfsd4_encode_nfstime4(xdr, &args->stat.atime);
3246}
3247
3248static __be32 nfsd4_encode_fattr4_time_create(struct xdr_stream *xdr,
3249					      const struct nfsd4_fattr_args *args)
3250{
3251	return nfsd4_encode_nfstime4(xdr, &args->stat.btime);
3252}
3253
3254/*
3255 * ctime (in NFSv4, time_metadata) is not writeable, and the client
3256 * doesn't really care what resolution could theoretically be stored by
3257 * the filesystem.
3258 *
3259 * The client cares how close together changes can be while still
3260 * guaranteeing ctime changes.  For most filesystems (which have
3261 * timestamps with nanosecond fields) that is limited by the resolution
3262 * of the time returned from current_time() (which I'm assuming to be
3263 * 1/HZ).
3264 */
3265static __be32 nfsd4_encode_fattr4_time_delta(struct xdr_stream *xdr,
3266					     const struct nfsd4_fattr_args *args)
3267{
3268	const struct inode *inode = d_inode(args->dentry);
3269	u32 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);
3270	struct timespec64 ts = ns_to_timespec64(ns);
3271
3272	return nfsd4_encode_nfstime4(xdr, &ts);
3273}
3274
3275static __be32 nfsd4_encode_fattr4_time_metadata(struct xdr_stream *xdr,
3276						const struct nfsd4_fattr_args *args)
3277{
3278	return nfsd4_encode_nfstime4(xdr, &args->stat.ctime);
3279}
3280
3281static __be32 nfsd4_encode_fattr4_time_modify(struct xdr_stream *xdr,
3282					      const struct nfsd4_fattr_args *args)
3283{
3284	return nfsd4_encode_nfstime4(xdr, &args->stat.mtime);
3285}
3286
3287static __be32 nfsd4_encode_fattr4_mounted_on_fileid(struct xdr_stream *xdr,
3288						    const struct nfsd4_fattr_args *args)
3289{
3290	u64 ino;
3291	int err;
3292
3293	if (!args->ignore_crossmnt &&
3294	    args->dentry == args->exp->ex_path.mnt->mnt_root) {
3295		err = nfsd4_get_mounted_on_ino(args->exp, &ino);
3296		if (err)
3297			return nfserrno(err);
3298	} else
3299		ino = args->stat.ino;
3300
3301	return nfsd4_encode_uint64_t(xdr, ino);
3302}
3303
3304#ifdef CONFIG_NFSD_PNFS
3305
3306static __be32 nfsd4_encode_fattr4_fs_layout_types(struct xdr_stream *xdr,
3307						  const struct nfsd4_fattr_args *args)
3308{
3309	unsigned long mask = args->exp->ex_layout_types;
3310	int i;
3311
3312	/* Hamming weight of @mask is the number of layout types to return */
3313	if (xdr_stream_encode_u32(xdr, hweight_long(mask)) != XDR_UNIT)
3314		return nfserr_resource;
3315	for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
3316		if (mask & BIT(i)) {
3317			/* layouttype4 */
3318			if (xdr_stream_encode_u32(xdr, i) != XDR_UNIT)
3319				return nfserr_resource;
3320		}
3321	return nfs_ok;
3322}
3323
3324static __be32 nfsd4_encode_fattr4_layout_types(struct xdr_stream *xdr,
3325					       const struct nfsd4_fattr_args *args)
3326{
3327	unsigned long mask = args->exp->ex_layout_types;
3328	int i;
3329
3330	/* Hamming weight of @mask is the number of layout types to return */
3331	if (xdr_stream_encode_u32(xdr, hweight_long(mask)) != XDR_UNIT)
3332		return nfserr_resource;
3333	for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
3334		if (mask & BIT(i)) {
3335			/* layouttype4 */
3336			if (xdr_stream_encode_u32(xdr, i) != XDR_UNIT)
3337				return nfserr_resource;
3338		}
3339	return nfs_ok;
3340}
3341
3342static __be32 nfsd4_encode_fattr4_layout_blksize(struct xdr_stream *xdr,
3343						 const struct nfsd4_fattr_args *args)
3344{
3345	return nfsd4_encode_uint32_t(xdr, args->stat.blksize);
3346}
3347
3348#endif
3349
3350static __be32 nfsd4_encode_fattr4_suppattr_exclcreat(struct xdr_stream *xdr,
3351						     const struct nfsd4_fattr_args *args)
3352{
3353	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;
3354	u32 supp[3];
3355
3356	memcpy(supp, nfsd_suppattrs[resp->cstate.minorversion], sizeof(supp));
3357	supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
3358	supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
3359	supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;
3360
3361	return nfsd4_encode_bitmap4(xdr, supp[0], supp[1], supp[2]);
3362}
3363
3364#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3365static __be32 nfsd4_encode_fattr4_sec_label(struct xdr_stream *xdr,
3366					    const struct nfsd4_fattr_args *args)
3367{
3368	return nfsd4_encode_security_label(xdr, args->rqstp,
3369					   args->context, args->contextlen);
3370}
3371#endif
3372
3373static __be32 nfsd4_encode_fattr4_xattr_support(struct xdr_stream *xdr,
3374						const struct nfsd4_fattr_args *args)
3375{
3376	int err = xattr_supports_user_prefix(d_inode(args->dentry));
3377
3378	return nfsd4_encode_bool(xdr, err == 0);
3379}
3380
3381static const nfsd4_enc_attr nfsd4_enc_fattr4_encode_ops[] = {
3382	[FATTR4_SUPPORTED_ATTRS]	= nfsd4_encode_fattr4_supported_attrs,
3383	[FATTR4_TYPE]			= nfsd4_encode_fattr4_type,
3384	[FATTR4_FH_EXPIRE_TYPE]		= nfsd4_encode_fattr4_fh_expire_type,
3385	[FATTR4_CHANGE]			= nfsd4_encode_fattr4_change,
3386	[FATTR4_SIZE]			= nfsd4_encode_fattr4_size,
3387	[FATTR4_LINK_SUPPORT]		= nfsd4_encode_fattr4__true,
3388	[FATTR4_SYMLINK_SUPPORT]	= nfsd4_encode_fattr4__true,
3389	[FATTR4_NAMED_ATTR]		= nfsd4_encode_fattr4__false,
3390	[FATTR4_FSID]			= nfsd4_encode_fattr4_fsid,
3391	[FATTR4_UNIQUE_HANDLES]		= nfsd4_encode_fattr4__true,
3392	[FATTR4_LEASE_TIME]		= nfsd4_encode_fattr4_lease_time,
3393	[FATTR4_RDATTR_ERROR]		= nfsd4_encode_fattr4_rdattr_error,
3394	[FATTR4_ACL]			= nfsd4_encode_fattr4_acl,
3395	[FATTR4_ACLSUPPORT]		= nfsd4_encode_fattr4_aclsupport,
3396	[FATTR4_ARCHIVE]		= nfsd4_encode_fattr4__noop,
3397	[FATTR4_CANSETTIME]		= nfsd4_encode_fattr4__true,
3398	[FATTR4_CASE_INSENSITIVE]	= nfsd4_encode_fattr4__false,
3399	[FATTR4_CASE_PRESERVING]	= nfsd4_encode_fattr4__true,
3400	[FATTR4_CHOWN_RESTRICTED]	= nfsd4_encode_fattr4__true,
3401	[FATTR4_FILEHANDLE]		= nfsd4_encode_fattr4_filehandle,
3402	[FATTR4_FILEID]			= nfsd4_encode_fattr4_fileid,
3403	[FATTR4_FILES_AVAIL]		= nfsd4_encode_fattr4_files_avail,
3404	[FATTR4_FILES_FREE]		= nfsd4_encode_fattr4_files_free,
3405	[FATTR4_FILES_TOTAL]		= nfsd4_encode_fattr4_files_total,
3406	[FATTR4_FS_LOCATIONS]		= nfsd4_encode_fattr4_fs_locations,
3407	[FATTR4_HIDDEN]			= nfsd4_encode_fattr4__noop,
3408	[FATTR4_HOMOGENEOUS]		= nfsd4_encode_fattr4__true,
3409	[FATTR4_MAXFILESIZE]		= nfsd4_encode_fattr4_maxfilesize,
3410	[FATTR4_MAXLINK]		= nfsd4_encode_fattr4_maxlink,
3411	[FATTR4_MAXNAME]		= nfsd4_encode_fattr4_maxname,
3412	[FATTR4_MAXREAD]		= nfsd4_encode_fattr4_maxread,
3413	[FATTR4_MAXWRITE]		= nfsd4_encode_fattr4_maxwrite,
3414	[FATTR4_MIMETYPE]		= nfsd4_encode_fattr4__noop,
3415	[FATTR4_MODE]			= nfsd4_encode_fattr4_mode,
3416	[FATTR4_NO_TRUNC]		= nfsd4_encode_fattr4__true,
3417	[FATTR4_NUMLINKS]		= nfsd4_encode_fattr4_numlinks,
3418	[FATTR4_OWNER]			= nfsd4_encode_fattr4_owner,
3419	[FATTR4_OWNER_GROUP]		= nfsd4_encode_fattr4_owner_group,
3420	[FATTR4_QUOTA_AVAIL_HARD]	= nfsd4_encode_fattr4__noop,
3421	[FATTR4_QUOTA_AVAIL_SOFT]	= nfsd4_encode_fattr4__noop,
3422	[FATTR4_QUOTA_USED]		= nfsd4_encode_fattr4__noop,
3423	[FATTR4_RAWDEV]			= nfsd4_encode_fattr4_rawdev,
3424	[FATTR4_SPACE_AVAIL]		= nfsd4_encode_fattr4_space_avail,
3425	[FATTR4_SPACE_FREE]		= nfsd4_encode_fattr4_space_free,
3426	[FATTR4_SPACE_TOTAL]		= nfsd4_encode_fattr4_space_total,
3427	[FATTR4_SPACE_USED]		= nfsd4_encode_fattr4_space_used,
3428	[FATTR4_SYSTEM]			= nfsd4_encode_fattr4__noop,
3429	[FATTR4_TIME_ACCESS]		= nfsd4_encode_fattr4_time_access,
3430	[FATTR4_TIME_ACCESS_SET]	= nfsd4_encode_fattr4__noop,
3431	[FATTR4_TIME_BACKUP]		= nfsd4_encode_fattr4__noop,
3432	[FATTR4_TIME_CREATE]		= nfsd4_encode_fattr4_time_create,
3433	[FATTR4_TIME_DELTA]		= nfsd4_encode_fattr4_time_delta,
3434	[FATTR4_TIME_METADATA]		= nfsd4_encode_fattr4_time_metadata,
3435	[FATTR4_TIME_MODIFY]		= nfsd4_encode_fattr4_time_modify,
3436	[FATTR4_TIME_MODIFY_SET]	= nfsd4_encode_fattr4__noop,
3437	[FATTR4_MOUNTED_ON_FILEID]	= nfsd4_encode_fattr4_mounted_on_fileid,
3438	[FATTR4_DIR_NOTIF_DELAY]	= nfsd4_encode_fattr4__noop,
3439	[FATTR4_DIRENT_NOTIF_DELAY]	= nfsd4_encode_fattr4__noop,
3440	[FATTR4_DACL]			= nfsd4_encode_fattr4__noop,
3441	[FATTR4_SACL]			= nfsd4_encode_fattr4__noop,
3442	[FATTR4_CHANGE_POLICY]		= nfsd4_encode_fattr4__noop,
3443	[FATTR4_FS_STATUS]		= nfsd4_encode_fattr4__noop,
3444
3445#ifdef CONFIG_NFSD_PNFS
3446	[FATTR4_FS_LAYOUT_TYPES]	= nfsd4_encode_fattr4_fs_layout_types,
3447	[FATTR4_LAYOUT_HINT]		= nfsd4_encode_fattr4__noop,
3448	[FATTR4_LAYOUT_TYPES]		= nfsd4_encode_fattr4_layout_types,
3449	[FATTR4_LAYOUT_BLKSIZE]		= nfsd4_encode_fattr4_layout_blksize,
3450	[FATTR4_LAYOUT_ALIGNMENT]	= nfsd4_encode_fattr4__noop,
3451#else
3452	[FATTR4_FS_LAYOUT_TYPES]	= nfsd4_encode_fattr4__noop,
3453	[FATTR4_LAYOUT_HINT]		= nfsd4_encode_fattr4__noop,
3454	[FATTR4_LAYOUT_TYPES]		= nfsd4_encode_fattr4__noop,
3455	[FATTR4_LAYOUT_BLKSIZE]		= nfsd4_encode_fattr4__noop,
3456	[FATTR4_LAYOUT_ALIGNMENT]	= nfsd4_encode_fattr4__noop,
3457#endif
3458
3459	[FATTR4_FS_LOCATIONS_INFO]	= nfsd4_encode_fattr4__noop,
3460	[FATTR4_MDSTHRESHOLD]		= nfsd4_encode_fattr4__noop,
3461	[FATTR4_RETENTION_GET]		= nfsd4_encode_fattr4__noop,
3462	[FATTR4_RETENTION_SET]		= nfsd4_encode_fattr4__noop,
3463	[FATTR4_RETENTEVT_GET]		= nfsd4_encode_fattr4__noop,
3464	[FATTR4_RETENTEVT_SET]		= nfsd4_encode_fattr4__noop,
3465	[FATTR4_RETENTION_HOLD]		= nfsd4_encode_fattr4__noop,
3466	[FATTR4_MODE_SET_MASKED]	= nfsd4_encode_fattr4__noop,
3467	[FATTR4_SUPPATTR_EXCLCREAT]	= nfsd4_encode_fattr4_suppattr_exclcreat,
3468	[FATTR4_FS_CHARSET_CAP]		= nfsd4_encode_fattr4__noop,
3469	[FATTR4_CLONE_BLKSIZE]		= nfsd4_encode_fattr4__noop,
3470	[FATTR4_SPACE_FREED]		= nfsd4_encode_fattr4__noop,
3471	[FATTR4_CHANGE_ATTR_TYPE]	= nfsd4_encode_fattr4__noop,
3472
3473#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3474	[FATTR4_SEC_LABEL]		= nfsd4_encode_fattr4_sec_label,
3475#else
3476	[FATTR4_SEC_LABEL]		= nfsd4_encode_fattr4__noop,
3477#endif
3478
3479	[FATTR4_MODE_UMASK]		= nfsd4_encode_fattr4__noop,
3480	[FATTR4_XATTR_SUPPORT]		= nfsd4_encode_fattr4_xattr_support,
3481};
3482
3483/*
3484 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
3485 * ourselves.
3486 */
3487static __be32
3488nfsd4_encode_fattr4(struct svc_rqst *rqstp, struct xdr_stream *xdr,
3489		    struct svc_fh *fhp, struct svc_export *exp,
3490		    struct dentry *dentry, const u32 *bmval,
3491		    int ignore_crossmnt)
3492{
3493	DECLARE_BITMAP(attr_bitmap, ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops));
3494	struct nfsd4_fattr_args args;
 
 
3495	struct svc_fh *tempfh = NULL;
 
 
3496	int starting_len = xdr->buf->len;
3497	__be32 *attrlen_p, status;
3498	int attrlen_offset;
3499	u32 attrmask[3];
 
 
 
 
3500	int err;
 
 
 
 
3501	struct nfsd4_compoundres *resp = rqstp->rq_resp;
3502	u32 minorversion = resp->cstate.minorversion;
3503	struct path path = {
3504		.mnt	= exp->ex_path.mnt,
3505		.dentry	= dentry,
3506	};
3507	unsigned long bit;
3508	bool file_modified = false;
3509	u64 size = 0;
3510
3511	WARN_ON_ONCE(bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1);
3512	WARN_ON_ONCE(!nfsd_attrs_supported(minorversion, bmval));
3513
3514	args.rqstp = rqstp;
3515	args.exp = exp;
3516	args.dentry = dentry;
3517	args.ignore_crossmnt = (ignore_crossmnt != 0);
3518	args.acl = NULL;
3519
3520	/*
3521	 * Make a local copy of the attribute bitmap that can be modified.
3522	 */
3523	attrmask[0] = bmval[0];
3524	attrmask[1] = bmval[1];
3525	attrmask[2] = bmval[2];
3526
3527	args.rdattr_err = 0;
3528	if (exp->ex_fslocs.migrated) {
3529		status = fattr_handle_absent_fs(&attrmask[0], &attrmask[1],
3530						&attrmask[2], &args.rdattr_err);
3531		if (status)
3532			goto out;
3533	}
3534	args.size = 0;
3535	if (attrmask[0] & (FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE)) {
3536		status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry),
3537					&file_modified, &size);
3538		if (status)
3539			goto out;
3540	}
3541
3542	err = vfs_getattr(&path, &args.stat,
3543			  STATX_BASIC_STATS | STATX_BTIME | STATX_CHANGE_COOKIE,
3544			  AT_STATX_SYNC_AS_STAT);
3545	if (err)
3546		goto out_nfserr;
3547	if (file_modified)
3548		args.size = size;
3549	else
3550		args.size = args.stat.size;
3551
3552	if (!(args.stat.result_mask & STATX_BTIME))
3553		/* underlying FS does not offer btime so we can't share it */
3554		attrmask[1] &= ~FATTR4_WORD1_TIME_CREATE;
3555	if ((attrmask[0] & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
3556			FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
3557	    (attrmask[1] & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
3558		       FATTR4_WORD1_SPACE_TOTAL))) {
3559		err = vfs_statfs(&path, &args.statfs);
3560		if (err)
3561			goto out_nfserr;
3562	}
3563	if ((attrmask[0] & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) &&
3564	    !fhp) {
3565		tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
3566		status = nfserr_jukebox;
3567		if (!tempfh)
3568			goto out;
3569		fh_init(tempfh, NFS4_FHSIZE);
3570		status = fh_compose(tempfh, exp, dentry, NULL);
3571		if (status)
3572			goto out;
3573		args.fhp = tempfh;
3574	} else
3575		args.fhp = fhp;
3576
3577	if (attrmask[0] & FATTR4_WORD0_ACL) {
3578		err = nfsd4_get_nfs4_acl(rqstp, dentry, &args.acl);
3579		if (err == -EOPNOTSUPP)
3580			attrmask[0] &= ~FATTR4_WORD0_ACL;
3581		else if (err == -EINVAL) {
3582			status = nfserr_attrnotsupp;
3583			goto out;
3584		} else if (err != 0)
3585			goto out_nfserr;
3586	}
3587
3588	args.contextsupport = false;
3589
3590#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3591	args.context = NULL;
3592	if ((attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) ||
3593	     attrmask[0] & FATTR4_WORD0_SUPPORTED_ATTRS) {
3594		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
3595			err = security_inode_getsecctx(d_inode(dentry),
3596						&args.context, &args.contextlen);
3597		else
3598			err = -EOPNOTSUPP;
3599		args.contextsupport = (err == 0);
3600		if (attrmask[2] & FATTR4_WORD2_SECURITY_LABEL) {
3601			if (err == -EOPNOTSUPP)
3602				attrmask[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3603			else if (err)
3604				goto out_nfserr;
3605		}
3606	}
3607#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3608
3609	/* attrmask */
3610	status = nfsd4_encode_bitmap4(xdr, attrmask[0], attrmask[1],
3611				      attrmask[2]);
3612	if (status)
3613		goto out;
3614
3615	/* attr_vals */
3616	attrlen_offset = xdr->buf->len;
3617	attrlen_p = xdr_reserve_space(xdr, XDR_UNIT);
3618	if (!attrlen_p)
3619		goto out_resource;
3620	bitmap_from_arr32(attr_bitmap, attrmask,
3621			  ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops));
3622	for_each_set_bit(bit, attr_bitmap,
3623			 ARRAY_SIZE(nfsd4_enc_fattr4_encode_ops)) {
3624		status = nfsd4_enc_fattr4_encode_ops[bit](xdr, &args);
3625		if (status != nfs_ok)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3626			goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3627	}
3628	*attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3629	status = nfs_ok;
3630
3631out:
3632#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3633	if (args.context)
3634		security_release_secctx(args.context, args.contextlen);
3635#endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3636	kfree(args.acl);
3637	if (tempfh) {
3638		fh_put(tempfh);
3639		kfree(tempfh);
3640	}
3641	if (status)
3642		xdr_truncate_encode(xdr, starting_len);
3643	return status;
3644out_nfserr:
3645	status = nfserrno(err);
3646	goto out;
3647out_resource:
3648	status = nfserr_resource;
3649	goto out;
3650}
3651
3652static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
3653				struct xdr_buf *buf, __be32 *p, int bytes)
3654{
3655	xdr->scratch.iov_len = 0;
3656	memset(buf, 0, sizeof(struct xdr_buf));
3657	buf->head[0].iov_base = p;
3658	buf->head[0].iov_len = 0;
3659	buf->len = 0;
3660	xdr->buf = buf;
3661	xdr->iov = buf->head;
3662	xdr->p = p;
3663	xdr->end = (void *)p + bytes;
3664	buf->buflen = bytes;
3665}
3666
3667__be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
3668			struct svc_fh *fhp, struct svc_export *exp,
3669			struct dentry *dentry, u32 *bmval,
3670			struct svc_rqst *rqstp, int ignore_crossmnt)
3671{
3672	struct xdr_buf dummy;
3673	struct xdr_stream xdr;
3674	__be32 ret;
3675
3676	svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
3677	ret = nfsd4_encode_fattr4(rqstp, &xdr, fhp, exp, dentry, bmval,
3678				  ignore_crossmnt);
3679	*p = xdr.p;
3680	return ret;
3681}
3682
3683/*
3684 * The buffer space for this field was reserved during a previous
3685 * call to nfsd4_encode_entry4().
3686 */
3687static void nfsd4_encode_entry4_nfs_cookie4(const struct nfsd4_readdir *readdir,
3688					    u64 offset)
3689{
3690	__be64 cookie = cpu_to_be64(offset);
3691	struct xdr_stream *xdr = readdir->xdr;
3692
3693	if (!readdir->cookie_offset)
3694		return;
3695	write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie,
3696			       sizeof(cookie));
3697}
3698
3699static inline int attributes_need_mount(u32 *bmval)
3700{
3701	if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
3702		return 1;
3703	if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
3704		return 1;
3705	return 0;
3706}
3707
3708static __be32
3709nfsd4_encode_entry4_fattr(struct nfsd4_readdir *cd, const char *name,
3710			  int namlen)
3711{
3712	struct svc_export *exp = cd->rd_fhp->fh_export;
3713	struct dentry *dentry;
3714	__be32 nfserr;
3715	int ignore_crossmnt = 0;
3716
3717	dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
3718	if (IS_ERR(dentry))
3719		return nfserrno(PTR_ERR(dentry));
 
 
 
 
 
 
 
 
 
3720
3721	exp_get(exp);
3722	/*
3723	 * In the case of a mountpoint, the client may be asking for
3724	 * attributes that are only properties of the underlying filesystem
3725	 * as opposed to the cross-mounted file system. In such a case,
3726	 * we will not follow the cross mount and will fill the attribtutes
3727	 * directly from the mountpoint dentry.
3728	 */
3729	if (nfsd_mountpoint(dentry, exp)) {
3730		int err;
3731
3732		if (!(exp->ex_flags & NFSEXP_V4ROOT)
3733				&& !attributes_need_mount(cd->rd_bmval)) {
3734			ignore_crossmnt = 1;
3735			goto out_encode;
3736		}
3737		/*
3738		 * Why the heck aren't we just using nfsd_lookup??
3739		 * Different "."/".." handling?  Something else?
3740		 * At least, add a comment here to explain....
3741		 */
3742		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
3743		if (err) {
3744			nfserr = nfserrno(err);
3745			goto out_put;
3746		}
3747		nfserr = check_nfsd_access(exp, cd->rd_rqstp);
3748		if (nfserr)
3749			goto out_put;
3750
3751	}
3752out_encode:
3753	nfserr = nfsd4_encode_fattr4(cd->rd_rqstp, cd->xdr, NULL, exp, dentry,
3754				     cd->rd_bmval, ignore_crossmnt);
3755out_put:
3756	dput(dentry);
3757	exp_put(exp);
3758	return nfserr;
3759}
3760
3761static __be32
3762nfsd4_encode_entry4_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
3763{
3764	__be32 status;
3765
3766	/* attrmask */
3767	status = nfsd4_encode_bitmap4(xdr, FATTR4_WORD0_RDATTR_ERROR, 0, 0);
3768	if (status != nfs_ok)
3769		return status;
3770	/* attr_vals */
3771	if (xdr_stream_encode_u32(xdr, XDR_UNIT) != XDR_UNIT)
3772		return nfserr_resource;
3773	/* rdattr_error */
3774	if (xdr_stream_encode_be32(xdr, nfserr) != XDR_UNIT)
3775		return nfserr_resource;
3776	return nfs_ok;
3777}
3778
3779static int
3780nfsd4_encode_entry4(void *ccdv, const char *name, int namlen,
3781		    loff_t offset, u64 ino, unsigned int d_type)
3782{
3783	struct readdir_cd *ccd = ccdv;
3784	struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
3785	struct xdr_stream *xdr = cd->xdr;
3786	int start_offset = xdr->buf->len;
3787	int cookie_offset;
3788	u32 name_and_cookie;
3789	int entry_bytes;
3790	__be32 nfserr = nfserr_toosmall;
 
 
3791
3792	/* In nfsv4, "." and ".." never make it onto the wire.. */
3793	if (name && isdotent(name, namlen)) {
3794		cd->common.err = nfs_ok;
3795		return 0;
3796	}
3797
3798	/* Encode the previous entry's cookie value */
3799	nfsd4_encode_entry4_nfs_cookie4(cd, offset);
 
 
 
3800
3801	if (xdr_stream_encode_item_present(xdr) != XDR_UNIT)
 
3802		goto fail;
3803
3804	/* Reserve send buffer space for this entry's cookie value. */
3805	cookie_offset = xdr->buf->len;
3806	if (nfsd4_encode_nfs_cookie4(xdr, OFFSET_MAX) != nfs_ok)
3807		goto fail;
3808	if (nfsd4_encode_component4(xdr, name, namlen) != nfs_ok)
3809		goto fail;
3810	nfserr = nfsd4_encode_entry4_fattr(cd, name, namlen);
 
 
 
3811	switch (nfserr) {
3812	case nfs_ok:
3813		break;
3814	case nfserr_resource:
3815		nfserr = nfserr_toosmall;
3816		goto fail;
3817	case nfserr_noent:
3818		xdr_truncate_encode(xdr, start_offset);
3819		goto skip_entry;
3820	case nfserr_jukebox:
3821		/*
3822		 * The pseudoroot should only display dentries that lead to
3823		 * exports. If we get EJUKEBOX here, then we can't tell whether
3824		 * this entry should be included. Just fail the whole READDIR
3825		 * with NFS4ERR_DELAY in that case, and hope that the situation
3826		 * will resolve itself by the client's next attempt.
3827		 */
3828		if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT)
3829			goto fail;
3830		fallthrough;
3831	default:
3832		/*
3833		 * If the client requested the RDATTR_ERROR attribute,
3834		 * we stuff the error code into this attribute
3835		 * and continue.  If this attribute was not requested,
3836		 * then in accordance with the spec, we fail the
3837		 * entire READDIR operation(!)
3838		 */
3839		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
3840			goto fail;
3841		if (nfsd4_encode_entry4_rdattr_error(xdr, nfserr)) {
 
3842			nfserr = nfserr_toosmall;
3843			goto fail;
3844		}
3845	}
3846	nfserr = nfserr_toosmall;
3847	entry_bytes = xdr->buf->len - start_offset;
3848	if (entry_bytes > cd->rd_maxcount)
3849		goto fail;
3850	cd->rd_maxcount -= entry_bytes;
3851	/*
3852	 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and
3853	 * notes that it could be zero. If it is zero, then the server
3854	 * should enforce only the rd_maxcount value.
3855	 */
3856	if (cd->rd_dircount) {
3857		name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
3858		if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
3859			goto fail;
3860		cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
3861		if (!cd->rd_dircount)
3862			cd->rd_maxcount = 0;
3863	}
3864
3865	cd->cookie_offset = cookie_offset;
3866skip_entry:
3867	cd->common.err = nfs_ok;
3868	return 0;
3869fail:
3870	xdr_truncate_encode(xdr, start_offset);
3871	cd->common.err = nfserr;
3872	return -EINVAL;
3873}
3874
3875static __be32
3876nfsd4_encode_verifier4(struct xdr_stream *xdr, const nfs4_verifier *verf)
3877{
3878	__be32 *p;
3879
3880	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3881	if (!p)
3882		return nfserr_resource;
3883	memcpy(p, verf->data, sizeof(verf->data));
3884	return nfs_ok;
 
 
3885}
3886
3887static __be32
3888nfsd4_encode_clientid4(struct xdr_stream *xdr, const clientid_t *clientid)
3889{
 
3890	__be32 *p;
3891
3892	p = xdr_reserve_space(xdr, sizeof(__be64));
3893	if (!p)
3894		return nfserr_resource;
3895	memcpy(p, clientid, sizeof(*clientid));
3896	return nfs_ok;
 
3897}
3898
3899/* This is a frequently-encoded item; open-coded for speed */
3900static __be32
3901nfsd4_encode_stateid4(struct xdr_stream *xdr, const stateid_t *sid)
3902{
 
3903	__be32 *p;
3904
3905	p = xdr_reserve_space(xdr, NFS4_STATEID_SIZE);
3906	if (!p)
3907		return nfserr_resource;
3908	*p++ = cpu_to_be32(sid->si_generation);
3909	memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque));
3910	return nfs_ok;
3911}
3912
3913static __be32
3914nfsd4_encode_sessionid4(struct xdr_stream *xdr,
3915			const struct nfs4_sessionid *sessionid)
3916{
3917	return nfsd4_encode_opaque_fixed(xdr, sessionid->data,
3918					 NFS4_MAX_SESSIONID_LEN);
3919}
3920
3921static __be32
3922nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr,
3923		    union nfsd4_op_u *u)
3924{
3925	struct nfsd4_access *access = &u->access;
3926	struct xdr_stream *xdr = resp->xdr;
3927	__be32 status;
3928
3929	/* supported */
3930	status = nfsd4_encode_uint32_t(xdr, access->ac_supported);
3931	if (status != nfs_ok)
3932		return status;
3933	/* access */
3934	return nfsd4_encode_uint32_t(xdr, access->ac_resp_access);
3935}
3936
3937static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr,
3938						union nfsd4_op_u *u)
3939{
3940	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
3941	struct xdr_stream *xdr = resp->xdr;
3942
3943	/* bctsr_sessid */
3944	nfserr = nfsd4_encode_sessionid4(xdr, &bcts->sessionid);
3945	if (nfserr != nfs_ok)
3946		return nfserr;
3947	/* bctsr_dir */
3948	if (xdr_stream_encode_u32(xdr, bcts->dir) != XDR_UNIT)
3949		return nfserr_resource;
3950	/* bctsr_use_conn_in_rdma_mode */
3951	return nfsd4_encode_bool(xdr, false);
3952}
3953
3954static __be32
3955nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr,
3956		   union nfsd4_op_u *u)
3957{
3958	struct nfsd4_close *close = &u->close;
3959	struct xdr_stream *xdr = resp->xdr;
3960
3961	/* open_stateid */
3962	return nfsd4_encode_stateid4(xdr, &close->cl_stateid);
3963}
3964
3965
3966static __be32
3967nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr,
3968		    union nfsd4_op_u *u)
3969{
3970	struct nfsd4_commit *commit = &u->commit;
 
3971
3972	return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf);
 
 
 
 
 
3973}
3974
3975static __be32
3976nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr,
3977		    union nfsd4_op_u *u)
3978{
3979	struct nfsd4_create *create = &u->create;
3980	struct xdr_stream *xdr = resp->xdr;
3981
3982	/* cinfo */
3983	nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo);
3984	if (nfserr)
3985		return nfserr;
3986	/* attrset */
3987	return nfsd4_encode_bitmap4(xdr, create->cr_bmval[0],
3988				    create->cr_bmval[1], create->cr_bmval[2]);
3989}
3990
3991static __be32
3992nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr,
3993		     union nfsd4_op_u *u)
3994{
3995	struct nfsd4_getattr *getattr = &u->getattr;
3996	struct svc_fh *fhp = getattr->ga_fhp;
3997	struct xdr_stream *xdr = resp->xdr;
3998
3999	/* obj_attributes */
4000	return nfsd4_encode_fattr4(resp->rqstp, xdr, fhp, fhp->fh_export,
4001				   fhp->fh_dentry, getattr->ga_bmval, 0);
4002}
4003
4004static __be32
4005nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr,
4006		   union nfsd4_op_u *u)
4007{
4008	struct xdr_stream *xdr = resp->xdr;
4009	struct svc_fh *fhp = u->getfh;
4010
4011	/* object */
4012	return nfsd4_encode_nfs_fh4(xdr, &fhp->fh_handle);
4013}
4014
4015static __be32
4016nfsd4_encode_lock_owner4(struct xdr_stream *xdr, const clientid_t *clientid,
4017			 const struct xdr_netobj *owner)
4018{
4019	__be32 status;
4020
4021	/* clientid */
4022	status = nfsd4_encode_clientid4(xdr, clientid);
4023	if (status != nfs_ok)
4024		return status;
4025	/* owner */
4026	return nfsd4_encode_opaque(xdr, owner->data, owner->len);
4027}
4028
4029static __be32
4030nfsd4_encode_lock4denied(struct xdr_stream *xdr,
4031			 const struct nfsd4_lock_denied *ld)
4032{
4033	__be32 status;
4034
4035	/* offset */
4036	status = nfsd4_encode_offset4(xdr, ld->ld_start);
4037	if (status != nfs_ok)
4038		return status;
4039	/* length */
4040	status = nfsd4_encode_length4(xdr, ld->ld_length);
4041	if (status != nfs_ok)
4042		return status;
4043	/* locktype */
4044	if (xdr_stream_encode_u32(xdr, ld->ld_type) != XDR_UNIT)
4045		return nfserr_resource;
4046	/* owner */
4047	return nfsd4_encode_lock_owner4(xdr, &ld->ld_clientid,
4048					&ld->ld_owner);
4049}
4050
 
 
 
 
4051static __be32
4052nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr,
4053		  union nfsd4_op_u *u)
4054{
4055	struct nfsd4_lock *lock = &u->lock;
4056	struct xdr_stream *xdr = resp->xdr;
4057	__be32 status;
4058
4059	switch (nfserr) {
4060	case nfs_ok:
4061		/* resok4 */
4062		status = nfsd4_encode_stateid4(xdr, &lock->lk_resp_stateid);
4063		break;
4064	case nfserr_denied:
4065		/* denied */
4066		status = nfsd4_encode_lock4denied(xdr, &lock->lk_denied);
4067		break;
4068	default:
4069		return nfserr;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4070	}
4071	return status != nfs_ok ? status : nfserr;
4072}
4073
4074static __be32
4075nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr,
4076		   union nfsd4_op_u *u)
4077{
4078	struct nfsd4_lockt *lockt = &u->lockt;
4079	struct xdr_stream *xdr = resp->xdr;
4080	__be32 status;
 
 
 
4081
4082	if (nfserr == nfserr_denied) {
4083		/* denied */
4084		status = nfsd4_encode_lock4denied(xdr, &lockt->lt_denied);
4085		if (status != nfs_ok)
4086			return status;
4087	}
4088	return nfserr;
4089}
4090
4091static __be32
4092nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr,
4093		   union nfsd4_op_u *u)
4094{
4095	struct nfsd4_locku *locku = &u->locku;
4096	struct xdr_stream *xdr = resp->xdr;
4097
4098	/* lock_stateid */
4099	return nfsd4_encode_stateid4(xdr, &locku->lu_stateid);
 
4100}
4101
4102
4103static __be32
4104nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr,
4105		  union nfsd4_op_u *u)
4106{
4107	struct nfsd4_link *link = &u->link;
4108	struct xdr_stream *xdr = resp->xdr;
4109
4110	return nfsd4_encode_change_info4(xdr, &link->li_cinfo);
4111}
4112
4113/*
4114 * This implementation does not yet support returning an ACE in an
4115 * OPEN that offers a delegation.
4116 */
4117static __be32
4118nfsd4_encode_open_nfsace4(struct xdr_stream *xdr)
4119{
4120	__be32 status;
4121
4122	/* type */
4123	status = nfsd4_encode_acetype4(xdr, NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
4124	if (status != nfs_ok)
4125		return nfserr_resource;
4126	/* flag */
4127	status = nfsd4_encode_aceflag4(xdr, 0);
4128	if (status != nfs_ok)
4129		return nfserr_resource;
4130	/* access mask */
4131	status = nfsd4_encode_acemask4(xdr, 0);
4132	if (status != nfs_ok)
4133		return nfserr_resource;
4134	/* who - empty for now */
4135	if (xdr_stream_encode_u32(xdr, 0) != XDR_UNIT)
4136		return nfserr_resource;
4137	return nfs_ok;
4138}
4139
4140static __be32
4141nfsd4_encode_open_read_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open)
4142{
4143	__be32 status;
4144
4145	/* stateid */
4146	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);
4147	if (status != nfs_ok)
4148		return status;
4149	/* recall */
4150	status = nfsd4_encode_bool(xdr, open->op_recall);
4151	if (status != nfs_ok)
4152		return status;
4153	/* permissions */
4154	return nfsd4_encode_open_nfsace4(xdr);
4155}
4156
4157static __be32
4158nfsd4_encode_nfs_space_limit4(struct xdr_stream *xdr, u64 filesize)
4159{
4160	/* limitby */
4161	if (xdr_stream_encode_u32(xdr, NFS4_LIMIT_SIZE) != XDR_UNIT)
4162		return nfserr_resource;
4163	/* filesize */
4164	return nfsd4_encode_uint64_t(xdr, filesize);
4165}
4166
4167static __be32
4168nfsd4_encode_open_write_delegation4(struct xdr_stream *xdr,
4169				    struct nfsd4_open *open)
4170{
4171	__be32 status;
4172
4173	/* stateid */
4174	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);
4175	if (status != nfs_ok)
4176		return status;
4177	/* recall */
4178	status = nfsd4_encode_bool(xdr, open->op_recall);
4179	if (status != nfs_ok)
4180		return status;
4181	/* space_limit */
4182	status = nfsd4_encode_nfs_space_limit4(xdr, 0);
4183	if (status != nfs_ok)
4184		return status;
4185	return nfsd4_encode_open_nfsace4(xdr);
4186}
4187
4188static __be32
4189nfsd4_encode_open_none_delegation4(struct xdr_stream *xdr,
4190				   struct nfsd4_open *open)
4191{
4192	__be32 status = nfs_ok;
 
4193
4194	/* ond_why */
4195	if (xdr_stream_encode_u32(xdr, open->op_why_no_deleg) != XDR_UNIT)
 
 
 
4196		return nfserr_resource;
4197	switch (open->op_why_no_deleg) {
4198	case WND4_CONTENTION:
4199		/* ond_server_will_push_deleg */
4200		status = nfsd4_encode_bool(xdr, false);
4201		break;
4202	case WND4_RESOURCE:
4203		/* ond_server_will_signal_avail */
4204		status = nfsd4_encode_bool(xdr, false);
4205	}
4206	return status;
4207}
4208
4209static __be32
4210nfsd4_encode_open_delegation4(struct xdr_stream *xdr, struct nfsd4_open *open)
4211{
4212	__be32 status;
4213
4214	/* delegation_type */
4215	if (xdr_stream_encode_u32(xdr, open->op_delegate_type) != XDR_UNIT)
4216		return nfserr_resource;
 
 
4217	switch (open->op_delegate_type) {
4218	case NFS4_OPEN_DELEGATE_NONE:
4219		status = nfs_ok;
4220		break;
4221	case NFS4_OPEN_DELEGATE_READ:
4222		/* read */
4223		status = nfsd4_encode_open_read_delegation4(xdr, open);
 
 
 
 
 
 
 
 
 
 
 
 
 
4224		break;
4225	case NFS4_OPEN_DELEGATE_WRITE:
4226		/* write */
4227		status = nfsd4_encode_open_write_delegation4(xdr, open);
4228		break;
4229	case NFS4_OPEN_DELEGATE_NONE_EXT:
4230		/* od_whynone */
4231		status = nfsd4_encode_open_none_delegation4(xdr, open);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4232		break;
4233	default:
4234		status = nfserr_serverfault;
4235	}
4236
4237	return status;
4238}
4239
4240static __be32
4241nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr,
4242		  union nfsd4_op_u *u)
4243{
4244	struct nfsd4_open *open = &u->open;
4245	struct xdr_stream *xdr = resp->xdr;
4246
4247	/* stateid */
4248	nfserr = nfsd4_encode_stateid4(xdr, &open->op_stateid);
4249	if (nfserr != nfs_ok)
4250		return nfserr;
4251	/* cinfo */
4252	nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo);
4253	if (nfserr != nfs_ok)
4254		return nfserr;
4255	/* rflags */
4256	nfserr = nfsd4_encode_uint32_t(xdr, open->op_rflags);
4257	if (nfserr != nfs_ok)
4258		return nfserr;
4259	/* attrset */
4260	nfserr = nfsd4_encode_bitmap4(xdr, open->op_bmval[0],
4261				      open->op_bmval[1], open->op_bmval[2]);
4262	if (nfserr != nfs_ok)
4263		return nfserr;
4264	/* delegation */
4265	return nfsd4_encode_open_delegation4(xdr, open);
4266}
4267
4268static __be32
4269nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr,
4270			  union nfsd4_op_u *u)
4271{
4272	struct nfsd4_open_confirm *oc = &u->open_confirm;
4273	struct xdr_stream *xdr = resp->xdr;
4274
4275	/* open_stateid */
4276	return nfsd4_encode_stateid4(xdr, &oc->oc_resp_stateid);
4277}
4278
4279static __be32
4280nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr,
4281			    union nfsd4_op_u *u)
4282{
4283	struct nfsd4_open_downgrade *od = &u->open_downgrade;
4284	struct xdr_stream *xdr = resp->xdr;
4285
4286	/* open_stateid */
4287	return nfsd4_encode_stateid4(xdr, &od->od_stateid);
4288}
4289
4290/*
4291 * The operation of this function assumes that this is the only
4292 * READ operation in the COMPOUND. If there are multiple READs,
4293 * we use nfsd4_encode_readv().
4294 */
4295static __be32 nfsd4_encode_splice_read(
4296				struct nfsd4_compoundres *resp,
4297				struct nfsd4_read *read,
4298				struct file *file, unsigned long maxcount)
4299{
4300	struct xdr_stream *xdr = resp->xdr;
4301	struct xdr_buf *buf = xdr->buf;
4302	int status, space_left;
 
 
4303	__be32 nfserr;
 
4304
4305	/*
4306	 * Make sure there is room at the end of buf->head for
4307	 * svcxdr_encode_opaque_pages() to create a tail buffer
4308	 * to XDR-pad the payload.
4309	 */
4310	if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1)
4311		return nfserr_resource;
4312
 
4313	nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,
4314				  file, read->rd_offset, &maxcount,
4315				  &read->rd_eof);
4316	read->rd_length = maxcount;
4317	if (nfserr)
4318		goto out_err;
4319	svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages,
4320				   buf->page_base, maxcount);
4321	status = svc_encode_result_payload(read->rd_rqstp,
4322					   buf->head[0].iov_len, maxcount);
4323	if (status) {
4324		nfserr = nfserrno(status);
4325		goto out_err;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4326	}
4327
4328	/*
4329	 * Prepare to encode subsequent operations.
4330	 *
4331	 * xdr_truncate_encode() is not safe to use after a successful
4332	 * splice read has been done, so the following stream
4333	 * manipulations are open-coded.
4334	 */
4335	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
4336				buf->buflen - buf->len);
4337	buf->buflen = buf->len + space_left;
4338	xdr->end = (__be32 *)((void *)xdr->end + space_left);
4339
4340	return nfs_ok;
4341
4342out_err:
4343	/*
4344	 * nfsd_splice_actor may have already messed with the
4345	 * page length; reset it so as not to confuse
4346	 * xdr_truncate_encode in our caller.
4347	 */
4348	buf->page_len = 0;
4349	return nfserr;
4350}
4351
4352static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
4353				 struct nfsd4_read *read,
4354				 struct file *file, unsigned long maxcount)
4355{
4356	struct xdr_stream *xdr = resp->xdr;
4357	unsigned int base = xdr->buf->page_len & ~PAGE_MASK;
4358	unsigned int starting_len = xdr->buf->len;
4359	__be32 zero = xdr_zero;
 
 
4360	__be32 nfserr;
 
 
 
 
4361
4362	if (xdr_reserve_space_vec(xdr, maxcount) < 0)
4363		return nfserr_resource;
4364
4365	nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file,
4366				read->rd_offset, &maxcount, base,
4367				&read->rd_eof);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4368	read->rd_length = maxcount;
4369	if (nfserr)
4370		return nfserr;
4371	if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount))
4372		return nfserr_io;
4373	xdr_truncate_encode(xdr, starting_len + xdr_align_size(maxcount));
 
 
 
 
 
 
 
 
 
 
 
4374
4375	write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero,
4376			       xdr_pad_size(maxcount));
4377	return nfs_ok;
4378}
4379
4380static __be32
4381nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
4382		  union nfsd4_op_u *u)
4383{
4384	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;
4385	struct nfsd4_read *read = &u->read;
4386	struct xdr_stream *xdr = resp->xdr;
4387	int starting_len = xdr->buf->len;
4388	bool splice_ok = argp->splice_ok;
4389	unsigned long maxcount;
4390	struct file *file;
 
 
 
4391	__be32 *p;
4392
4393	if (nfserr)
4394		return nfserr;
4395	file = read->rd_nf->nf_file;
4396
4397	p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
4398	if (!p) {
4399		WARN_ON_ONCE(splice_ok);
4400		return nfserr_resource;
4401	}
4402	if (resp->xdr->buf->page_len && splice_ok) {
 
4403		WARN_ON_ONCE(1);
4404		return nfserr_serverfault;
4405	}
4406	xdr_commit_encode(xdr);
4407
4408	maxcount = min_t(unsigned long, read->rd_length,
 
4409			 (xdr->buf->buflen - xdr->buf->len));
 
 
 
 
4410
4411	if (file->f_op->splice_read && splice_ok)
 
4412		nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
4413	else
4414		nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
4415	if (nfserr) {
 
 
 
 
4416		xdr_truncate_encode(xdr, starting_len);
4417		return nfserr;
4418	}
4419
4420	p = xdr_encode_bool(p, read->rd_eof);
4421	*p = cpu_to_be32(read->rd_length);
4422	return nfs_ok;
4423}
4424
4425static __be32
4426nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr,
4427		      union nfsd4_op_u *u)
4428{
4429	struct nfsd4_readlink *readlink = &u->readlink;
4430	__be32 *p, *maxcount_p, zero = xdr_zero;
4431	struct xdr_stream *xdr = resp->xdr;
 
4432	int length_offset = xdr->buf->len;
4433	int maxcount, status;
4434
4435	maxcount_p = xdr_reserve_space(xdr, XDR_UNIT);
4436	if (!maxcount_p)
4437		return nfserr_resource;
4438	maxcount = PAGE_SIZE;
4439
4440	p = xdr_reserve_space(xdr, maxcount);
4441	if (!p)
4442		return nfserr_resource;
4443	/*
4444	 * XXX: By default, vfs_readlink() will truncate symlinks if they
4445	 * would overflow the buffer.  Is this kosher in NFSv4?  If not, one
4446	 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4447	 * that truncation occurred, and return NFS4ERR_RESOURCE.
4448	 */
4449	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
4450						(char *)p, &maxcount);
4451	if (nfserr == nfserr_isdir)
4452		nfserr = nfserr_inval;
4453	if (nfserr)
4454		goto out_err;
4455	status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,
4456					   maxcount);
4457	if (status) {
4458		nfserr = nfserrno(status);
4459		goto out_err;
4460	}
4461	*maxcount_p = cpu_to_be32(maxcount);
4462	xdr_truncate_encode(xdr, length_offset + 4 + xdr_align_size(maxcount));
4463	write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero,
4464			       xdr_pad_size(maxcount));
4465	return nfs_ok;
4466
4467out_err:
4468	xdr_truncate_encode(xdr, length_offset);
4469	return nfserr;
 
 
 
 
4470}
4471
4472static __be32 nfsd4_encode_dirlist4(struct xdr_stream *xdr,
4473				    struct nfsd4_readdir *readdir,
4474				    u32 max_payload)
4475{
4476	int bytes_left, maxcount, starting_len = xdr->buf->len;
 
4477	loff_t offset;
4478	__be32 status;
 
 
 
 
 
 
 
 
 
 
 
 
 
4479
4480	/*
4481	 * Number of bytes left for directory entries allowing for the
4482	 * final 8 bytes of the readdir and a following failed op.
4483	 */
4484	bytes_left = xdr->buf->buflen - xdr->buf->len -
4485		COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2;
4486	if (bytes_left < 0)
4487		return nfserr_resource;
4488	maxcount = min_t(u32, readdir->rd_maxcount, max_payload);
4489
 
4490	/*
4491	 * The RFC defines rd_maxcount as the size of the
4492	 * READDIR4resok structure, which includes the verifier
4493	 * and the 8 bytes encoded at the end of this function.
4494	 */
4495	if (maxcount < XDR_UNIT * 4)
4496		return nfserr_toosmall;
4497	maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left);
 
 
4498
4499	/* RFC 3530 14.2.24 allows us to ignore dircount when it's 0 */
4500	if (!readdir->rd_dircount)
4501		readdir->rd_dircount = max_payload;
4502
4503	/* *entries */
4504	readdir->xdr = xdr;
4505	readdir->rd_maxcount = maxcount;
4506	readdir->common.err = 0;
4507	readdir->cookie_offset = 0;
 
4508	offset = readdir->rd_cookie;
4509	status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset,
4510			      &readdir->common, nfsd4_encode_entry4);
4511	if (status)
4512		return status;
4513	if (readdir->common.err == nfserr_toosmall &&
4514	    xdr->buf->len == starting_len) {
4515		/* No entries were encoded. Which limit did we hit? */
4516		if (maxcount - XDR_UNIT * 4 < bytes_left)
4517			/* It was the fault of rd_maxcount */
4518			return nfserr_toosmall;
4519		/* We ran out of buffer space */
4520		return nfserr_resource;
 
4521	}
4522	/* Encode the final entry's cookie value */
4523	nfsd4_encode_entry4_nfs_cookie4(readdir, offset);
4524	/* No entries follow */
4525	if (xdr_stream_encode_item_absent(xdr) != XDR_UNIT)
4526		return nfserr_resource;
4527
4528	/* eof */
4529	return nfsd4_encode_bool(xdr, readdir->common.err == nfserr_eof);
4530}
4531
4532static __be32
4533nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr,
4534		     union nfsd4_op_u *u)
4535{
4536	struct nfsd4_readdir *readdir = &u->readdir;
4537	struct xdr_stream *xdr = resp->xdr;
4538	int starting_len = xdr->buf->len;
4539
4540	/* cookieverf */
4541	nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf);
4542	if (nfserr != nfs_ok)
4543		return nfserr;
 
 
 
4544
4545	/* reply */
4546	nfserr = nfsd4_encode_dirlist4(xdr, readdir, svc_max_payload(resp->rqstp));
4547	if (nfserr != nfs_ok)
4548		xdr_truncate_encode(xdr, starting_len);
4549	return nfserr;
4550}
4551
4552static __be32
4553nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr,
4554		    union nfsd4_op_u *u)
4555{
4556	struct nfsd4_remove *remove = &u->remove;
4557	struct xdr_stream *xdr = resp->xdr;
4558
4559	return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo);
4560}
4561
4562static __be32
4563nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr,
4564		    union nfsd4_op_u *u)
4565{
4566	struct nfsd4_rename *rename = &u->rename;
4567	struct xdr_stream *xdr = resp->xdr;
4568
4569	nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo);
4570	if (nfserr)
4571		return nfserr;
4572	return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo);
 
4573}
4574
4575static __be32
4576nfsd4_encode_rpcsec_gss_info(struct xdr_stream *xdr,
4577			     struct rpcsec_gss_info *info)
4578{
4579	__be32 status;
 
4580
4581	/* oid */
4582	if (xdr_stream_encode_opaque(xdr, info->oid.data, info->oid.len) < 0)
4583		return nfserr_resource;
4584	/* qop */
4585	status = nfsd4_encode_qop4(xdr, info->qop);
4586	if (status != nfs_ok)
4587		return status;
4588	/* service */
4589	if (xdr_stream_encode_u32(xdr, info->service) != XDR_UNIT)
4590		return nfserr_resource;
4591
4592	return nfs_ok;
 
4593}
4594
4595static __be32
4596nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)
4597{
4598	u32 i, nflavs, supported;
4599	struct exp_flavor_info *flavs;
4600	struct exp_flavor_info def_flavs[2];
 
4601	static bool report = true;
4602	__be32 *flavorsp;
4603	__be32 status;
4604
4605	if (exp->ex_nflavors) {
4606		flavs = exp->ex_flavors;
4607		nflavs = exp->ex_nflavors;
4608	} else { /* Handling of some defaults in absence of real secinfo: */
4609		flavs = def_flavs;
4610		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
4611			nflavs = 2;
4612			flavs[0].pseudoflavor = RPC_AUTH_UNIX;
4613			flavs[1].pseudoflavor = RPC_AUTH_NULL;
4614		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
4615			nflavs = 1;
4616			flavs[0].pseudoflavor
4617					= svcauth_gss_flavor(exp->ex_client);
4618		} else {
4619			nflavs = 1;
4620			flavs[0].pseudoflavor
4621					= exp->ex_client->flavour->flavour;
4622		}
4623	}
4624
4625	supported = 0;
4626	flavorsp = xdr_reserve_space(xdr, XDR_UNIT);
4627	if (!flavorsp)
4628		return nfserr_resource;
 
4629
4630	for (i = 0; i < nflavs; i++) {
4631		rpc_authflavor_t pf = flavs[i].pseudoflavor;
4632		struct rpcsec_gss_info info;
4633
4634		if (rpcauth_get_gssinfo(pf, &info) == 0) {
4635			supported++;
4636
4637			/* flavor */
4638			status = nfsd4_encode_uint32_t(xdr, RPC_AUTH_GSS);
4639			if (status != nfs_ok)
4640				return status;
4641			/* flavor_info */
4642			status = nfsd4_encode_rpcsec_gss_info(xdr, &info);
4643			if (status != nfs_ok)
4644				return status;
4645		} else if (pf < RPC_AUTH_MAXFLAVOR) {
4646			supported++;
4647
4648			/* flavor */
4649			status = nfsd4_encode_uint32_t(xdr, pf);
4650			if (status != nfs_ok)
4651				return status;
4652		} else {
4653			if (report)
4654				pr_warn("NFS: SECINFO: security flavor %u "
4655					"is not supported\n", pf);
4656		}
4657	}
4658
4659	if (nflavs != supported)
4660		report = false;
4661	*flavorsp = cpu_to_be32(supported);
4662	return 0;
4663}
4664
4665static __be32
4666nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4667		     union nfsd4_op_u *u)
4668{
4669	struct nfsd4_secinfo *secinfo = &u->secinfo;
4670	struct xdr_stream *xdr = resp->xdr;
4671
4672	return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);
4673}
4674
4675static __be32
4676nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
4677		     union nfsd4_op_u *u)
4678{
4679	struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name;
4680	struct xdr_stream *xdr = resp->xdr;
4681
4682	return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);
4683}
4684
 
 
 
 
4685static __be32
4686nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr,
4687		     union nfsd4_op_u *u)
4688{
4689	struct nfsd4_setattr *setattr = &u->setattr;
4690	__be32 status;
4691
4692	switch (nfserr) {
4693	case nfs_ok:
4694		/* attrsset */
4695		status = nfsd4_encode_bitmap4(resp->xdr, setattr->sa_bmval[0],
4696					      setattr->sa_bmval[1],
4697					      setattr->sa_bmval[2]);
4698		break;
4699	default:
4700		/* attrsset */
4701		status = nfsd4_encode_bitmap4(resp->xdr, 0, 0, 0);
 
 
 
 
4702	}
4703	return status != nfs_ok ? status : nfserr;
4704}
4705
4706static __be32
4707nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr,
4708			 union nfsd4_op_u *u)
4709{
4710	struct nfsd4_setclientid *scd = &u->setclientid;
4711	struct xdr_stream *xdr = resp->xdr;
4712
4713	if (!nfserr) {
4714		nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid);
4715		if (nfserr != nfs_ok)
4716			goto out;
4717		nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm);
4718	} else if (nfserr == nfserr_clid_inuse) {
4719		/* empty network id */
4720		if (xdr_stream_encode_u32(xdr, 0) < 0) {
4721			nfserr = nfserr_resource;
4722			goto out;
4723		}
4724		/* empty universal address */
4725		if (xdr_stream_encode_u32(xdr, 0) < 0) {
4726			nfserr = nfserr_resource;
4727			goto out;
4728		}
4729	}
4730out:
4731	return nfserr;
4732}
4733
4734static __be32
4735nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr,
4736		   union nfsd4_op_u *u)
4737{
4738	struct nfsd4_write *write = &u->write;
4739	struct xdr_stream *xdr = resp->xdr;
4740
4741	/* count */
4742	nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written);
4743	if (nfserr)
4744		return nfserr;
4745	/* committed */
4746	if (xdr_stream_encode_u32(xdr, write->wr_how_written) != XDR_UNIT)
4747		return nfserr_resource;
4748	/* writeverf */
4749	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);
 
 
 
4750}
4751
4752static __be32
4753nfsd4_encode_state_protect_ops4(struct xdr_stream *xdr,
4754				struct nfsd4_exchange_id *exid)
4755{
4756	__be32 status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4757
4758	/* spo_must_enforce */
4759	status = nfsd4_encode_bitmap4(xdr, exid->spo_must_enforce[0],
4760				      exid->spo_must_enforce[1],
4761				      exid->spo_must_enforce[2]);
4762	if (status != nfs_ok)
4763		return status;
4764	/* spo_must_allow */
4765	return nfsd4_encode_bitmap4(xdr, exid->spo_must_allow[0],
4766				    exid->spo_must_allow[1],
4767				    exid->spo_must_allow[2]);
4768}
4769
4770static __be32
4771nfsd4_encode_state_protect4_r(struct xdr_stream *xdr, struct nfsd4_exchange_id *exid)
4772{
4773	__be32 status;
4774
4775	if (xdr_stream_encode_u32(xdr, exid->spa_how) != XDR_UNIT)
4776		return nfserr_resource;
4777	switch (exid->spa_how) {
4778	case SP4_NONE:
4779		status = nfs_ok;
4780		break;
4781	case SP4_MACH_CRED:
4782		/* spr_mach_ops */
4783		status = nfsd4_encode_state_protect_ops4(xdr, exid);
 
 
 
 
 
 
 
 
 
 
 
 
4784		break;
4785	default:
4786		status = nfserr_serverfault;
4787	}
4788	return status;
4789}
4790
4791static __be32
4792nfsd4_encode_server_owner4(struct xdr_stream *xdr, struct svc_rqst *rqstp)
4793{
4794	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4795	__be32 status;
 
 
 
 
4796
4797	/* so_minor_id */
4798	status = nfsd4_encode_uint64_t(xdr, 0);
4799	if (status != nfs_ok)
4800		return status;
4801	/* so_major_id */
4802	return nfsd4_encode_opaque(xdr, nn->nfsd_name, strlen(nn->nfsd_name));
4803}
4804
4805static __be32
4806nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
4807			 union nfsd4_op_u *u)
4808{
4809	struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);
4810	struct nfsd4_exchange_id *exid = &u->exchange_id;
4811	struct xdr_stream *xdr = resp->xdr;
4812
4813	/* eir_clientid */
4814	nfserr = nfsd4_encode_clientid4(xdr, &exid->clientid);
4815	if (nfserr != nfs_ok)
4816		return nfserr;
4817	/* eir_sequenceid */
4818	nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid);
4819	if (nfserr != nfs_ok)
4820		return nfserr;
4821	/* eir_flags */
4822	nfserr = nfsd4_encode_uint32_t(xdr, exid->flags);
4823	if (nfserr != nfs_ok)
4824		return nfserr;
4825	/* eir_state_protect */
4826	nfserr = nfsd4_encode_state_protect4_r(xdr, exid);
4827	if (nfserr != nfs_ok)
4828		return nfserr;
4829	/* eir_server_owner */
4830	nfserr = nfsd4_encode_server_owner4(xdr, resp->rqstp);
4831	if (nfserr != nfs_ok)
4832		return nfserr;
4833	/* eir_server_scope */
4834	nfserr = nfsd4_encode_opaque(xdr, nn->nfsd_name,
4835				     strlen(nn->nfsd_name));
4836	if (nfserr != nfs_ok)
4837		return nfserr;
4838	/* eir_server_impl_id<1> */
4839	if (xdr_stream_encode_u32(xdr, 0) != XDR_UNIT)
4840		return nfserr_resource;
4841
4842	return nfs_ok;
 
 
4843}
4844
4845static __be32
4846nfsd4_encode_channel_attrs4(struct xdr_stream *xdr,
4847			    const struct nfsd4_channel_attrs *attrs)
4848{
4849	__be32 status;
 
4850
4851	/* ca_headerpadsize */
4852	status = nfsd4_encode_count4(xdr, 0);
4853	if (status != nfs_ok)
4854		return status;
4855	/* ca_maxrequestsize */
4856	status = nfsd4_encode_count4(xdr, attrs->maxreq_sz);
4857	if (status != nfs_ok)
4858		return status;
4859	/* ca_maxresponsesize */
4860	status = nfsd4_encode_count4(xdr, attrs->maxresp_sz);
4861	if (status != nfs_ok)
4862		return status;
4863	/* ca_maxresponsesize_cached */
4864	status = nfsd4_encode_count4(xdr, attrs->maxresp_cached);
4865	if (status != nfs_ok)
4866		return status;
4867	/* ca_maxoperations */
4868	status = nfsd4_encode_count4(xdr, attrs->maxops);
4869	if (status != nfs_ok)
4870		return status;
4871	/* ca_maxrequests */
4872	status = nfsd4_encode_count4(xdr, attrs->maxreqs);
4873	if (status != nfs_ok)
4874		return status;
4875	/* ca_rdma_ird<1> */
4876	if (xdr_stream_encode_u32(xdr, attrs->nr_rdma_attrs) != XDR_UNIT)
4877		return nfserr_resource;
4878	if (attrs->nr_rdma_attrs)
4879		return nfsd4_encode_uint32_t(xdr, attrs->rdma_attrs);
4880	return nfs_ok;
4881}
4882
4883static __be32
4884nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
4885			    union nfsd4_op_u *u)
4886{
4887	struct nfsd4_create_session *sess = &u->create_session;
4888	struct xdr_stream *xdr = resp->xdr;
 
 
 
 
4889
4890	/* csr_sessionid */
4891	nfserr = nfsd4_encode_sessionid4(xdr, &sess->sessionid);
4892	if (nfserr != nfs_ok)
4893		return nfserr;
4894	/* csr_sequence */
4895	nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid);
4896	if (nfserr != nfs_ok)
4897		return nfserr;
4898	/* csr_flags */
4899	nfserr = nfsd4_encode_uint32_t(xdr, sess->flags);
4900	if (nfserr != nfs_ok)
4901		return nfserr;
4902	/* csr_fore_chan_attrs */
4903	nfserr = nfsd4_encode_channel_attrs4(xdr, &sess->fore_channel);
4904	if (nfserr != nfs_ok)
4905		return nfserr;
4906	/* csr_back_chan_attrs */
4907	return nfsd4_encode_channel_attrs4(xdr, &sess->back_channel);
 
 
 
 
 
 
 
4908}
4909
4910static __be32
4911nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
4912		      union nfsd4_op_u *u)
4913{
4914	struct nfsd4_sequence *seq = &u->sequence;
4915	struct xdr_stream *xdr = resp->xdr;
4916
4917	/* sr_sessionid */
4918	nfserr = nfsd4_encode_sessionid4(xdr, &seq->sessionid);
4919	if (nfserr != nfs_ok)
4920		return nfserr;
4921	/* sr_sequenceid */
4922	nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid);
4923	if (nfserr != nfs_ok)
4924		return nfserr;
4925	/* sr_slotid */
4926	nfserr = nfsd4_encode_slotid4(xdr, seq->slotid);
4927	if (nfserr != nfs_ok)
4928		return nfserr;
4929	/* Note slotid's are numbered from zero: */
4930	/* sr_highest_slotid */
4931	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);
4932	if (nfserr != nfs_ok)
4933		return nfserr;
4934	/* sr_target_highest_slotid */
4935	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);
4936	if (nfserr != nfs_ok)
4937		return nfserr;
4938	/* sr_status_flags */
4939	nfserr = nfsd4_encode_uint32_t(xdr, seq->status_flags);
4940	if (nfserr != nfs_ok)
4941		return nfserr;
4942
4943	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
4944	return nfs_ok;
4945}
4946
4947static __be32
4948nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
4949			  union nfsd4_op_u *u)
4950{
4951	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;
4952	struct nfsd4_test_stateid_id *stateid, *next;
4953	struct xdr_stream *xdr = resp->xdr;
4954
4955	/* tsr_status_codes<> */
4956	if (xdr_stream_encode_u32(xdr, test_stateid->ts_num_ids) != XDR_UNIT)
4957		return nfserr_resource;
4958	list_for_each_entry_safe(stateid, next,
4959				 &test_stateid->ts_stateid_list, ts_id_list) {
4960		if (xdr_stream_encode_be32(xdr, stateid->ts_id_status) != XDR_UNIT)
4961			return nfserr_resource;
4962	}
4963	return nfs_ok;
4964}
4965
4966#ifdef CONFIG_NFSD_PNFS
4967static __be32
4968nfsd4_encode_device_addr4(struct xdr_stream *xdr,
4969			  const struct nfsd4_getdeviceinfo *gdev)
4970{
4971	u32 needed_len, starting_len = xdr->buf->len;
4972	const struct nfsd4_layout_ops *ops;
4973	__be32 status;
4974
4975	/* da_layout_type */
4976	if (xdr_stream_encode_u32(xdr, gdev->gd_layout_type) != XDR_UNIT)
4977		return nfserr_resource;
4978	/* da_addr_body */
4979	ops = nfsd4_layout_ops[gdev->gd_layout_type];
4980	status = ops->encode_getdeviceinfo(xdr, gdev);
4981	if (status != nfs_ok) {
4982		/*
4983		 * Don't burden the layout drivers with enforcing
4984		 * gd_maxcount. Just tell the client to come back
4985		 * with a bigger buffer if it's not enough.
4986		 */
4987		if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount)
4988			goto toosmall;
4989		return status;
4990	}
4991
4992	return nfs_ok;
4993
4994toosmall:
4995	needed_len = xdr->buf->len + XDR_UNIT;	/* notifications */
4996	xdr_truncate_encode(xdr, starting_len);
4997
4998	status = nfsd4_encode_count4(xdr, needed_len);
4999	if (status != nfs_ok)
5000		return status;
5001	return nfserr_toosmall;
5002}
5003
 
5004static __be32
5005nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
5006		union nfsd4_op_u *u)
5007{
5008	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;
5009	struct xdr_stream *xdr = resp->xdr;
5010
5011	/* gdir_device_addr */
5012	nfserr = nfsd4_encode_device_addr4(xdr, gdev);
5013	if (nfserr)
5014		return nfserr;
5015	/* gdir_notification */
5016	return nfsd4_encode_bitmap4(xdr, gdev->gd_notify_types, 0, 0);
5017}
5018
5019static __be32
5020nfsd4_encode_layout4(struct xdr_stream *xdr, const struct nfsd4_layoutget *lgp)
5021{
5022	const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type];
5023	__be32 status;
5024
5025	/* lo_offset */
5026	status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset);
5027	if (status != nfs_ok)
5028		return status;
5029	/* lo_length */
5030	status = nfsd4_encode_length4(xdr, lgp->lg_seg.length);
5031	if (status != nfs_ok)
5032		return status;
5033	/* lo_iomode */
5034	if (xdr_stream_encode_u32(xdr, lgp->lg_seg.iomode) != XDR_UNIT)
5035		return nfserr_resource;
5036	/* lo_content */
5037	if (xdr_stream_encode_u32(xdr, lgp->lg_layout_type) != XDR_UNIT)
5038		return nfserr_resource;
5039	return ops->encode_layoutget(xdr, lgp);
5040}
5041
5042static __be32
5043nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
5044		union nfsd4_op_u *u)
5045{
5046	struct nfsd4_layoutget *lgp = &u->layoutget;
5047	struct xdr_stream *xdr = resp->xdr;
5048
5049	/* logr_return_on_close */
5050	nfserr = nfsd4_encode_bool(xdr, true);
5051	if (nfserr != nfs_ok)
5052		return nfserr;
5053	/* logr_stateid */
5054	nfserr = nfsd4_encode_stateid4(xdr, &lgp->lg_sid);
5055	if (nfserr != nfs_ok)
5056		return nfserr;
5057	/* logr_layout<> */
5058	if (xdr_stream_encode_u32(xdr, 1) != XDR_UNIT)
5059		return nfserr_resource;
5060	return nfsd4_encode_layout4(xdr, lgp);
5061}
5062
5063static __be32
5064nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
5065			  union nfsd4_op_u *u)
5066{
5067	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
5068	struct xdr_stream *xdr = resp->xdr;
5069
5070	/* ns_sizechanged */
5071	nfserr = nfsd4_encode_bool(xdr, lcp->lc_size_chg);
5072	if (nfserr != nfs_ok)
5073		return nfserr;
5074	if (lcp->lc_size_chg)
5075		/* ns_size */
5076		return nfsd4_encode_length4(xdr, lcp->lc_newsize);
5077	return nfs_ok;
5078}
5079
5080static __be32
5081nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
5082		union nfsd4_op_u *u)
5083{
5084	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
5085	struct xdr_stream *xdr = resp->xdr;
5086
5087	/* lrs_present */
5088	nfserr = nfsd4_encode_bool(xdr, lrp->lrs_present);
5089	if (nfserr != nfs_ok)
5090		return nfserr;
5091	if (lrp->lrs_present)
5092		/* lrs_stateid */
5093		return nfsd4_encode_stateid4(xdr, &lrp->lr_sid);
5094	return nfs_ok;
5095}
5096#endif /* CONFIG_NFSD_PNFS */
5097
5098static __be32
5099nfsd4_encode_write_response4(struct xdr_stream *xdr,
5100			     const struct nfsd4_copy *copy)
5101{
5102	const struct nfsd42_write_res *write = &copy->cp_res;
5103	u32 count = nfsd4_copy_is_sync(copy) ? 0 : 1;
5104	__be32 status;
5105
5106	/* wr_callback_id<1> */
5107	if (xdr_stream_encode_u32(xdr, count) != XDR_UNIT)
5108		return nfserr_resource;
5109	if (count) {
5110		status = nfsd4_encode_stateid4(xdr, &write->cb_stateid);
5111		if (status != nfs_ok)
5112			return status;
5113	}
5114
5115	/* wr_count */
5116	status = nfsd4_encode_length4(xdr, write->wr_bytes_written);
5117	if (status != nfs_ok)
5118		return status;
5119	/* wr_committed */
5120	if (xdr_stream_encode_u32(xdr, write->wr_stable_how) != XDR_UNIT)
5121		return nfserr_resource;
5122	/* wr_writeverf */
5123	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);
5124}
5125
5126static __be32 nfsd4_encode_copy_requirements4(struct xdr_stream *xdr,
5127					      const struct nfsd4_copy *copy)
5128{
5129	__be32 status;
5130
5131	/* cr_consecutive */
5132	status = nfsd4_encode_bool(xdr, true);
5133	if (status != nfs_ok)
5134		return status;
5135	/* cr_synchronous */
5136	return nfsd4_encode_bool(xdr, nfsd4_copy_is_sync(copy));
5137}
5138
5139static __be32
5140nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
5141		  union nfsd4_op_u *u)
5142{
5143	struct nfsd4_copy *copy = &u->copy;
5144
5145	nfserr = nfsd4_encode_write_response4(resp->xdr, copy);
5146	if (nfserr != nfs_ok)
5147		return nfserr;
5148	return nfsd4_encode_copy_requirements4(resp->xdr, copy);
5149}
5150
5151static __be32
5152nfsd4_encode_netloc4(struct xdr_stream *xdr, const struct nl4_server *ns)
5153{
5154	__be32 status;
5155
5156	if (xdr_stream_encode_u32(xdr, ns->nl4_type) != XDR_UNIT)
5157		return nfserr_resource;
5158	switch (ns->nl4_type) {
5159	case NL4_NETADDR:
5160		/* nl_addr */
5161		status = nfsd4_encode_netaddr4(xdr, &ns->u.nl4_addr);
5162		break;
5163	default:
5164		status = nfserr_serverfault;
5165	}
5166	return status;
5167}
5168
5169static __be32
5170nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr,
5171			 union nfsd4_op_u *u)
5172{
5173	struct nfsd4_copy_notify *cn = &u->copy_notify;
5174	struct xdr_stream *xdr = resp->xdr;
5175
5176	/* cnr_lease_time */
5177	nfserr = nfsd4_encode_nfstime4(xdr, &cn->cpn_lease_time);
5178	if (nfserr)
5179		return nfserr;
5180	/* cnr_stateid */
5181	nfserr = nfsd4_encode_stateid4(xdr, &cn->cpn_cnr_stateid);
5182	if (nfserr)
5183		return nfserr;
5184	/* cnr_source_server<> */
5185	if (xdr_stream_encode_u32(xdr, 1) != XDR_UNIT)
5186		return nfserr_resource;
5187	return nfsd4_encode_netloc4(xdr, cn->cpn_src);
5188}
5189
5190static __be32
5191nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr,
5192			    union nfsd4_op_u *u)
5193{
5194	struct nfsd4_offload_status *os = &u->offload_status;
5195	struct xdr_stream *xdr = resp->xdr;
5196
5197	/* osr_count */
5198	nfserr = nfsd4_encode_length4(xdr, os->count);
5199	if (nfserr != nfs_ok)
5200		return nfserr;
5201	/* osr_complete<1> */
5202	if (xdr_stream_encode_u32(xdr, 0) != XDR_UNIT)
5203		return nfserr_resource;
5204	return nfs_ok;
5205}
5206
5207static __be32
5208nfsd4_encode_read_plus_data(struct nfsd4_compoundres *resp,
5209			    struct nfsd4_read *read)
5210{
5211	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;
5212	struct file *file = read->rd_nf->nf_file;
5213	struct xdr_stream *xdr = resp->xdr;
5214	bool splice_ok = argp->splice_ok;
5215	unsigned long maxcount;
5216	__be32 nfserr, *p;
5217
5218	/* Content type, offset, byte count */
5219	p = xdr_reserve_space(xdr, 4 + 8 + 4);
5220	if (!p)
5221		return nfserr_io;
5222	if (resp->xdr->buf->page_len && splice_ok) {
5223		WARN_ON_ONCE(splice_ok);
5224		return nfserr_serverfault;
5225	}
5226
5227	maxcount = min_t(unsigned long, read->rd_length,
5228			 (xdr->buf->buflen - xdr->buf->len));
5229
5230	if (file->f_op->splice_read && splice_ok)
5231		nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
5232	else
5233		nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
5234	if (nfserr)
5235		return nfserr;
5236
5237	*p++ = cpu_to_be32(NFS4_CONTENT_DATA);
5238	p = xdr_encode_hyper(p, read->rd_offset);
5239	*p = cpu_to_be32(read->rd_length);
5240
5241	return nfs_ok;
5242}
5243
5244static __be32
5245nfsd4_encode_read_plus(struct nfsd4_compoundres *resp, __be32 nfserr,
5246		       union nfsd4_op_u *u)
5247{
5248	struct nfsd4_read *read = &u->read;
5249	struct file *file = read->rd_nf->nf_file;
5250	struct xdr_stream *xdr = resp->xdr;
5251	int starting_len = xdr->buf->len;
5252	u32 segments = 0;
5253	__be32 *p;
5254
5255	if (nfserr)
5256		return nfserr;
5257
5258	/* eof flag, segment count */
5259	p = xdr_reserve_space(xdr, 4 + 4);
5260	if (!p)
5261		return nfserr_io;
5262	xdr_commit_encode(xdr);
5263
5264	read->rd_eof = read->rd_offset >= i_size_read(file_inode(file));
5265	if (read->rd_eof)
5266		goto out;
5267
5268	nfserr = nfsd4_encode_read_plus_data(resp, read);
5269	if (nfserr) {
5270		xdr_truncate_encode(xdr, starting_len);
5271		return nfserr;
5272	}
5273
5274	segments++;
5275
5276out:
5277	p = xdr_encode_bool(p, read->rd_eof);
5278	*p = cpu_to_be32(segments);
5279	return nfserr;
5280}
5281
5282static __be32
5283nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
5284		  union nfsd4_op_u *u)
5285{
5286	struct nfsd4_seek *seek = &u->seek;
5287	struct xdr_stream *xdr = resp->xdr;
5288
5289	/* sr_eof */
5290	nfserr = nfsd4_encode_bool(xdr, seek->seek_eof);
5291	if (nfserr != nfs_ok)
5292		return nfserr;
5293	/* sr_offset */
5294	return nfsd4_encode_offset4(xdr, seek->seek_pos);
5295}
 
 
 
5296
5297static __be32
5298nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr,
5299		  union nfsd4_op_u *p)
5300{
5301	return nfserr;
5302}
5303
5304/*
5305 * Encode kmalloc-ed buffer in to XDR stream.
5306 */
5307static __be32
5308nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen)
 
5309{
5310	u32 cplen;
5311	__be32 *p;
5312
5313	cplen = min_t(unsigned long, buflen,
5314		      ((void *)xdr->end - (void *)xdr->p));
5315	p = xdr_reserve_space(xdr, cplen);
5316	if (!p)
5317		return nfserr_resource;
5318
5319	memcpy(p, buf, cplen);
5320	buf += cplen;
5321	buflen -= cplen;
5322
5323	while (buflen) {
5324		cplen = min_t(u32, buflen, PAGE_SIZE);
5325		p = xdr_reserve_space(xdr, cplen);
5326		if (!p)
5327			return nfserr_resource;
5328
5329		memcpy(p, buf, cplen);
5330
5331		if (cplen < PAGE_SIZE) {
5332			/*
5333			 * We're done, with a length that wasn't page
5334			 * aligned, so possibly not word aligned. Pad
5335			 * any trailing bytes with 0.
5336			 */
5337			xdr_encode_opaque_fixed(p, NULL, cplen);
5338			break;
5339		}
5340
5341		buflen -= PAGE_SIZE;
5342		buf += PAGE_SIZE;
5343	}
5344
5345	return 0;
5346}
5347
5348static __be32
5349nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5350		      union nfsd4_op_u *u)
5351{
5352	struct nfsd4_getxattr *getxattr = &u->getxattr;
5353	struct xdr_stream *xdr = resp->xdr;
5354	__be32 *p, err;
5355
5356	p = xdr_reserve_space(xdr, 4);
5357	if (!p)
5358		return nfserr_resource;
5359
5360	*p = cpu_to_be32(getxattr->getxa_len);
5361
5362	if (getxattr->getxa_len == 0)
5363		return 0;
5364
5365	err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,
5366				    getxattr->getxa_len);
5367
5368	kvfree(getxattr->getxa_buf);
5369
5370	return err;
5371}
 
5372
5373static __be32
5374nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5375		      union nfsd4_op_u *u)
5376{
5377	struct nfsd4_setxattr *setxattr = &u->setxattr;
5378	struct xdr_stream *xdr = resp->xdr;
 
 
 
5379
5380	return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo);
 
 
 
 
 
5381}
5382
5383/*
5384 * See if there are cookie values that can be rejected outright.
5385 */
5386static __be32
5387nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs,
5388				u32 *offsetp)
5389{
5390	u64 cookie = listxattrs->lsxa_cookie;
5391
5392	/*
5393	 * If the cookie is larger than the maximum number we can fit
5394	 * in the buffer we just got back from vfs_listxattr, it's invalid.
5395	 */
5396	if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))
5397		return nfserr_badcookie;
5398
5399	*offsetp = (u32)cookie;
 
 
5400	return 0;
5401}
5402
5403static __be32
5404nfsd4_encode_listxattrs(struct nfsd4_compoundres *resp, __be32 nfserr,
5405			union nfsd4_op_u *u)
5406{
5407	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;
5408	struct xdr_stream *xdr = resp->xdr;
5409	u32 cookie_offset, count_offset, eof;
5410	u32 left, xdrleft, slen, count;
5411	u32 xdrlen, offset;
5412	u64 cookie;
5413	char *sp;
5414	__be32 status, tmp;
5415	__be64 wire_cookie;
5416	__be32 *p;
5417	u32 nuser;
5418
5419	eof = 1;
5420
5421	status = nfsd4_listxattr_validate_cookie(listxattrs, &offset);
5422	if (status)
5423		goto out;
5424
5425	/*
5426	 * Reserve space for the cookie and the name array count. Record
5427	 * the offsets to save them later.
5428	 */
5429	cookie_offset = xdr->buf->len;
5430	count_offset = cookie_offset + 8;
5431	p = xdr_reserve_space(xdr, XDR_UNIT * 3);
5432	if (!p) {
5433		status = nfserr_resource;
5434		goto out;
5435	}
5436
5437	count = 0;
5438	left = listxattrs->lsxa_len;
5439	sp = listxattrs->lsxa_buf;
5440	nuser = 0;
5441
5442	/* Bytes left is maxcount - 8 (cookie) - 4 (array count) */
5443	xdrleft = listxattrs->lsxa_maxcount - XDR_UNIT * 3;
5444
5445	while (left > 0 && xdrleft > 0) {
5446		slen = strlen(sp);
5447
5448		/*
5449		 * Check if this is a "user." attribute, skip it if not.
5450		 */
5451		if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
5452			goto contloop;
5453
5454		slen -= XATTR_USER_PREFIX_LEN;
5455		xdrlen = 4 + ((slen + 3) & ~3);
5456		/* Check if both entry and eof can fit in the XDR buffer */
5457		if (xdrlen + XDR_UNIT > xdrleft) {
5458			if (count == 0) {
5459				/*
5460				 * Can't even fit the first attribute name.
5461				 */
5462				status = nfserr_toosmall;
5463				goto out;
5464			}
5465			eof = 0;
5466			goto wreof;
5467		}
5468
5469		left -= XATTR_USER_PREFIX_LEN;
5470		sp += XATTR_USER_PREFIX_LEN;
5471		if (nuser++ < offset)
5472			goto contloop;
5473
5474
5475		p = xdr_reserve_space(xdr, xdrlen);
5476		if (!p) {
5477			status = nfserr_resource;
5478			goto out;
5479		}
5480
5481		xdr_encode_opaque(p, sp, slen);
5482
5483		xdrleft -= xdrlen;
5484		count++;
5485contloop:
5486		sp += slen + 1;
5487		left -= slen + 1;
5488	}
5489
5490	/*
5491	 * If there were user attributes to copy, but we didn't copy
5492	 * any, the offset was too large (e.g. the cookie was invalid).
5493	 */
5494	if (nuser > 0 && count == 0) {
5495		status = nfserr_badcookie;
5496		goto out;
5497	}
5498
5499wreof:
5500	p = xdr_reserve_space(xdr, 4);
5501	if (!p) {
5502		status = nfserr_resource;
5503		goto out;
5504	}
5505	*p = cpu_to_be32(eof);
5506
5507	cookie = offset + count;
5508
5509	wire_cookie = cpu_to_be64(cookie);
5510	write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &wire_cookie, 8);
5511	tmp = cpu_to_be32(count);
5512	write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);
5513out:
5514	if (listxattrs->lsxa_len)
5515		kvfree(listxattrs->lsxa_buf);
5516	return status;
5517}
5518
5519static __be32
5520nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5521			 union nfsd4_op_u *u)
5522{
5523	struct nfsd4_removexattr *removexattr = &u->removexattr;
5524	struct xdr_stream *xdr = resp->xdr;
5525
5526	return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo);
5527}
5528
5529typedef __be32(*nfsd4_enc)(struct nfsd4_compoundres *, __be32, union nfsd4_op_u *u);
5530
5531/*
5532 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5533 * since we don't need to filter out obsolete ops as this is
5534 * done in the decoding phase.
5535 */
5536static const nfsd4_enc nfsd4_enc_ops[] = {
5537	[OP_ACCESS]		= nfsd4_encode_access,
5538	[OP_CLOSE]		= nfsd4_encode_close,
5539	[OP_COMMIT]		= nfsd4_encode_commit,
5540	[OP_CREATE]		= nfsd4_encode_create,
5541	[OP_DELEGPURGE]		= nfsd4_encode_noop,
5542	[OP_DELEGRETURN]	= nfsd4_encode_noop,
5543	[OP_GETATTR]		= nfsd4_encode_getattr,
5544	[OP_GETFH]		= nfsd4_encode_getfh,
5545	[OP_LINK]		= nfsd4_encode_link,
5546	[OP_LOCK]		= nfsd4_encode_lock,
5547	[OP_LOCKT]		= nfsd4_encode_lockt,
5548	[OP_LOCKU]		= nfsd4_encode_locku,
5549	[OP_LOOKUP]		= nfsd4_encode_noop,
5550	[OP_LOOKUPP]		= nfsd4_encode_noop,
5551	[OP_NVERIFY]		= nfsd4_encode_noop,
5552	[OP_OPEN]		= nfsd4_encode_open,
5553	[OP_OPENATTR]		= nfsd4_encode_noop,
5554	[OP_OPEN_CONFIRM]	= nfsd4_encode_open_confirm,
5555	[OP_OPEN_DOWNGRADE]	= nfsd4_encode_open_downgrade,
5556	[OP_PUTFH]		= nfsd4_encode_noop,
5557	[OP_PUTPUBFH]		= nfsd4_encode_noop,
5558	[OP_PUTROOTFH]		= nfsd4_encode_noop,
5559	[OP_READ]		= nfsd4_encode_read,
5560	[OP_READDIR]		= nfsd4_encode_readdir,
5561	[OP_READLINK]		= nfsd4_encode_readlink,
5562	[OP_REMOVE]		= nfsd4_encode_remove,
5563	[OP_RENAME]		= nfsd4_encode_rename,
5564	[OP_RENEW]		= nfsd4_encode_noop,
5565	[OP_RESTOREFH]		= nfsd4_encode_noop,
5566	[OP_SAVEFH]		= nfsd4_encode_noop,
5567	[OP_SECINFO]		= nfsd4_encode_secinfo,
5568	[OP_SETATTR]		= nfsd4_encode_setattr,
5569	[OP_SETCLIENTID]	= nfsd4_encode_setclientid,
5570	[OP_SETCLIENTID_CONFIRM] = nfsd4_encode_noop,
5571	[OP_VERIFY]		= nfsd4_encode_noop,
5572	[OP_WRITE]		= nfsd4_encode_write,
5573	[OP_RELEASE_LOCKOWNER]	= nfsd4_encode_noop,
5574
5575	/* NFSv4.1 operations */
5576	[OP_BACKCHANNEL_CTL]	= nfsd4_encode_noop,
5577	[OP_BIND_CONN_TO_SESSION] = nfsd4_encode_bind_conn_to_session,
5578	[OP_EXCHANGE_ID]	= nfsd4_encode_exchange_id,
5579	[OP_CREATE_SESSION]	= nfsd4_encode_create_session,
5580	[OP_DESTROY_SESSION]	= nfsd4_encode_noop,
5581	[OP_FREE_STATEID]	= nfsd4_encode_noop,
5582	[OP_GET_DIR_DELEGATION]	= nfsd4_encode_noop,
5583#ifdef CONFIG_NFSD_PNFS
5584	[OP_GETDEVICEINFO]	= nfsd4_encode_getdeviceinfo,
5585	[OP_GETDEVICELIST]	= nfsd4_encode_noop,
5586	[OP_LAYOUTCOMMIT]	= nfsd4_encode_layoutcommit,
5587	[OP_LAYOUTGET]		= nfsd4_encode_layoutget,
5588	[OP_LAYOUTRETURN]	= nfsd4_encode_layoutreturn,
5589#else
5590	[OP_GETDEVICEINFO]	= nfsd4_encode_noop,
5591	[OP_GETDEVICELIST]	= nfsd4_encode_noop,
5592	[OP_LAYOUTCOMMIT]	= nfsd4_encode_noop,
5593	[OP_LAYOUTGET]		= nfsd4_encode_noop,
5594	[OP_LAYOUTRETURN]	= nfsd4_encode_noop,
5595#endif
5596	[OP_SECINFO_NO_NAME]	= nfsd4_encode_secinfo_no_name,
5597	[OP_SEQUENCE]		= nfsd4_encode_sequence,
5598	[OP_SET_SSV]		= nfsd4_encode_noop,
5599	[OP_TEST_STATEID]	= nfsd4_encode_test_stateid,
5600	[OP_WANT_DELEGATION]	= nfsd4_encode_noop,
5601	[OP_DESTROY_CLIENTID]	= nfsd4_encode_noop,
5602	[OP_RECLAIM_COMPLETE]	= nfsd4_encode_noop,
5603
5604	/* NFSv4.2 operations */
5605	[OP_ALLOCATE]		= nfsd4_encode_noop,
5606	[OP_COPY]		= nfsd4_encode_copy,
5607	[OP_COPY_NOTIFY]	= nfsd4_encode_copy_notify,
5608	[OP_DEALLOCATE]		= nfsd4_encode_noop,
5609	[OP_IO_ADVISE]		= nfsd4_encode_noop,
5610	[OP_LAYOUTERROR]	= nfsd4_encode_noop,
5611	[OP_LAYOUTSTATS]	= nfsd4_encode_noop,
5612	[OP_OFFLOAD_CANCEL]	= nfsd4_encode_noop,
5613	[OP_OFFLOAD_STATUS]	= nfsd4_encode_offload_status,
5614	[OP_READ_PLUS]		= nfsd4_encode_read_plus,
5615	[OP_SEEK]		= nfsd4_encode_seek,
5616	[OP_WRITE_SAME]		= nfsd4_encode_noop,
5617	[OP_CLONE]		= nfsd4_encode_noop,
5618
5619	/* RFC 8276 extended atributes operations */
5620	[OP_GETXATTR]		= nfsd4_encode_getxattr,
5621	[OP_SETXATTR]		= nfsd4_encode_setxattr,
5622	[OP_LISTXATTRS]		= nfsd4_encode_listxattrs,
5623	[OP_REMOVEXATTR]	= nfsd4_encode_removexattr,
5624};
5625
5626/*
5627 * Calculate whether we still have space to encode repsize bytes.
5628 * There are two considerations:
5629 *     - For NFS versions >=4.1, the size of the reply must stay within
5630 *       session limits
5631 *     - For all NFS versions, we must stay within limited preallocated
5632 *       buffer space.
5633 *
5634 * This is called before the operation is processed, so can only provide
5635 * an upper estimate.  For some nonidempotent operations (such as
5636 * getattr), it's not necessarily a problem if that estimate is wrong,
5637 * as we can fail it after processing without significant side effects.
5638 */
5639__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
5640{
5641	struct xdr_buf *buf = &resp->rqstp->rq_res;
5642	struct nfsd4_slot *slot = resp->cstate.slot;
5643
5644	if (buf->len + respsize <= buf->buflen)
5645		return nfs_ok;
5646	if (!nfsd4_has_session(&resp->cstate))
5647		return nfserr_resource;
5648	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
5649		WARN_ON_ONCE(1);
5650		return nfserr_rep_too_big_to_cache;
5651	}
5652	return nfserr_rep_too_big;
5653}
5654
5655void
5656nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
5657{
5658	struct xdr_stream *xdr = resp->xdr;
5659	struct nfs4_stateowner *so = resp->cstate.replay_owner;
5660	struct svc_rqst *rqstp = resp->rqstp;
5661	const struct nfsd4_operation *opdesc = op->opdesc;
5662	int post_err_offset;
5663	nfsd4_enc encoder;
5664	__be32 *p;
5665
5666	p = xdr_reserve_space(xdr, 8);
5667	if (!p)
5668		goto release;
 
 
5669	*p++ = cpu_to_be32(op->opnum);
5670	post_err_offset = xdr->buf->len;
5671
5672	if (op->opnum == OP_ILLEGAL)
5673		goto status;
5674	if (op->status && opdesc &&
5675			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))
5676		goto status;
5677	BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
5678	       !nfsd4_enc_ops[op->opnum]);
5679	encoder = nfsd4_enc_ops[op->opnum];
5680	op->status = encoder(resp, op->status, &op->u);
5681	if (op->status)
5682		trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);
5683	xdr_commit_encode(xdr);
5684
5685	/* nfsd4_check_resp_size guarantees enough room for error status */
5686	if (!op->status) {
5687		int space_needed = 0;
5688		if (!nfsd4_last_compound_op(rqstp))
5689			space_needed = COMPOUND_ERR_SLACK_SPACE;
5690		op->status = nfsd4_check_resp_size(resp, space_needed);
5691	}
5692	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
5693		struct nfsd4_slot *slot = resp->cstate.slot;
5694
5695		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
5696			op->status = nfserr_rep_too_big_to_cache;
5697		else
5698			op->status = nfserr_rep_too_big;
5699	}
5700	if (op->status == nfserr_resource ||
5701	    op->status == nfserr_rep_too_big ||
5702	    op->status == nfserr_rep_too_big_to_cache) {
5703		/*
5704		 * The operation may have already been encoded or
5705		 * partially encoded.  No op returns anything additional
5706		 * in the case of one of these three errors, so we can
5707		 * just truncate back to after the status.  But it's a
5708		 * bug if we had to do this on a non-idempotent op:
5709		 */
5710		warn_on_nonidempotent_op(op);
5711		xdr_truncate_encode(xdr, post_err_offset);
5712	}
5713	if (so) {
5714		int len = xdr->buf->len - post_err_offset;
5715
5716		so->so_replay.rp_status = op->status;
5717		so->so_replay.rp_buflen = len;
5718		read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
5719						so->so_replay.rp_buf, len);
5720	}
5721status:
5722	*p = op->status;
5723release:
5724	if (opdesc && opdesc->op_release)
5725		opdesc->op_release(&op->u);
5726
5727	/*
5728	 * Account for pages consumed while encoding this operation.
5729	 * The xdr_stream primitives don't manage rq_next_page.
5730	 */
5731	rqstp->rq_next_page = xdr->page_ptr + 1;
5732}
5733
5734/**
5735 * nfsd4_encode_replay - encode a result stored in the stateowner reply cache
5736 * @xdr: send buffer's XDR stream
5737 * @op: operation being replayed
5738 *
5739 * @op->replay->rp_buf contains the previously-sent already-encoded result.
5740 */
5741void nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
 
5742{
 
5743	struct nfs4_replay *rp = op->replay;
5744
5745	trace_nfsd_stateowner_replay(op->opnum, rp);
5746
5747	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)
5748		return;
5749	if (xdr_stream_encode_be32(xdr, rp->rp_status) != XDR_UNIT)
5750		return;
5751	xdr_stream_encode_opaque_fixed(xdr, rp->rp_buf, rp->rp_buflen);
 
 
 
 
 
 
 
 
 
 
5752}
5753
5754void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
5755{
5756	struct nfsd4_compoundargs *args = rqstp->rq_argp;
5757
5758	if (args->ops != args->iops) {
5759		vfree(args->ops);
5760		args->ops = args->iops;
5761	}
 
 
5762	while (args->to_free) {
5763		struct svcxdr_tmpbuf *tb = args->to_free;
5764		args->to_free = tb->next;
5765		kfree(tb);
5766	}
5767}
5768
5769bool
5770nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5771{
5772	struct nfsd4_compoundargs *args = rqstp->rq_argp;
5773
5774	/* svcxdr_tmp_alloc */
 
 
 
 
 
 
 
 
 
 
 
5775	args->to_free = NULL;
5776
5777	args->xdr = xdr;
5778	args->ops = args->iops;
5779	args->rqstp = rqstp;
5780
5781	return nfsd4_decode_compound(args);
5782}
5783
5784bool
5785nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5786{
5787	struct nfsd4_compoundres *resp = rqstp->rq_resp;
5788	__be32 *p;
5789
5790	/*
5791	 * Send buffer space for the following items is reserved
5792	 * at the top of nfsd4_proc_compound().
5793	 */
5794	p = resp->statusp;
 
 
 
 
 
 
5795
5796	*p++ = resp->cstate.status;
5797	*p++ = htonl(resp->taglen);
5798	memcpy(p, resp->tag, resp->taglen);
5799	p += XDR_QUADLEN(resp->taglen);
5800	*p++ = htonl(resp->opcnt);
5801
5802	nfsd4_sequence_done(resp);
5803	return true;
5804}