xref: /openbmc/linux/fs/nfs/nfs2xdr.c (revision 1be27f36) 
1 /*
2  * linux/fs/nfs/nfs2xdr.c
3  *
4  * XDR functions to encode/decode NFS RPC arguments and results.
5  *
6  * Copyright (C) 1992, 1993, 1994  Rick Sladkey
7  * Copyright (C) 1996 Olaf Kirch
8  * 04 Aug 1998  Ion Badulescu <ionut@cs.columbia.edu>
9  * 		FIFO's need special handling in NFSv2
10  */
11 
12 #include <linux/param.h>
13 #include <linux/time.h>
14 #include <linux/mm.h>
15 #include <linux/slab.h>
16 #include <linux/utsname.h>
17 #include <linux/errno.h>
18 #include <linux/string.h>
19 #include <linux/in.h>
20 #include <linux/pagemap.h>
21 #include <linux/proc_fs.h>
22 #include <linux/sunrpc/clnt.h>
23 #include <linux/nfs.h>
24 #include <linux/nfs2.h>
25 #include <linux/nfs_fs.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_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 /*
66  * Common NFS XDR functions as inlines
67  */
68 static inline __be32 *
69 xdr_encode_fhandle(__be32 *p, struct nfs_fh *fhandle)
70 {
71 	memcpy(p, fhandle->data, NFS2_FHSIZE);
72 	return p + XDR_QUADLEN(NFS2_FHSIZE);
73 }
74 
75 static inline __be32 *
76 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle)
77 {
78 	/* NFSv2 handles have a fixed length */
79 	fhandle->size = NFS2_FHSIZE;
80 	memcpy(fhandle->data, p, NFS2_FHSIZE);
81 	return p + XDR_QUADLEN(NFS2_FHSIZE);
82 }
83 
84 static inline __be32*
85 xdr_encode_time(__be32 *p, struct timespec *timep)
86 {
87 	*p++ = htonl(timep->tv_sec);
88 	/* Convert nanoseconds into microseconds */
89 	*p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
90 	return p;
91 }
92 
93 static inline __be32*
94 xdr_encode_current_server_time(__be32 *p, struct timespec *timep)
95 {
96 	/*
97 	 * Passing the invalid value useconds=1000000 is a
98 	 * Sun convention for "set to current server time".
99 	 * It's needed to make permissions checks for the
100 	 * "touch" program across v2 mounts to Solaris and
101 	 * Irix boxes work correctly. See description of
102 	 * sattr in section 6.1 of "NFS Illustrated" by
103 	 * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
104 	 */
105 	*p++ = htonl(timep->tv_sec);
106 	*p++ = htonl(1000000);
107 	return p;
108 }
109 
110 static inline __be32*
111 xdr_decode_time(__be32 *p, struct timespec *timep)
112 {
113 	timep->tv_sec = ntohl(*p++);
114 	/* Convert microseconds into nanoseconds */
115 	timep->tv_nsec = ntohl(*p++) * 1000;
116 	return p;
117 }
118 
119 static __be32 *
120 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
121 {
122 	u32 rdev;
123 	fattr->type = (enum nfs_ftype) ntohl(*p++);
124 	fattr->mode = ntohl(*p++);
125 	fattr->nlink = ntohl(*p++);
126 	fattr->uid = ntohl(*p++);
127 	fattr->gid = ntohl(*p++);
128 	fattr->size = ntohl(*p++);
129 	fattr->du.nfs2.blocksize = ntohl(*p++);
130 	rdev = ntohl(*p++);
131 	fattr->du.nfs2.blocks = ntohl(*p++);
132 	fattr->fsid.major = ntohl(*p++);
133 	fattr->fsid.minor = 0;
134 	fattr->fileid = ntohl(*p++);
135 	p = xdr_decode_time(p, &fattr->atime);
136 	p = xdr_decode_time(p, &fattr->mtime);
137 	p = xdr_decode_time(p, &fattr->ctime);
138 	fattr->valid |= NFS_ATTR_FATTR;
139 	fattr->rdev = new_decode_dev(rdev);
140 	if (fattr->type == NFCHR && rdev == NFS2_FIFO_DEV) {
141 		fattr->type = NFFIFO;
142 		fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO;
143 		fattr->rdev = 0;
144 	}
145 	return p;
146 }
147 
148 static inline __be32 *
149 xdr_encode_sattr(__be32 *p, struct iattr *attr)
150 {
151 	const __be32 not_set = __constant_htonl(0xFFFFFFFF);
152 
153 	*p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set;
154 	*p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set;
155 	*p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set;
156 	*p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set;
157 
158 	if (attr->ia_valid & ATTR_ATIME_SET) {
159 		p = xdr_encode_time(p, &attr->ia_atime);
160 	} else if (attr->ia_valid & ATTR_ATIME) {
161 		p = xdr_encode_current_server_time(p, &attr->ia_atime);
162 	} else {
163 		*p++ = not_set;
164 		*p++ = not_set;
165 	}
166 
167 	if (attr->ia_valid & ATTR_MTIME_SET) {
168 		p = xdr_encode_time(p, &attr->ia_mtime);
169 	} else if (attr->ia_valid & ATTR_MTIME) {
170 		p = xdr_encode_current_server_time(p, &attr->ia_mtime);
171 	} else {
172 		*p++ = not_set;
173 		*p++ = not_set;
174 	}
175   	return p;
176 }
177 
178 /*
179  * NFS encode functions
180  */
181 /*
182  * Encode file handle argument
183  * GETATTR, READLINK, STATFS
184  */
185 static int
186 nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
187 {
188 	p = xdr_encode_fhandle(p, fh);
189 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
190 	return 0;
191 }
192 
193 /*
194  * Encode SETATTR arguments
195  */
196 static int
197 nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args)
198 {
199 	p = xdr_encode_fhandle(p, args->fh);
200 	p = xdr_encode_sattr(p, args->sattr);
201 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
202 	return 0;
203 }
204 
205 /*
206  * Encode directory ops argument
207  * LOOKUP, REMOVE, RMDIR
208  */
209 static int
210 nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args)
211 {
212 	p = xdr_encode_fhandle(p, args->fh);
213 	p = xdr_encode_array(p, args->name, args->len);
214 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
215 	return 0;
216 }
217 
218 /*
219  * Arguments to a READ call. Since we read data directly into the page
220  * cache, we also set up the reply iovec here so that iov[1] points
221  * exactly to the page we want to fetch.
222  */
223 static int
224 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
225 {
226 	struct rpc_auth	*auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
227 	unsigned int replen;
228 	u32 offset = (u32)args->offset;
229 	u32 count = args->count;
230 
231 	p = xdr_encode_fhandle(p, args->fh);
232 	*p++ = htonl(offset);
233 	*p++ = htonl(count);
234 	*p++ = htonl(count);
235 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
236 
237 	/* Inline the page array */
238 	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
239 	xdr_inline_pages(&req->rq_rcv_buf, replen,
240 			 args->pages, args->pgbase, count);
241 	return 0;
242 }
243 
244 /*
245  * Decode READ reply
246  */
247 static int
248 nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
249 {
250 	struct kvec *iov = req->rq_rcv_buf.head;
251 	int	status, count, recvd, hdrlen;
252 
253 	if ((status = ntohl(*p++)))
254 		return -nfs_stat_to_errno(status);
255 	p = xdr_decode_fattr(p, res->fattr);
256 
257 	count = ntohl(*p++);
258 	res->eof = 0;
259 	hdrlen = (u8 *) p - (u8 *) iov->iov_base;
260 	if (iov->iov_len < hdrlen) {
261 		printk(KERN_WARNING "NFS: READ reply header overflowed:"
262 				"length %d > %Zu\n", hdrlen, iov->iov_len);
263 		return -errno_NFSERR_IO;
264 	} else if (iov->iov_len != hdrlen) {
265 		dprintk("NFS: READ header is short. iovec will be shifted.\n");
266 		xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
267 	}
268 
269 	recvd = req->rq_rcv_buf.len - hdrlen;
270 	if (count > recvd) {
271 		printk(KERN_WARNING "NFS: server cheating in read reply: "
272 			"count %d > recvd %d\n", count, recvd);
273 		count = recvd;
274 	}
275 
276 	dprintk("RPC:      readres OK count %d\n", count);
277 	if (count < res->count)
278 		res->count = count;
279 
280 	return count;
281 }
282 
283 
284 /*
285  * Write arguments. Splice the buffer to be written into the iovec.
286  */
287 static int
288 nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
289 {
290 	struct xdr_buf *sndbuf = &req->rq_snd_buf;
291 	u32 offset = (u32)args->offset;
292 	u32 count = args->count;
293 
294 	p = xdr_encode_fhandle(p, args->fh);
295 	*p++ = htonl(offset);
296 	*p++ = htonl(offset);
297 	*p++ = htonl(count);
298 	*p++ = htonl(count);
299 	sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
300 
301 	/* Copy the page array */
302 	xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
303 	return 0;
304 }
305 
306 /*
307  * Encode create arguments
308  * CREATE, MKDIR
309  */
310 static int
311 nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args)
312 {
313 	p = xdr_encode_fhandle(p, args->fh);
314 	p = xdr_encode_array(p, args->name, args->len);
315 	p = xdr_encode_sattr(p, args->sattr);
316 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
317 	return 0;
318 }
319 
320 /*
321  * Encode RENAME arguments
322  */
323 static int
324 nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args)
325 {
326 	p = xdr_encode_fhandle(p, args->fromfh);
327 	p = xdr_encode_array(p, args->fromname, args->fromlen);
328 	p = xdr_encode_fhandle(p, args->tofh);
329 	p = xdr_encode_array(p, args->toname, args->tolen);
330 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
331 	return 0;
332 }
333 
334 /*
335  * Encode LINK arguments
336  */
337 static int
338 nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args)
339 {
340 	p = xdr_encode_fhandle(p, args->fromfh);
341 	p = xdr_encode_fhandle(p, args->tofh);
342 	p = xdr_encode_array(p, args->toname, args->tolen);
343 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
344 	return 0;
345 }
346 
347 /*
348  * Encode SYMLINK arguments
349  */
350 static int
351 nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args)
352 {
353 	struct xdr_buf *sndbuf = &req->rq_snd_buf;
354 	size_t pad;
355 
356 	p = xdr_encode_fhandle(p, args->fromfh);
357 	p = xdr_encode_array(p, args->fromname, args->fromlen);
358 	*p++ = htonl(args->pathlen);
359 	sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
360 
361 	xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
362 
363 	/*
364 	 * xdr_encode_pages may have added a few bytes to ensure the
365 	 * pathname ends on a 4-byte boundary.  Start encoding the
366 	 * attributes after the pad bytes.
367 	 */
368 	pad = sndbuf->tail->iov_len;
369 	if (pad > 0)
370 		p++;
371 	p = xdr_encode_sattr(p, args->sattr);
372 	sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
373 	return 0;
374 }
375 
376 /*
377  * Encode arguments to readdir call
378  */
379 static int
380 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
381 {
382 	struct rpc_task	*task = req->rq_task;
383 	struct rpc_auth	*auth = task->tk_msg.rpc_cred->cr_auth;
384 	unsigned int replen;
385 	u32 count = args->count;
386 
387 	p = xdr_encode_fhandle(p, args->fh);
388 	*p++ = htonl(args->cookie);
389 	*p++ = htonl(count); /* see above */
390 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
391 
392 	/* Inline the page array */
393 	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
394 	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
395 	return 0;
396 }
397 
398 /*
399  * Decode the result of a readdir call.
400  * We're not really decoding anymore, we just leave the buffer untouched
401  * and only check that it is syntactically correct.
402  * The real decoding happens in nfs_decode_entry below, called directly
403  * from nfs_readdir for each entry.
404  */
405 static int
406 nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy)
407 {
408 	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
409 	struct kvec *iov = rcvbuf->head;
410 	struct page **page;
411 	int hdrlen, recvd;
412 	int status, nr;
413 	unsigned int len, pglen;
414 	__be32 *end, *entry, *kaddr;
415 
416 	if ((status = ntohl(*p++)))
417 		return -nfs_stat_to_errno(status);
418 
419 	hdrlen = (u8 *) p - (u8 *) iov->iov_base;
420 	if (iov->iov_len < hdrlen) {
421 		printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
422 				"length %d > %Zu\n", hdrlen, iov->iov_len);
423 		return -errno_NFSERR_IO;
424 	} else if (iov->iov_len != hdrlen) {
425 		dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
426 		xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
427 	}
428 
429 	pglen = rcvbuf->page_len;
430 	recvd = rcvbuf->len - hdrlen;
431 	if (pglen > recvd)
432 		pglen = recvd;
433 	page = rcvbuf->pages;
434 	kaddr = p = kmap_atomic(*page, KM_USER0);
435 	end = (__be32 *)((char *)p + pglen);
436 	entry = p;
437 	for (nr = 0; *p++; nr++) {
438 		if (p + 2 > end)
439 			goto short_pkt;
440 		p++; /* fileid */
441 		len = ntohl(*p++);
442 		p += XDR_QUADLEN(len) + 1;	/* name plus cookie */
443 		if (len > NFS2_MAXNAMLEN) {
444 			printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!\n",
445 						len);
446 			goto err_unmap;
447 		}
448 		if (p + 2 > end)
449 			goto short_pkt;
450 		entry = p;
451 	}
452 	if (!nr && (entry[0] != 0 || entry[1] == 0))
453 		goto short_pkt;
454  out:
455 	kunmap_atomic(kaddr, KM_USER0);
456 	return nr;
457  short_pkt:
458 	entry[0] = entry[1] = 0;
459 	/* truncate listing ? */
460 	if (!nr) {
461 		printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
462 		entry[1] = 1;
463 	}
464 	goto out;
465 err_unmap:
466 	nr = -errno_NFSERR_IO;
467 	goto out;
468 }
469 
470 __be32 *
471 nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
472 {
473 	if (!*p++) {
474 		if (!*p)
475 			return ERR_PTR(-EAGAIN);
476 		entry->eof = 1;
477 		return ERR_PTR(-EBADCOOKIE);
478 	}
479 
480 	entry->ino	  = ntohl(*p++);
481 	entry->len	  = ntohl(*p++);
482 	entry->name	  = (const char *) p;
483 	p		 += XDR_QUADLEN(entry->len);
484 	entry->prev_cookie	  = entry->cookie;
485 	entry->cookie	  = ntohl(*p++);
486 	entry->eof	  = !p[0] && p[1];
487 
488 	return p;
489 }
490 
491 /*
492  * NFS XDR decode functions
493  */
494 /*
495  * Decode simple status reply
496  */
497 static int
498 nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy)
499 {
500 	int	status;
501 
502 	if ((status = ntohl(*p++)) != 0)
503 		status = -nfs_stat_to_errno(status);
504 	return status;
505 }
506 
507 /*
508  * Decode attrstat reply
509  * GETATTR, SETATTR, WRITE
510  */
511 static int
512 nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
513 {
514 	int	status;
515 
516 	if ((status = ntohl(*p++)))
517 		return -nfs_stat_to_errno(status);
518 	xdr_decode_fattr(p, fattr);
519 	return 0;
520 }
521 
522 /*
523  * Decode diropres reply
524  * LOOKUP, CREATE, MKDIR
525  */
526 static int
527 nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
528 {
529 	int	status;
530 
531 	if ((status = ntohl(*p++)))
532 		return -nfs_stat_to_errno(status);
533 	p = xdr_decode_fhandle(p, res->fh);
534 	xdr_decode_fattr(p, res->fattr);
535 	return 0;
536 }
537 
538 /*
539  * Encode READLINK args
540  */
541 static int
542 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
543 {
544 	struct rpc_auth	*auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
545 	unsigned int replen;
546 
547 	p = xdr_encode_fhandle(p, args->fh);
548 	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
549 
550 	/* Inline the page array */
551 	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
552 	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
553 	return 0;
554 }
555 
556 /*
557  * Decode READLINK reply
558  */
559 static int
560 nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy)
561 {
562 	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
563 	struct kvec *iov = rcvbuf->head;
564 	int hdrlen, len, recvd;
565 	char	*kaddr;
566 	int	status;
567 
568 	if ((status = ntohl(*p++)))
569 		return -nfs_stat_to_errno(status);
570 	/* Convert length of symlink */
571 	len = ntohl(*p++);
572 	if (len >= rcvbuf->page_len || len <= 0) {
573 		dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
574 		return -ENAMETOOLONG;
575 	}
576 	hdrlen = (u8 *) p - (u8 *) iov->iov_base;
577 	if (iov->iov_len < hdrlen) {
578 		printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
579 				"length %d > %Zu\n", hdrlen, iov->iov_len);
580 		return -errno_NFSERR_IO;
581 	} else if (iov->iov_len != hdrlen) {
582 		dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
583 		xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
584 	}
585 	recvd = req->rq_rcv_buf.len - hdrlen;
586 	if (recvd < len) {
587 		printk(KERN_WARNING "NFS: server cheating in readlink reply: "
588 				"count %u > recvd %u\n", len, recvd);
589 		return -EIO;
590 	}
591 
592 	/* NULL terminate the string we got */
593 	kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
594 	kaddr[len+rcvbuf->page_base] = '\0';
595 	kunmap_atomic(kaddr, KM_USER0);
596 	return 0;
597 }
598 
599 /*
600  * Decode WRITE reply
601  */
602 static int
603 nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
604 {
605 	res->verf->committed = NFS_FILE_SYNC;
606 	return nfs_xdr_attrstat(req, p, res->fattr);
607 }
608 
609 /*
610  * Decode STATFS reply
611  */
612 static int
613 nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res)
614 {
615 	int	status;
616 
617 	if ((status = ntohl(*p++)))
618 		return -nfs_stat_to_errno(status);
619 
620 	res->tsize  = ntohl(*p++);
621 	res->bsize  = ntohl(*p++);
622 	res->blocks = ntohl(*p++);
623 	res->bfree  = ntohl(*p++);
624 	res->bavail = ntohl(*p++);
625 	return 0;
626 }
627 
628 /*
629  * We need to translate between nfs status return values and
630  * the local errno values which may not be the same.
631  */
632 static struct {
633 	int stat;
634 	int errno;
635 } nfs_errtbl[] = {
636 	{ NFS_OK,		0		},
637 	{ NFSERR_PERM,		EPERM		},
638 	{ NFSERR_NOENT,		ENOENT		},
639 	{ NFSERR_IO,		errno_NFSERR_IO	},
640 	{ NFSERR_NXIO,		ENXIO		},
641 /*	{ NFSERR_EAGAIN,	EAGAIN		}, */
642 	{ NFSERR_ACCES,		EACCES		},
643 	{ NFSERR_EXIST,		EEXIST		},
644 	{ NFSERR_XDEV,		EXDEV		},
645 	{ NFSERR_NODEV,		ENODEV		},
646 	{ NFSERR_NOTDIR,	ENOTDIR		},
647 	{ NFSERR_ISDIR,		EISDIR		},
648 	{ NFSERR_INVAL,		EINVAL		},
649 	{ NFSERR_FBIG,		EFBIG		},
650 	{ NFSERR_NOSPC,		ENOSPC		},
651 	{ NFSERR_ROFS,		EROFS		},
652 	{ NFSERR_MLINK,		EMLINK		},
653 	{ NFSERR_NAMETOOLONG,	ENAMETOOLONG	},
654 	{ NFSERR_NOTEMPTY,	ENOTEMPTY	},
655 	{ NFSERR_DQUOT,		EDQUOT		},
656 	{ NFSERR_STALE,		ESTALE		},
657 	{ NFSERR_REMOTE,	EREMOTE		},
658 #ifdef EWFLUSH
659 	{ NFSERR_WFLUSH,	EWFLUSH		},
660 #endif
661 	{ NFSERR_BADHANDLE,	EBADHANDLE	},
662 	{ NFSERR_NOT_SYNC,	ENOTSYNC	},
663 	{ NFSERR_BAD_COOKIE,	EBADCOOKIE	},
664 	{ NFSERR_NOTSUPP,	ENOTSUPP	},
665 	{ NFSERR_TOOSMALL,	ETOOSMALL	},
666 	{ NFSERR_SERVERFAULT,	ESERVERFAULT	},
667 	{ NFSERR_BADTYPE,	EBADTYPE	},
668 	{ NFSERR_JUKEBOX,	EJUKEBOX	},
669 	{ -1,			EIO		}
670 };
671 
672 /*
673  * Convert an NFS error code to a local one.
674  * This one is used jointly by NFSv2 and NFSv3.
675  */
676 int
677 nfs_stat_to_errno(int stat)
678 {
679 	int i;
680 
681 	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
682 		if (nfs_errtbl[i].stat == stat)
683 			return nfs_errtbl[i].errno;
684 	}
685 	printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
686 	return nfs_errtbl[i].errno;
687 }
688 
689 #define PROC(proc, argtype, restype, timer)				\
690 [NFSPROC_##proc] = {							\
691 	.p_proc	    =  NFSPROC_##proc,					\
692 	.p_encode   =  (kxdrproc_t) nfs_xdr_##argtype,			\
693 	.p_decode   =  (kxdrproc_t) nfs_xdr_##restype,			\
694 	.p_arglen   =  NFS_##argtype##_sz,				\
695 	.p_replen   =  NFS_##restype##_sz,				\
696 	.p_timer    =  timer,						\
697 	.p_statidx  =  NFSPROC_##proc,					\
698 	.p_name     =  #proc,						\
699 	}
700 struct rpc_procinfo	nfs_procedures[] = {
701     PROC(GETATTR,	fhandle,	attrstat, 1),
702     PROC(SETATTR,	sattrargs,	attrstat, 0),
703     PROC(LOOKUP,	diropargs,	diropres, 2),
704     PROC(READLINK,	readlinkargs,	readlinkres, 3),
705     PROC(READ,		readargs,	readres, 3),
706     PROC(WRITE,		writeargs,	writeres, 4),
707     PROC(CREATE,	createargs,	diropres, 0),
708     PROC(REMOVE,	diropargs,	stat, 0),
709     PROC(RENAME,	renameargs,	stat, 0),
710     PROC(LINK,		linkargs,	stat, 0),
711     PROC(SYMLINK,	symlinkargs,	stat, 0),
712     PROC(MKDIR,		createargs,	diropres, 0),
713     PROC(RMDIR,		diropargs,	stat, 0),
714     PROC(READDIR,	readdirargs,	readdirres, 3),
715     PROC(STATFS,	fhandle,	statfsres, 0),
716 };
717 
718 struct rpc_version		nfs_version2 = {
719 	.number			= 2,
720 	.nrprocs		= ARRAY_SIZE(nfs_procedures),
721 	.procs			= nfs_procedures
722 };
723