?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm: remove XFREE86_VERSION macros.
[linux-2.6/mini2440.git] / fs / nfs / nfs3xdr.c
blobd9e08f0cf2a057aa2f903781c33adc86839aaf7f
1 /*
2 * linux/fs/nfs/nfs3xdr.c
3 *
4 * XDR functions to encode/decode NFSv3 RPC arguments and results.
5 *
6 * Copyright (C) 1996, 1997 Olaf Kirch
7 */
8
9 #include <linux/param.h>
10 #include <linux/time.h>
11 #include <linux/mm.h>
12 #include <linux/slab.h>
13 #include <linux/utsname.h>
14 #include <linux/errno.h>
15 #include <linux/string.h>
16 #include <linux/in.h>
17 #include <linux/pagemap.h>
18 #include <linux/proc_fs.h>
19 #include <linux/kdev_t.h>
20 #include <linux/sunrpc/clnt.h>
21 #include <linux/nfs.h>
22 #include <linux/nfs3.h>
23 #include <linux/nfs_fs.h>
24 #include <linux/nfsacl.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 NFS3_fhandle_sz (1+16)
37 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
38 #define NFS3_sattr_sz (15)
39 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
40 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
41 #define NFS3_fattr_sz (21)
42 #define NFS3_wcc_attr_sz (6)
43 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
44 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
45 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
46 #define NFS3_fsstat_sz
47 #define NFS3_fsinfo_sz
48 #define NFS3_pathconf_sz
49 #define NFS3_entry_sz (NFS3_filename_sz+3)
50
51 #define NFS3_sattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
52 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
53 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
54 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
55 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
56 #define NFS3_readargs_sz (NFS3_fh_sz+3)
57 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
58 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
59 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
60 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
61 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
62 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
63 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
64 #define NFS3_readdirargs_sz (NFS3_fh_sz+2)
65 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
66
67 #define NFS3_attrstat_sz (1+NFS3_fattr_sz)
68 #define NFS3_wccstat_sz (1+NFS3_wcc_data_sz)
69 #define NFS3_removeres_sz (NFS3_wccstat_sz)
70 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
71 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
72 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1)
73 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3)
74 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
75 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
76 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
77 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
78 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2)
79 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
80 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
81 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
82 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
83
84 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
85 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+2*(2+5*3))
86 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+2*(2+5*3))
87 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
88
89 /*
90 * Map file type to S_IFMT bits
91 */
92 static struct {
93 unsigned int mode;
94 unsigned int nfs2type;
95 } nfs_type2fmt[] = {
96 { 0, NFNON },
97 { S_IFREG, NFREG },
98 { S_IFDIR, NFDIR },
99 { S_IFBLK, NFBLK },
100 { S_IFCHR, NFCHR },
101 { S_IFLNK, NFLNK },
102 { S_IFSOCK, NFSOCK },
103 { S_IFIFO, NFFIFO },
104 { 0, NFBAD }
105 };
106
107 /*
108 * Common NFS XDR functions as inlines
109 */
110 static inline __be32 *
111 xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fh)
112 {
113 return xdr_encode_array(p, fh->data, fh->size);
114 }
115
116 static inline __be32 *
117 xdr_decode_fhandle(__be32 *p, struct nfs_fh *fh)
118 {
119 if ((fh->size = ntohl(*p++)) <= NFS3_FHSIZE) {
120 memcpy(fh->data, p, fh->size);
121 return p + XDR_QUADLEN(fh->size);
122 }
123 return NULL;
124 }
125
126 /*
127 * Encode/decode time.
128 */
129 static inline __be32 *
130 xdr_encode_time3(__be32 *p, struct timespec *timep)
131 {
132 *p++ = htonl(timep->tv_sec);
133 *p++ = htonl(timep->tv_nsec);
134 return p;
135 }
136
137 static inline __be32 *
138 xdr_decode_time3(__be32 *p, struct timespec *timep)
139 {
140 timep->tv_sec = ntohl(*p++);
141 timep->tv_nsec = ntohl(*p++);
142 return p;
143 }
144
145 static __be32 *
146 xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr)
147 {
148 unsigned int type, major, minor;
149 int fmode;
150
151 type = ntohl(*p++);
152 if (type >= NF3BAD)
153 type = NF3BAD;
154 fmode = nfs_type2fmt[type].mode;
155 fattr->type = nfs_type2fmt[type].nfs2type;
156 fattr->mode = (ntohl(*p++) & ~S_IFMT) | fmode;
157 fattr->nlink = ntohl(*p++);
158 fattr->uid = ntohl(*p++);
159 fattr->gid = ntohl(*p++);
160 p = xdr_decode_hyper(p, &fattr->size);
161 p = xdr_decode_hyper(p, &fattr->du.nfs3.used);
162
163 /* Turn remote device info into Linux-specific dev_t */
164 major = ntohl(*p++);
165 minor = ntohl(*p++);
166 fattr->rdev = MKDEV(major, minor);
167 if (MAJOR(fattr->rdev) != major || MINOR(fattr->rdev) != minor)
168 fattr->rdev = 0;
169
170 p = xdr_decode_hyper(p, &fattr->fsid.major);
171 fattr->fsid.minor = 0;
172 p = xdr_decode_hyper(p, &fattr->fileid);
173 p = xdr_decode_time3(p, &fattr->atime);
174 p = xdr_decode_time3(p, &fattr->mtime);
175 p = xdr_decode_time3(p, &fattr->ctime);
176
177 /* Update the mode bits */
178 fattr->valid |= (NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3);
179 return p;
180 }
181
182 static inline __be32 *
183 xdr_encode_sattr(__be32 *p, struct iattr *attr)
184 {
185 if (attr->ia_valid & ATTR_MODE) {
186 *p++ = xdr_one;
187 *p++ = htonl(attr->ia_mode & S_IALLUGO);
188 } else {
189 *p++ = xdr_zero;
190 }
191 if (attr->ia_valid & ATTR_UID) {
192 *p++ = xdr_one;
193 *p++ = htonl(attr->ia_uid);
194 } else {
195 *p++ = xdr_zero;
196 }
197 if (attr->ia_valid & ATTR_GID) {
198 *p++ = xdr_one;
199 *p++ = htonl(attr->ia_gid);
200 } else {
201 *p++ = xdr_zero;
202 }
203 if (attr->ia_valid & ATTR_SIZE) {
204 *p++ = xdr_one;
205 p = xdr_encode_hyper(p, (__u64) attr->ia_size);
206 } else {
207 *p++ = xdr_zero;
208 }
209 if (attr->ia_valid & ATTR_ATIME_SET) {
210 *p++ = xdr_two;
211 p = xdr_encode_time3(p, &attr->ia_atime);
212 } else if (attr->ia_valid & ATTR_ATIME) {
213 *p++ = xdr_one;
214 } else {
215 *p++ = xdr_zero;
216 }
217 if (attr->ia_valid & ATTR_MTIME_SET) {
218 *p++ = xdr_two;
219 p = xdr_encode_time3(p, &attr->ia_mtime);
220 } else if (attr->ia_valid & ATTR_MTIME) {
221 *p++ = xdr_one;
222 } else {
223 *p++ = xdr_zero;
224 }
225 return p;
226 }
227
228 static inline __be32 *
229 xdr_decode_wcc_attr(__be32 *p, struct nfs_fattr *fattr)
230 {
231 p = xdr_decode_hyper(p, &fattr->pre_size);
232 p = xdr_decode_time3(p, &fattr->pre_mtime);
233 p = xdr_decode_time3(p, &fattr->pre_ctime);
234 fattr->valid |= NFS_ATTR_WCC;
235 return p;
236 }
237
238 static inline __be32 *
239 xdr_decode_post_op_attr(__be32 *p, struct nfs_fattr *fattr)
240 {
241 if (*p++)
242 p = xdr_decode_fattr(p, fattr);
243 return p;
244 }
245
246 static inline __be32 *
247 xdr_decode_pre_op_attr(__be32 *p, struct nfs_fattr *fattr)
248 {
249 if (*p++)
250 return xdr_decode_wcc_attr(p, fattr);
251 return p;
252 }
253
254
255 static inline __be32 *
256 xdr_decode_wcc_data(__be32 *p, struct nfs_fattr *fattr)
257 {
258 p = xdr_decode_pre_op_attr(p, fattr);
259 return xdr_decode_post_op_attr(p, fattr);
260 }
261
262 /*
263 * NFS encode functions
264 */
265
266 /*
267 * Encode file handle argument
268 */
269 static int
270 nfs3_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh)
271 {
272 p = xdr_encode_fhandle(p, fh);
273 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
274 return 0;
275 }
276
277 /*
278 * Encode SETATTR arguments
279 */
280 static int
281 nfs3_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs3_sattrargs *args)
282 {
283 p = xdr_encode_fhandle(p, args->fh);
284 p = xdr_encode_sattr(p, args->sattr);
285 *p++ = htonl(args->guard);
286 if (args->guard)
287 p = xdr_encode_time3(p, &args->guardtime);
288 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
289 return 0;
290 }
291
292 /*
293 * Encode directory ops argument
294 */
295 static int
296 nfs3_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs3_diropargs *args)
297 {
298 p = xdr_encode_fhandle(p, args->fh);
299 p = xdr_encode_array(p, args->name, args->len);
300 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
301 return 0;
302 }
303
304 /*
305 * Encode REMOVE argument
306 */
307 static int
308 nfs3_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
309 {
310 p = xdr_encode_fhandle(p, args->fh);
311 p = xdr_encode_array(p, args->name.name, args->name.len);
312 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
313 return 0;
314 }
315
316 /*
317 * Encode access() argument
318 */
319 static int
320 nfs3_xdr_accessargs(struct rpc_rqst *req, __be32 *p, struct nfs3_accessargs *args)
321 {
322 p = xdr_encode_fhandle(p, args->fh);
323 *p++ = htonl(args->access);
324 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
325 return 0;
326 }
327
328 /*
329 * Arguments to a READ call. Since we read data directly into the page
330 * cache, we also set up the reply iovec here so that iov[1] points
331 * exactly to the page we want to fetch.
332 */
333 static int
334 nfs3_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
335 {
336 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
337 unsigned int replen;
338 u32 count = args->count;
339
340 p = xdr_encode_fhandle(p, args->fh);
341 p = xdr_encode_hyper(p, args->offset);
342 *p++ = htonl(count);
343 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
344
345 /* Inline the page array */
346 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readres_sz) << 2;
347 xdr_inline_pages(&req->rq_rcv_buf, replen,
348 args->pages, args->pgbase, count);
349 return 0;
350 }
351
352 /*
353 * Write arguments. Splice the buffer to be written into the iovec.
354 */
355 static int
356 nfs3_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
357 {
358 struct xdr_buf *sndbuf = &req->rq_snd_buf;
359 u32 count = args->count;
360
361 p = xdr_encode_fhandle(p, args->fh);
362 p = xdr_encode_hyper(p, args->offset);
363 *p++ = htonl(count);
364 *p++ = htonl(args->stable);
365 *p++ = htonl(count);
366 sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
367
368 /* Copy the page array */
369 xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
370 return 0;
371 }
372
373 /*
374 * Encode CREATE arguments
375 */
376 static int
377 nfs3_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs3_createargs *args)
378 {
379 p = xdr_encode_fhandle(p, args->fh);
380 p = xdr_encode_array(p, args->name, args->len);
381
382 *p++ = htonl(args->createmode);
383 if (args->createmode == NFS3_CREATE_EXCLUSIVE) {
384 *p++ = args->verifier[0];
385 *p++ = args->verifier[1];
386 } else
387 p = xdr_encode_sattr(p, args->sattr);
388
389 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
390 return 0;
391 }
392
393 /*
394 * Encode MKDIR arguments
395 */
396 static int
397 nfs3_xdr_mkdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mkdirargs *args)
398 {
399 p = xdr_encode_fhandle(p, args->fh);
400 p = xdr_encode_array(p, args->name, args->len);
401 p = xdr_encode_sattr(p, args->sattr);
402 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
403 return 0;
404 }
405
406 /*
407 * Encode SYMLINK arguments
408 */
409 static int
410 nfs3_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_symlinkargs *args)
411 {
412 p = xdr_encode_fhandle(p, args->fromfh);
413 p = xdr_encode_array(p, args->fromname, args->fromlen);
414 p = xdr_encode_sattr(p, args->sattr);
415 *p++ = htonl(args->pathlen);
416 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
417
418 /* Copy the page */
419 xdr_encode_pages(&req->rq_snd_buf, args->pages, 0, args->pathlen);
420 return 0;
421 }
422
423 /*
424 * Encode MKNOD arguments
425 */
426 static int
427 nfs3_xdr_mknodargs(struct rpc_rqst *req, __be32 *p, struct nfs3_mknodargs *args)
428 {
429 p = xdr_encode_fhandle(p, args->fh);
430 p = xdr_encode_array(p, args->name, args->len);
431 *p++ = htonl(args->type);
432 p = xdr_encode_sattr(p, args->sattr);
433 if (args->type == NF3CHR || args->type == NF3BLK) {
434 *p++ = htonl(MAJOR(args->rdev));
435 *p++ = htonl(MINOR(args->rdev));
436 }
437
438 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
439 return 0;
440 }
441
442 /*
443 * Encode RENAME arguments
444 */
445 static int
446 nfs3_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs3_renameargs *args)
447 {
448 p = xdr_encode_fhandle(p, args->fromfh);
449 p = xdr_encode_array(p, args->fromname, args->fromlen);
450 p = xdr_encode_fhandle(p, args->tofh);
451 p = xdr_encode_array(p, args->toname, args->tolen);
452 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
453 return 0;
454 }
455
456 /*
457 * Encode LINK arguments
458 */
459 static int
460 nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args)
461 {
462 p = xdr_encode_fhandle(p, args->fromfh);
463 p = xdr_encode_fhandle(p, args->tofh);
464 p = xdr_encode_array(p, args->toname, args->tolen);
465 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
466 return 0;
467 }
468
469 /*
470 * Encode arguments to readdir call
471 */
472 static int
473 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args)
474 {
475 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
476 unsigned int replen;
477 u32 count = args->count;
478
479 p = xdr_encode_fhandle(p, args->fh);
480 p = xdr_encode_hyper(p, args->cookie);
481 *p++ = args->verf[0];
482 *p++ = args->verf[1];
483 if (args->plus) {
484 /* readdirplus: need dircount + buffer size.
485 * We just make sure we make dircount big enough */
486 *p++ = htonl(count >> 3);
487 }
488 *p++ = htonl(count);
489 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
490
491 /* Inline the page array */
492 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readdirres_sz) << 2;
493 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
494 return 0;
495 }
496
497 /*
498 * Decode the result of a readdir call.
499 * We just check for syntactical correctness.
500 */
501 static int
502 nfs3_xdr_readdirres(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirres *res)
503 {
504 struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
505 struct kvec *iov = rcvbuf->head;
506 struct page **page;
507 int hdrlen, recvd;
508 int status, nr;
509 unsigned int len, pglen;
510 __be32 *entry, *end, *kaddr;
511
512 status = ntohl(*p++);
513 /* Decode post_op_attrs */
514 p = xdr_decode_post_op_attr(p, res->dir_attr);
515 if (status)
516 return -nfs_stat_to_errno(status);
517 /* Decode verifier cookie */
518 if (res->verf) {
519 res->verf[0] = *p++;
520 res->verf[1] = *p++;
521 } else {
522 p += 2;
523 }
524
525 hdrlen = (u8 *) p - (u8 *) iov->iov_base;
526 if (iov->iov_len < hdrlen) {
527 printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
528 "length %d > %Zu\n", hdrlen, iov->iov_len);
529 return -errno_NFSERR_IO;
530 } else if (iov->iov_len != hdrlen) {
531 dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
532 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
533 }
534
535 pglen = rcvbuf->page_len;
536 recvd = rcvbuf->len - hdrlen;
537 if (pglen > recvd)
538 pglen = recvd;
539 page = rcvbuf->pages;
540 kaddr = p = kmap_atomic(*page, KM_USER0);
541 end = (__be32 *)((char *)p + pglen);
542 entry = p;
543 for (nr = 0; *p++; nr++) {
544 if (p + 3 > end)
545 goto short_pkt;
546 p += 2; /* inode # */
547 len = ntohl(*p++); /* string length */
548 p += XDR_QUADLEN(len) + 2; /* name + cookie */
549 if (len > NFS3_MAXNAMLEN) {
550 printk(KERN_WARNING "NFS: giant filename in readdir (len %x)!\n",
551 len);
552 goto err_unmap;
553 }
554
555 if (res->plus) {
556 /* post_op_attr */
557 if (p + 2 > end)
558 goto short_pkt;
559 if (*p++) {
560 p += 21;
561 if (p + 1 > end)
562 goto short_pkt;
563 }
564 /* post_op_fh3 */
565 if (*p++) {
566 if (p + 1 > end)
567 goto short_pkt;
568 len = ntohl(*p++);
569 if (len > NFS3_FHSIZE) {
570 printk(KERN_WARNING "NFS: giant filehandle in "
571 "readdir (len %x)!\n", len);
572 goto err_unmap;
573 }
574 p += XDR_QUADLEN(len);
575 }
576 }
577
578 if (p + 2 > end)
579 goto short_pkt;
580 entry = p;
581 }
582 if (!nr && (entry[0] != 0 || entry[1] == 0))
583 goto short_pkt;
584 out:
585 kunmap_atomic(kaddr, KM_USER0);
586 return nr;
587 short_pkt:
588 entry[0] = entry[1] = 0;
589 /* truncate listing ? */
590 if (!nr) {
591 printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
592 entry[1] = 1;
593 }
594 goto out;
595 err_unmap:
596 nr = -errno_NFSERR_IO;
597 goto out;
598 }
599
600 __be32 *
601 nfs3_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
602 {
603 struct nfs_entry old = *entry;
604
605 if (!*p++) {
606 if (!*p)
607 return ERR_PTR(-EAGAIN);
608 entry->eof = 1;
609 return ERR_PTR(-EBADCOOKIE);
610 }
611
612 p = xdr_decode_hyper(p, &entry->ino);
613 entry->len = ntohl(*p++);
614 entry->name = (const char *) p;
615 p += XDR_QUADLEN(entry->len);
616 entry->prev_cookie = entry->cookie;
617 p = xdr_decode_hyper(p, &entry->cookie);
618
619 if (plus) {
620 entry->fattr->valid = 0;
621 p = xdr_decode_post_op_attr(p, entry->fattr);
622 /* In fact, a post_op_fh3: */
623 if (*p++) {
624 p = xdr_decode_fhandle(p, entry->fh);
625 /* Ugh -- server reply was truncated */
626 if (p == NULL) {
627 dprintk("NFS: FH truncated\n");
628 *entry = old;
629 return ERR_PTR(-EAGAIN);
630 }
631 } else
632 memset((u8*)(entry->fh), 0, sizeof(*entry->fh));
633 }
634
635 entry->eof = !p[0] && p[1];
636 return p;
637 }
638
639 /*
640 * Encode COMMIT arguments
641 */
642 static int
643 nfs3_xdr_commitargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
644 {
645 p = xdr_encode_fhandle(p, args->fh);
646 p = xdr_encode_hyper(p, args->offset);
647 *p++ = htonl(args->count);
648 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
649 return 0;
650 }
651
652 #ifdef CONFIG_NFS_V3_ACL
653 /*
654 * Encode GETACL arguments
655 */
656 static int
657 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p,
658 struct nfs3_getaclargs *args)
659 {
660 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
661 unsigned int replen;
662
663 p = xdr_encode_fhandle(p, args->fh);
664 *p++ = htonl(args->mask);
665 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
666
667 if (args->mask & (NFS_ACL | NFS_DFACL)) {
668 /* Inline the page array */
669 replen = (RPC_REPHDRSIZE + auth->au_rslack +
670 ACL3_getaclres_sz) << 2;
671 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0,
672 NFSACL_MAXPAGES << PAGE_SHIFT);
673 }
674 return 0;
675 }
676
677 /*
678 * Encode SETACL arguments
679 */
680 static int
681 nfs3_xdr_setaclargs(struct rpc_rqst *req, __be32 *p,
682 struct nfs3_setaclargs *args)
683 {
684 struct xdr_buf *buf = &req->rq_snd_buf;
685 unsigned int base, len_in_head, len = nfsacl_size(
686 (args->mask & NFS_ACL) ? args->acl_access : NULL,
687 (args->mask & NFS_DFACL) ? args->acl_default : NULL);
688 int count, err;
689
690 p = xdr_encode_fhandle(p, NFS_FH(args->inode));
691 *p++ = htonl(args->mask);
692 base = (char *)p - (char *)buf->head->iov_base;
693 /* put as much of the acls into head as possible. */
694 len_in_head = min_t(unsigned int, buf->head->iov_len - base, len);
695 len -= len_in_head;
696 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p + (len_in_head >> 2));
697
698 for (count = 0; (count << PAGE_SHIFT) < len; count++) {
699 args->pages[count] = alloc_page(GFP_KERNEL);
700 if (!args->pages[count]) {
701 while (count)
702 __free_page(args->pages[--count]);
703 return -ENOMEM;
704 }
705 }
706 xdr_encode_pages(buf, args->pages, 0, len);
707
708 err = nfsacl_encode(buf, base, args->inode,
709 (args->mask & NFS_ACL) ?
710 args->acl_access : NULL, 1, 0);
711 if (err > 0)
712 err = nfsacl_encode(buf, base + err, args->inode,
713 (args->mask & NFS_DFACL) ?
714 args->acl_default : NULL, 1,
715 NFS_ACL_DEFAULT);
716 return (err > 0) ? 0 : err;
717 }
718 #endif /* CONFIG_NFS_V3_ACL */
719
720 /*
721 * NFS XDR decode functions
722 */
723
724 /*
725 * Decode attrstat reply.
726 */
727 static int
728 nfs3_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
729 {
730 int status;
731
732 if ((status = ntohl(*p++)))
733 return -nfs_stat_to_errno(status);
734 xdr_decode_fattr(p, fattr);
735 return 0;
736 }
737
738 /*
739 * Decode status+wcc_data reply
740 * SATTR, REMOVE, RMDIR
741 */
742 static int
743 nfs3_xdr_wccstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
744 {
745 int status;
746
747 if ((status = ntohl(*p++)))
748 status = -nfs_stat_to_errno(status);
749 xdr_decode_wcc_data(p, fattr);
750 return status;
751 }
752
753 static int
754 nfs3_xdr_removeres(struct rpc_rqst *req, __be32 *p, struct nfs_removeres *res)
755 {
756 return nfs3_xdr_wccstat(req, p, &res->dir_attr);
757 }
758
759 /*
760 * Decode LOOKUP reply
761 */
762 static int
763 nfs3_xdr_lookupres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
764 {
765 int status;
766
767 if ((status = ntohl(*p++))) {
768 status = -nfs_stat_to_errno(status);
769 } else {
770 if (!(p = xdr_decode_fhandle(p, res->fh)))
771 return -errno_NFSERR_IO;
772 p = xdr_decode_post_op_attr(p, res->fattr);
773 }
774 xdr_decode_post_op_attr(p, res->dir_attr);
775 return status;
776 }
777
778 /*
779 * Decode ACCESS reply
780 */
781 static int
782 nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res)
783 {
784 int status = ntohl(*p++);
785
786 p = xdr_decode_post_op_attr(p, res->fattr);
787 if (status)
788 return -nfs_stat_to_errno(status);
789 res->access = ntohl(*p++);
790 return 0;
791 }
792
793 static int
794 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args)
795 {
796 struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
797 unsigned int replen;
798
799 p = xdr_encode_fhandle(p, args->fh);
800 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
801
802 /* Inline the page array */
803 replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS3_readlinkres_sz) << 2;
804 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
805 return 0;
806 }
807
808 /*
809 * Decode READLINK reply
810 */
811 static int
812 nfs3_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
813 {
814 struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
815 struct kvec *iov = rcvbuf->head;
816 int hdrlen, len, recvd;
817 char *kaddr;
818 int status;
819
820 status = ntohl(*p++);
821 p = xdr_decode_post_op_attr(p, fattr);
822
823 if (status != 0)
824 return -nfs_stat_to_errno(status);
825
826 /* Convert length of symlink */
827 len = ntohl(*p++);
828 if (len >= rcvbuf->page_len || len <= 0) {
829 dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
830 return -ENAMETOOLONG;
831 }
832
833 hdrlen = (u8 *) p - (u8 *) iov->iov_base;
834 if (iov->iov_len < hdrlen) {
835 printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
836 "length %d > %Zu\n", hdrlen, iov->iov_len);
837 return -errno_NFSERR_IO;
838 } else if (iov->iov_len != hdrlen) {
839 dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
840 xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
841 }
842 recvd = req->rq_rcv_buf.len - hdrlen;
843 if (recvd < len) {
844 printk(KERN_WARNING "NFS: server cheating in readlink reply: "
845 "count %u > recvd %u\n", len, recvd);
846 return -EIO;
847 }
848
849 /* NULL terminate the string we got */
850 kaddr = (char*)kmap_atomic(rcvbuf->pages[0], KM_USER0);
851 kaddr[len+rcvbuf->page_base] = '\0';
852 kunmap_atomic(kaddr, KM_USER0);
853 return 0;
854 }
855
856 /*
857 * Decode READ reply
858 */
859 static int
860 nfs3_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res)
861 {
862 struct kvec *iov = req->rq_rcv_buf.head;
863 int status, count, ocount, recvd, hdrlen;
864
865 status = ntohl(*p++);
866 p = xdr_decode_post_op_attr(p, res->fattr);
867
868 if (status != 0)
869 return -nfs_stat_to_errno(status);
870
871 /* Decode reply could and EOF flag. NFSv3 is somewhat redundant
872 * in that it puts the count both in the res struct and in the
873 * opaque data count. */
874 count = ntohl(*p++);
875 res->eof = ntohl(*p++);
876 ocount = ntohl(*p++);
877
878 if (ocount != count) {
879 printk(KERN_WARNING "NFS: READ count doesn't match RPC opaque count.\n");
880 return -errno_NFSERR_IO;
881 }
882
883 hdrlen = (u8 *) p - (u8 *) iov->iov_base;
884 if (iov->iov_len < hdrlen) {
885 printk(KERN_WARNING "NFS: READ reply header overflowed:"
886 "length %d > %Zu\n", hdrlen, iov->iov_len);
887 return -errno_NFSERR_IO;
888 } else if (iov->iov_len != hdrlen) {
889 dprintk("NFS: READ header is short. iovec will be shifted.\n");
890 xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
891 }
892
893 recvd = req->rq_rcv_buf.len - hdrlen;
894 if (count > recvd) {
895 printk(KERN_WARNING "NFS: server cheating in read reply: "
896 "count %d > recvd %d\n", count, recvd);
897 count = recvd;
898 res->eof = 0;
899 }
900
901 if (count < res->count)
902 res->count = count;
903
904 return count;
905 }
906
907 /*
908 * Decode WRITE response
909 */
910 static int
911 nfs3_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
912 {
913 int status;
914
915 status = ntohl(*p++);
916 p = xdr_decode_wcc_data(p, res->fattr);
917
918 if (status != 0)
919 return -nfs_stat_to_errno(status);
920
921 res->count = ntohl(*p++);
922 res->verf->committed = (enum nfs3_stable_how)ntohl(*p++);
923 res->verf->verifier[0] = *p++;
924 res->verf->verifier[1] = *p++;
925
926 return res->count;
927 }
928
929 /*
930 * Decode a CREATE response
931 */
932 static int
933 nfs3_xdr_createres(struct rpc_rqst *req, __be32 *p, struct nfs3_diropres *res)
934 {
935 int status;
936
937 status = ntohl(*p++);
938 if (status == 0) {
939 if (*p++) {
940 if (!(p = xdr_decode_fhandle(p, res->fh)))
941 return -errno_NFSERR_IO;
942 p = xdr_decode_post_op_attr(p, res->fattr);
943 } else {
944 memset(res->fh, 0, sizeof(*res->fh));
945 /* Do decode post_op_attr but set it to NULL */
946 p = xdr_decode_post_op_attr(p, res->fattr);
947 res->fattr->valid = 0;
948 }
949 } else {
950 status = -nfs_stat_to_errno(status);
951 }
952 p = xdr_decode_wcc_data(p, res->dir_attr);
953 return status;
954 }
955
956 /*
957 * Decode RENAME reply
958 */
959 static int
960 nfs3_xdr_renameres(struct rpc_rqst *req, __be32 *p, struct nfs3_renameres *res)
961 {
962 int status;
963
964 if ((status = ntohl(*p++)) != 0)
965 status = -nfs_stat_to_errno(status);
966 p = xdr_decode_wcc_data(p, res->fromattr);
967 p = xdr_decode_wcc_data(p, res->toattr);
968 return status;
969 }
970
971 /*
972 * Decode LINK reply
973 */
974 static int
975 nfs3_xdr_linkres(struct rpc_rqst *req, __be32 *p, struct nfs3_linkres *res)
976 {
977 int status;
978
979 if ((status = ntohl(*p++)) != 0)
980 status = -nfs_stat_to_errno(status);
981 p = xdr_decode_post_op_attr(p, res->fattr);
982 p = xdr_decode_wcc_data(p, res->dir_attr);
983 return status;
984 }
985
986 /*
987 * Decode FSSTAT reply
988 */
989 static int
990 nfs3_xdr_fsstatres(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *res)
991 {
992 int status;
993
994 status = ntohl(*p++);
995
996 p = xdr_decode_post_op_attr(p, res->fattr);
997 if (status != 0)
998 return -nfs_stat_to_errno(status);
999
1000 p = xdr_decode_hyper(p, &res->tbytes);
1001 p = xdr_decode_hyper(p, &res->fbytes);
1002 p = xdr_decode_hyper(p, &res->abytes);
1003 p = xdr_decode_hyper(p, &res->tfiles);
1004 p = xdr_decode_hyper(p, &res->ffiles);
1005 p = xdr_decode_hyper(p, &res->afiles);
1006
1007 /* ignore invarsec */
1008 return 0;
1009 }
1010
1011 /*
1012 * Decode FSINFO reply
1013 */
1014 static int
1015 nfs3_xdr_fsinfores(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *res)
1016 {
1017 int status;
1018
1019 status = ntohl(*p++);
1020
1021 p = xdr_decode_post_op_attr(p, res->fattr);
1022 if (status != 0)
1023 return -nfs_stat_to_errno(status);
1024
1025 res->rtmax = ntohl(*p++);
1026 res->rtpref = ntohl(*p++);
1027 res->rtmult = ntohl(*p++);
1028 res->wtmax = ntohl(*p++);
1029 res->wtpref = ntohl(*p++);
1030 res->wtmult = ntohl(*p++);
1031 res->dtpref = ntohl(*p++);
1032 p = xdr_decode_hyper(p, &res->maxfilesize);
1033
1034 /* ignore time_delta and properties */
1035 res->lease_time = 0;
1036 return 0;
1037 }
1038
1039 /*
1040 * Decode PATHCONF reply
1041 */
1042 static int
1043 nfs3_xdr_pathconfres(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *res)
1044 {
1045 int status;
1046
1047 status = ntohl(*p++);
1048
1049 p = xdr_decode_post_op_attr(p, res->fattr);
1050 if (status != 0)
1051 return -nfs_stat_to_errno(status);
1052 res->max_link = ntohl(*p++);
1053 res->max_namelen = ntohl(*p++);
1054
1055 /* ignore remaining fields */
1056 return 0;
1057 }
1058
1059 /*
1060 * Decode COMMIT reply
1061 */
1062 static int
1063 nfs3_xdr_commitres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res)
1064 {
1065 int status;
1066
1067 status = ntohl(*p++);
1068 p = xdr_decode_wcc_data(p, res->fattr);
1069 if (status != 0)
1070 return -nfs_stat_to_errno(status);
1071
1072 res->verf->verifier[0] = *p++;
1073 res->verf->verifier[1] = *p++;
1074 return 0;
1075 }
1076
1077 #ifdef CONFIG_NFS_V3_ACL
1078 /*
1079 * Decode GETACL reply
1080 */
1081 static int
1082 nfs3_xdr_getaclres(struct rpc_rqst *req, __be32 *p,
1083 struct nfs3_getaclres *res)
1084 {
1085 struct xdr_buf *buf = &req->rq_rcv_buf;
1086 int status = ntohl(*p++);
1087 struct posix_acl **acl;
1088 unsigned int *aclcnt;
1089 int err, base;
1090
1091 if (status != 0)
1092 return -nfs_stat_to_errno(status);
1093 p = xdr_decode_post_op_attr(p, res->fattr);
1094 res->mask = ntohl(*p++);
1095 if (res->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
1096 return -EINVAL;
1097 base = (char *)p - (char *)req->rq_rcv_buf.head->iov_base;
1098
1099 acl = (res->mask & NFS_ACL) ? &res->acl_access : NULL;
1100 aclcnt = (res->mask & NFS_ACLCNT) ? &res->acl_access_count : NULL;
1101 err = nfsacl_decode(buf, base, aclcnt, acl);
1102
1103 acl = (res->mask & NFS_DFACL) ? &res->acl_default : NULL;
1104 aclcnt = (res->mask & NFS_DFACLCNT) ? &res->acl_default_count : NULL;
1105 if (err > 0)
1106 err = nfsacl_decode(buf, base + err, aclcnt, acl);
1107 return (err > 0) ? 0 : err;
1108 }
1109
1110 /*
1111 * Decode setacl reply.
1112 */
1113 static int
1114 nfs3_xdr_setaclres(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr)
1115 {
1116 int status = ntohl(*p++);
1117
1118 if (status)
1119 return -nfs_stat_to_errno(status);
1120 xdr_decode_post_op_attr(p, fattr);
1121 return 0;
1122 }
1123 #endif /* CONFIG_NFS_V3_ACL */
1124
1125 #define PROC(proc, argtype, restype, timer) \
1126 [NFS3PROC_##proc] = { \
1127 .p_proc = NFS3PROC_##proc, \
1128 .p_encode = (kxdrproc_t) nfs3_xdr_##argtype, \
1129 .p_decode = (kxdrproc_t) nfs3_xdr_##restype, \
1130 .p_arglen = NFS3_##argtype##_sz, \
1131 .p_replen = NFS3_##restype##_sz, \
1132 .p_timer = timer, \
1133 .p_statidx = NFS3PROC_##proc, \
1134 .p_name = #proc, \
1135 }
1136
1137 struct rpc_procinfo nfs3_procedures[] = {
1138 PROC(GETATTR, fhandle, attrstat, 1),
1139 PROC(SETATTR, sattrargs, wccstat, 0),
1140 PROC(LOOKUP, diropargs, lookupres, 2),
1141 PROC(ACCESS, accessargs, accessres, 1),
1142 PROC(READLINK, readlinkargs, readlinkres, 3),
1143 PROC(READ, readargs, readres, 3),
1144 PROC(WRITE, writeargs, writeres, 4),
1145 PROC(CREATE, createargs, createres, 0),
1146 PROC(MKDIR, mkdirargs, createres, 0),
1147 PROC(SYMLINK, symlinkargs, createres, 0),
1148 PROC(MKNOD, mknodargs, createres, 0),
1149 PROC(REMOVE, removeargs, removeres, 0),
1150 PROC(RMDIR, diropargs, wccstat, 0),
1151 PROC(RENAME, renameargs, renameres, 0),
1152 PROC(LINK, linkargs, linkres, 0),
1153 PROC(READDIR, readdirargs, readdirres, 3),
1154 PROC(READDIRPLUS, readdirargs, readdirres, 3),
1155 PROC(FSSTAT, fhandle, fsstatres, 0),
1156 PROC(FSINFO, fhandle, fsinfores, 0),
1157 PROC(PATHCONF, fhandle, pathconfres, 0),
1158 PROC(COMMIT, commitargs, commitres, 5),
1159 };
1160
1161 struct rpc_version nfs_version3 = {
1162 .number = 3,
1163 .nrprocs = ARRAY_SIZE(nfs3_procedures),
1164 .procs = nfs3_procedures
1165 };
1166
1167 #ifdef CONFIG_NFS_V3_ACL
1168 static struct rpc_procinfo nfs3_acl_procedures[] = {
1169 [ACLPROC3_GETACL] = {
1170 .p_proc = ACLPROC3_GETACL,
1171 .p_encode = (kxdrproc_t) nfs3_xdr_getaclargs,
1172 .p_decode = (kxdrproc_t) nfs3_xdr_getaclres,
1173 .p_arglen = ACL3_getaclargs_sz,
1174 .p_replen = ACL3_getaclres_sz,
1175 .p_timer = 1,
1176 .p_name = "GETACL",
1177 },
1178 [ACLPROC3_SETACL] = {
1179 .p_proc = ACLPROC3_SETACL,
1180 .p_encode = (kxdrproc_t) nfs3_xdr_setaclargs,
1181 .p_decode = (kxdrproc_t) nfs3_xdr_setaclres,
1182 .p_arglen = ACL3_setaclargs_sz,
1183 .p_replen = ACL3_setaclres_sz,
1184 .p_timer = 0,
1185 .p_name = "SETACL",
1186 },
1187 };
1188
1189 struct rpc_version nfsacl_version3 = {
1190 .number = 3,
1191 .nrprocs = sizeof(nfs3_acl_procedures)/
1192 sizeof(nfs3_acl_procedures[0]),
1193 .procs = nfs3_acl_procedures,
1194 };
1195 #endif /* CONFIG_NFS_V3_ACL */
Support for the Chinese Samsung S3C2440 based development boards