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