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