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