xref: /linux/fs/nfsd/nfs3xdr.c (revision 905e46acd3272d04566fec49afbd7ad9e2ed9ae3)
1 /*
2  * XDR support for nfsd/protocol version 3.
3  *
4  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
5  *
6  * 2003-08-09 Jamie Lokier: Use htonl() for nanoseconds, not htons()!
7  */
8 
9 #include <linux/namei.h>
10 #include <linux/sunrpc/svc_xprt.h>
11 #include "xdr3.h"
12 #include "auth.h"
13 #include "netns.h"
14 #include "vfs.h"
15 
16 #define NFSDDBG_FACILITY		NFSDDBG_XDR
17 
18 
19 /*
20  * Mapping of S_IF* types to NFS file types
21  */
22 static u32	nfs3_ftypes[] = {
23 	NF3NON,  NF3FIFO, NF3CHR, NF3BAD,
24 	NF3DIR,  NF3BAD,  NF3BLK, NF3BAD,
25 	NF3REG,  NF3BAD,  NF3LNK, NF3BAD,
26 	NF3SOCK, NF3BAD,  NF3LNK, NF3BAD,
27 };
28 
29 /*
30  * XDR functions for basic NFS types
31  */
32 static __be32 *
33 encode_time3(__be32 *p, struct timespec *time)
34 {
35 	*p++ = htonl((u32) time->tv_sec); *p++ = htonl(time->tv_nsec);
36 	return p;
37 }
38 
39 static __be32 *
40 decode_time3(__be32 *p, struct timespec *time)
41 {
42 	time->tv_sec = ntohl(*p++);
43 	time->tv_nsec = ntohl(*p++);
44 	return p;
45 }
46 
47 static __be32 *
48 decode_fh(__be32 *p, struct svc_fh *fhp)
49 {
50 	unsigned int size;
51 	fh_init(fhp, NFS3_FHSIZE);
52 	size = ntohl(*p++);
53 	if (size > NFS3_FHSIZE)
54 		return NULL;
55 
56 	memcpy(&fhp->fh_handle.fh_base, p, size);
57 	fhp->fh_handle.fh_size = size;
58 	return p + XDR_QUADLEN(size);
59 }
60 
61 /* Helper function for NFSv3 ACL code */
62 __be32 *nfs3svc_decode_fh(__be32 *p, struct svc_fh *fhp)
63 {
64 	return decode_fh(p, fhp);
65 }
66 
67 static __be32 *
68 encode_fh(__be32 *p, struct svc_fh *fhp)
69 {
70 	unsigned int size = fhp->fh_handle.fh_size;
71 	*p++ = htonl(size);
72 	if (size) p[XDR_QUADLEN(size)-1]=0;
73 	memcpy(p, &fhp->fh_handle.fh_base, size);
74 	return p + XDR_QUADLEN(size);
75 }
76 
77 /*
78  * Decode a file name and make sure that the path contains
79  * no slashes or null bytes.
80  */
81 static __be32 *
82 decode_filename(__be32 *p, char **namp, unsigned int *lenp)
83 {
84 	char		*name;
85 	unsigned int	i;
86 
87 	if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS3_MAXNAMLEN)) != NULL) {
88 		for (i = 0, name = *namp; i < *lenp; i++, name++) {
89 			if (*name == '\0' || *name == '/')
90 				return NULL;
91 		}
92 	}
93 
94 	return p;
95 }
96 
97 static __be32 *
98 decode_sattr3(__be32 *p, struct iattr *iap)
99 {
100 	u32	tmp;
101 
102 	iap->ia_valid = 0;
103 
104 	if (*p++) {
105 		iap->ia_valid |= ATTR_MODE;
106 		iap->ia_mode = ntohl(*p++);
107 	}
108 	if (*p++) {
109 		iap->ia_uid = make_kuid(&init_user_ns, ntohl(*p++));
110 		if (uid_valid(iap->ia_uid))
111 			iap->ia_valid |= ATTR_UID;
112 	}
113 	if (*p++) {
114 		iap->ia_gid = make_kgid(&init_user_ns, ntohl(*p++));
115 		if (gid_valid(iap->ia_gid))
116 			iap->ia_valid |= ATTR_GID;
117 	}
118 	if (*p++) {
119 		u64	newsize;
120 
121 		iap->ia_valid |= ATTR_SIZE;
122 		p = xdr_decode_hyper(p, &newsize);
123 		iap->ia_size = min_t(u64, newsize, NFS_OFFSET_MAX);
124 	}
125 	if ((tmp = ntohl(*p++)) == 1) {	/* set to server time */
126 		iap->ia_valid |= ATTR_ATIME;
127 	} else if (tmp == 2) {		/* set to client time */
128 		iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
129 		iap->ia_atime.tv_sec = ntohl(*p++);
130 		iap->ia_atime.tv_nsec = ntohl(*p++);
131 	}
132 	if ((tmp = ntohl(*p++)) == 1) {	/* set to server time */
133 		iap->ia_valid |= ATTR_MTIME;
134 	} else if (tmp == 2) {		/* set to client time */
135 		iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
136 		iap->ia_mtime.tv_sec = ntohl(*p++);
137 		iap->ia_mtime.tv_nsec = ntohl(*p++);
138 	}
139 	return p;
140 }
141 
142 static __be32 *encode_fsid(__be32 *p, struct svc_fh *fhp)
143 {
144 	u64 f;
145 	switch(fsid_source(fhp)) {
146 	default:
147 	case FSIDSOURCE_DEV:
148 		p = xdr_encode_hyper(p, (u64)huge_encode_dev
149 				     (fhp->fh_dentry->d_sb->s_dev));
150 		break;
151 	case FSIDSOURCE_FSID:
152 		p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid);
153 		break;
154 	case FSIDSOURCE_UUID:
155 		f = ((u64*)fhp->fh_export->ex_uuid)[0];
156 		f ^= ((u64*)fhp->fh_export->ex_uuid)[1];
157 		p = xdr_encode_hyper(p, f);
158 		break;
159 	}
160 	return p;
161 }
162 
163 static __be32 *
164 encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
165 	      struct kstat *stat)
166 {
167 	*p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);
168 	*p++ = htonl((u32) (stat->mode & S_IALLUGO));
169 	*p++ = htonl((u32) stat->nlink);
170 	*p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid));
171 	*p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid));
172 	if (S_ISLNK(stat->mode) && stat->size > NFS3_MAXPATHLEN) {
173 		p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);
174 	} else {
175 		p = xdr_encode_hyper(p, (u64) stat->size);
176 	}
177 	p = xdr_encode_hyper(p, ((u64)stat->blocks) << 9);
178 	*p++ = htonl((u32) MAJOR(stat->rdev));
179 	*p++ = htonl((u32) MINOR(stat->rdev));
180 	p = encode_fsid(p, fhp);
181 	p = xdr_encode_hyper(p, stat->ino);
182 	p = encode_time3(p, &stat->atime);
183 	p = encode_time3(p, &stat->mtime);
184 	p = encode_time3(p, &stat->ctime);
185 
186 	return p;
187 }
188 
189 static __be32 *
190 encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
191 {
192 	/* Attributes to follow */
193 	*p++ = xdr_one;
194 	return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);
195 }
196 
197 /*
198  * Encode post-operation attributes.
199  * The inode may be NULL if the call failed because of a stale file
200  * handle. In this case, no attributes are returned.
201  */
202 static __be32 *
203 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
204 {
205 	struct dentry *dentry = fhp->fh_dentry;
206 	if (dentry && d_really_is_positive(dentry)) {
207 	        __be32 err;
208 		struct kstat stat;
209 
210 		err = fh_getattr(fhp, &stat);
211 		if (!err) {
212 			*p++ = xdr_one;		/* attributes follow */
213 			lease_get_mtime(d_inode(dentry), &stat.mtime);
214 			return encode_fattr3(rqstp, p, fhp, &stat);
215 		}
216 	}
217 	*p++ = xdr_zero;
218 	return p;
219 }
220 
221 /* Helper for NFSv3 ACLs */
222 __be32 *
223 nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
224 {
225 	return encode_post_op_attr(rqstp, p, fhp);
226 }
227 
228 /*
229  * Enocde weak cache consistency data
230  */
231 static __be32 *
232 encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
233 {
234 	struct dentry	*dentry = fhp->fh_dentry;
235 
236 	if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) {
237 		if (fhp->fh_pre_saved) {
238 			*p++ = xdr_one;
239 			p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size);
240 			p = encode_time3(p, &fhp->fh_pre_mtime);
241 			p = encode_time3(p, &fhp->fh_pre_ctime);
242 		} else {
243 			*p++ = xdr_zero;
244 		}
245 		return encode_saved_post_attr(rqstp, p, fhp);
246 	}
247 	/* no pre- or post-attrs */
248 	*p++ = xdr_zero;
249 	return encode_post_op_attr(rqstp, p, fhp);
250 }
251 
252 /*
253  * Fill in the post_op attr for the wcc data
254  */
255 void fill_post_wcc(struct svc_fh *fhp)
256 {
257 	__be32 err;
258 
259 	if (fhp->fh_post_saved)
260 		printk("nfsd: inode locked twice during operation.\n");
261 
262 	err = fh_getattr(fhp, &fhp->fh_post_attr);
263 	fhp->fh_post_change = d_inode(fhp->fh_dentry)->i_version;
264 	if (err) {
265 		fhp->fh_post_saved = false;
266 		/* Grab the ctime anyway - set_change_info might use it */
267 		fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime;
268 	} else
269 		fhp->fh_post_saved = true;
270 }
271 
272 /*
273  * XDR decode functions
274  */
275 int
276 nfs3svc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args)
277 {
278 	p = decode_fh(p, &args->fh);
279 	if (!p)
280 		return 0;
281 	return xdr_argsize_check(rqstp, p);
282 }
283 
284 int
285 nfs3svc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p,
286 					struct nfsd3_sattrargs *args)
287 {
288 	p = decode_fh(p, &args->fh);
289 	if (!p)
290 		return 0;
291 	p = decode_sattr3(p, &args->attrs);
292 
293 	if ((args->check_guard = ntohl(*p++)) != 0) {
294 		struct timespec time;
295 		p = decode_time3(p, &time);
296 		args->guardtime = time.tv_sec;
297 	}
298 
299 	return xdr_argsize_check(rqstp, p);
300 }
301 
302 int
303 nfs3svc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p,
304 					struct nfsd3_diropargs *args)
305 {
306 	if (!(p = decode_fh(p, &args->fh))
307 	 || !(p = decode_filename(p, &args->name, &args->len)))
308 		return 0;
309 
310 	return xdr_argsize_check(rqstp, p);
311 }
312 
313 int
314 nfs3svc_decode_accessargs(struct svc_rqst *rqstp, __be32 *p,
315 					struct nfsd3_accessargs *args)
316 {
317 	p = decode_fh(p, &args->fh);
318 	if (!p)
319 		return 0;
320 	args->access = ntohl(*p++);
321 
322 	return xdr_argsize_check(rqstp, p);
323 }
324 
325 int
326 nfs3svc_decode_readargs(struct svc_rqst *rqstp, __be32 *p,
327 					struct nfsd3_readargs *args)
328 {
329 	unsigned int len;
330 	int v;
331 	u32 max_blocksize = svc_max_payload(rqstp);
332 
333 	p = decode_fh(p, &args->fh);
334 	if (!p)
335 		return 0;
336 	p = xdr_decode_hyper(p, &args->offset);
337 	args->count = ntohl(*p++);
338 
339 	if (!xdr_argsize_check(rqstp, p))
340 		return 0;
341 
342 	len = min(args->count, max_blocksize);
343 
344 	/* set up the kvec */
345 	v=0;
346 	while (len > 0) {
347 		struct page *p = *(rqstp->rq_next_page++);
348 
349 		rqstp->rq_vec[v].iov_base = page_address(p);
350 		rqstp->rq_vec[v].iov_len = min_t(unsigned int, len, PAGE_SIZE);
351 		len -= rqstp->rq_vec[v].iov_len;
352 		v++;
353 	}
354 	args->vlen = v;
355 	return 1;
356 }
357 
358 int
359 nfs3svc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p,
360 					struct nfsd3_writeargs *args)
361 {
362 	unsigned int len, v, hdr, dlen;
363 	u32 max_blocksize = svc_max_payload(rqstp);
364 	struct kvec *head = rqstp->rq_arg.head;
365 	struct kvec *tail = rqstp->rq_arg.tail;
366 
367 	p = decode_fh(p, &args->fh);
368 	if (!p)
369 		return 0;
370 	p = xdr_decode_hyper(p, &args->offset);
371 
372 	args->count = ntohl(*p++);
373 	args->stable = ntohl(*p++);
374 	len = args->len = ntohl(*p++);
375 	if ((void *)p > head->iov_base + head->iov_len)
376 		return 0;
377 	/*
378 	 * The count must equal the amount of data passed.
379 	 */
380 	if (args->count != args->len)
381 		return 0;
382 
383 	/*
384 	 * Check to make sure that we got the right number of
385 	 * bytes.
386 	 */
387 	hdr = (void*)p - head->iov_base;
388 	dlen = head->iov_len + rqstp->rq_arg.page_len + tail->iov_len - hdr;
389 	/*
390 	 * Round the length of the data which was specified up to
391 	 * the next multiple of XDR units and then compare that
392 	 * against the length which was actually received.
393 	 * Note that when RPCSEC/GSS (for example) is used, the
394 	 * data buffer can be padded so dlen might be larger
395 	 * than required.  It must never be smaller.
396 	 */
397 	if (dlen < XDR_QUADLEN(len)*4)
398 		return 0;
399 
400 	if (args->count > max_blocksize) {
401 		args->count = max_blocksize;
402 		len = args->len = max_blocksize;
403 	}
404 	rqstp->rq_vec[0].iov_base = (void*)p;
405 	rqstp->rq_vec[0].iov_len = head->iov_len - hdr;
406 	v = 0;
407 	while (len > rqstp->rq_vec[v].iov_len) {
408 		len -= rqstp->rq_vec[v].iov_len;
409 		v++;
410 		rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]);
411 		rqstp->rq_vec[v].iov_len = PAGE_SIZE;
412 	}
413 	rqstp->rq_vec[v].iov_len = len;
414 	args->vlen = v + 1;
415 	return 1;
416 }
417 
418 int
419 nfs3svc_decode_createargs(struct svc_rqst *rqstp, __be32 *p,
420 					struct nfsd3_createargs *args)
421 {
422 	if (!(p = decode_fh(p, &args->fh))
423 	 || !(p = decode_filename(p, &args->name, &args->len)))
424 		return 0;
425 
426 	switch (args->createmode = ntohl(*p++)) {
427 	case NFS3_CREATE_UNCHECKED:
428 	case NFS3_CREATE_GUARDED:
429 		p = decode_sattr3(p, &args->attrs);
430 		break;
431 	case NFS3_CREATE_EXCLUSIVE:
432 		args->verf = p;
433 		p += 2;
434 		break;
435 	default:
436 		return 0;
437 	}
438 
439 	return xdr_argsize_check(rqstp, p);
440 }
441 int
442 nfs3svc_decode_mkdirargs(struct svc_rqst *rqstp, __be32 *p,
443 					struct nfsd3_createargs *args)
444 {
445 	if (!(p = decode_fh(p, &args->fh)) ||
446 	    !(p = decode_filename(p, &args->name, &args->len)))
447 		return 0;
448 	p = decode_sattr3(p, &args->attrs);
449 
450 	return xdr_argsize_check(rqstp, p);
451 }
452 
453 int
454 nfs3svc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p,
455 					struct nfsd3_symlinkargs *args)
456 {
457 	unsigned int len, avail;
458 	char *old, *new;
459 	struct kvec *vec;
460 
461 	if (!(p = decode_fh(p, &args->ffh)) ||
462 	    !(p = decode_filename(p, &args->fname, &args->flen))
463 		)
464 		return 0;
465 	p = decode_sattr3(p, &args->attrs);
466 
467 	/* now decode the pathname, which might be larger than the first page.
468 	 * As we have to check for nul's anyway, we copy it into a new page
469 	 * This page appears in the rq_res.pages list, but as pages_len is always
470 	 * 0, it won't get in the way
471 	 */
472 	len = ntohl(*p++);
473 	if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
474 		return 0;
475 	args->tname = new = page_address(*(rqstp->rq_next_page++));
476 	args->tlen = len;
477 	/* first copy and check from the first page */
478 	old = (char*)p;
479 	vec = &rqstp->rq_arg.head[0];
480 	if ((void *)old > vec->iov_base + vec->iov_len)
481 		return 0;
482 	avail = vec->iov_len - (old - (char*)vec->iov_base);
483 	while (len && avail && *old) {
484 		*new++ = *old++;
485 		len--;
486 		avail--;
487 	}
488 	/* now copy next page if there is one */
489 	if (len && !avail && rqstp->rq_arg.page_len) {
490 		avail = min_t(unsigned int, rqstp->rq_arg.page_len, PAGE_SIZE);
491 		old = page_address(rqstp->rq_arg.pages[0]);
492 	}
493 	while (len && avail && *old) {
494 		*new++ = *old++;
495 		len--;
496 		avail--;
497 	}
498 	*new = '\0';
499 	if (len)
500 		return 0;
501 
502 	return 1;
503 }
504 
505 int
506 nfs3svc_decode_mknodargs(struct svc_rqst *rqstp, __be32 *p,
507 					struct nfsd3_mknodargs *args)
508 {
509 	if (!(p = decode_fh(p, &args->fh))
510 	 || !(p = decode_filename(p, &args->name, &args->len)))
511 		return 0;
512 
513 	args->ftype = ntohl(*p++);
514 
515 	if (args->ftype == NF3BLK  || args->ftype == NF3CHR
516 	 || args->ftype == NF3SOCK || args->ftype == NF3FIFO)
517 		p = decode_sattr3(p, &args->attrs);
518 
519 	if (args->ftype == NF3BLK || args->ftype == NF3CHR) {
520 		args->major = ntohl(*p++);
521 		args->minor = ntohl(*p++);
522 	}
523 
524 	return xdr_argsize_check(rqstp, p);
525 }
526 
527 int
528 nfs3svc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p,
529 					struct nfsd3_renameargs *args)
530 {
531 	if (!(p = decode_fh(p, &args->ffh))
532 	 || !(p = decode_filename(p, &args->fname, &args->flen))
533 	 || !(p = decode_fh(p, &args->tfh))
534 	 || !(p = decode_filename(p, &args->tname, &args->tlen)))
535 		return 0;
536 
537 	return xdr_argsize_check(rqstp, p);
538 }
539 
540 int
541 nfs3svc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p,
542 					struct nfsd3_readlinkargs *args)
543 {
544 	p = decode_fh(p, &args->fh);
545 	if (!p)
546 		return 0;
547 	if (!xdr_argsize_check(rqstp, p))
548 		return 0;
549 	args->buffer = page_address(*(rqstp->rq_next_page++));
550 
551 	return 1;
552 }
553 
554 int
555 nfs3svc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p,
556 					struct nfsd3_linkargs *args)
557 {
558 	if (!(p = decode_fh(p, &args->ffh))
559 	 || !(p = decode_fh(p, &args->tfh))
560 	 || !(p = decode_filename(p, &args->tname, &args->tlen)))
561 		return 0;
562 
563 	return xdr_argsize_check(rqstp, p);
564 }
565 
566 int
567 nfs3svc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p,
568 					struct nfsd3_readdirargs *args)
569 {
570 	p = decode_fh(p, &args->fh);
571 	if (!p)
572 		return 0;
573 	p = xdr_decode_hyper(p, &args->cookie);
574 	args->verf   = p; p += 2;
575 	args->dircount = ~0;
576 	args->count  = ntohl(*p++);
577 
578 	if (!xdr_argsize_check(rqstp, p))
579 		return 0;
580 
581 	args->count  = min_t(u32, args->count, PAGE_SIZE);
582 	args->buffer = page_address(*(rqstp->rq_next_page++));
583 
584 	return 1;
585 }
586 
587 int
588 nfs3svc_decode_readdirplusargs(struct svc_rqst *rqstp, __be32 *p,
589 					struct nfsd3_readdirargs *args)
590 {
591 	int len;
592 	u32 max_blocksize = svc_max_payload(rqstp);
593 
594 	p = decode_fh(p, &args->fh);
595 	if (!p)
596 		return 0;
597 	p = xdr_decode_hyper(p, &args->cookie);
598 	args->verf     = p; p += 2;
599 	args->dircount = ntohl(*p++);
600 	args->count    = ntohl(*p++);
601 
602 	if (!xdr_argsize_check(rqstp, p))
603 		return 0;
604 
605 	len = args->count = min(args->count, max_blocksize);
606 	while (len > 0) {
607 		struct page *p = *(rqstp->rq_next_page++);
608 		if (!args->buffer)
609 			args->buffer = page_address(p);
610 		len -= PAGE_SIZE;
611 	}
612 	return 1;
613 }
614 
615 int
616 nfs3svc_decode_commitargs(struct svc_rqst *rqstp, __be32 *p,
617 					struct nfsd3_commitargs *args)
618 {
619 	p = decode_fh(p, &args->fh);
620 	if (!p)
621 		return 0;
622 	p = xdr_decode_hyper(p, &args->offset);
623 	args->count = ntohl(*p++);
624 
625 	return xdr_argsize_check(rqstp, p);
626 }
627 
628 /*
629  * XDR encode functions
630  */
631 /*
632  * There must be an encoding function for void results so svc_process
633  * will work properly.
634  */
635 int
636 nfs3svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy)
637 {
638 	return xdr_ressize_check(rqstp, p);
639 }
640 
641 /* GETATTR */
642 int
643 nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,
644 					struct nfsd3_attrstat *resp)
645 {
646 	if (resp->status == 0) {
647 		lease_get_mtime(d_inode(resp->fh.fh_dentry),
648 				&resp->stat.mtime);
649 		p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);
650 	}
651 	return xdr_ressize_check(rqstp, p);
652 }
653 
654 /* SETATTR, REMOVE, RMDIR */
655 int
656 nfs3svc_encode_wccstat(struct svc_rqst *rqstp, __be32 *p,
657 					struct nfsd3_attrstat *resp)
658 {
659 	p = encode_wcc_data(rqstp, p, &resp->fh);
660 	return xdr_ressize_check(rqstp, p);
661 }
662 
663 /* LOOKUP */
664 int
665 nfs3svc_encode_diropres(struct svc_rqst *rqstp, __be32 *p,
666 					struct nfsd3_diropres *resp)
667 {
668 	if (resp->status == 0) {
669 		p = encode_fh(p, &resp->fh);
670 		p = encode_post_op_attr(rqstp, p, &resp->fh);
671 	}
672 	p = encode_post_op_attr(rqstp, p, &resp->dirfh);
673 	return xdr_ressize_check(rqstp, p);
674 }
675 
676 /* ACCESS */
677 int
678 nfs3svc_encode_accessres(struct svc_rqst *rqstp, __be32 *p,
679 					struct nfsd3_accessres *resp)
680 {
681 	p = encode_post_op_attr(rqstp, p, &resp->fh);
682 	if (resp->status == 0)
683 		*p++ = htonl(resp->access);
684 	return xdr_ressize_check(rqstp, p);
685 }
686 
687 /* READLINK */
688 int
689 nfs3svc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p,
690 					struct nfsd3_readlinkres *resp)
691 {
692 	p = encode_post_op_attr(rqstp, p, &resp->fh);
693 	if (resp->status == 0) {
694 		*p++ = htonl(resp->len);
695 		xdr_ressize_check(rqstp, p);
696 		rqstp->rq_res.page_len = resp->len;
697 		if (resp->len & 3) {
698 			/* need to pad the tail */
699 			rqstp->rq_res.tail[0].iov_base = p;
700 			*p = 0;
701 			rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3);
702 		}
703 		return 1;
704 	} else
705 		return xdr_ressize_check(rqstp, p);
706 }
707 
708 /* READ */
709 int
710 nfs3svc_encode_readres(struct svc_rqst *rqstp, __be32 *p,
711 					struct nfsd3_readres *resp)
712 {
713 	p = encode_post_op_attr(rqstp, p, &resp->fh);
714 	if (resp->status == 0) {
715 		*p++ = htonl(resp->count);
716 		*p++ = htonl(resp->eof);
717 		*p++ = htonl(resp->count);	/* xdr opaque count */
718 		xdr_ressize_check(rqstp, p);
719 		/* now update rqstp->rq_res to reflect data as well */
720 		rqstp->rq_res.page_len = resp->count;
721 		if (resp->count & 3) {
722 			/* need to pad the tail */
723 			rqstp->rq_res.tail[0].iov_base = p;
724 			*p = 0;
725 			rqstp->rq_res.tail[0].iov_len = 4 - (resp->count & 3);
726 		}
727 		return 1;
728 	} else
729 		return xdr_ressize_check(rqstp, p);
730 }
731 
732 /* WRITE */
733 int
734 nfs3svc_encode_writeres(struct svc_rqst *rqstp, __be32 *p,
735 					struct nfsd3_writeres *resp)
736 {
737 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
738 
739 	p = encode_wcc_data(rqstp, p, &resp->fh);
740 	if (resp->status == 0) {
741 		*p++ = htonl(resp->count);
742 		*p++ = htonl(resp->committed);
743 		*p++ = htonl(nn->nfssvc_boot.tv_sec);
744 		*p++ = htonl(nn->nfssvc_boot.tv_usec);
745 	}
746 	return xdr_ressize_check(rqstp, p);
747 }
748 
749 /* CREATE, MKDIR, SYMLINK, MKNOD */
750 int
751 nfs3svc_encode_createres(struct svc_rqst *rqstp, __be32 *p,
752 					struct nfsd3_diropres *resp)
753 {
754 	if (resp->status == 0) {
755 		*p++ = xdr_one;
756 		p = encode_fh(p, &resp->fh);
757 		p = encode_post_op_attr(rqstp, p, &resp->fh);
758 	}
759 	p = encode_wcc_data(rqstp, p, &resp->dirfh);
760 	return xdr_ressize_check(rqstp, p);
761 }
762 
763 /* RENAME */
764 int
765 nfs3svc_encode_renameres(struct svc_rqst *rqstp, __be32 *p,
766 					struct nfsd3_renameres *resp)
767 {
768 	p = encode_wcc_data(rqstp, p, &resp->ffh);
769 	p = encode_wcc_data(rqstp, p, &resp->tfh);
770 	return xdr_ressize_check(rqstp, p);
771 }
772 
773 /* LINK */
774 int
775 nfs3svc_encode_linkres(struct svc_rqst *rqstp, __be32 *p,
776 					struct nfsd3_linkres *resp)
777 {
778 	p = encode_post_op_attr(rqstp, p, &resp->fh);
779 	p = encode_wcc_data(rqstp, p, &resp->tfh);
780 	return xdr_ressize_check(rqstp, p);
781 }
782 
783 /* READDIR */
784 int
785 nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
786 					struct nfsd3_readdirres *resp)
787 {
788 	p = encode_post_op_attr(rqstp, p, &resp->fh);
789 
790 	if (resp->status == 0) {
791 		/* stupid readdir cookie */
792 		memcpy(p, resp->verf, 8); p += 2;
793 		xdr_ressize_check(rqstp, p);
794 		if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
795 			return 1; /*No room for trailer */
796 		rqstp->rq_res.page_len = (resp->count) << 2;
797 
798 		/* add the 'tail' to the end of the 'head' page - page 0. */
799 		rqstp->rq_res.tail[0].iov_base = p;
800 		*p++ = 0;		/* no more entries */
801 		*p++ = htonl(resp->common.err == nfserr_eof);
802 		rqstp->rq_res.tail[0].iov_len = 2<<2;
803 		return 1;
804 	} else
805 		return xdr_ressize_check(rqstp, p);
806 }
807 
808 static __be32 *
809 encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,
810 	     int namlen, u64 ino)
811 {
812 	*p++ = xdr_one;				 /* mark entry present */
813 	p    = xdr_encode_hyper(p, ino);	 /* file id */
814 	p    = xdr_encode_array(p, name, namlen);/* name length & name */
815 
816 	cd->offset = p;				/* remember pointer */
817 	p = xdr_encode_hyper(p, NFS_OFFSET_MAX);/* offset of next entry */
818 
819 	return p;
820 }
821 
822 static __be32
823 compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp,
824 		 const char *name, int namlen, u64 ino)
825 {
826 	struct svc_export	*exp;
827 	struct dentry		*dparent, *dchild;
828 	__be32 rv = nfserr_noent;
829 
830 	dparent = cd->fh.fh_dentry;
831 	exp  = cd->fh.fh_export;
832 
833 	if (isdotent(name, namlen)) {
834 		if (namlen == 2) {
835 			dchild = dget_parent(dparent);
836 			/* filesystem root - cannot return filehandle for ".." */
837 			if (dchild == dparent)
838 				goto out;
839 		} else
840 			dchild = dget(dparent);
841 	} else
842 		dchild = lookup_one_len_unlocked(name, dparent, namlen);
843 	if (IS_ERR(dchild))
844 		return rv;
845 	if (d_mountpoint(dchild))
846 		goto out;
847 	if (d_really_is_negative(dchild))
848 		goto out;
849 	if (dchild->d_inode->i_ino != ino)
850 		goto out;
851 	rv = fh_compose(fhp, exp, dchild, &cd->fh);
852 out:
853 	dput(dchild);
854 	return rv;
855 }
856 
857 static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen, u64 ino)
858 {
859 	struct svc_fh	*fh = &cd->scratch;
860 	__be32 err;
861 
862 	fh_init(fh, NFS3_FHSIZE);
863 	err = compose_entry_fh(cd, fh, name, namlen, ino);
864 	if (err) {
865 		*p++ = 0;
866 		*p++ = 0;
867 		goto out;
868 	}
869 	p = encode_post_op_attr(cd->rqstp, p, fh);
870 	*p++ = xdr_one;			/* yes, a file handle follows */
871 	p = encode_fh(p, fh);
872 out:
873 	fh_put(fh);
874 	return p;
875 }
876 
877 /*
878  * Encode a directory entry. This one works for both normal readdir
879  * and readdirplus.
880  * The normal readdir reply requires 2 (fileid) + 1 (stringlen)
881  * + string + 2 (cookie) + 1 (next) words, i.e. 6 + strlen.
882  *
883  * The readdirplus baggage is 1+21 words for post_op_attr, plus the
884  * file handle.
885  */
886 
887 #define NFS3_ENTRY_BAGGAGE	(2 + 1 + 2 + 1)
888 #define NFS3_ENTRYPLUS_BAGGAGE	(1 + 21 + 1 + (NFS3_FHSIZE >> 2))
889 static int
890 encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
891 	     loff_t offset, u64 ino, unsigned int d_type, int plus)
892 {
893 	struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
894 		       					common);
895 	__be32		*p = cd->buffer;
896 	caddr_t		curr_page_addr = NULL;
897 	struct page **	page;
898 	int		slen;		/* string (name) length */
899 	int		elen;		/* estimated entry length in words */
900 	int		num_entry_words = 0;	/* actual number of words */
901 
902 	if (cd->offset) {
903 		u64 offset64 = offset;
904 
905 		if (unlikely(cd->offset1)) {
906 			/* we ended up with offset on a page boundary */
907 			*cd->offset = htonl(offset64 >> 32);
908 			*cd->offset1 = htonl(offset64 & 0xffffffff);
909 			cd->offset1 = NULL;
910 		} else {
911 			xdr_encode_hyper(cd->offset, offset64);
912 		}
913 	}
914 
915 	/*
916 	dprintk("encode_entry(%.*s @%ld%s)\n",
917 		namlen, name, (long) offset, plus? " plus" : "");
918 	 */
919 
920 	/* truncate filename if too long */
921 	namlen = min(namlen, NFS3_MAXNAMLEN);
922 
923 	slen = XDR_QUADLEN(namlen);
924 	elen = slen + NFS3_ENTRY_BAGGAGE
925 		+ (plus? NFS3_ENTRYPLUS_BAGGAGE : 0);
926 
927 	if (cd->buflen < elen) {
928 		cd->common.err = nfserr_toosmall;
929 		return -EINVAL;
930 	}
931 
932 	/* determine which page in rq_respages[] we are currently filling */
933 	for (page = cd->rqstp->rq_respages + 1;
934 				page < cd->rqstp->rq_next_page; page++) {
935 		curr_page_addr = page_address(*page);
936 
937 		if (((caddr_t)cd->buffer >= curr_page_addr) &&
938 		    ((caddr_t)cd->buffer <  curr_page_addr + PAGE_SIZE))
939 			break;
940 	}
941 
942 	if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
943 		/* encode entry in current page */
944 
945 		p = encode_entry_baggage(cd, p, name, namlen, ino);
946 
947 		if (plus)
948 			p = encode_entryplus_baggage(cd, p, name, namlen, ino);
949 		num_entry_words = p - cd->buffer;
950 	} else if (*(page+1) != NULL) {
951 		/* temporarily encode entry into next page, then move back to
952 		 * current and next page in rq_respages[] */
953 		__be32 *p1, *tmp;
954 		int len1, len2;
955 
956 		/* grab next page for temporary storage of entry */
957 		p1 = tmp = page_address(*(page+1));
958 
959 		p1 = encode_entry_baggage(cd, p1, name, namlen, ino);
960 
961 		if (plus)
962 			p1 = encode_entryplus_baggage(cd, p1, name, namlen, ino);
963 
964 		/* determine entry word length and lengths to go in pages */
965 		num_entry_words = p1 - tmp;
966 		len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
967 		if ((num_entry_words << 2) < len1) {
968 			/* the actual number of words in the entry is less
969 			 * than elen and can still fit in the current page
970 			 */
971 			memmove(p, tmp, num_entry_words << 2);
972 			p += num_entry_words;
973 
974 			/* update offset */
975 			cd->offset = cd->buffer + (cd->offset - tmp);
976 		} else {
977 			unsigned int offset_r = (cd->offset - tmp) << 2;
978 
979 			/* update pointer to offset location.
980 			 * This is a 64bit quantity, so we need to
981 			 * deal with 3 cases:
982 			 *  -	entirely in first page
983 			 *  -	entirely in second page
984 			 *  -	4 bytes in each page
985 			 */
986 			if (offset_r + 8 <= len1) {
987 				cd->offset = p + (cd->offset - tmp);
988 			} else if (offset_r >= len1) {
989 				cd->offset -= len1 >> 2;
990 			} else {
991 				/* sitting on the fence */
992 				BUG_ON(offset_r != len1 - 4);
993 				cd->offset = p + (cd->offset - tmp);
994 				cd->offset1 = tmp;
995 			}
996 
997 			len2 = (num_entry_words << 2) - len1;
998 
999 			/* move from temp page to current and next pages */
1000 			memmove(p, tmp, len1);
1001 			memmove(tmp, (caddr_t)tmp+len1, len2);
1002 
1003 			p = tmp + (len2 >> 2);
1004 		}
1005 	}
1006 	else {
1007 		cd->common.err = nfserr_toosmall;
1008 		return -EINVAL;
1009 	}
1010 
1011 	cd->buflen -= num_entry_words;
1012 	cd->buffer = p;
1013 	cd->common.err = nfs_ok;
1014 	return 0;
1015 
1016 }
1017 
1018 int
1019 nfs3svc_encode_entry(void *cd, const char *name,
1020 		     int namlen, loff_t offset, u64 ino, unsigned int d_type)
1021 {
1022 	return encode_entry(cd, name, namlen, offset, ino, d_type, 0);
1023 }
1024 
1025 int
1026 nfs3svc_encode_entry_plus(void *cd, const char *name,
1027 			  int namlen, loff_t offset, u64 ino,
1028 			  unsigned int d_type)
1029 {
1030 	return encode_entry(cd, name, namlen, offset, ino, d_type, 1);
1031 }
1032 
1033 /* FSSTAT */
1034 int
1035 nfs3svc_encode_fsstatres(struct svc_rqst *rqstp, __be32 *p,
1036 					struct nfsd3_fsstatres *resp)
1037 {
1038 	struct kstatfs	*s = &resp->stats;
1039 	u64		bs = s->f_bsize;
1040 
1041 	*p++ = xdr_zero;	/* no post_op_attr */
1042 
1043 	if (resp->status == 0) {
1044 		p = xdr_encode_hyper(p, bs * s->f_blocks);	/* total bytes */
1045 		p = xdr_encode_hyper(p, bs * s->f_bfree);	/* free bytes */
1046 		p = xdr_encode_hyper(p, bs * s->f_bavail);	/* user available bytes */
1047 		p = xdr_encode_hyper(p, s->f_files);	/* total inodes */
1048 		p = xdr_encode_hyper(p, s->f_ffree);	/* free inodes */
1049 		p = xdr_encode_hyper(p, s->f_ffree);	/* user available inodes */
1050 		*p++ = htonl(resp->invarsec);	/* mean unchanged time */
1051 	}
1052 	return xdr_ressize_check(rqstp, p);
1053 }
1054 
1055 /* FSINFO */
1056 int
1057 nfs3svc_encode_fsinfores(struct svc_rqst *rqstp, __be32 *p,
1058 					struct nfsd3_fsinfores *resp)
1059 {
1060 	*p++ = xdr_zero;	/* no post_op_attr */
1061 
1062 	if (resp->status == 0) {
1063 		*p++ = htonl(resp->f_rtmax);
1064 		*p++ = htonl(resp->f_rtpref);
1065 		*p++ = htonl(resp->f_rtmult);
1066 		*p++ = htonl(resp->f_wtmax);
1067 		*p++ = htonl(resp->f_wtpref);
1068 		*p++ = htonl(resp->f_wtmult);
1069 		*p++ = htonl(resp->f_dtpref);
1070 		p = xdr_encode_hyper(p, resp->f_maxfilesize);
1071 		*p++ = xdr_one;
1072 		*p++ = xdr_zero;
1073 		*p++ = htonl(resp->f_properties);
1074 	}
1075 
1076 	return xdr_ressize_check(rqstp, p);
1077 }
1078 
1079 /* PATHCONF */
1080 int
1081 nfs3svc_encode_pathconfres(struct svc_rqst *rqstp, __be32 *p,
1082 					struct nfsd3_pathconfres *resp)
1083 {
1084 	*p++ = xdr_zero;	/* no post_op_attr */
1085 
1086 	if (resp->status == 0) {
1087 		*p++ = htonl(resp->p_link_max);
1088 		*p++ = htonl(resp->p_name_max);
1089 		*p++ = htonl(resp->p_no_trunc);
1090 		*p++ = htonl(resp->p_chown_restricted);
1091 		*p++ = htonl(resp->p_case_insensitive);
1092 		*p++ = htonl(resp->p_case_preserving);
1093 	}
1094 
1095 	return xdr_ressize_check(rqstp, p);
1096 }
1097 
1098 /* COMMIT */
1099 int
1100 nfs3svc_encode_commitres(struct svc_rqst *rqstp, __be32 *p,
1101 					struct nfsd3_commitres *resp)
1102 {
1103 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1104 
1105 	p = encode_wcc_data(rqstp, p, &resp->fh);
1106 	/* Write verifier */
1107 	if (resp->status == 0) {
1108 		*p++ = htonl(nn->nfssvc_boot.tv_sec);
1109 		*p++ = htonl(nn->nfssvc_boot.tv_usec);
1110 	}
1111 	return xdr_ressize_check(rqstp, p);
1112 }
1113 
1114 /*
1115  * XDR release functions
1116  */
1117 int
1118 nfs3svc_release_fhandle(struct svc_rqst *rqstp, __be32 *p,
1119 					struct nfsd3_attrstat *resp)
1120 {
1121 	fh_put(&resp->fh);
1122 	return 1;
1123 }
1124 
1125 int
1126 nfs3svc_release_fhandle2(struct svc_rqst *rqstp, __be32 *p,
1127 					struct nfsd3_fhandle_pair *resp)
1128 {
1129 	fh_put(&resp->fh1);
1130 	fh_put(&resp->fh2);
1131 	return 1;
1132 }
1133