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