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