Kernel

Kernel Git Source Tree

Root/fs/nfsd/nfs4xdr.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/fs/nfsd/nfs4xdr.c

interactive