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