1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/fs/nfs/nfs2xdr.c
4  *
5  * XDR functions to encode/decode NFS RPC arguments and results.
6  *
7  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
8  * Copyright (C) 1996 Olaf Kirch
9  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
10  * 		FIFO's need special handling in NFSv2
11  */
12 
13 #include <linux/param.h>
14 #include <linux/time.h>
15 #include <linux/mm.h>
16 #include <linux/errno.h>
17 #include <linux/string.h>
18 #include <linux/in.h>
19 #include <linux/pagemap.h>
20 #include <linux/proc_fs.h>
21 #include <linux/sunrpc/clnt.h>
22 #include <linux/nfs.h>
23 #include <linux/nfs2.h>
24 #include <linux/nfs_fs.h>
25 #include "internal.h"
26 
27 #define NFSDBG_FACILITY		NFSDBG_XDR
28 
29 /* Mapping from NFS error code to "errno" error code. */
30 #define errno_NFSERR_IO		EIO
31 
32 /*
33  * Declare the space requirements for NFS arguments and replies as
34  * number of 32bit-words
35  */
36 #define NFS_fhandle_sz		(8)
37 #define NFS_sattr_sz		(8)
38 #define NFS_filename_sz		(1+(NFS2_MAXNAMLEN>>2))
39 #define NFS_path_sz		(1+(NFS2_MAXPATHLEN>>2))
40 #define NFS_fattr_sz		(17)
41 #define NFS_info_sz		(5)
42 #define NFS_entry_sz		(NFS_filename_sz+3)
43 
44 #define NFS_diropargs_sz	(NFS_fhandle_sz+NFS_filename_sz)
45 #define NFS_removeargs_sz	(NFS_fhandle_sz+NFS_filename_sz)
46 #define NFS_sattrargs_sz	(NFS_fhandle_sz+NFS_sattr_sz)
47 #define NFS_readlinkargs_sz	(NFS_fhandle_sz)
48 #define NFS_readargs_sz		(NFS_fhandle_sz+3)
49 #define NFS_writeargs_sz	(NFS_fhandle_sz+4)
50 #define NFS_createargs_sz	(NFS_diropargs_sz+NFS_sattr_sz)
51 #define NFS_renameargs_sz	(NFS_diropargs_sz+NFS_diropargs_sz)
52 #define NFS_linkargs_sz		(NFS_fhandle_sz+NFS_diropargs_sz)
53 #define NFS_symlinkargs_sz	(NFS_diropargs_sz+1+NFS_sattr_sz)
54 #define NFS_readdirargs_sz	(NFS_fhandle_sz+2)
55 
56 #define NFS_attrstat_sz		(1+NFS_fattr_sz)
57 #define NFS_diropres_sz		(1+NFS_fhandle_sz+NFS_fattr_sz)
58 #define NFS_readlinkres_sz	(2)
59 #define NFS_readres_sz		(1+NFS_fattr_sz+1)
60 #define NFS_writeres_sz         (NFS_attrstat_sz)
61 #define NFS_stat_sz		(1)
62 #define NFS_readdirres_sz	(1)
63 #define NFS_statfsres_sz	(1+NFS_info_sz)
64 
65 static int nfs_stat_to_errno(enum nfs_stat);
66 
67 /*
68  * While encoding arguments, set up the reply buffer in advance to
69  * receive reply data directly into the page cache.
70  */
prepare_reply_buffer(struct rpc_rqst * req,struct page ** pages,unsigned int base,unsigned int len,unsigned int bufsize)71 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
72 				 unsigned int base, unsigned int len,
73 				 unsigned int bufsize)
74 {
75 	struct rpc_auth	*auth = req->rq_cred->cr_auth;
76 	unsigned int replen;
77 
78 	replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
79 	xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
80 }
81 
82 /*
83  * Handle decode buffer overflows out-of-line.
84  */
print_overflow_msg(const char * func,const struct xdr_stream * xdr)85 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
86 {
87 	dprintk("NFS: %s prematurely hit the end of our receive buffer. "
88 		"Remaining buffer length is %tu words.\n",
89 		func, xdr->end - xdr->p);
90 }
91 
92 
93 /*
94  * Encode/decode NFSv2 basic data types
95  *
96  * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
97  * "NFS: Network File System Protocol Specification".
98  *
99  * Not all basic data types have their own encoding and decoding
100  * functions.  For run-time efficiency, some data types are encoded
101  * or decoded inline.
102  */
103 
104 /*
105  *	typedef opaque	nfsdata<>;
106  */
decode_nfsdata(struct xdr_stream * xdr,struct nfs_pgio_res * result)107 static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_pgio_res *result)
108 {
109 	u32 recvd, count;
110 	__be32 *p;
111 
112 	p = xdr_inline_decode(xdr, 4);
113 	if (unlikely(p == NULL))
114 		goto out_overflow;
115 	count = be32_to_cpup(p);
116 	recvd = xdr_read_pages(xdr, count);
117 	if (unlikely(count > recvd))
118 		goto out_cheating;
119 out:
120 	result->eof = 0;	/* NFSv2 does not pass EOF flag on the wire. */
121 	result->count = count;
122 	return count;
123 out_cheating:
124 	dprintk("NFS: server cheating in read result: "
125 		"count %u > recvd %u\n", count, recvd);
126 	count = recvd;
127 	goto out;
128 out_overflow:
129 	print_overflow_msg(__func__, xdr);
130 	return -EIO;
131 }
132 
133 /*
134  *	enum stat {
135  *		NFS_OK = 0,
136  *		NFSERR_PERM = 1,
137  *		NFSERR_NOENT = 2,
138  *		NFSERR_IO = 5,
139  *		NFSERR_NXIO = 6,
140  *		NFSERR_ACCES = 13,
141  *		NFSERR_EXIST = 17,
142  *		NFSERR_NODEV = 19,
143  *		NFSERR_NOTDIR = 20,
144  *		NFSERR_ISDIR = 21,
145  *		NFSERR_FBIG = 27,
146  *		NFSERR_NOSPC = 28,
147  *		NFSERR_ROFS = 30,
148  *		NFSERR_NAMETOOLONG = 63,
149  *		NFSERR_NOTEMPTY = 66,
150  *		NFSERR_DQUOT = 69,
151  *		NFSERR_STALE = 70,
152  *		NFSERR_WFLUSH = 99
153  *	};
154  */
decode_stat(struct xdr_stream * xdr,enum nfs_stat * status)155 static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status)
156 {
157 	__be32 *p;
158 
159 	p = xdr_inline_decode(xdr, 4);
160 	if (unlikely(p == NULL))
161 		goto out_overflow;
162 	*status = be32_to_cpup(p);
163 	return 0;
164 out_overflow:
165 	print_overflow_msg(__func__, xdr);
166 	return -EIO;
167 }
168 
169 /*
170  * 2.3.2.  ftype
171  *
172  *	enum ftype {
173  *		NFNON = 0,
174  *		NFREG = 1,
175  *		NFDIR = 2,
176  *		NFBLK = 3,
177  *		NFCHR = 4,
178  *		NFLNK = 5
179  *	};
180  *
181  */
xdr_decode_ftype(__be32 * p,u32 * type)182 static __be32 *xdr_decode_ftype(__be32 *p, u32 *type)
183 {
184 	*type = be32_to_cpup(p++);
185 	if (unlikely(*type > NF2FIFO))
186 		*type = NFBAD;
187 	return p;
188 }
189 
190 /*
191  * 2.3.3.  fhandle
192  *
193  *	typedef opaque fhandle[FHSIZE];
194  */
encode_fhandle(struct xdr_stream * xdr,const struct nfs_fh * fh)195 static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh)
196 {
197 	__be32 *p;
198 
199 	p = xdr_reserve_space(xdr, NFS2_FHSIZE);
200 	memcpy(p, fh->data, NFS2_FHSIZE);
201 }
202 
decode_fhandle(struct xdr_stream * xdr,struct nfs_fh * fh)203 static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh)
204 {
205 	__be32 *p;
206 
207 	p = xdr_inline_decode(xdr, NFS2_FHSIZE);
208 	if (unlikely(p == NULL))
209 		goto out_overflow;
210 	fh->size = NFS2_FHSIZE;
211 	memcpy(fh->data, p, NFS2_FHSIZE);
212 	return 0;
213 out_overflow:
214 	print_overflow_msg(__func__, xdr);
215 	return -EIO;
216 }
217 
218 /*
219  * 2.3.4.  timeval
220  *
221  *	struct timeval {
222  *		unsigned int seconds;
223  *		unsigned int useconds;
224  *	};
225  */
xdr_encode_time(__be32 * p,const struct timespec * timep)226 static __be32 *xdr_encode_time(__be32 *p, const struct timespec *timep)
227 {
228 	*p++ = cpu_to_be32(timep->tv_sec);
229 	if (timep->tv_nsec != 0)
230 		*p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC);
231 	else
232 		*p++ = cpu_to_be32(0);
233 	return p;
234 }
235 
236 /*
237  * Passing the invalid value useconds=1000000 is a Sun convention for
238  * "set to current server time".  It's needed to make permissions checks
239  * for the "touch" program across v2 mounts to Solaris and Irix servers
240  * work correctly.  See description of sattr in section 6.1 of "NFS
241  * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5.
242  */
xdr_encode_current_server_time(__be32 * p,const struct timespec * timep)243 static __be32 *xdr_encode_current_server_time(__be32 *p,
244 					      const struct timespec *timep)
245 {
246 	*p++ = cpu_to_be32(timep->tv_sec);
247 	*p++ = cpu_to_be32(1000000);
248 	return p;
249 }
250 
xdr_decode_time(__be32 * p,struct timespec * timep)251 static __be32 *xdr_decode_time(__be32 *p, struct timespec *timep)
252 {
253 	timep->tv_sec = be32_to_cpup(p++);
254 	timep->tv_nsec = be32_to_cpup(p++) * NSEC_PER_USEC;
255 	return p;
256 }
257 
258 /*
259  * 2.3.5.  fattr
260  *
261  *	struct fattr {
262  *		ftype		type;
263  *		unsigned int	mode;
264  *		unsigned int	nlink;
265  *		unsigned int	uid;
266  *		unsigned int	gid;
267  *		unsigned int	size;
268  *		unsigned int	blocksize;
269  *		unsigned int	rdev;
270  *		unsigned int	blocks;
271  *		unsigned int	fsid;
272  *		unsigned int	fileid;
273  *		timeval		atime;
274  *		timeval		mtime;
275  *		timeval		ctime;
276  *	};
277  *
278  */
decode_fattr(struct xdr_stream * xdr,struct nfs_fattr * fattr)279 static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
280 {
281 	u32 rdev, type;
282 	__be32 *p;
283 
284 	p = xdr_inline_decode(xdr, NFS_fattr_sz << 2);
285 	if (unlikely(p == NULL))
286 		goto out_overflow;
287 
288 	fattr->valid |= NFS_ATTR_FATTR_V2;
289 
290 	p = xdr_decode_ftype(p, &type);
291 
292 	fattr->mode = be32_to_cpup(p++);
293 	fattr->nlink = be32_to_cpup(p++);
294 	fattr->uid = make_kuid(&init_user_ns, be32_to_cpup(p++));
295 	if (!uid_valid(fattr->uid))
296 		goto out_uid;
297 	fattr->gid = make_kgid(&init_user_ns, be32_to_cpup(p++));
298 	if (!gid_valid(fattr->gid))
299 		goto out_gid;
300 
301 	fattr->size = be32_to_cpup(p++);
302 	fattr->du.nfs2.blocksize = be32_to_cpup(p++);
303 
304 	rdev = be32_to_cpup(p++);
305 	fattr->rdev = new_decode_dev(rdev);
306 	if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) {
307 		fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
308 		fattr->rdev = 0;
309 	}
310 
311 	fattr->du.nfs2.blocks = be32_to_cpup(p++);
312 	fattr->fsid.major = be32_to_cpup(p++);
313 	fattr->fsid.minor = 0;
314 	fattr->fileid = be32_to_cpup(p++);
315 
316 	p = xdr_decode_time(p, &fattr->atime);
317 	p = xdr_decode_time(p, &fattr->mtime);
318 	xdr_decode_time(p, &fattr->ctime);
319 	fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
320 
321 	return 0;
322 out_uid:
323 	dprintk("NFS: returned invalid uid\n");
324 	return -EINVAL;
325 out_gid:
326 	dprintk("NFS: returned invalid gid\n");
327 	return -EINVAL;
328 out_overflow:
329 	print_overflow_msg(__func__, xdr);
330 	return -EIO;
331 }
332 
333 /*
334  * 2.3.6.  sattr
335  *
336  *	struct sattr {
337  *		unsigned int	mode;
338  *		unsigned int	uid;
339  *		unsigned int	gid;
340  *		unsigned int	size;
341  *		timeval		atime;
342  *		timeval		mtime;
343  *	};
344  */
345 
346 #define NFS2_SATTR_NOT_SET	(0xffffffff)
347 
xdr_time_not_set(__be32 * p)348 static __be32 *xdr_time_not_set(__be32 *p)
349 {
350 	*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
351 	*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
352 	return p;
353 }
354 
encode_sattr(struct xdr_stream * xdr,const struct iattr * attr)355 static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr)
356 {
357 	struct timespec ts;
358 	__be32 *p;
359 
360 	p = xdr_reserve_space(xdr, NFS_sattr_sz << 2);
361 
362 	if (attr->ia_valid & ATTR_MODE)
363 		*p++ = cpu_to_be32(attr->ia_mode);
364 	else
365 		*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
366 	if (attr->ia_valid & ATTR_UID)
367 		*p++ = cpu_to_be32(from_kuid(&init_user_ns, attr->ia_uid));
368 	else
369 		*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
370 	if (attr->ia_valid & ATTR_GID)
371 		*p++ = cpu_to_be32(from_kgid(&init_user_ns, attr->ia_gid));
372 	else
373 		*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
374 	if (attr->ia_valid & ATTR_SIZE)
375 		*p++ = cpu_to_be32((u32)attr->ia_size);
376 	else
377 		*p++ = cpu_to_be32(NFS2_SATTR_NOT_SET);
378 
379 	if (attr->ia_valid & ATTR_ATIME_SET) {
380 		ts = timespec64_to_timespec(attr->ia_atime);
381 		p = xdr_encode_time(p, &ts);
382 	} else if (attr->ia_valid & ATTR_ATIME) {
383 		ts = timespec64_to_timespec(attr->ia_atime);
384 		p = xdr_encode_current_server_time(p, &ts);
385 	} else
386 		p = xdr_time_not_set(p);
387 	if (attr->ia_valid & ATTR_MTIME_SET) {
388 		ts = timespec64_to_timespec(attr->ia_mtime);
389 		xdr_encode_time(p, &ts);
390 	} else if (attr->ia_valid & ATTR_MTIME) {
391 		ts = timespec64_to_timespec(attr->ia_mtime);
392 		xdr_encode_current_server_time(p, &ts);
393 	} else
394 		xdr_time_not_set(p);
395 }
396 
397 /*
398  * 2.3.7.  filename
399  *
400  *	typedef string filename<MAXNAMLEN>;
401  */
encode_filename(struct xdr_stream * xdr,const char * name,u32 length)402 static void encode_filename(struct xdr_stream *xdr,
403 			    const char *name, u32 length)
404 {
405 	__be32 *p;
406 
407 	WARN_ON_ONCE(length > NFS2_MAXNAMLEN);
408 	p = xdr_reserve_space(xdr, 4 + length);
409 	xdr_encode_opaque(p, name, length);
410 }
411 
decode_filename_inline(struct xdr_stream * xdr,const char ** name,u32 * length)412 static int decode_filename_inline(struct xdr_stream *xdr,
413 				  const char **name, u32 *length)
414 {
415 	__be32 *p;
416 	u32 count;
417 
418 	p = xdr_inline_decode(xdr, 4);
419 	if (unlikely(p == NULL))
420 		goto out_overflow;
421 	count = be32_to_cpup(p);
422 	if (count > NFS3_MAXNAMLEN)
423 		goto out_nametoolong;
424 	p = xdr_inline_decode(xdr, count);
425 	if (unlikely(p == NULL))
426 		goto out_overflow;
427 	*name = (const char *)p;
428 	*length = count;
429 	return 0;
430 out_nametoolong:
431 	dprintk("NFS: returned filename too long: %u\n", count);
432 	return -ENAMETOOLONG;
433 out_overflow:
434 	print_overflow_msg(__func__, xdr);
435 	return -EIO;
436 }
437 
438 /*
439  * 2.3.8.  path
440  *
441  *	typedef string path<MAXPATHLEN>;
442  */
encode_path(struct xdr_stream * xdr,struct page ** pages,u32 length)443 static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length)
444 {
445 	__be32 *p;
446 
447 	p = xdr_reserve_space(xdr, 4);
448 	*p = cpu_to_be32(length);
449 	xdr_write_pages(xdr, pages, 0, length);
450 }
451 
decode_path(struct xdr_stream * xdr)452 static int decode_path(struct xdr_stream *xdr)
453 {
454 	u32 length, recvd;
455 	__be32 *p;
456 
457 	p = xdr_inline_decode(xdr, 4);
458 	if (unlikely(p == NULL))
459 		goto out_overflow;
460 	length = be32_to_cpup(p);
461 	if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN))
462 		goto out_size;
463 	recvd = xdr_read_pages(xdr, length);
464 	if (unlikely(length > recvd))
465 		goto out_cheating;
466 	xdr_terminate_string(xdr->buf, length);
467 	return 0;
468 out_size:
469 	dprintk("NFS: returned pathname too long: %u\n", length);
470 	return -ENAMETOOLONG;
471 out_cheating:
472 	dprintk("NFS: server cheating in pathname result: "
473 		"length %u > received %u\n", length, recvd);
474 	return -EIO;
475 out_overflow:
476 	print_overflow_msg(__func__, xdr);
477 	return -EIO;
478 }
479 
480 /*
481  * 2.3.9.  attrstat
482  *
483  *	union attrstat switch (stat status) {
484  *	case NFS_OK:
485  *		fattr attributes;
486  *	default:
487  *		void;
488  *	};
489  */
decode_attrstat(struct xdr_stream * xdr,struct nfs_fattr * result,__u32 * op_status)490 static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result,
491 			   __u32 *op_status)
492 {
493 	enum nfs_stat status;
494 	int error;
495 
496 	error = decode_stat(xdr, &status);
497 	if (unlikely(error))
498 		goto out;
499 	if (op_status)
500 		*op_status = status;
501 	if (status != NFS_OK)
502 		goto out_default;
503 	error = decode_fattr(xdr, result);
504 out:
505 	return error;
506 out_default:
507 	return nfs_stat_to_errno(status);
508 }
509 
510 /*
511  * 2.3.10.  diropargs
512  *
513  *	struct diropargs {
514  *		fhandle  dir;
515  *		filename name;
516  *	};
517  */
encode_diropargs(struct xdr_stream * xdr,const struct nfs_fh * fh,const char * name,u32 length)518 static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh,
519 			     const char *name, u32 length)
520 {
521 	encode_fhandle(xdr, fh);
522 	encode_filename(xdr, name, length);
523 }
524 
525 /*
526  * 2.3.11.  diropres
527  *
528  *	union diropres switch (stat status) {
529  *	case NFS_OK:
530  *		struct {
531  *			fhandle file;
532  *			fattr   attributes;
533  *		} diropok;
534  *	default:
535  *		void;
536  *	};
537  */
decode_diropok(struct xdr_stream * xdr,struct nfs_diropok * result)538 static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result)
539 {
540 	int error;
541 
542 	error = decode_fhandle(xdr, result->fh);
543 	if (unlikely(error))
544 		goto out;
545 	error = decode_fattr(xdr, result->fattr);
546 out:
547 	return error;
548 }
549 
decode_diropres(struct xdr_stream * xdr,struct nfs_diropok * result)550 static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result)
551 {
552 	enum nfs_stat status;
553 	int error;
554 
555 	error = decode_stat(xdr, &status);
556 	if (unlikely(error))
557 		goto out;
558 	if (status != NFS_OK)
559 		goto out_default;
560 	error = decode_diropok(xdr, result);
561 out:
562 	return error;
563 out_default:
564 	return nfs_stat_to_errno(status);
565 }
566 
567 
568 /*
569  * NFSv2 XDR encode functions
570  *
571  * NFSv2 argument types are defined in section 2.2 of RFC 1094:
572  * "NFS: Network File System Protocol Specification".
573  */
574 
nfs2_xdr_enc_fhandle(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)575 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req,
576 				 struct xdr_stream *xdr,
577 				 const void *data)
578 {
579 	const struct nfs_fh *fh = data;
580 
581 	encode_fhandle(xdr, fh);
582 }
583 
584 /*
585  * 2.2.3.  sattrargs
586  *
587  *	struct sattrargs {
588  *		fhandle file;
589  *		sattr attributes;
590  *	};
591  */
nfs2_xdr_enc_sattrargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)592 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req,
593 				   struct xdr_stream *xdr,
594 				   const void *data)
595 {
596 	const struct nfs_sattrargs *args = data;
597 
598 	encode_fhandle(xdr, args->fh);
599 	encode_sattr(xdr, args->sattr);
600 }
601 
nfs2_xdr_enc_diropargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)602 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req,
603 				   struct xdr_stream *xdr,
604 				   const void *data)
605 {
606 	const struct nfs_diropargs *args = data;
607 
608 	encode_diropargs(xdr, args->fh, args->name, args->len);
609 }
610 
nfs2_xdr_enc_readlinkargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)611 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req,
612 				      struct xdr_stream *xdr,
613 				      const void *data)
614 {
615 	const struct nfs_readlinkargs *args = data;
616 
617 	encode_fhandle(xdr, args->fh);
618 	prepare_reply_buffer(req, args->pages, args->pgbase,
619 					args->pglen, NFS_readlinkres_sz);
620 }
621 
622 /*
623  * 2.2.7.  readargs
624  *
625  *	struct readargs {
626  *		fhandle file;
627  *		unsigned offset;
628  *		unsigned count;
629  *		unsigned totalcount;
630  *	};
631  */
encode_readargs(struct xdr_stream * xdr,const struct nfs_pgio_args * args)632 static void encode_readargs(struct xdr_stream *xdr,
633 			    const struct nfs_pgio_args *args)
634 {
635 	u32 offset = args->offset;
636 	u32 count = args->count;
637 	__be32 *p;
638 
639 	encode_fhandle(xdr, args->fh);
640 
641 	p = xdr_reserve_space(xdr, 4 + 4 + 4);
642 	*p++ = cpu_to_be32(offset);
643 	*p++ = cpu_to_be32(count);
644 	*p = cpu_to_be32(count);
645 }
646 
nfs2_xdr_enc_readargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)647 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req,
648 				  struct xdr_stream *xdr,
649 				  const void *data)
650 {
651 	const struct nfs_pgio_args *args = data;
652 
653 	encode_readargs(xdr, args);
654 	prepare_reply_buffer(req, args->pages, args->pgbase,
655 					args->count, NFS_readres_sz);
656 	req->rq_rcv_buf.flags |= XDRBUF_READ;
657 }
658 
659 /*
660  * 2.2.9.  writeargs
661  *
662  *	struct writeargs {
663  *		fhandle file;
664  *		unsigned beginoffset;
665  *		unsigned offset;
666  *		unsigned totalcount;
667  *		nfsdata data;
668  *	};
669  */
encode_writeargs(struct xdr_stream * xdr,const struct nfs_pgio_args * args)670 static void encode_writeargs(struct xdr_stream *xdr,
671 			     const struct nfs_pgio_args *args)
672 {
673 	u32 offset = args->offset;
674 	u32 count = args->count;
675 	__be32 *p;
676 
677 	encode_fhandle(xdr, args->fh);
678 
679 	p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4);
680 	*p++ = cpu_to_be32(offset);
681 	*p++ = cpu_to_be32(offset);
682 	*p++ = cpu_to_be32(count);
683 
684 	/* nfsdata */
685 	*p = cpu_to_be32(count);
686 	xdr_write_pages(xdr, args->pages, args->pgbase, count);
687 }
688 
nfs2_xdr_enc_writeargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)689 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req,
690 				   struct xdr_stream *xdr,
691 				   const void *data)
692 {
693 	const struct nfs_pgio_args *args = data;
694 
695 	encode_writeargs(xdr, args);
696 	xdr->buf->flags |= XDRBUF_WRITE;
697 }
698 
699 /*
700  * 2.2.10.  createargs
701  *
702  *	struct createargs {
703  *		diropargs where;
704  *		sattr attributes;
705  *	};
706  */
nfs2_xdr_enc_createargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)707 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req,
708 				    struct xdr_stream *xdr,
709 				    const void *data)
710 {
711 	const struct nfs_createargs *args = data;
712 
713 	encode_diropargs(xdr, args->fh, args->name, args->len);
714 	encode_sattr(xdr, args->sattr);
715 }
716 
nfs2_xdr_enc_removeargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)717 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req,
718 				    struct xdr_stream *xdr,
719 				    const void *data)
720 {
721 	const struct nfs_removeargs *args = data;
722 
723 	encode_diropargs(xdr, args->fh, args->name.name, args->name.len);
724 }
725 
726 /*
727  * 2.2.12.  renameargs
728  *
729  *	struct renameargs {
730  *		diropargs from;
731  *		diropargs to;
732  *	};
733  */
nfs2_xdr_enc_renameargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)734 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req,
735 				    struct xdr_stream *xdr,
736 				    const void *data)
737 {
738 	const struct nfs_renameargs *args = data;
739 	const struct qstr *old = args->old_name;
740 	const struct qstr *new = args->new_name;
741 
742 	encode_diropargs(xdr, args->old_dir, old->name, old->len);
743 	encode_diropargs(xdr, args->new_dir, new->name, new->len);
744 }
745 
746 /*
747  * 2.2.13.  linkargs
748  *
749  *	struct linkargs {
750  *		fhandle from;
751  *		diropargs to;
752  *	};
753  */
nfs2_xdr_enc_linkargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)754 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req,
755 				  struct xdr_stream *xdr,
756 				  const void *data)
757 {
758 	const struct nfs_linkargs *args = data;
759 
760 	encode_fhandle(xdr, args->fromfh);
761 	encode_diropargs(xdr, args->tofh, args->toname, args->tolen);
762 }
763 
764 /*
765  * 2.2.14.  symlinkargs
766  *
767  *	struct symlinkargs {
768  *		diropargs from;
769  *		path to;
770  *		sattr attributes;
771  *	};
772  */
nfs2_xdr_enc_symlinkargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)773 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req,
774 				     struct xdr_stream *xdr,
775 				     const void *data)
776 {
777 	const struct nfs_symlinkargs *args = data;
778 
779 	encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen);
780 	encode_path(xdr, args->pages, args->pathlen);
781 	encode_sattr(xdr, args->sattr);
782 }
783 
784 /*
785  * 2.2.17.  readdirargs
786  *
787  *	struct readdirargs {
788  *		fhandle dir;
789  *		nfscookie cookie;
790  *		unsigned count;
791  *	};
792  */
encode_readdirargs(struct xdr_stream * xdr,const struct nfs_readdirargs * args)793 static void encode_readdirargs(struct xdr_stream *xdr,
794 			       const struct nfs_readdirargs *args)
795 {
796 	__be32 *p;
797 
798 	encode_fhandle(xdr, args->fh);
799 
800 	p = xdr_reserve_space(xdr, 4 + 4);
801 	*p++ = cpu_to_be32(args->cookie);
802 	*p = cpu_to_be32(args->count);
803 }
804 
nfs2_xdr_enc_readdirargs(struct rpc_rqst * req,struct xdr_stream * xdr,const void * data)805 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req,
806 				     struct xdr_stream *xdr,
807 				     const void *data)
808 {
809 	const struct nfs_readdirargs *args = data;
810 
811 	encode_readdirargs(xdr, args);
812 	prepare_reply_buffer(req, args->pages, 0,
813 					args->count, NFS_readdirres_sz);
814 }
815 
816 /*
817  * NFSv2 XDR decode functions
818  *
819  * NFSv2 result types are defined in section 2.2 of RFC 1094:
820  * "NFS: Network File System Protocol Specification".
821  */
822 
nfs2_xdr_dec_stat(struct rpc_rqst * req,struct xdr_stream * xdr,void * __unused)823 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr,
824 			     void *__unused)
825 {
826 	enum nfs_stat status;
827 	int error;
828 
829 	error = decode_stat(xdr, &status);
830 	if (unlikely(error))
831 		goto out;
832 	if (status != NFS_OK)
833 		goto out_default;
834 out:
835 	return error;
836 out_default:
837 	return nfs_stat_to_errno(status);
838 }
839 
nfs2_xdr_dec_attrstat(struct rpc_rqst * req,struct xdr_stream * xdr,void * result)840 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr,
841 				 void *result)
842 {
843 	return decode_attrstat(xdr, result, NULL);
844 }
845 
nfs2_xdr_dec_diropres(struct rpc_rqst * req,struct xdr_stream * xdr,void * result)846 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr,
847 				 void *result)
848 {
849 	return decode_diropres(xdr, result);
850 }
851 
852 /*
853  * 2.2.6.  readlinkres
854  *
855  *	union readlinkres switch (stat status) {
856  *	case NFS_OK:
857  *		path data;
858  *	default:
859  *		void;
860  *	};
861  */
nfs2_xdr_dec_readlinkres(struct rpc_rqst * req,struct xdr_stream * xdr,void * __unused)862 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req,
863 				    struct xdr_stream *xdr, void *__unused)
864 {
865 	enum nfs_stat status;
866 	int error;
867 
868 	error = decode_stat(xdr, &status);
869 	if (unlikely(error))
870 		goto out;
871 	if (status != NFS_OK)
872 		goto out_default;
873 	error = decode_path(xdr);
874 out:
875 	return error;
876 out_default:
877 	return nfs_stat_to_errno(status);
878 }
879 
880 /*
881  * 2.2.7.  readres
882  *
883  *	union readres switch (stat status) {
884  *	case NFS_OK:
885  *		fattr attributes;
886  *		nfsdata data;
887  *	default:
888  *		void;
889  *	};
890  */
nfs2_xdr_dec_readres(struct rpc_rqst * req,struct xdr_stream * xdr,void * data)891 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr,
892 				void *data)
893 {
894 	struct nfs_pgio_res *result = data;
895 	enum nfs_stat status;
896 	int error;
897 
898 	error = decode_stat(xdr, &status);
899 	if (unlikely(error))
900 		goto out;
901 	result->op_status = status;
902 	if (status != NFS_OK)
903 		goto out_default;
904 	error = decode_fattr(xdr, result->fattr);
905 	if (unlikely(error))
906 		goto out;
907 	error = decode_nfsdata(xdr, result);
908 out:
909 	return error;
910 out_default:
911 	return nfs_stat_to_errno(status);
912 }
913 
nfs2_xdr_dec_writeres(struct rpc_rqst * req,struct xdr_stream * xdr,void * data)914 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr,
915 				 void *data)
916 {
917 	struct nfs_pgio_res *result = data;
918 
919 	/* All NFSv2 writes are "file sync" writes */
920 	result->verf->committed = NFS_FILE_SYNC;
921 	return decode_attrstat(xdr, result->fattr, &result->op_status);
922 }
923 
924 /**
925  * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
926  *                      the local page cache.
927  * @xdr: XDR stream where entry resides
928  * @entry: buffer to fill in with entry data
929  * @plus: boolean indicating whether this should be a readdirplus entry
930  *
931  * Returns zero if successful, otherwise a negative errno value is
932  * returned.
933  *
934  * This function is not invoked during READDIR reply decoding, but
935  * rather whenever an application invokes the getdents(2) system call
936  * on a directory already in our cache.
937  *
938  * 2.2.17.  entry
939  *
940  *	struct entry {
941  *		unsigned	fileid;
942  *		filename	name;
943  *		nfscookie	cookie;
944  *		entry		*nextentry;
945  *	};
946  */
nfs2_decode_dirent(struct xdr_stream * xdr,struct nfs_entry * entry,bool plus)947 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
948 		       bool plus)
949 {
950 	__be32 *p;
951 	int error;
952 
953 	p = xdr_inline_decode(xdr, 4);
954 	if (unlikely(p == NULL))
955 		goto out_overflow;
956 	if (*p++ == xdr_zero) {
957 		p = xdr_inline_decode(xdr, 4);
958 		if (unlikely(p == NULL))
959 			goto out_overflow;
960 		if (*p++ == xdr_zero)
961 			return -EAGAIN;
962 		entry->eof = 1;
963 		return -EBADCOOKIE;
964 	}
965 
966 	p = xdr_inline_decode(xdr, 4);
967 	if (unlikely(p == NULL))
968 		goto out_overflow;
969 	entry->ino = be32_to_cpup(p);
970 
971 	error = decode_filename_inline(xdr, &entry->name, &entry->len);
972 	if (unlikely(error))
973 		return error;
974 
975 	/*
976 	 * The type (size and byte order) of nfscookie isn't defined in
977 	 * RFC 1094.  This implementation assumes that it's an XDR uint32.
978 	 */
979 	entry->prev_cookie = entry->cookie;
980 	p = xdr_inline_decode(xdr, 4);
981 	if (unlikely(p == NULL))
982 		goto out_overflow;
983 	entry->cookie = be32_to_cpup(p);
984 
985 	entry->d_type = DT_UNKNOWN;
986 
987 	return 0;
988 
989 out_overflow:
990 	print_overflow_msg(__func__, xdr);
991 	return -EAGAIN;
992 }
993 
994 /*
995  * 2.2.17.  readdirres
996  *
997  *	union readdirres switch (stat status) {
998  *	case NFS_OK:
999  *		struct {
1000  *			entry *entries;
1001  *			bool eof;
1002  *		} readdirok;
1003  *	default:
1004  *		void;
1005  *	};
1006  *
1007  * Read the directory contents into the page cache, but don't
1008  * touch them.  The actual decoding is done by nfs2_decode_dirent()
1009  * during subsequent nfs_readdir() calls.
1010  */
decode_readdirok(struct xdr_stream * xdr)1011 static int decode_readdirok(struct xdr_stream *xdr)
1012 {
1013 	return xdr_read_pages(xdr, xdr->buf->page_len);
1014 }
1015 
nfs2_xdr_dec_readdirres(struct rpc_rqst * req,struct xdr_stream * xdr,void * __unused)1016 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req,
1017 				   struct xdr_stream *xdr, void *__unused)
1018 {
1019 	enum nfs_stat status;
1020 	int error;
1021 
1022 	error = decode_stat(xdr, &status);
1023 	if (unlikely(error))
1024 		goto out;
1025 	if (status != NFS_OK)
1026 		goto out_default;
1027 	error = decode_readdirok(xdr);
1028 out:
1029 	return error;
1030 out_default:
1031 	return nfs_stat_to_errno(status);
1032 }
1033 
1034 /*
1035  * 2.2.18.  statfsres
1036  *
1037  *	union statfsres (stat status) {
1038  *	case NFS_OK:
1039  *		struct {
1040  *			unsigned tsize;
1041  *			unsigned bsize;
1042  *			unsigned blocks;
1043  *			unsigned bfree;
1044  *			unsigned bavail;
1045  *		} info;
1046  *	default:
1047  *		void;
1048  *	};
1049  */
decode_info(struct xdr_stream * xdr,struct nfs2_fsstat * result)1050 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result)
1051 {
1052 	__be32 *p;
1053 
1054 	p = xdr_inline_decode(xdr, NFS_info_sz << 2);
1055 	if (unlikely(p == NULL))
1056 		goto out_overflow;
1057 	result->tsize  = be32_to_cpup(p++);
1058 	result->bsize  = be32_to_cpup(p++);
1059 	result->blocks = be32_to_cpup(p++);
1060 	result->bfree  = be32_to_cpup(p++);
1061 	result->bavail = be32_to_cpup(p);
1062 	return 0;
1063 out_overflow:
1064 	print_overflow_msg(__func__, xdr);
1065 	return -EIO;
1066 }
1067 
nfs2_xdr_dec_statfsres(struct rpc_rqst * req,struct xdr_stream * xdr,void * result)1068 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr,
1069 				  void *result)
1070 {
1071 	enum nfs_stat status;
1072 	int error;
1073 
1074 	error = decode_stat(xdr, &status);
1075 	if (unlikely(error))
1076 		goto out;
1077 	if (status != NFS_OK)
1078 		goto out_default;
1079 	error = decode_info(xdr, result);
1080 out:
1081 	return error;
1082 out_default:
1083 	return nfs_stat_to_errno(status);
1084 }
1085 
1086 
1087 /*
1088  * We need to translate between nfs status return values and
1089  * the local errno values which may not be the same.
1090  */
1091 static const struct {
1092 	int stat;
1093 	int errno;
1094 } nfs_errtbl[] = {
1095 	{ NFS_OK,		0		},
1096 	{ NFSERR_PERM,		-EPERM		},
1097 	{ NFSERR_NOENT,		-ENOENT		},
1098 	{ NFSERR_IO,		-errno_NFSERR_IO},
1099 	{ NFSERR_NXIO,		-ENXIO		},
1100 /*	{ NFSERR_EAGAIN,	-EAGAIN		}, */
1101 	{ NFSERR_ACCES,		-EACCES		},
1102 	{ NFSERR_EXIST,		-EEXIST		},
1103 	{ NFSERR_XDEV,		-EXDEV		},
1104 	{ NFSERR_NODEV,		-ENODEV		},
1105 	{ NFSERR_NOTDIR,	-ENOTDIR	},
1106 	{ NFSERR_ISDIR,		-EISDIR		},
1107 	{ NFSERR_INVAL,		-EINVAL		},
1108 	{ NFSERR_FBIG,		-EFBIG		},
1109 	{ NFSERR_NOSPC,		-ENOSPC		},
1110 	{ NFSERR_ROFS,		-EROFS		},
1111 	{ NFSERR_MLINK,		-EMLINK		},
1112 	{ NFSERR_NAMETOOLONG,	-ENAMETOOLONG	},
1113 	{ NFSERR_NOTEMPTY,	-ENOTEMPTY	},
1114 	{ NFSERR_DQUOT,		-EDQUOT		},
1115 	{ NFSERR_STALE,		-ESTALE		},
1116 	{ NFSERR_REMOTE,	-EREMOTE	},
1117 #ifdef EWFLUSH
1118 	{ NFSERR_WFLUSH,	-EWFLUSH	},
1119 #endif
1120 	{ NFSERR_BADHANDLE,	-EBADHANDLE	},
1121 	{ NFSERR_NOT_SYNC,	-ENOTSYNC	},
1122 	{ NFSERR_BAD_COOKIE,	-EBADCOOKIE	},
1123 	{ NFSERR_NOTSUPP,	-ENOTSUPP	},
1124 	{ NFSERR_TOOSMALL,	-ETOOSMALL	},
1125 	{ NFSERR_SERVERFAULT,	-EREMOTEIO	},
1126 	{ NFSERR_BADTYPE,	-EBADTYPE	},
1127 	{ NFSERR_JUKEBOX,	-EJUKEBOX	},
1128 	{ -1,			-EIO		}
1129 };
1130 
1131 /**
1132  * nfs_stat_to_errno - convert an NFS status code to a local errno
1133  * @status: NFS status code to convert
1134  *
1135  * Returns a local errno value, or -EIO if the NFS status code is
1136  * not recognized.  This function is used jointly by NFSv2 and NFSv3.
1137  */
nfs_stat_to_errno(enum nfs_stat status)1138 static int nfs_stat_to_errno(enum nfs_stat status)
1139 {
1140 	int i;
1141 
1142 	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
1143 		if (nfs_errtbl[i].stat == (int)status)
1144 			return nfs_errtbl[i].errno;
1145 	}
1146 	dprintk("NFS: Unrecognized nfs status value: %u\n", status);
1147 	return nfs_errtbl[i].errno;
1148 }
1149 
1150 #define PROC(proc, argtype, restype, timer)				\
1151 [NFSPROC_##proc] = {							\
1152 	.p_proc	    =  NFSPROC_##proc,					\
1153 	.p_encode   =  nfs2_xdr_enc_##argtype,				\
1154 	.p_decode   =  nfs2_xdr_dec_##restype,				\
1155 	.p_arglen   =  NFS_##argtype##_sz,				\
1156 	.p_replen   =  NFS_##restype##_sz,				\
1157 	.p_timer    =  timer,						\
1158 	.p_statidx  =  NFSPROC_##proc,					\
1159 	.p_name     =  #proc,						\
1160 	}
1161 const struct rpc_procinfo nfs_procedures[] = {
1162 	PROC(GETATTR,	fhandle,	attrstat,	1),
1163 	PROC(SETATTR,	sattrargs,	attrstat,	0),
1164 	PROC(LOOKUP,	diropargs,	diropres,	2),
1165 	PROC(READLINK,	readlinkargs,	readlinkres,	3),
1166 	PROC(READ,	readargs,	readres,	3),
1167 	PROC(WRITE,	writeargs,	writeres,	4),
1168 	PROC(CREATE,	createargs,	diropres,	0),
1169 	PROC(REMOVE,	removeargs,	stat,		0),
1170 	PROC(RENAME,	renameargs,	stat,		0),
1171 	PROC(LINK,	linkargs,	stat,		0),
1172 	PROC(SYMLINK,	symlinkargs,	stat,		0),
1173 	PROC(MKDIR,	createargs,	diropres,	0),
1174 	PROC(RMDIR,	diropargs,	stat,		0),
1175 	PROC(READDIR,	readdirargs,	readdirres,	3),
1176 	PROC(STATFS,	fhandle,	statfsres,	0),
1177 };
1178 
1179 static unsigned int nfs_version2_counts[ARRAY_SIZE(nfs_procedures)];
1180 const struct rpc_version nfs_version2 = {
1181 	.number			= 2,
1182 	.nrprocs		= ARRAY_SIZE(nfs_procedures),
1183 	.procs			= nfs_procedures,
1184 	.counts			= nfs_version2_counts,
1185 };
1186