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