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