Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
1da177e4 LT |
15 | #include <linux/errno.h> |
16 | #include <linux/string.h> | |
17 | #include <linux/in.h> | |
18 | #include <linux/pagemap.h> | |
19 | #include <linux/proc_fs.h> | |
20 | #include <linux/sunrpc/clnt.h> | |
21 | #include <linux/nfs.h> | |
22 | #include <linux/nfs2.h> | |
23 | #include <linux/nfs_fs.h> | |
816724e6 | 24 | #include "internal.h" |
1da177e4 LT |
25 | |
26 | #define NFSDBG_FACILITY NFSDBG_XDR | |
1da177e4 | 27 | |
1da177e4 LT |
28 | /* Mapping from NFS error code to "errno" error code. */ |
29 | #define errno_NFSERR_IO EIO | |
30 | ||
31 | /* | |
32 | * Declare the space requirements for NFS arguments and replies as | |
33 | * number of 32bit-words | |
34 | */ | |
35 | #define NFS_fhandle_sz (8) | |
36 | #define NFS_sattr_sz (8) | |
37 | #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2)) | |
38 | #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2)) | |
39 | #define NFS_fattr_sz (17) | |
40 | #define NFS_info_sz (5) | |
41 | #define NFS_entry_sz (NFS_filename_sz+3) | |
42 | ||
43 | #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz) | |
4fdc17b2 | 44 | #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz) |
1da177e4 LT |
45 | #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz) |
46 | #define NFS_readlinkargs_sz (NFS_fhandle_sz) | |
47 | #define NFS_readargs_sz (NFS_fhandle_sz+3) | |
48 | #define NFS_writeargs_sz (NFS_fhandle_sz+4) | |
49 | #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz) | |
50 | #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz) | |
51 | #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz) | |
94a6d753 | 52 | #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz) |
1da177e4 LT |
53 | #define NFS_readdirargs_sz (NFS_fhandle_sz+2) |
54 | ||
55 | #define NFS_attrstat_sz (1+NFS_fattr_sz) | |
56 | #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz) | |
57 | #define NFS_readlinkres_sz (2) | |
58 | #define NFS_readres_sz (1+NFS_fattr_sz+1) | |
59 | #define NFS_writeres_sz (NFS_attrstat_sz) | |
60 | #define NFS_stat_sz (1) | |
61 | #define NFS_readdirres_sz (1) | |
62 | #define NFS_statfsres_sz (1+NFS_info_sz) | |
63 | ||
25a0866c CL |
64 | |
65 | /* | |
66 | * While encoding arguments, set up the reply buffer in advance to | |
67 | * receive reply data directly into the page cache. | |
68 | */ | |
69 | static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages, | |
70 | unsigned int base, unsigned int len, | |
71 | unsigned int bufsize) | |
72 | { | |
73 | struct rpc_auth *auth = req->rq_cred->cr_auth; | |
74 | unsigned int replen; | |
75 | ||
76 | replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize; | |
77 | xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len); | |
78 | } | |
79 | ||
f796f8b3 CL |
80 | /* |
81 | * Handle decode buffer overflows out-of-line. | |
82 | */ | |
83 | static void print_overflow_msg(const char *func, const struct xdr_stream *xdr) | |
84 | { | |
85 | dprintk("NFS: %s prematurely hit the end of our receive buffer. " | |
86 | "Remaining buffer length is %tu words.\n", | |
87 | func, xdr->end - xdr->p); | |
88 | } | |
89 | ||
25a0866c | 90 | |
25a0866c CL |
91 | /* |
92 | * Encode/decode NFSv2 basic data types | |
93 | * | |
94 | * Basic NFSv2 data types are defined in section 2.3 of RFC 1094: | |
95 | * "NFS: Network File System Protocol Specification". | |
96 | * | |
97 | * Not all basic data types have their own encoding and decoding | |
98 | * functions. For run-time efficiency, some data types are encoded | |
99 | * or decoded inline. | |
100 | */ | |
101 | ||
f796f8b3 CL |
102 | /* |
103 | * typedef opaque nfsdata<>; | |
104 | */ | |
105 | static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_readres *result) | |
106 | { | |
107 | u32 recvd, count; | |
108 | size_t hdrlen; | |
109 | __be32 *p; | |
110 | ||
111 | p = xdr_inline_decode(xdr, 4); | |
112 | if (unlikely(p == NULL)) | |
113 | goto out_overflow; | |
114 | count = be32_to_cpup(p); | |
115 | hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; | |
116 | recvd = xdr->buf->len - hdrlen; | |
117 | if (unlikely(count > recvd)) | |
118 | goto out_cheating; | |
119 | out: | |
120 | xdr_read_pages(xdr, count); | |
121 | result->eof = 0; /* NFSv2 does not pass EOF flag on the wire. */ | |
122 | result->count = count; | |
123 | return count; | |
124 | out_cheating: | |
125 | dprintk("NFS: server cheating in read result: " | |
126 | "count %u > recvd %u\n", count, recvd); | |
127 | count = recvd; | |
128 | goto out; | |
129 | out_overflow: | |
130 | print_overflow_msg(__func__, xdr); | |
131 | return -EIO; | |
132 | } | |
133 | ||
134 | /* | |
135 | * enum stat { | |
136 | * NFS_OK = 0, | |
137 | * NFSERR_PERM = 1, | |
138 | * NFSERR_NOENT = 2, | |
139 | * NFSERR_IO = 5, | |
140 | * NFSERR_NXIO = 6, | |
141 | * NFSERR_ACCES = 13, | |
142 | * NFSERR_EXIST = 17, | |
143 | * NFSERR_NODEV = 19, | |
144 | * NFSERR_NOTDIR = 20, | |
145 | * NFSERR_ISDIR = 21, | |
146 | * NFSERR_FBIG = 27, | |
147 | * NFSERR_NOSPC = 28, | |
148 | * NFSERR_ROFS = 30, | |
149 | * NFSERR_NAMETOOLONG = 63, | |
150 | * NFSERR_NOTEMPTY = 66, | |
151 | * NFSERR_DQUOT = 69, | |
152 | * NFSERR_STALE = 70, | |
153 | * NFSERR_WFLUSH = 99 | |
154 | * }; | |
155 | */ | |
156 | static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status) | |
157 | { | |
158 | __be32 *p; | |
159 | ||
160 | p = xdr_inline_decode(xdr, 4); | |
161 | if (unlikely(p == NULL)) | |
162 | goto out_overflow; | |
163 | *status = be32_to_cpup(p); | |
164 | return 0; | |
165 | out_overflow: | |
166 | print_overflow_msg(__func__, xdr); | |
167 | return -EIO; | |
168 | } | |
169 | ||
5f96e5e3 CL |
170 | /* |
171 | * 2.3.2. ftype | |
172 | * | |
173 | * enum ftype { | |
174 | * NFNON = 0, | |
175 | * NFREG = 1, | |
176 | * NFDIR = 2, | |
177 | * NFBLK = 3, | |
178 | * NFCHR = 4, | |
179 | * NFLNK = 5 | |
180 | * }; | |
181 | * | |
182 | */ | |
183 | static __be32 *xdr_decode_ftype(__be32 *p, u32 *type) | |
184 | { | |
185 | *type = be32_to_cpup(p++); | |
186 | if (unlikely(*type > NF2FIFO)) | |
187 | *type = NFBAD; | |
188 | return p; | |
189 | } | |
190 | ||
25a0866c CL |
191 | /* |
192 | * 2.3.3. fhandle | |
193 | * | |
194 | * typedef opaque fhandle[FHSIZE]; | |
195 | */ | |
196 | static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh) | |
197 | { | |
198 | __be32 *p; | |
199 | ||
200 | BUG_ON(fh->size != NFS2_FHSIZE); | |
201 | p = xdr_reserve_space(xdr, NFS2_FHSIZE); | |
202 | memcpy(p, fh->data, NFS2_FHSIZE); | |
203 | } | |
204 | ||
f796f8b3 CL |
205 | static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh) |
206 | { | |
207 | __be32 *p; | |
208 | ||
209 | p = xdr_inline_decode(xdr, NFS2_FHSIZE); | |
210 | if (unlikely(p == NULL)) | |
211 | goto out_overflow; | |
212 | fh->size = NFS2_FHSIZE; | |
213 | memcpy(fh->data, p, NFS2_FHSIZE); | |
214 | return 0; | |
215 | out_overflow: | |
216 | print_overflow_msg(__func__, xdr); | |
217 | return -EIO; | |
218 | } | |
219 | ||
282ac2a5 CL |
220 | /* |
221 | * 2.3.4. timeval | |
222 | * | |
223 | * struct timeval { | |
224 | * unsigned int seconds; | |
225 | * unsigned int useconds; | |
226 | * }; | |
227 | */ | |
228 | static __be32 *xdr_encode_time(__be32 *p, const struct timespec *timep) | |
229 | { | |
230 | *p++ = cpu_to_be32(timep->tv_sec); | |
231 | if (timep->tv_nsec != 0) | |
232 | *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC); | |
233 | else | |
234 | *p++ = cpu_to_be32(0); | |
235 | return p; | |
236 | } | |
237 | ||
238 | /* | |
239 | * Passing the invalid value useconds=1000000 is a Sun convention for | |
240 | * "set to current server time". It's needed to make permissions checks | |
241 | * for the "touch" program across v2 mounts to Solaris and Irix servers | |
242 | * work correctly. See description of sattr in section 6.1 of "NFS | |
243 | * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5. | |
244 | */ | |
245 | static __be32 *xdr_encode_current_server_time(__be32 *p, | |
246 | const struct timespec *timep) | |
247 | { | |
248 | *p++ = cpu_to_be32(timep->tv_sec); | |
249 | *p++ = cpu_to_be32(1000000); | |
250 | return p; | |
251 | } | |
252 | ||
5f96e5e3 CL |
253 | static __be32 *xdr_decode_time(__be32 *p, struct timespec *timep) |
254 | { | |
255 | timep->tv_sec = be32_to_cpup(p++); | |
256 | timep->tv_nsec = be32_to_cpup(p++) * NSEC_PER_USEC; | |
257 | return p; | |
258 | } | |
259 | ||
f796f8b3 CL |
260 | /* |
261 | * 2.3.5. fattr | |
262 | * | |
263 | * struct fattr { | |
264 | * ftype type; | |
265 | * unsigned int mode; | |
266 | * unsigned int nlink; | |
267 | * unsigned int uid; | |
268 | * unsigned int gid; | |
269 | * unsigned int size; | |
270 | * unsigned int blocksize; | |
271 | * unsigned int rdev; | |
272 | * unsigned int blocks; | |
273 | * unsigned int fsid; | |
274 | * unsigned int fileid; | |
275 | * timeval atime; | |
276 | * timeval mtime; | |
277 | * timeval ctime; | |
278 | * }; | |
279 | * | |
280 | */ | |
281 | static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr) | |
282 | { | |
5f96e5e3 | 283 | u32 rdev, type; |
f796f8b3 CL |
284 | __be32 *p; |
285 | ||
286 | p = xdr_inline_decode(xdr, NFS_fattr_sz << 2); | |
287 | if (unlikely(p == NULL)) | |
288 | goto out_overflow; | |
5f96e5e3 CL |
289 | |
290 | fattr->valid |= NFS_ATTR_FATTR_V2; | |
291 | ||
292 | p = xdr_decode_ftype(p, &type); | |
293 | ||
294 | fattr->mode = be32_to_cpup(p++); | |
295 | fattr->nlink = be32_to_cpup(p++); | |
296 | fattr->uid = be32_to_cpup(p++); | |
297 | fattr->gid = be32_to_cpup(p++); | |
298 | fattr->size = be32_to_cpup(p++); | |
299 | fattr->du.nfs2.blocksize = be32_to_cpup(p++); | |
300 | ||
301 | rdev = be32_to_cpup(p++); | |
302 | fattr->rdev = new_decode_dev(rdev); | |
303 | if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) { | |
304 | fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; | |
305 | fattr->rdev = 0; | |
306 | } | |
307 | ||
308 | fattr->du.nfs2.blocks = be32_to_cpup(p++); | |
309 | fattr->fsid.major = be32_to_cpup(p++); | |
310 | fattr->fsid.minor = 0; | |
311 | fattr->fileid = be32_to_cpup(p++); | |
312 | ||
313 | p = xdr_decode_time(p, &fattr->atime); | |
314 | p = xdr_decode_time(p, &fattr->mtime); | |
315 | xdr_decode_time(p, &fattr->ctime); | |
f796f8b3 CL |
316 | return 0; |
317 | out_overflow: | |
318 | print_overflow_msg(__func__, xdr); | |
319 | return -EIO; | |
320 | } | |
321 | ||
25a0866c CL |
322 | /* |
323 | * 2.3.6. sattr | |
324 | * | |
325 | * struct sattr { | |
326 | * unsigned int mode; | |
327 | * unsigned int uid; | |
328 | * unsigned int gid; | |
329 | * unsigned int size; | |
330 | * timeval atime; | |
331 | * timeval mtime; | |
332 | * }; | |
333 | */ | |
334 | ||
335 | #define NFS2_SATTR_NOT_SET (0xffffffff) | |
336 | ||
337 | static __be32 *xdr_time_not_set(__be32 *p) | |
338 | { | |
339 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
340 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
341 | return p; | |
342 | } | |
343 | ||
344 | static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr) | |
345 | { | |
346 | __be32 *p; | |
347 | ||
348 | p = xdr_reserve_space(xdr, NFS_sattr_sz << 2); | |
349 | ||
350 | if (attr->ia_valid & ATTR_MODE) | |
351 | *p++ = cpu_to_be32(attr->ia_mode); | |
352 | else | |
353 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
354 | if (attr->ia_valid & ATTR_UID) | |
355 | *p++ = cpu_to_be32(attr->ia_uid); | |
356 | else | |
357 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
358 | if (attr->ia_valid & ATTR_GID) | |
359 | *p++ = cpu_to_be32(attr->ia_gid); | |
360 | else | |
361 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
362 | if (attr->ia_valid & ATTR_SIZE) | |
363 | *p++ = cpu_to_be32((u32)attr->ia_size); | |
364 | else | |
365 | *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); | |
366 | ||
367 | if (attr->ia_valid & ATTR_ATIME_SET) | |
368 | p = xdr_encode_time(p, &attr->ia_atime); | |
369 | else if (attr->ia_valid & ATTR_ATIME) | |
370 | p = xdr_encode_current_server_time(p, &attr->ia_atime); | |
371 | else | |
372 | p = xdr_time_not_set(p); | |
373 | if (attr->ia_valid & ATTR_MTIME_SET) | |
374 | xdr_encode_time(p, &attr->ia_mtime); | |
375 | else if (attr->ia_valid & ATTR_MTIME) | |
376 | xdr_encode_current_server_time(p, &attr->ia_mtime); | |
377 | else | |
378 | xdr_time_not_set(p); | |
379 | } | |
380 | ||
381 | /* | |
382 | * 2.3.7. filename | |
383 | * | |
384 | * typedef string filename<MAXNAMLEN>; | |
385 | */ | |
386 | static void encode_filename(struct xdr_stream *xdr, | |
387 | const char *name, u32 length) | |
388 | { | |
389 | __be32 *p; | |
390 | ||
391 | BUG_ON(length > NFS2_MAXNAMLEN); | |
392 | p = xdr_reserve_space(xdr, 4 + length); | |
393 | xdr_encode_opaque(p, name, length); | |
394 | } | |
395 | ||
f796f8b3 CL |
396 | static int decode_filename_inline(struct xdr_stream *xdr, |
397 | const char **name, u32 *length) | |
398 | { | |
399 | __be32 *p; | |
400 | u32 count; | |
401 | ||
402 | p = xdr_inline_decode(xdr, 4); | |
403 | if (unlikely(p == NULL)) | |
404 | goto out_overflow; | |
405 | count = be32_to_cpup(p); | |
406 | if (count > NFS3_MAXNAMLEN) | |
407 | goto out_nametoolong; | |
408 | p = xdr_inline_decode(xdr, count); | |
409 | if (unlikely(p == NULL)) | |
410 | goto out_overflow; | |
411 | *name = (const char *)p; | |
412 | *length = count; | |
413 | return 0; | |
414 | out_nametoolong: | |
415 | dprintk("NFS: returned filename too long: %u\n", count); | |
416 | return -ENAMETOOLONG; | |
417 | out_overflow: | |
418 | print_overflow_msg(__func__, xdr); | |
419 | return -EIO; | |
420 | } | |
421 | ||
25a0866c CL |
422 | /* |
423 | * 2.3.8. path | |
424 | * | |
425 | * typedef string path<MAXPATHLEN>; | |
426 | */ | |
427 | static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length) | |
428 | { | |
429 | __be32 *p; | |
430 | ||
431 | BUG_ON(length > NFS2_MAXPATHLEN); | |
432 | p = xdr_reserve_space(xdr, 4); | |
433 | *p = cpu_to_be32(length); | |
434 | xdr_write_pages(xdr, pages, 0, length); | |
435 | } | |
436 | ||
f796f8b3 CL |
437 | static int decode_path(struct xdr_stream *xdr) |
438 | { | |
439 | u32 length, recvd; | |
440 | size_t hdrlen; | |
441 | __be32 *p; | |
442 | ||
443 | p = xdr_inline_decode(xdr, 4); | |
444 | if (unlikely(p == NULL)) | |
445 | goto out_overflow; | |
446 | length = be32_to_cpup(p); | |
447 | if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN)) | |
448 | goto out_size; | |
449 | hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; | |
450 | recvd = xdr->buf->len - hdrlen; | |
451 | if (unlikely(length > recvd)) | |
452 | goto out_cheating; | |
453 | ||
454 | xdr_read_pages(xdr, length); | |
455 | xdr_terminate_string(xdr->buf, length); | |
456 | return 0; | |
457 | out_size: | |
458 | dprintk("NFS: returned pathname too long: %u\n", length); | |
459 | return -ENAMETOOLONG; | |
460 | out_cheating: | |
461 | dprintk("NFS: server cheating in pathname result: " | |
462 | "length %u > received %u\n", length, recvd); | |
463 | return -EIO; | |
464 | out_overflow: | |
465 | print_overflow_msg(__func__, xdr); | |
466 | return -EIO; | |
467 | } | |
468 | ||
469 | /* | |
470 | * 2.3.9. attrstat | |
471 | * | |
472 | * union attrstat switch (stat status) { | |
473 | * case NFS_OK: | |
474 | * fattr attributes; | |
475 | * default: | |
476 | * void; | |
477 | * }; | |
478 | */ | |
479 | static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result) | |
480 | { | |
481 | enum nfs_stat status; | |
482 | int error; | |
483 | ||
484 | error = decode_stat(xdr, &status); | |
485 | if (unlikely(error)) | |
486 | goto out; | |
487 | if (status != NFS_OK) | |
488 | goto out_default; | |
489 | error = decode_fattr(xdr, result); | |
490 | out: | |
491 | return error; | |
492 | out_default: | |
493 | return nfs_stat_to_errno(status); | |
494 | } | |
495 | ||
25a0866c CL |
496 | /* |
497 | * 2.3.10. diropargs | |
498 | * | |
499 | * struct diropargs { | |
500 | * fhandle dir; | |
501 | * filename name; | |
502 | * }; | |
503 | */ | |
504 | static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh, | |
505 | const char *name, u32 length) | |
506 | { | |
507 | encode_fhandle(xdr, fh); | |
508 | encode_filename(xdr, name, length); | |
509 | } | |
510 | ||
f796f8b3 CL |
511 | /* |
512 | * 2.3.11. diropres | |
513 | * | |
514 | * union diropres switch (stat status) { | |
515 | * case NFS_OK: | |
516 | * struct { | |
517 | * fhandle file; | |
518 | * fattr attributes; | |
519 | * } diropok; | |
520 | * default: | |
521 | * void; | |
522 | * }; | |
523 | */ | |
524 | static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result) | |
525 | { | |
526 | int error; | |
527 | ||
528 | error = decode_fhandle(xdr, result->fh); | |
529 | if (unlikely(error)) | |
530 | goto out; | |
531 | error = decode_fattr(xdr, result->fattr); | |
532 | out: | |
533 | return error; | |
534 | } | |
535 | ||
536 | static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result) | |
537 | { | |
538 | enum nfs_stat status; | |
539 | int error; | |
540 | ||
541 | error = decode_stat(xdr, &status); | |
542 | if (unlikely(error)) | |
543 | goto out; | |
544 | if (status != NFS_OK) | |
545 | goto out_default; | |
546 | error = decode_diropok(xdr, result); | |
547 | out: | |
548 | return error; | |
549 | out_default: | |
550 | return nfs_stat_to_errno(status); | |
551 | } | |
552 | ||
25a0866c | 553 | |
1da177e4 | 554 | /* |
2d70f533 CL |
555 | * NFSv2 XDR encode functions |
556 | * | |
557 | * NFSv2 argument types are defined in section 2.2 of RFC 1094: | |
558 | * "NFS: Network File System Protocol Specification". | |
1da177e4 | 559 | */ |
1da177e4 | 560 | |
25a0866c CL |
561 | static int nfs2_xdr_enc_fhandle(struct rpc_rqst *req, __be32 *p, |
562 | const struct nfs_fh *fh) | |
563 | { | |
564 | struct xdr_stream xdr; | |
565 | ||
566 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
567 | encode_fhandle(&xdr, fh); | |
568 | return 0; | |
569 | } | |
570 | ||
25a0866c CL |
571 | /* |
572 | * 2.2.3. sattrargs | |
573 | * | |
574 | * struct sattrargs { | |
575 | * fhandle file; | |
576 | * sattr attributes; | |
577 | * }; | |
578 | */ | |
579 | static int nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, __be32 *p, | |
580 | const struct nfs_sattrargs *args) | |
581 | { | |
582 | struct xdr_stream xdr; | |
583 | ||
584 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
585 | encode_fhandle(&xdr, args->fh); | |
586 | encode_sattr(&xdr, args->sattr); | |
587 | return 0; | |
588 | } | |
589 | ||
25a0866c CL |
590 | static int nfs2_xdr_enc_diropargs(struct rpc_rqst *req, __be32 *p, |
591 | const struct nfs_diropargs *args) | |
592 | { | |
593 | struct xdr_stream xdr; | |
594 | ||
595 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
596 | encode_diropargs(&xdr, args->fh, args->name, args->len); | |
597 | return 0; | |
598 | } | |
599 | ||
25a0866c CL |
600 | static int nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, __be32 *p, |
601 | const struct nfs_readlinkargs *args) | |
602 | { | |
603 | struct xdr_stream xdr; | |
604 | ||
605 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
606 | encode_fhandle(&xdr, args->fh); | |
607 | prepare_reply_buffer(req, args->pages, args->pgbase, | |
608 | args->pglen, NFS_readlinkres_sz); | |
609 | return 0; | |
610 | } | |
611 | ||
25a0866c CL |
612 | /* |
613 | * 2.2.7. readargs | |
614 | * | |
615 | * struct readargs { | |
616 | * fhandle file; | |
617 | * unsigned offset; | |
618 | * unsigned count; | |
619 | * unsigned totalcount; | |
620 | * }; | |
621 | */ | |
622 | static void encode_readargs(struct xdr_stream *xdr, | |
623 | const struct nfs_readargs *args) | |
624 | { | |
625 | u32 offset = args->offset; | |
626 | u32 count = args->count; | |
627 | __be32 *p; | |
628 | ||
629 | encode_fhandle(xdr, args->fh); | |
630 | ||
631 | p = xdr_reserve_space(xdr, 4 + 4 + 4); | |
632 | *p++ = cpu_to_be32(offset); | |
633 | *p++ = cpu_to_be32(count); | |
634 | *p = cpu_to_be32(count); | |
635 | } | |
636 | ||
637 | static int nfs2_xdr_enc_readargs(struct rpc_rqst *req, __be32 *p, | |
638 | const struct nfs_readargs *args) | |
639 | { | |
640 | struct xdr_stream xdr; | |
641 | ||
642 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
643 | encode_readargs(&xdr, args); | |
644 | prepare_reply_buffer(req, args->pages, args->pgbase, | |
645 | args->count, NFS_readres_sz); | |
646 | req->rq_rcv_buf.flags |= XDRBUF_READ; | |
647 | return 0; | |
648 | } | |
649 | ||
25a0866c CL |
650 | /* |
651 | * 2.2.9. writeargs | |
652 | * | |
653 | * struct writeargs { | |
654 | * fhandle file; | |
655 | * unsigned beginoffset; | |
656 | * unsigned offset; | |
657 | * unsigned totalcount; | |
658 | * nfsdata data; | |
659 | * }; | |
660 | */ | |
661 | static void encode_writeargs(struct xdr_stream *xdr, | |
662 | const struct nfs_writeargs *args) | |
663 | { | |
664 | u32 offset = args->offset; | |
665 | u32 count = args->count; | |
666 | __be32 *p; | |
667 | ||
668 | encode_fhandle(xdr, args->fh); | |
669 | ||
670 | p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4); | |
671 | *p++ = cpu_to_be32(offset); | |
672 | *p++ = cpu_to_be32(offset); | |
673 | *p++ = cpu_to_be32(count); | |
674 | ||
675 | /* nfsdata */ | |
676 | *p = cpu_to_be32(count); | |
677 | xdr_write_pages(xdr, args->pages, args->pgbase, count); | |
678 | } | |
679 | ||
680 | static int nfs2_xdr_enc_writeargs(struct rpc_rqst *req, __be32 *p, | |
681 | const struct nfs_writeargs *args) | |
682 | { | |
683 | struct xdr_stream xdr; | |
684 | ||
685 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
686 | encode_writeargs(&xdr, args); | |
687 | xdr.buf->flags |= XDRBUF_WRITE; | |
688 | return 0; | |
689 | } | |
690 | ||
25a0866c CL |
691 | /* |
692 | * 2.2.10. createargs | |
693 | * | |
694 | * struct createargs { | |
695 | * diropargs where; | |
696 | * sattr attributes; | |
697 | * }; | |
698 | */ | |
699 | static int nfs2_xdr_enc_createargs(struct rpc_rqst *req, __be32 *p, | |
700 | const struct nfs_createargs *args) | |
701 | { | |
702 | struct xdr_stream xdr; | |
703 | ||
704 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
705 | encode_diropargs(&xdr, args->fh, args->name, args->len); | |
706 | encode_sattr(&xdr, args->sattr); | |
707 | return 0; | |
708 | } | |
709 | ||
710 | static int nfs2_xdr_enc_removeargs(struct rpc_rqst *req, __be32 *p, | |
711 | const struct nfs_removeargs *args) | |
712 | { | |
713 | struct xdr_stream xdr; | |
714 | ||
715 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
716 | encode_diropargs(&xdr, args->fh, args->name.name, args->name.len); | |
717 | return 0; | |
718 | } | |
719 | ||
25a0866c CL |
720 | /* |
721 | * 2.2.12. renameargs | |
722 | * | |
723 | * struct renameargs { | |
724 | * diropargs from; | |
725 | * diropargs to; | |
726 | * }; | |
727 | */ | |
728 | static int nfs2_xdr_enc_renameargs(struct rpc_rqst *req, __be32 *p, | |
729 | const struct nfs_renameargs *args) | |
730 | { | |
731 | const struct qstr *old = args->old_name; | |
732 | const struct qstr *new = args->new_name; | |
733 | struct xdr_stream xdr; | |
734 | ||
735 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
736 | encode_diropargs(&xdr, args->old_dir, old->name, old->len); | |
737 | encode_diropargs(&xdr, args->new_dir, new->name, new->len); | |
738 | return 0; | |
739 | } | |
740 | ||
25a0866c CL |
741 | /* |
742 | * 2.2.13. linkargs | |
743 | * | |
744 | * struct linkargs { | |
745 | * fhandle from; | |
746 | * diropargs to; | |
747 | * }; | |
748 | */ | |
749 | static int nfs2_xdr_enc_linkargs(struct rpc_rqst *req, __be32 *p, | |
750 | const struct nfs_linkargs *args) | |
751 | { | |
752 | struct xdr_stream xdr; | |
753 | ||
754 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
755 | encode_fhandle(&xdr, args->fromfh); | |
756 | encode_diropargs(&xdr, args->tofh, args->toname, args->tolen); | |
757 | return 0; | |
758 | } | |
759 | ||
25a0866c CL |
760 | /* |
761 | * 2.2.14. symlinkargs | |
762 | * | |
763 | * struct symlinkargs { | |
764 | * diropargs from; | |
765 | * path to; | |
766 | * sattr attributes; | |
767 | * }; | |
768 | */ | |
769 | static int nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, __be32 *p, | |
770 | const struct nfs_symlinkargs *args) | |
771 | { | |
772 | struct xdr_stream xdr; | |
773 | ||
774 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
775 | encode_diropargs(&xdr, args->fromfh, args->fromname, args->fromlen); | |
776 | encode_path(&xdr, args->pages, args->pathlen); | |
777 | encode_sattr(&xdr, args->sattr); | |
778 | return 0; | |
779 | } | |
780 | ||
25a0866c CL |
781 | /* |
782 | * 2.2.17. readdirargs | |
783 | * | |
784 | * struct readdirargs { | |
785 | * fhandle dir; | |
786 | * nfscookie cookie; | |
787 | * unsigned count; | |
788 | * }; | |
789 | */ | |
790 | static void encode_readdirargs(struct xdr_stream *xdr, | |
791 | const struct nfs_readdirargs *args) | |
792 | { | |
793 | __be32 *p; | |
794 | ||
795 | encode_fhandle(xdr, args->fh); | |
796 | ||
797 | p = xdr_reserve_space(xdr, 4 + 4); | |
798 | *p++ = cpu_to_be32(args->cookie); | |
799 | *p = cpu_to_be32(args->count); | |
800 | } | |
801 | ||
802 | static int nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, __be32 *p, | |
803 | const struct nfs_readdirargs *args) | |
804 | { | |
805 | struct xdr_stream xdr; | |
806 | ||
807 | xdr_init_encode(&xdr, &req->rq_snd_buf, p); | |
808 | encode_readdirargs(&xdr, args); | |
809 | prepare_reply_buffer(req, args->pages, 0, | |
810 | args->count, NFS_readdirres_sz); | |
811 | return 0; | |
812 | } | |
813 | ||
1da177e4 | 814 | /* |
661ad423 CL |
815 | * NFSv2 XDR decode functions |
816 | * | |
817 | * NFSv2 result types are defined in section 2.2 of RFC 1094: | |
818 | * "NFS: Network File System Protocol Specification". | |
1da177e4 | 819 | */ |
1da177e4 | 820 | |
f796f8b3 CL |
821 | static int nfs2_xdr_dec_stat(struct rpc_rqst *req, __be32 *p, |
822 | void *__unused) | |
823 | { | |
824 | struct xdr_stream xdr; | |
825 | enum nfs_stat status; | |
826 | int error; | |
827 | ||
828 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
829 | error = decode_stat(&xdr, &status); | |
830 | if (unlikely(error)) | |
831 | goto out; | |
832 | if (status != NFS_OK) | |
833 | goto out_default; | |
834 | out: | |
835 | return error; | |
836 | out_default: | |
837 | return nfs_stat_to_errno(status); | |
838 | } | |
839 | ||
f796f8b3 CL |
840 | static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, __be32 *p, |
841 | struct nfs_fattr *result) | |
842 | { | |
843 | struct xdr_stream xdr; | |
844 | ||
845 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
846 | return decode_attrstat(&xdr, result); | |
847 | } | |
848 | ||
f796f8b3 CL |
849 | static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, __be32 *p, |
850 | struct nfs_diropok *result) | |
851 | { | |
852 | struct xdr_stream xdr; | |
853 | ||
854 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
855 | return decode_diropres(&xdr, result); | |
856 | } | |
857 | ||
f796f8b3 CL |
858 | /* |
859 | * 2.2.6. readlinkres | |
860 | * | |
861 | * union readlinkres switch (stat status) { | |
862 | * case NFS_OK: | |
863 | * path data; | |
864 | * default: | |
865 | * void; | |
866 | * }; | |
867 | */ | |
868 | static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req, __be32 *p, | |
869 | void *__unused) | |
870 | { | |
871 | struct xdr_stream xdr; | |
872 | enum nfs_stat status; | |
873 | int error; | |
874 | ||
875 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
876 | error = decode_stat(&xdr, &status); | |
877 | if (unlikely(error)) | |
878 | goto out; | |
879 | if (status != NFS_OK) | |
880 | goto out_default; | |
881 | error = decode_path(&xdr); | |
882 | out: | |
883 | return error; | |
884 | out_default: | |
885 | return nfs_stat_to_errno(status); | |
886 | } | |
887 | ||
888 | /* | |
889 | * 2.2.7. readres | |
890 | * | |
891 | * union readres switch (stat status) { | |
892 | * case NFS_OK: | |
893 | * fattr attributes; | |
894 | * nfsdata data; | |
895 | * default: | |
896 | * void; | |
897 | * }; | |
898 | */ | |
899 | static int nfs2_xdr_dec_readres(struct rpc_rqst *req, __be32 *p, | |
900 | struct nfs_readres *result) | |
901 | { | |
902 | struct xdr_stream xdr; | |
903 | enum nfs_stat status; | |
904 | int error; | |
905 | ||
906 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
907 | error = decode_stat(&xdr, &status); | |
908 | if (unlikely(error)) | |
909 | goto out; | |
910 | if (status != NFS_OK) | |
911 | goto out_default; | |
912 | error = decode_fattr(&xdr, result->fattr); | |
913 | if (unlikely(error)) | |
914 | goto out; | |
915 | error = decode_nfsdata(&xdr, result); | |
916 | out: | |
917 | return error; | |
918 | out_default: | |
919 | return nfs_stat_to_errno(status); | |
920 | } | |
921 | ||
f796f8b3 CL |
922 | static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, __be32 *p, |
923 | struct nfs_writeres *result) | |
924 | { | |
925 | struct xdr_stream xdr; | |
926 | ||
927 | /* All NFSv2 writes are "file sync" writes */ | |
928 | result->verf->committed = NFS_FILE_SYNC; | |
929 | ||
930 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
931 | return decode_attrstat(&xdr, result->fattr); | |
932 | } | |
933 | ||
934 | /** | |
935 | * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in | |
936 | * the local page cache. | |
937 | * @xdr: XDR stream where entry resides | |
938 | * @entry: buffer to fill in with entry data | |
939 | * @server: nfs_server data for this directory | |
940 | * @plus: boolean indicating whether this should be a readdirplus entry | |
941 | * | |
942 | * Returns the position of the next item in the buffer, or an ERR_PTR. | |
943 | * | |
944 | * This function is not invoked during READDIR reply decoding, but | |
945 | * rather whenever an application invokes the getdents(2) system call | |
946 | * on a directory already in our cache. | |
947 | * | |
948 | * 2.2.17. entry | |
949 | * | |
950 | * struct entry { | |
951 | * unsigned fileid; | |
952 | * filename name; | |
953 | * nfscookie cookie; | |
954 | * entry *nextentry; | |
955 | * }; | |
956 | */ | |
957 | __be32 *nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, | |
958 | struct nfs_server *server, int plus) | |
959 | { | |
960 | __be32 *p; | |
961 | int error; | |
962 | ||
963 | p = xdr_inline_decode(xdr, 4); | |
964 | if (unlikely(p == NULL)) | |
965 | goto out_overflow; | |
966 | if (*p++ == xdr_zero) { | |
967 | p = xdr_inline_decode(xdr, 4); | |
968 | if (unlikely(p == NULL)) | |
969 | goto out_overflow; | |
970 | if (*p++ == xdr_zero) | |
971 | return ERR_PTR(-EAGAIN); | |
972 | entry->eof = 1; | |
973 | return ERR_PTR(-EBADCOOKIE); | |
974 | } | |
975 | ||
976 | p = xdr_inline_decode(xdr, 4); | |
977 | if (unlikely(p == NULL)) | |
978 | goto out_overflow; | |
979 | entry->ino = be32_to_cpup(p); | |
980 | ||
981 | error = decode_filename_inline(xdr, &entry->name, &entry->len); | |
982 | if (unlikely(error)) | |
983 | return ERR_PTR(error); | |
984 | ||
985 | /* | |
986 | * The type (size and byte order) of nfscookie isn't defined in | |
987 | * RFC 1094. This implementation assumes that it's an XDR uint32. | |
988 | */ | |
989 | entry->prev_cookie = entry->cookie; | |
990 | p = xdr_inline_decode(xdr, 4); | |
991 | if (unlikely(p == NULL)) | |
992 | goto out_overflow; | |
993 | entry->cookie = be32_to_cpup(p); | |
994 | ||
995 | entry->d_type = DT_UNKNOWN; | |
996 | ||
997 | /* Peek at the next entry to see if we're at EOD */ | |
998 | p = xdr_inline_peek(xdr, 4 + 4); | |
999 | entry->eof = 0; | |
1000 | if (p != NULL) | |
1001 | entry->eof = (p[0] == xdr_zero) && (p[1] != xdr_zero); | |
1002 | return p; | |
1003 | ||
1004 | out_overflow: | |
1005 | print_overflow_msg(__func__, xdr); | |
1006 | return ERR_PTR(-EAGAIN); | |
1007 | } | |
1008 | ||
1009 | /* | |
1010 | * 2.2.17. readdirres | |
1011 | * | |
1012 | * union readdirres switch (stat status) { | |
1013 | * case NFS_OK: | |
1014 | * struct { | |
1015 | * entry *entries; | |
1016 | * bool eof; | |
1017 | * } readdirok; | |
1018 | * default: | |
1019 | * void; | |
1020 | * }; | |
1021 | * | |
1022 | * Read the directory contents into the page cache, but don't | |
1023 | * touch them. The actual decoding is done by nfs2_decode_dirent() | |
1024 | * during subsequent nfs_readdir() calls. | |
1025 | */ | |
1026 | static int decode_readdirok(struct xdr_stream *xdr) | |
1027 | { | |
1028 | u32 recvd, pglen; | |
1029 | size_t hdrlen; | |
1030 | ||
1031 | pglen = xdr->buf->page_len; | |
1032 | hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; | |
1033 | recvd = xdr->buf->len - hdrlen; | |
1034 | if (unlikely(pglen > recvd)) | |
1035 | goto out_cheating; | |
1036 | out: | |
1037 | xdr_read_pages(xdr, pglen); | |
1038 | return pglen; | |
1039 | out_cheating: | |
1040 | dprintk("NFS: server cheating in readdir result: " | |
1041 | "pglen %u > recvd %u\n", pglen, recvd); | |
1042 | pglen = recvd; | |
1043 | goto out; | |
1044 | } | |
1045 | ||
1046 | static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req, __be32 *p, | |
1047 | void *__unused) | |
1048 | { | |
1049 | struct xdr_stream xdr; | |
1050 | enum nfs_stat status; | |
1051 | int error; | |
1052 | ||
1053 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
1054 | error = decode_stat(&xdr, &status); | |
1055 | if (unlikely(error)) | |
1056 | goto out; | |
1057 | if (status != NFS_OK) | |
1058 | goto out_default; | |
1059 | error = decode_readdirok(&xdr); | |
1060 | out: | |
1061 | return error; | |
1062 | out_default: | |
1063 | return nfs_stat_to_errno(status); | |
1064 | } | |
1065 | ||
f796f8b3 CL |
1066 | /* |
1067 | * 2.2.18. statfsres | |
1068 | * | |
1069 | * union statfsres (stat status) { | |
1070 | * case NFS_OK: | |
1071 | * struct { | |
1072 | * unsigned tsize; | |
1073 | * unsigned bsize; | |
1074 | * unsigned blocks; | |
1075 | * unsigned bfree; | |
1076 | * unsigned bavail; | |
1077 | * } info; | |
1078 | * default: | |
1079 | * void; | |
1080 | * }; | |
1081 | */ | |
1082 | static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result) | |
1083 | { | |
1084 | __be32 *p; | |
1085 | ||
1086 | p = xdr_inline_decode(xdr, NFS_info_sz << 2); | |
1087 | if (unlikely(p == NULL)) | |
1088 | goto out_overflow; | |
1089 | result->tsize = be32_to_cpup(p++); | |
1090 | result->bsize = be32_to_cpup(p++); | |
1091 | result->blocks = be32_to_cpup(p++); | |
1092 | result->bfree = be32_to_cpup(p++); | |
1093 | result->bavail = be32_to_cpup(p); | |
1094 | return 0; | |
1095 | out_overflow: | |
1096 | print_overflow_msg(__func__, xdr); | |
1097 | return -EIO; | |
1098 | } | |
1099 | ||
1100 | static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, __be32 *p, | |
1101 | struct nfs2_fsstat *result) | |
1102 | { | |
1103 | struct xdr_stream xdr; | |
1104 | enum nfs_stat status; | |
1105 | int error; | |
1106 | ||
1107 | xdr_init_decode(&xdr, &req->rq_rcv_buf, p); | |
1108 | error = decode_stat(&xdr, &status); | |
1109 | if (unlikely(error)) | |
1110 | goto out; | |
1111 | if (status != NFS_OK) | |
1112 | goto out_default; | |
1113 | error = decode_info(&xdr, result); | |
1114 | out: | |
1115 | return error; | |
1116 | out_default: | |
1117 | return nfs_stat_to_errno(status); | |
1118 | } | |
1119 | ||
1120 | ||
1da177e4 LT |
1121 | /* |
1122 | * We need to translate between nfs status return values and | |
1123 | * the local errno values which may not be the same. | |
1124 | */ | |
85828493 | 1125 | static const struct { |
1da177e4 LT |
1126 | int stat; |
1127 | int errno; | |
1128 | } nfs_errtbl[] = { | |
1129 | { NFS_OK, 0 }, | |
856dff3d BH |
1130 | { NFSERR_PERM, -EPERM }, |
1131 | { NFSERR_NOENT, -ENOENT }, | |
1132 | { NFSERR_IO, -errno_NFSERR_IO}, | |
1133 | { NFSERR_NXIO, -ENXIO }, | |
1134 | /* { NFSERR_EAGAIN, -EAGAIN }, */ | |
1135 | { NFSERR_ACCES, -EACCES }, | |
1136 | { NFSERR_EXIST, -EEXIST }, | |
1137 | { NFSERR_XDEV, -EXDEV }, | |
1138 | { NFSERR_NODEV, -ENODEV }, | |
1139 | { NFSERR_NOTDIR, -ENOTDIR }, | |
1140 | { NFSERR_ISDIR, -EISDIR }, | |
1141 | { NFSERR_INVAL, -EINVAL }, | |
1142 | { NFSERR_FBIG, -EFBIG }, | |
1143 | { NFSERR_NOSPC, -ENOSPC }, | |
1144 | { NFSERR_ROFS, -EROFS }, | |
1145 | { NFSERR_MLINK, -EMLINK }, | |
1146 | { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, | |
1147 | { NFSERR_NOTEMPTY, -ENOTEMPTY }, | |
1148 | { NFSERR_DQUOT, -EDQUOT }, | |
1149 | { NFSERR_STALE, -ESTALE }, | |
1150 | { NFSERR_REMOTE, -EREMOTE }, | |
1da177e4 | 1151 | #ifdef EWFLUSH |
856dff3d | 1152 | { NFSERR_WFLUSH, -EWFLUSH }, |
1da177e4 | 1153 | #endif |
856dff3d BH |
1154 | { NFSERR_BADHANDLE, -EBADHANDLE }, |
1155 | { NFSERR_NOT_SYNC, -ENOTSYNC }, | |
1156 | { NFSERR_BAD_COOKIE, -EBADCOOKIE }, | |
1157 | { NFSERR_NOTSUPP, -ENOTSUPP }, | |
1158 | { NFSERR_TOOSMALL, -ETOOSMALL }, | |
fdcb4577 | 1159 | { NFSERR_SERVERFAULT, -EREMOTEIO }, |
856dff3d BH |
1160 | { NFSERR_BADTYPE, -EBADTYPE }, |
1161 | { NFSERR_JUKEBOX, -EJUKEBOX }, | |
1162 | { -1, -EIO } | |
1da177e4 LT |
1163 | }; |
1164 | ||
85828493 CL |
1165 | /** |
1166 | * nfs_stat_to_errno - convert an NFS status code to a local errno | |
1167 | * @status: NFS status code to convert | |
1168 | * | |
1169 | * Returns a local errno value, or -EIO if the NFS status code is | |
1170 | * not recognized. This function is used jointly by NFSv2 and NFSv3. | |
1da177e4 | 1171 | */ |
85828493 | 1172 | int nfs_stat_to_errno(enum nfs_stat status) |
1da177e4 LT |
1173 | { |
1174 | int i; | |
1175 | ||
1176 | for (i = 0; nfs_errtbl[i].stat != -1; i++) { | |
85828493 | 1177 | if (nfs_errtbl[i].stat == (int)status) |
1da177e4 LT |
1178 | return nfs_errtbl[i].errno; |
1179 | } | |
85828493 | 1180 | dprintk("NFS: Unrecognized nfs status value: %u\n", status); |
1da177e4 LT |
1181 | return nfs_errtbl[i].errno; |
1182 | } | |
1183 | ||
1da177e4 LT |
1184 | #define PROC(proc, argtype, restype, timer) \ |
1185 | [NFSPROC_##proc] = { \ | |
1186 | .p_proc = NFSPROC_##proc, \ | |
25a0866c | 1187 | .p_encode = (kxdrproc_t)nfs2_xdr_enc_##argtype, \ |
f796f8b3 | 1188 | .p_decode = (kxdrproc_t)nfs2_xdr_dec_##restype, \ |
2bea90d4 CL |
1189 | .p_arglen = NFS_##argtype##_sz, \ |
1190 | .p_replen = NFS_##restype##_sz, \ | |
cc0175c1 CL |
1191 | .p_timer = timer, \ |
1192 | .p_statidx = NFSPROC_##proc, \ | |
1193 | .p_name = #proc, \ | |
1da177e4 LT |
1194 | } |
1195 | struct rpc_procinfo nfs_procedures[] = { | |
1196 | PROC(GETATTR, fhandle, attrstat, 1), | |
1197 | PROC(SETATTR, sattrargs, attrstat, 0), | |
1198 | PROC(LOOKUP, diropargs, diropres, 2), | |
1199 | PROC(READLINK, readlinkargs, readlinkres, 3), | |
1200 | PROC(READ, readargs, readres, 3), | |
1201 | PROC(WRITE, writeargs, writeres, 4), | |
1202 | PROC(CREATE, createargs, diropres, 0), | |
4fdc17b2 | 1203 | PROC(REMOVE, removeargs, stat, 0), |
1da177e4 LT |
1204 | PROC(RENAME, renameargs, stat, 0), |
1205 | PROC(LINK, linkargs, stat, 0), | |
1206 | PROC(SYMLINK, symlinkargs, stat, 0), | |
1207 | PROC(MKDIR, createargs, diropres, 0), | |
1208 | PROC(RMDIR, diropargs, stat, 0), | |
1209 | PROC(READDIR, readdirargs, readdirres, 3), | |
1210 | PROC(STATFS, fhandle, statfsres, 0), | |
1211 | }; | |
1212 | ||
1213 | struct rpc_version nfs_version2 = { | |
1214 | .number = 2, | |
e8c96f8c | 1215 | .nrprocs = ARRAY_SIZE(nfs_procedures), |
1da177e4 LT |
1216 | .procs = nfs_procedures |
1217 | }; |