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