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 /* 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 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 90 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 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 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 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 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 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 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 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 { 283 u32 rdev, type; 284 __be32 *p; 285 286 p = xdr_inline_decode(xdr, NFS_fattr_sz << 2); 287 if (unlikely(p == NULL)) 288 goto out_overflow; 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); 316 return 0; 317 out_overflow: 318 print_overflow_msg(__func__, xdr); 319 return -EIO; 320 } 321 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 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 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 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 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 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 553 554 /* 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". 559 */ 560 561 static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req, 562 struct xdr_stream *xdr, 563 const struct nfs_fh *fh) 564 { 565 encode_fhandle(xdr, fh); 566 } 567 568 /* 569 * 2.2.3. sattrargs 570 * 571 * struct sattrargs { 572 * fhandle file; 573 * sattr attributes; 574 * }; 575 */ 576 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, 577 struct xdr_stream *xdr, 578 const struct nfs_sattrargs *args) 579 { 580 encode_fhandle(xdr, args->fh); 581 encode_sattr(xdr, args->sattr); 582 } 583 584 static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req, 585 struct xdr_stream *xdr, 586 const struct nfs_diropargs *args) 587 { 588 encode_diropargs(xdr, args->fh, args->name, args->len); 589 } 590 591 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, 592 struct xdr_stream *xdr, 593 const struct nfs_readlinkargs *args) 594 { 595 encode_fhandle(xdr, args->fh); 596 prepare_reply_buffer(req, args->pages, args->pgbase, 597 args->pglen, NFS_readlinkres_sz); 598 } 599 600 /* 601 * 2.2.7. readargs 602 * 603 * struct readargs { 604 * fhandle file; 605 * unsigned offset; 606 * unsigned count; 607 * unsigned totalcount; 608 * }; 609 */ 610 static void encode_readargs(struct xdr_stream *xdr, 611 const struct nfs_readargs *args) 612 { 613 u32 offset = args->offset; 614 u32 count = args->count; 615 __be32 *p; 616 617 encode_fhandle(xdr, args->fh); 618 619 p = xdr_reserve_space(xdr, 4 + 4 + 4); 620 *p++ = cpu_to_be32(offset); 621 *p++ = cpu_to_be32(count); 622 *p = cpu_to_be32(count); 623 } 624 625 static void nfs2_xdr_enc_readargs(struct rpc_rqst *req, 626 struct xdr_stream *xdr, 627 const struct nfs_readargs *args) 628 { 629 encode_readargs(xdr, args); 630 prepare_reply_buffer(req, args->pages, args->pgbase, 631 args->count, NFS_readres_sz); 632 req->rq_rcv_buf.flags |= XDRBUF_READ; 633 } 634 635 /* 636 * 2.2.9. writeargs 637 * 638 * struct writeargs { 639 * fhandle file; 640 * unsigned beginoffset; 641 * unsigned offset; 642 * unsigned totalcount; 643 * nfsdata data; 644 * }; 645 */ 646 static void encode_writeargs(struct xdr_stream *xdr, 647 const struct nfs_writeargs *args) 648 { 649 u32 offset = args->offset; 650 u32 count = args->count; 651 __be32 *p; 652 653 encode_fhandle(xdr, args->fh); 654 655 p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4); 656 *p++ = cpu_to_be32(offset); 657 *p++ = cpu_to_be32(offset); 658 *p++ = cpu_to_be32(count); 659 660 /* nfsdata */ 661 *p = cpu_to_be32(count); 662 xdr_write_pages(xdr, args->pages, args->pgbase, count); 663 } 664 665 static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req, 666 struct xdr_stream *xdr, 667 const struct nfs_writeargs *args) 668 { 669 encode_writeargs(xdr, args); 670 xdr->buf->flags |= XDRBUF_WRITE; 671 } 672 673 /* 674 * 2.2.10. createargs 675 * 676 * struct createargs { 677 * diropargs where; 678 * sattr attributes; 679 * }; 680 */ 681 static void nfs2_xdr_enc_createargs(struct rpc_rqst *req, 682 struct xdr_stream *xdr, 683 const struct nfs_createargs *args) 684 { 685 encode_diropargs(xdr, args->fh, args->name, args->len); 686 encode_sattr(xdr, args->sattr); 687 } 688 689 static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req, 690 struct xdr_stream *xdr, 691 const struct nfs_removeargs *args) 692 { 693 encode_diropargs(xdr, args->fh, args->name.name, args->name.len); 694 } 695 696 /* 697 * 2.2.12. renameargs 698 * 699 * struct renameargs { 700 * diropargs from; 701 * diropargs to; 702 * }; 703 */ 704 static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req, 705 struct xdr_stream *xdr, 706 const struct nfs_renameargs *args) 707 { 708 const struct qstr *old = args->old_name; 709 const struct qstr *new = args->new_name; 710 711 encode_diropargs(xdr, args->old_dir, old->name, old->len); 712 encode_diropargs(xdr, args->new_dir, new->name, new->len); 713 } 714 715 /* 716 * 2.2.13. linkargs 717 * 718 * struct linkargs { 719 * fhandle from; 720 * diropargs to; 721 * }; 722 */ 723 static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req, 724 struct xdr_stream *xdr, 725 const struct nfs_linkargs *args) 726 { 727 encode_fhandle(xdr, args->fromfh); 728 encode_diropargs(xdr, args->tofh, args->toname, args->tolen); 729 } 730 731 /* 732 * 2.2.14. symlinkargs 733 * 734 * struct symlinkargs { 735 * diropargs from; 736 * path to; 737 * sattr attributes; 738 * }; 739 */ 740 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, 741 struct xdr_stream *xdr, 742 const struct nfs_symlinkargs *args) 743 { 744 encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen); 745 encode_path(xdr, args->pages, args->pathlen); 746 encode_sattr(xdr, args->sattr); 747 } 748 749 /* 750 * 2.2.17. readdirargs 751 * 752 * struct readdirargs { 753 * fhandle dir; 754 * nfscookie cookie; 755 * unsigned count; 756 * }; 757 */ 758 static void encode_readdirargs(struct xdr_stream *xdr, 759 const struct nfs_readdirargs *args) 760 { 761 __be32 *p; 762 763 encode_fhandle(xdr, args->fh); 764 765 p = xdr_reserve_space(xdr, 4 + 4); 766 *p++ = cpu_to_be32(args->cookie); 767 *p = cpu_to_be32(args->count); 768 } 769 770 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, 771 struct xdr_stream *xdr, 772 const struct nfs_readdirargs *args) 773 { 774 encode_readdirargs(xdr, args); 775 prepare_reply_buffer(req, args->pages, 0, 776 args->count, NFS_readdirres_sz); 777 } 778 779 /* 780 * NFSv2 XDR decode functions 781 * 782 * NFSv2 result types are defined in section 2.2 of RFC 1094: 783 * "NFS: Network File System Protocol Specification". 784 */ 785 786 static int nfs2_xdr_dec_stat(struct rpc_rqst *req, __be32 *p, 787 void *__unused) 788 { 789 struct xdr_stream xdr; 790 enum nfs_stat status; 791 int error; 792 793 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 794 error = decode_stat(&xdr, &status); 795 if (unlikely(error)) 796 goto out; 797 if (status != NFS_OK) 798 goto out_default; 799 out: 800 return error; 801 out_default: 802 return nfs_stat_to_errno(status); 803 } 804 805 static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, __be32 *p, 806 struct nfs_fattr *result) 807 { 808 struct xdr_stream xdr; 809 810 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 811 return decode_attrstat(&xdr, result); 812 } 813 814 static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, __be32 *p, 815 struct nfs_diropok *result) 816 { 817 struct xdr_stream xdr; 818 819 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 820 return decode_diropres(&xdr, result); 821 } 822 823 /* 824 * 2.2.6. readlinkres 825 * 826 * union readlinkres switch (stat status) { 827 * case NFS_OK: 828 * path data; 829 * default: 830 * void; 831 * }; 832 */ 833 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req, __be32 *p, 834 void *__unused) 835 { 836 struct xdr_stream xdr; 837 enum nfs_stat status; 838 int error; 839 840 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 841 error = decode_stat(&xdr, &status); 842 if (unlikely(error)) 843 goto out; 844 if (status != NFS_OK) 845 goto out_default; 846 error = decode_path(&xdr); 847 out: 848 return error; 849 out_default: 850 return nfs_stat_to_errno(status); 851 } 852 853 /* 854 * 2.2.7. readres 855 * 856 * union readres switch (stat status) { 857 * case NFS_OK: 858 * fattr attributes; 859 * nfsdata data; 860 * default: 861 * void; 862 * }; 863 */ 864 static int nfs2_xdr_dec_readres(struct rpc_rqst *req, __be32 *p, 865 struct nfs_readres *result) 866 { 867 struct xdr_stream xdr; 868 enum nfs_stat status; 869 int error; 870 871 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 872 error = decode_stat(&xdr, &status); 873 if (unlikely(error)) 874 goto out; 875 if (status != NFS_OK) 876 goto out_default; 877 error = decode_fattr(&xdr, result->fattr); 878 if (unlikely(error)) 879 goto out; 880 error = decode_nfsdata(&xdr, result); 881 out: 882 return error; 883 out_default: 884 return nfs_stat_to_errno(status); 885 } 886 887 static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, __be32 *p, 888 struct nfs_writeres *result) 889 { 890 struct xdr_stream xdr; 891 892 /* All NFSv2 writes are "file sync" writes */ 893 result->verf->committed = NFS_FILE_SYNC; 894 895 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 896 return decode_attrstat(&xdr, result->fattr); 897 } 898 899 /** 900 * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in 901 * the local page cache. 902 * @xdr: XDR stream where entry resides 903 * @entry: buffer to fill in with entry data 904 * @plus: boolean indicating whether this should be a readdirplus entry 905 * 906 * Returns zero if successful, otherwise a negative errno value is 907 * returned. 908 * 909 * This function is not invoked during READDIR reply decoding, but 910 * rather whenever an application invokes the getdents(2) system call 911 * on a directory already in our cache. 912 * 913 * 2.2.17. entry 914 * 915 * struct entry { 916 * unsigned fileid; 917 * filename name; 918 * nfscookie cookie; 919 * entry *nextentry; 920 * }; 921 */ 922 int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, 923 int plus) 924 { 925 __be32 *p; 926 int error; 927 928 p = xdr_inline_decode(xdr, 4); 929 if (unlikely(p == NULL)) 930 goto out_overflow; 931 if (*p++ == xdr_zero) { 932 p = xdr_inline_decode(xdr, 4); 933 if (unlikely(p == NULL)) 934 goto out_overflow; 935 if (*p++ == xdr_zero) 936 return -EAGAIN; 937 entry->eof = 1; 938 return -EBADCOOKIE; 939 } 940 941 p = xdr_inline_decode(xdr, 4); 942 if (unlikely(p == NULL)) 943 goto out_overflow; 944 entry->ino = be32_to_cpup(p); 945 946 error = decode_filename_inline(xdr, &entry->name, &entry->len); 947 if (unlikely(error)) 948 return error; 949 950 /* 951 * The type (size and byte order) of nfscookie isn't defined in 952 * RFC 1094. This implementation assumes that it's an XDR uint32. 953 */ 954 entry->prev_cookie = entry->cookie; 955 p = xdr_inline_decode(xdr, 4); 956 if (unlikely(p == NULL)) 957 goto out_overflow; 958 entry->cookie = be32_to_cpup(p); 959 960 entry->d_type = DT_UNKNOWN; 961 962 /* Peek at the next entry to see if we're at EOD */ 963 p = xdr_inline_peek(xdr, 4 + 4); 964 entry->eof = 0; 965 if (p != NULL) 966 entry->eof = (p[0] == xdr_zero) && (p[1] != xdr_zero); 967 return 0; 968 969 out_overflow: 970 print_overflow_msg(__func__, xdr); 971 return -EAGAIN; 972 } 973 974 /* 975 * 2.2.17. readdirres 976 * 977 * union readdirres switch (stat status) { 978 * case NFS_OK: 979 * struct { 980 * entry *entries; 981 * bool eof; 982 * } readdirok; 983 * default: 984 * void; 985 * }; 986 * 987 * Read the directory contents into the page cache, but don't 988 * touch them. The actual decoding is done by nfs2_decode_dirent() 989 * during subsequent nfs_readdir() calls. 990 */ 991 static int decode_readdirok(struct xdr_stream *xdr) 992 { 993 u32 recvd, pglen; 994 size_t hdrlen; 995 996 pglen = xdr->buf->page_len; 997 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; 998 recvd = xdr->buf->len - hdrlen; 999 if (unlikely(pglen > recvd)) 1000 goto out_cheating; 1001 out: 1002 xdr_read_pages(xdr, pglen); 1003 return pglen; 1004 out_cheating: 1005 dprintk("NFS: server cheating in readdir result: " 1006 "pglen %u > recvd %u\n", pglen, recvd); 1007 pglen = recvd; 1008 goto out; 1009 } 1010 1011 static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req, __be32 *p, 1012 void *__unused) 1013 { 1014 struct xdr_stream xdr; 1015 enum nfs_stat status; 1016 int error; 1017 1018 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 1019 error = decode_stat(&xdr, &status); 1020 if (unlikely(error)) 1021 goto out; 1022 if (status != NFS_OK) 1023 goto out_default; 1024 error = decode_readdirok(&xdr); 1025 out: 1026 return error; 1027 out_default: 1028 return nfs_stat_to_errno(status); 1029 } 1030 1031 /* 1032 * 2.2.18. statfsres 1033 * 1034 * union statfsres (stat status) { 1035 * case NFS_OK: 1036 * struct { 1037 * unsigned tsize; 1038 * unsigned bsize; 1039 * unsigned blocks; 1040 * unsigned bfree; 1041 * unsigned bavail; 1042 * } info; 1043 * default: 1044 * void; 1045 * }; 1046 */ 1047 static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result) 1048 { 1049 __be32 *p; 1050 1051 p = xdr_inline_decode(xdr, NFS_info_sz << 2); 1052 if (unlikely(p == NULL)) 1053 goto out_overflow; 1054 result->tsize = be32_to_cpup(p++); 1055 result->bsize = be32_to_cpup(p++); 1056 result->blocks = be32_to_cpup(p++); 1057 result->bfree = be32_to_cpup(p++); 1058 result->bavail = be32_to_cpup(p); 1059 return 0; 1060 out_overflow: 1061 print_overflow_msg(__func__, xdr); 1062 return -EIO; 1063 } 1064 1065 static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, __be32 *p, 1066 struct nfs2_fsstat *result) 1067 { 1068 struct xdr_stream xdr; 1069 enum nfs_stat status; 1070 int error; 1071 1072 xdr_init_decode(&xdr, &req->rq_rcv_buf, p); 1073 error = decode_stat(&xdr, &status); 1074 if (unlikely(error)) 1075 goto out; 1076 if (status != NFS_OK) 1077 goto out_default; 1078 error = decode_info(&xdr, result); 1079 out: 1080 return error; 1081 out_default: 1082 return nfs_stat_to_errno(status); 1083 } 1084 1085 1086 /* 1087 * We need to translate between nfs status return values and 1088 * the local errno values which may not be the same. 1089 */ 1090 static const struct { 1091 int stat; 1092 int errno; 1093 } nfs_errtbl[] = { 1094 { NFS_OK, 0 }, 1095 { NFSERR_PERM, -EPERM }, 1096 { NFSERR_NOENT, -ENOENT }, 1097 { NFSERR_IO, -errno_NFSERR_IO}, 1098 { NFSERR_NXIO, -ENXIO }, 1099 /* { NFSERR_EAGAIN, -EAGAIN }, */ 1100 { NFSERR_ACCES, -EACCES }, 1101 { NFSERR_EXIST, -EEXIST }, 1102 { NFSERR_XDEV, -EXDEV }, 1103 { NFSERR_NODEV, -ENODEV }, 1104 { NFSERR_NOTDIR, -ENOTDIR }, 1105 { NFSERR_ISDIR, -EISDIR }, 1106 { NFSERR_INVAL, -EINVAL }, 1107 { NFSERR_FBIG, -EFBIG }, 1108 { NFSERR_NOSPC, -ENOSPC }, 1109 { NFSERR_ROFS, -EROFS }, 1110 { NFSERR_MLINK, -EMLINK }, 1111 { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, 1112 { NFSERR_NOTEMPTY, -ENOTEMPTY }, 1113 { NFSERR_DQUOT, -EDQUOT }, 1114 { NFSERR_STALE, -ESTALE }, 1115 { NFSERR_REMOTE, -EREMOTE }, 1116 #ifdef EWFLUSH 1117 { NFSERR_WFLUSH, -EWFLUSH }, 1118 #endif 1119 { NFSERR_BADHANDLE, -EBADHANDLE }, 1120 { NFSERR_NOT_SYNC, -ENOTSYNC }, 1121 { NFSERR_BAD_COOKIE, -EBADCOOKIE }, 1122 { NFSERR_NOTSUPP, -ENOTSUPP }, 1123 { NFSERR_TOOSMALL, -ETOOSMALL }, 1124 { NFSERR_SERVERFAULT, -EREMOTEIO }, 1125 { NFSERR_BADTYPE, -EBADTYPE }, 1126 { NFSERR_JUKEBOX, -EJUKEBOX }, 1127 { -1, -EIO } 1128 }; 1129 1130 /** 1131 * nfs_stat_to_errno - convert an NFS status code to a local errno 1132 * @status: NFS status code to convert 1133 * 1134 * Returns a local errno value, or -EIO if the NFS status code is 1135 * not recognized. This function is used jointly by NFSv2 and NFSv3. 1136 */ 1137 int nfs_stat_to_errno(enum nfs_stat status) 1138 { 1139 int i; 1140 1141 for (i = 0; nfs_errtbl[i].stat != -1; i++) { 1142 if (nfs_errtbl[i].stat == (int)status) 1143 return nfs_errtbl[i].errno; 1144 } 1145 dprintk("NFS: Unrecognized nfs status value: %u\n", status); 1146 return nfs_errtbl[i].errno; 1147 } 1148 1149 #define PROC(proc, argtype, restype, timer) \ 1150 [NFSPROC_##proc] = { \ 1151 .p_proc = NFSPROC_##proc, \ 1152 .p_encode = (kxdreproc_t)nfs2_xdr_enc_##argtype, \ 1153 .p_decode = (kxdrproc_t)nfs2_xdr_dec_##restype, \ 1154 .p_arglen = NFS_##argtype##_sz, \ 1155 .p_replen = NFS_##restype##_sz, \ 1156 .p_timer = timer, \ 1157 .p_statidx = NFSPROC_##proc, \ 1158 .p_name = #proc, \ 1159 } 1160 struct rpc_procinfo nfs_procedures[] = { 1161 PROC(GETATTR, fhandle, attrstat, 1), 1162 PROC(SETATTR, sattrargs, attrstat, 0), 1163 PROC(LOOKUP, diropargs, diropres, 2), 1164 PROC(READLINK, readlinkargs, readlinkres, 3), 1165 PROC(READ, readargs, readres, 3), 1166 PROC(WRITE, writeargs, writeres, 4), 1167 PROC(CREATE, createargs, diropres, 0), 1168 PROC(REMOVE, removeargs, stat, 0), 1169 PROC(RENAME, renameargs, stat, 0), 1170 PROC(LINK, linkargs, stat, 0), 1171 PROC(SYMLINK, symlinkargs, stat, 0), 1172 PROC(MKDIR, createargs, diropres, 0), 1173 PROC(RMDIR, diropargs, stat, 0), 1174 PROC(READDIR, readdirargs, readdirres, 3), 1175 PROC(STATFS, fhandle, statfsres, 0), 1176 }; 1177 1178 struct rpc_version nfs_version2 = { 1179 .number = 2, 1180 .nrprocs = ARRAY_SIZE(nfs_procedures), 1181 .procs = nfs_procedures 1182 }; 1183