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