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