xref: /openbmc/linux/fs/nfsd/nfsxdr.c (revision 82078b98)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * XDR support for nfsd
4  *
5  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
6  */
7 
8 #include "vfs.h"
9 #include "xdr.h"
10 #include "auth.h"
11 
12 /*
13  * Mapping of S_IF* types to NFS file types
14  */
15 static const u32 nfs_ftypes[] = {
16 	NFNON,  NFCHR,  NFCHR, NFBAD,
17 	NFDIR,  NFBAD,  NFBLK, NFBAD,
18 	NFREG,  NFBAD,  NFLNK, NFBAD,
19 	NFSOCK, NFBAD,  NFLNK, NFBAD,
20 };
21 
22 
23 /*
24  * Basic NFSv2 data types (RFC 1094 Section 2.3)
25  */
26 
27 /**
28  * svcxdr_encode_stat - Encode an NFSv2 status code
29  * @xdr: XDR stream
30  * @status: status value to encode
31  *
32  * Return values:
33  *   %false: Send buffer space was exhausted
34  *   %true: Success
35  */
36 bool
svcxdr_encode_stat(struct xdr_stream * xdr,__be32 status)37 svcxdr_encode_stat(struct xdr_stream *xdr, __be32 status)
38 {
39 	__be32 *p;
40 
41 	p = xdr_reserve_space(xdr, sizeof(status));
42 	if (!p)
43 		return false;
44 	*p = status;
45 
46 	return true;
47 }
48 
49 /**
50  * svcxdr_decode_fhandle - Decode an NFSv2 file handle
51  * @xdr: XDR stream positioned at an encoded NFSv2 FH
52  * @fhp: OUT: filled-in server file handle
53  *
54  * Return values:
55  *  %false: The encoded file handle was not valid
56  *  %true: @fhp has been initialized
57  */
58 bool
svcxdr_decode_fhandle(struct xdr_stream * xdr,struct svc_fh * fhp)59 svcxdr_decode_fhandle(struct xdr_stream *xdr, struct svc_fh *fhp)
60 {
61 	__be32 *p;
62 
63 	p = xdr_inline_decode(xdr, NFS_FHSIZE);
64 	if (!p)
65 		return false;
66 	fh_init(fhp, NFS_FHSIZE);
67 	memcpy(&fhp->fh_handle.fh_raw, p, NFS_FHSIZE);
68 	fhp->fh_handle.fh_size = NFS_FHSIZE;
69 
70 	return true;
71 }
72 
73 static bool
svcxdr_encode_fhandle(struct xdr_stream * xdr,const struct svc_fh * fhp)74 svcxdr_encode_fhandle(struct xdr_stream *xdr, const struct svc_fh *fhp)
75 {
76 	__be32 *p;
77 
78 	p = xdr_reserve_space(xdr, NFS_FHSIZE);
79 	if (!p)
80 		return false;
81 	memcpy(p, &fhp->fh_handle.fh_raw, NFS_FHSIZE);
82 
83 	return true;
84 }
85 
86 static __be32 *
encode_timeval(__be32 * p,const struct timespec64 * time)87 encode_timeval(__be32 *p, const struct timespec64 *time)
88 {
89 	*p++ = cpu_to_be32((u32)time->tv_sec);
90 	if (time->tv_nsec)
91 		*p++ = cpu_to_be32(time->tv_nsec / NSEC_PER_USEC);
92 	else
93 		*p++ = xdr_zero;
94 	return p;
95 }
96 
97 static bool
svcxdr_decode_filename(struct xdr_stream * xdr,char ** name,unsigned int * len)98 svcxdr_decode_filename(struct xdr_stream *xdr, char **name, unsigned int *len)
99 {
100 	u32 size, i;
101 	__be32 *p;
102 	char *c;
103 
104 	if (xdr_stream_decode_u32(xdr, &size) < 0)
105 		return false;
106 	if (size == 0 || size > NFS_MAXNAMLEN)
107 		return false;
108 	p = xdr_inline_decode(xdr, size);
109 	if (!p)
110 		return false;
111 
112 	*len = size;
113 	*name = (char *)p;
114 	for (i = 0, c = *name; i < size; i++, c++)
115 		if (*c == '\0' || *c == '/')
116 			return false;
117 
118 	return true;
119 }
120 
121 static bool
svcxdr_decode_diropargs(struct xdr_stream * xdr,struct svc_fh * fhp,char ** name,unsigned int * len)122 svcxdr_decode_diropargs(struct xdr_stream *xdr, struct svc_fh *fhp,
123 			char **name, unsigned int *len)
124 {
125 	return svcxdr_decode_fhandle(xdr, fhp) &&
126 		svcxdr_decode_filename(xdr, name, len);
127 }
128 
129 static bool
svcxdr_decode_sattr(struct svc_rqst * rqstp,struct xdr_stream * xdr,struct iattr * iap)130 svcxdr_decode_sattr(struct svc_rqst *rqstp, struct xdr_stream *xdr,
131 		    struct iattr *iap)
132 {
133 	u32 tmp1, tmp2;
134 	__be32 *p;
135 
136 	p = xdr_inline_decode(xdr, XDR_UNIT * 8);
137 	if (!p)
138 		return false;
139 
140 	iap->ia_valid = 0;
141 
142 	/*
143 	 * Some Sun clients put 0xffff in the mode field when they
144 	 * mean 0xffffffff.
145 	 */
146 	tmp1 = be32_to_cpup(p++);
147 	if (tmp1 != (u32)-1 && tmp1 != 0xffff) {
148 		iap->ia_valid |= ATTR_MODE;
149 		iap->ia_mode = tmp1;
150 	}
151 
152 	tmp1 = be32_to_cpup(p++);
153 	if (tmp1 != (u32)-1) {
154 		iap->ia_uid = make_kuid(nfsd_user_namespace(rqstp), tmp1);
155 		if (uid_valid(iap->ia_uid))
156 			iap->ia_valid |= ATTR_UID;
157 	}
158 
159 	tmp1 = be32_to_cpup(p++);
160 	if (tmp1 != (u32)-1) {
161 		iap->ia_gid = make_kgid(nfsd_user_namespace(rqstp), tmp1);
162 		if (gid_valid(iap->ia_gid))
163 			iap->ia_valid |= ATTR_GID;
164 	}
165 
166 	tmp1 = be32_to_cpup(p++);
167 	if (tmp1 != (u32)-1) {
168 		iap->ia_valid |= ATTR_SIZE;
169 		iap->ia_size = tmp1;
170 	}
171 
172 	tmp1 = be32_to_cpup(p++);
173 	tmp2 = be32_to_cpup(p++);
174 	if (tmp1 != (u32)-1 && tmp2 != (u32)-1) {
175 		iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET;
176 		iap->ia_atime.tv_sec = tmp1;
177 		iap->ia_atime.tv_nsec = tmp2 * NSEC_PER_USEC;
178 	}
179 
180 	tmp1 = be32_to_cpup(p++);
181 	tmp2 = be32_to_cpup(p++);
182 	if (tmp1 != (u32)-1 && tmp2 != (u32)-1) {
183 		iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET;
184 		iap->ia_mtime.tv_sec = tmp1;
185 		iap->ia_mtime.tv_nsec = tmp2 * NSEC_PER_USEC;
186 		/*
187 		 * Passing the invalid value useconds=1000000 for mtime
188 		 * is a Sun convention for "set both mtime and atime to
189 		 * current server time".  It's needed to make permissions
190 		 * checks for the "touch" program across v2 mounts to
191 		 * Solaris and Irix boxes work correctly. See description of
192 		 * sattr in section 6.1 of "NFS Illustrated" by
193 		 * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
194 		 */
195 		if (tmp2 == 1000000)
196 			iap->ia_valid &= ~(ATTR_ATIME_SET|ATTR_MTIME_SET);
197 	}
198 
199 	return true;
200 }
201 
202 /**
203  * svcxdr_encode_fattr - Encode NFSv2 file attributes
204  * @rqstp: Context of a completed RPC transaction
205  * @xdr: XDR stream
206  * @fhp: File handle to encode
207  * @stat: Attributes to encode
208  *
209  * Return values:
210  *   %false: Send buffer space was exhausted
211  *   %true: Success
212  */
213 bool
svcxdr_encode_fattr(struct svc_rqst * rqstp,struct xdr_stream * xdr,const struct svc_fh * fhp,const struct kstat * stat)214 svcxdr_encode_fattr(struct svc_rqst *rqstp, struct xdr_stream *xdr,
215 		    const struct svc_fh *fhp, const struct kstat *stat)
216 {
217 	struct user_namespace *userns = nfsd_user_namespace(rqstp);
218 	struct dentry *dentry = fhp->fh_dentry;
219 	int type = stat->mode & S_IFMT;
220 	struct timespec64 time;
221 	__be32 *p;
222 	u32 fsid;
223 
224 	p = xdr_reserve_space(xdr, XDR_UNIT * 17);
225 	if (!p)
226 		return false;
227 
228 	*p++ = cpu_to_be32(nfs_ftypes[type >> 12]);
229 	*p++ = cpu_to_be32((u32)stat->mode);
230 	*p++ = cpu_to_be32((u32)stat->nlink);
231 	*p++ = cpu_to_be32((u32)from_kuid_munged(userns, stat->uid));
232 	*p++ = cpu_to_be32((u32)from_kgid_munged(userns, stat->gid));
233 
234 	if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN)
235 		*p++ = cpu_to_be32(NFS_MAXPATHLEN);
236 	else
237 		*p++ = cpu_to_be32((u32) stat->size);
238 	*p++ = cpu_to_be32((u32) stat->blksize);
239 	if (S_ISCHR(type) || S_ISBLK(type))
240 		*p++ = cpu_to_be32(new_encode_dev(stat->rdev));
241 	else
242 		*p++ = cpu_to_be32(0xffffffff);
243 	*p++ = cpu_to_be32((u32)stat->blocks);
244 
245 	switch (fsid_source(fhp)) {
246 	case FSIDSOURCE_FSID:
247 		fsid = (u32)fhp->fh_export->ex_fsid;
248 		break;
249 	case FSIDSOURCE_UUID:
250 		fsid = ((u32 *)fhp->fh_export->ex_uuid)[0];
251 		fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[1];
252 		fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[2];
253 		fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[3];
254 		break;
255 	default:
256 		fsid = new_encode_dev(stat->dev);
257 		break;
258 	}
259 	*p++ = cpu_to_be32(fsid);
260 
261 	*p++ = cpu_to_be32((u32)stat->ino);
262 	p = encode_timeval(p, &stat->atime);
263 	time = stat->mtime;
264 	lease_get_mtime(d_inode(dentry), &time);
265 	p = encode_timeval(p, &time);
266 	encode_timeval(p, &stat->ctime);
267 
268 	return true;
269 }
270 
271 /*
272  * XDR decode functions
273  */
274 
275 bool
nfssvc_decode_fhandleargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)276 nfssvc_decode_fhandleargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
277 {
278 	struct nfsd_fhandle *args = rqstp->rq_argp;
279 
280 	return svcxdr_decode_fhandle(xdr, &args->fh);
281 }
282 
283 bool
nfssvc_decode_sattrargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)284 nfssvc_decode_sattrargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
285 {
286 	struct nfsd_sattrargs *args = rqstp->rq_argp;
287 
288 	return svcxdr_decode_fhandle(xdr, &args->fh) &&
289 		svcxdr_decode_sattr(rqstp, xdr, &args->attrs);
290 }
291 
292 bool
nfssvc_decode_diropargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)293 nfssvc_decode_diropargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
294 {
295 	struct nfsd_diropargs *args = rqstp->rq_argp;
296 
297 	return svcxdr_decode_diropargs(xdr, &args->fh, &args->name, &args->len);
298 }
299 
300 bool
nfssvc_decode_readargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)301 nfssvc_decode_readargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
302 {
303 	struct nfsd_readargs *args = rqstp->rq_argp;
304 	u32 totalcount;
305 
306 	if (!svcxdr_decode_fhandle(xdr, &args->fh))
307 		return false;
308 	if (xdr_stream_decode_u32(xdr, &args->offset) < 0)
309 		return false;
310 	if (xdr_stream_decode_u32(xdr, &args->count) < 0)
311 		return false;
312 	/* totalcount is ignored */
313 	if (xdr_stream_decode_u32(xdr, &totalcount) < 0)
314 		return false;
315 
316 	return true;
317 }
318 
319 bool
nfssvc_decode_writeargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)320 nfssvc_decode_writeargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
321 {
322 	struct nfsd_writeargs *args = rqstp->rq_argp;
323 	u32 beginoffset, totalcount;
324 
325 	if (!svcxdr_decode_fhandle(xdr, &args->fh))
326 		return false;
327 	/* beginoffset is ignored */
328 	if (xdr_stream_decode_u32(xdr, &beginoffset) < 0)
329 		return false;
330 	if (xdr_stream_decode_u32(xdr, &args->offset) < 0)
331 		return false;
332 	/* totalcount is ignored */
333 	if (xdr_stream_decode_u32(xdr, &totalcount) < 0)
334 		return false;
335 
336 	/* opaque data */
337 	if (xdr_stream_decode_u32(xdr, &args->len) < 0)
338 		return false;
339 	if (args->len > NFSSVC_MAXBLKSIZE_V2)
340 		return false;
341 
342 	return xdr_stream_subsegment(xdr, &args->payload, args->len);
343 }
344 
345 bool
nfssvc_decode_createargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)346 nfssvc_decode_createargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
347 {
348 	struct nfsd_createargs *args = rqstp->rq_argp;
349 
350 	return svcxdr_decode_diropargs(xdr, &args->fh,
351 				       &args->name, &args->len) &&
352 		svcxdr_decode_sattr(rqstp, xdr, &args->attrs);
353 }
354 
355 bool
nfssvc_decode_renameargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)356 nfssvc_decode_renameargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
357 {
358 	struct nfsd_renameargs *args = rqstp->rq_argp;
359 
360 	return svcxdr_decode_diropargs(xdr, &args->ffh,
361 				       &args->fname, &args->flen) &&
362 		svcxdr_decode_diropargs(xdr, &args->tfh,
363 					&args->tname, &args->tlen);
364 }
365 
366 bool
nfssvc_decode_linkargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)367 nfssvc_decode_linkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
368 {
369 	struct nfsd_linkargs *args = rqstp->rq_argp;
370 
371 	return svcxdr_decode_fhandle(xdr, &args->ffh) &&
372 		svcxdr_decode_diropargs(xdr, &args->tfh,
373 					&args->tname, &args->tlen);
374 }
375 
376 bool
nfssvc_decode_symlinkargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)377 nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
378 {
379 	struct nfsd_symlinkargs *args = rqstp->rq_argp;
380 	struct kvec *head = rqstp->rq_arg.head;
381 
382 	if (!svcxdr_decode_diropargs(xdr, &args->ffh, &args->fname, &args->flen))
383 		return false;
384 	if (xdr_stream_decode_u32(xdr, &args->tlen) < 0)
385 		return false;
386 	if (args->tlen == 0)
387 		return false;
388 
389 	args->first.iov_len = head->iov_len - xdr_stream_pos(xdr);
390 	args->first.iov_base = xdr_inline_decode(xdr, args->tlen);
391 	if (!args->first.iov_base)
392 		return false;
393 	return svcxdr_decode_sattr(rqstp, xdr, &args->attrs);
394 }
395 
396 bool
nfssvc_decode_readdirargs(struct svc_rqst * rqstp,struct xdr_stream * xdr)397 nfssvc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
398 {
399 	struct nfsd_readdirargs *args = rqstp->rq_argp;
400 
401 	if (!svcxdr_decode_fhandle(xdr, &args->fh))
402 		return false;
403 	if (xdr_stream_decode_u32(xdr, &args->cookie) < 0)
404 		return false;
405 	if (xdr_stream_decode_u32(xdr, &args->count) < 0)
406 		return false;
407 
408 	return true;
409 }
410 
411 /*
412  * XDR encode functions
413  */
414 
415 bool
nfssvc_encode_statres(struct svc_rqst * rqstp,struct xdr_stream * xdr)416 nfssvc_encode_statres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
417 {
418 	struct nfsd_stat *resp = rqstp->rq_resp;
419 
420 	return svcxdr_encode_stat(xdr, resp->status);
421 }
422 
423 bool
nfssvc_encode_attrstatres(struct svc_rqst * rqstp,struct xdr_stream * xdr)424 nfssvc_encode_attrstatres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
425 {
426 	struct nfsd_attrstat *resp = rqstp->rq_resp;
427 
428 	if (!svcxdr_encode_stat(xdr, resp->status))
429 		return false;
430 	switch (resp->status) {
431 	case nfs_ok:
432 		if (!svcxdr_encode_fattr(rqstp, xdr, &resp->fh, &resp->stat))
433 			return false;
434 		break;
435 	}
436 
437 	return true;
438 }
439 
440 bool
nfssvc_encode_diropres(struct svc_rqst * rqstp,struct xdr_stream * xdr)441 nfssvc_encode_diropres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
442 {
443 	struct nfsd_diropres *resp = rqstp->rq_resp;
444 
445 	if (!svcxdr_encode_stat(xdr, resp->status))
446 		return false;
447 	switch (resp->status) {
448 	case nfs_ok:
449 		if (!svcxdr_encode_fhandle(xdr, &resp->fh))
450 			return false;
451 		if (!svcxdr_encode_fattr(rqstp, xdr, &resp->fh, &resp->stat))
452 			return false;
453 		break;
454 	}
455 
456 	return true;
457 }
458 
459 bool
nfssvc_encode_readlinkres(struct svc_rqst * rqstp,struct xdr_stream * xdr)460 nfssvc_encode_readlinkres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
461 {
462 	struct nfsd_readlinkres *resp = rqstp->rq_resp;
463 	struct kvec *head = rqstp->rq_res.head;
464 
465 	if (!svcxdr_encode_stat(xdr, resp->status))
466 		return false;
467 	switch (resp->status) {
468 	case nfs_ok:
469 		if (xdr_stream_encode_u32(xdr, resp->len) < 0)
470 			return false;
471 		svcxdr_encode_opaque_pages(rqstp, xdr, &resp->page, 0,
472 					   resp->len);
473 		if (svc_encode_result_payload(rqstp, head->iov_len, resp->len) < 0)
474 			return false;
475 		break;
476 	}
477 
478 	return true;
479 }
480 
481 bool
nfssvc_encode_readres(struct svc_rqst * rqstp,struct xdr_stream * xdr)482 nfssvc_encode_readres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
483 {
484 	struct nfsd_readres *resp = rqstp->rq_resp;
485 	struct kvec *head = rqstp->rq_res.head;
486 
487 	if (!svcxdr_encode_stat(xdr, resp->status))
488 		return false;
489 	switch (resp->status) {
490 	case nfs_ok:
491 		if (!svcxdr_encode_fattr(rqstp, xdr, &resp->fh, &resp->stat))
492 			return false;
493 		if (xdr_stream_encode_u32(xdr, resp->count) < 0)
494 			return false;
495 		svcxdr_encode_opaque_pages(rqstp, xdr, resp->pages,
496 					   rqstp->rq_res.page_base,
497 					   resp->count);
498 		if (svc_encode_result_payload(rqstp, head->iov_len, resp->count) < 0)
499 			return false;
500 		break;
501 	}
502 
503 	return true;
504 }
505 
506 bool
nfssvc_encode_readdirres(struct svc_rqst * rqstp,struct xdr_stream * xdr)507 nfssvc_encode_readdirres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
508 {
509 	struct nfsd_readdirres *resp = rqstp->rq_resp;
510 	struct xdr_buf *dirlist = &resp->dirlist;
511 
512 	if (!svcxdr_encode_stat(xdr, resp->status))
513 		return false;
514 	switch (resp->status) {
515 	case nfs_ok:
516 		svcxdr_encode_opaque_pages(rqstp, xdr, dirlist->pages, 0,
517 					   dirlist->len);
518 		/* no more entries */
519 		if (xdr_stream_encode_item_absent(xdr) < 0)
520 			return false;
521 		if (xdr_stream_encode_bool(xdr, resp->common.err == nfserr_eof) < 0)
522 			return false;
523 		break;
524 	}
525 
526 	return true;
527 }
528 
529 bool
nfssvc_encode_statfsres(struct svc_rqst * rqstp,struct xdr_stream * xdr)530 nfssvc_encode_statfsres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
531 {
532 	struct nfsd_statfsres *resp = rqstp->rq_resp;
533 	struct kstatfs	*stat = &resp->stats;
534 	__be32 *p;
535 
536 	if (!svcxdr_encode_stat(xdr, resp->status))
537 		return false;
538 	switch (resp->status) {
539 	case nfs_ok:
540 		p = xdr_reserve_space(xdr, XDR_UNIT * 5);
541 		if (!p)
542 			return false;
543 		*p++ = cpu_to_be32(NFSSVC_MAXBLKSIZE_V2);
544 		*p++ = cpu_to_be32(stat->f_bsize);
545 		*p++ = cpu_to_be32(stat->f_blocks);
546 		*p++ = cpu_to_be32(stat->f_bfree);
547 		*p = cpu_to_be32(stat->f_bavail);
548 		break;
549 	}
550 
551 	return true;
552 }
553 
554 /**
555  * nfssvc_encode_nfscookie - Encode a directory offset cookie
556  * @resp: readdir result context
557  * @offset: offset cookie to encode
558  *
559  * The buffer space for the offset cookie has already been reserved
560  * by svcxdr_encode_entry_common().
561  */
nfssvc_encode_nfscookie(struct nfsd_readdirres * resp,u32 offset)562 void nfssvc_encode_nfscookie(struct nfsd_readdirres *resp, u32 offset)
563 {
564 	__be32 cookie = cpu_to_be32(offset);
565 
566 	if (!resp->cookie_offset)
567 		return;
568 
569 	write_bytes_to_xdr_buf(&resp->dirlist, resp->cookie_offset, &cookie,
570 			       sizeof(cookie));
571 	resp->cookie_offset = 0;
572 }
573 
574 static bool
svcxdr_encode_entry_common(struct nfsd_readdirres * resp,const char * name,int namlen,loff_t offset,u64 ino)575 svcxdr_encode_entry_common(struct nfsd_readdirres *resp, const char *name,
576 			   int namlen, loff_t offset, u64 ino)
577 {
578 	struct xdr_buf *dirlist = &resp->dirlist;
579 	struct xdr_stream *xdr = &resp->xdr;
580 
581 	if (xdr_stream_encode_item_present(xdr) < 0)
582 		return false;
583 	/* fileid */
584 	if (xdr_stream_encode_u32(xdr, (u32)ino) < 0)
585 		return false;
586 	/* name */
587 	if (xdr_stream_encode_opaque(xdr, name, min(namlen, NFS2_MAXNAMLEN)) < 0)
588 		return false;
589 	/* cookie */
590 	resp->cookie_offset = dirlist->len;
591 	if (xdr_stream_encode_u32(xdr, ~0U) < 0)
592 		return false;
593 
594 	return true;
595 }
596 
597 /**
598  * nfssvc_encode_entry - encode one NFSv2 READDIR entry
599  * @data: directory context
600  * @name: name of the object to be encoded
601  * @namlen: length of that name, in bytes
602  * @offset: the offset of the previous entry
603  * @ino: the fileid of this entry
604  * @d_type: unused
605  *
606  * Return values:
607  *   %0: Entry was successfully encoded.
608  *   %-EINVAL: An encoding problem occured, secondary status code in resp->common.err
609  *
610  * On exit, the following fields are updated:
611  *   - resp->xdr
612  *   - resp->common.err
613  *   - resp->cookie_offset
614  */
nfssvc_encode_entry(void * data,const char * name,int namlen,loff_t offset,u64 ino,unsigned int d_type)615 int nfssvc_encode_entry(void *data, const char *name, int namlen,
616 			loff_t offset, u64 ino, unsigned int d_type)
617 {
618 	struct readdir_cd *ccd = data;
619 	struct nfsd_readdirres *resp = container_of(ccd,
620 						    struct nfsd_readdirres,
621 						    common);
622 	unsigned int starting_length = resp->dirlist.len;
623 
624 	/* The offset cookie for the previous entry */
625 	nfssvc_encode_nfscookie(resp, offset);
626 
627 	if (!svcxdr_encode_entry_common(resp, name, namlen, offset, ino))
628 		goto out_toosmall;
629 
630 	xdr_commit_encode(&resp->xdr);
631 	resp->common.err = nfs_ok;
632 	return 0;
633 
634 out_toosmall:
635 	resp->cookie_offset = 0;
636 	resp->common.err = nfserr_toosmall;
637 	resp->dirlist.len = starting_length;
638 	return -EINVAL;
639 }
640 
641 /*
642  * XDR release functions
643  */
nfssvc_release_attrstat(struct svc_rqst * rqstp)644 void nfssvc_release_attrstat(struct svc_rqst *rqstp)
645 {
646 	struct nfsd_attrstat *resp = rqstp->rq_resp;
647 
648 	fh_put(&resp->fh);
649 }
650 
nfssvc_release_diropres(struct svc_rqst * rqstp)651 void nfssvc_release_diropres(struct svc_rqst *rqstp)
652 {
653 	struct nfsd_diropres *resp = rqstp->rq_resp;
654 
655 	fh_put(&resp->fh);
656 }
657 
nfssvc_release_readres(struct svc_rqst * rqstp)658 void nfssvc_release_readres(struct svc_rqst *rqstp)
659 {
660 	struct nfsd_readres *resp = rqstp->rq_resp;
661 
662 	fh_put(&resp->fh);
663 }
664