1 /* 2 * linux/fs/nfs/nfs3xdr.c 3 * 4 * XDR functions to encode/decode NFSv3 RPC arguments and results. 5 * 6 * Copyright (C) 1996, 1997 Olaf Kirch 7 */ 8 9 #include <linux/param.h> 10 #include <linux/time.h> 11 #include <linux/mm.h> 12 #include <linux/errno.h> 13 #include <linux/string.h> 14 #include <linux/in.h> 15 #include <linux/pagemap.h> 16 #include <linux/proc_fs.h> 17 #include <linux/kdev_t.h> 18 #include <linux/sunrpc/clnt.h> 19 #include <linux/nfs.h> 20 #include <linux/nfs3.h> 21 #include <linux/nfs_fs.h> 22 #include <linux/nfsacl.h> 23 #include "internal.h" 24 25 #define NFSDBG_FACILITY NFSDBG_XDR 26 27 /* Mapping from NFS error code to "errno" error code. */ 28 #define errno_NFSERR_IO EIO 29 30 /* 31 * Declare the space requirements for NFS arguments and replies as 32 * number of 32bit-words 33 */ 34 #define NFS3_fhandle_sz (1+16) 35 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */ 36 #define NFS3_sattr_sz (15) 37 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2)) 38 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2)) 39 #define NFS3_fattr_sz (21) 40 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2) 41 #define NFS3_wcc_attr_sz (6) 42 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz) 43 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz) 44 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz) 45 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz) 46 47 #define NFS3_getattrargs_sz (NFS3_fh_sz) 48 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3) 49 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz) 50 #define NFS3_accessargs_sz (NFS3_fh_sz+1) 51 #define NFS3_readlinkargs_sz (NFS3_fh_sz) 52 #define NFS3_readargs_sz (NFS3_fh_sz+3) 53 #define NFS3_writeargs_sz (NFS3_fh_sz+5) 54 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 55 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz) 56 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz) 57 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz) 58 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz) 59 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz) 60 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz) 61 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3) 62 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4) 63 #define NFS3_commitargs_sz (NFS3_fh_sz+3) 64 65 #define NFS3_getattrres_sz (1+NFS3_fattr_sz) 66 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz) 67 #define NFS3_removeres_sz (NFS3_setattrres_sz) 68 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz)) 69 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1) 70 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1) 71 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3) 72 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4) 73 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 74 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz)) 75 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) 76 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2) 77 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13) 78 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12) 79 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6) 80 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2) 81 82 #define ACL3_getaclargs_sz (NFS3_fh_sz+1) 83 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \ 84 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)) 85 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \ 86 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)) 87 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz) 88 89 static int nfs3_stat_to_errno(enum nfs_stat); 90 91 /* 92 * Map file type to S_IFMT bits 93 */ 94 static const umode_t nfs_type2fmt[] = { 95 [NF3BAD] = 0, 96 [NF3REG] = S_IFREG, 97 [NF3DIR] = S_IFDIR, 98 [NF3BLK] = S_IFBLK, 99 [NF3CHR] = S_IFCHR, 100 [NF3LNK] = S_IFLNK, 101 [NF3SOCK] = S_IFSOCK, 102 [NF3FIFO] = S_IFIFO, 103 }; 104 105 /* 106 * While encoding arguments, set up the reply buffer in advance to 107 * receive reply data directly into the page cache. 108 */ 109 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages, 110 unsigned int base, unsigned int len, 111 unsigned int bufsize) 112 { 113 struct rpc_auth *auth = req->rq_cred->cr_auth; 114 unsigned int replen; 115 116 replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize; 117 xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len); 118 } 119 120 /* 121 * Handle decode buffer overflows out-of-line. 122 */ 123 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr) 124 { 125 dprintk("NFS: %s prematurely hit the end of our receive buffer. " 126 "Remaining buffer length is %tu words.\n", 127 func, xdr->end - xdr->p); 128 } 129 130 131 /* 132 * Encode/decode NFSv3 basic data types 133 * 134 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813: 135 * "NFS Version 3 Protocol Specification". 136 * 137 * Not all basic data types have their own encoding and decoding 138 * functions. For run-time efficiency, some data types are encoded 139 * or decoded inline. 140 */ 141 142 static void encode_uint32(struct xdr_stream *xdr, u32 value) 143 { 144 __be32 *p = xdr_reserve_space(xdr, 4); 145 *p = cpu_to_be32(value); 146 } 147 148 static int decode_uint32(struct xdr_stream *xdr, u32 *value) 149 { 150 __be32 *p; 151 152 p = xdr_inline_decode(xdr, 4); 153 if (unlikely(p == NULL)) 154 goto out_overflow; 155 *value = be32_to_cpup(p); 156 return 0; 157 out_overflow: 158 print_overflow_msg(__func__, xdr); 159 return -EIO; 160 } 161 162 static int decode_uint64(struct xdr_stream *xdr, u64 *value) 163 { 164 __be32 *p; 165 166 p = xdr_inline_decode(xdr, 8); 167 if (unlikely(p == NULL)) 168 goto out_overflow; 169 xdr_decode_hyper(p, value); 170 return 0; 171 out_overflow: 172 print_overflow_msg(__func__, xdr); 173 return -EIO; 174 } 175 176 /* 177 * fileid3 178 * 179 * typedef uint64 fileid3; 180 */ 181 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid) 182 { 183 return xdr_decode_hyper(p, fileid); 184 } 185 186 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid) 187 { 188 return decode_uint64(xdr, fileid); 189 } 190 191 /* 192 * filename3 193 * 194 * typedef string filename3<>; 195 */ 196 static void encode_filename3(struct xdr_stream *xdr, 197 const char *name, u32 length) 198 { 199 __be32 *p; 200 201 BUG_ON(length > NFS3_MAXNAMLEN); 202 p = xdr_reserve_space(xdr, 4 + length); 203 xdr_encode_opaque(p, name, length); 204 } 205 206 static int decode_inline_filename3(struct xdr_stream *xdr, 207 const char **name, u32 *length) 208 { 209 __be32 *p; 210 u32 count; 211 212 p = xdr_inline_decode(xdr, 4); 213 if (unlikely(p == NULL)) 214 goto out_overflow; 215 count = be32_to_cpup(p); 216 if (count > NFS3_MAXNAMLEN) 217 goto out_nametoolong; 218 p = xdr_inline_decode(xdr, count); 219 if (unlikely(p == NULL)) 220 goto out_overflow; 221 *name = (const char *)p; 222 *length = count; 223 return 0; 224 225 out_nametoolong: 226 dprintk("NFS: returned filename too long: %u\n", count); 227 return -ENAMETOOLONG; 228 out_overflow: 229 print_overflow_msg(__func__, xdr); 230 return -EIO; 231 } 232 233 /* 234 * nfspath3 235 * 236 * typedef string nfspath3<>; 237 */ 238 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages, 239 const u32 length) 240 { 241 BUG_ON(length > NFS3_MAXPATHLEN); 242 encode_uint32(xdr, length); 243 xdr_write_pages(xdr, pages, 0, length); 244 } 245 246 static int decode_nfspath3(struct xdr_stream *xdr) 247 { 248 u32 recvd, count; 249 size_t hdrlen; 250 __be32 *p; 251 252 p = xdr_inline_decode(xdr, 4); 253 if (unlikely(p == NULL)) 254 goto out_overflow; 255 count = be32_to_cpup(p); 256 if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN)) 257 goto out_nametoolong; 258 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; 259 recvd = xdr->buf->len - hdrlen; 260 if (unlikely(count > recvd)) 261 goto out_cheating; 262 263 xdr_read_pages(xdr, count); 264 xdr_terminate_string(xdr->buf, count); 265 return 0; 266 267 out_nametoolong: 268 dprintk("NFS: returned pathname too long: %u\n", count); 269 return -ENAMETOOLONG; 270 out_cheating: 271 dprintk("NFS: server cheating in pathname result: " 272 "count %u > recvd %u\n", count, recvd); 273 return -EIO; 274 out_overflow: 275 print_overflow_msg(__func__, xdr); 276 return -EIO; 277 } 278 279 /* 280 * cookie3 281 * 282 * typedef uint64 cookie3 283 */ 284 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie) 285 { 286 return xdr_encode_hyper(p, cookie); 287 } 288 289 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie) 290 { 291 return decode_uint64(xdr, cookie); 292 } 293 294 /* 295 * cookieverf3 296 * 297 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE]; 298 */ 299 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier) 300 { 301 memcpy(p, verifier, NFS3_COOKIEVERFSIZE); 302 return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE); 303 } 304 305 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier) 306 { 307 __be32 *p; 308 309 p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE); 310 if (unlikely(p == NULL)) 311 goto out_overflow; 312 memcpy(verifier, p, NFS3_COOKIEVERFSIZE); 313 return 0; 314 out_overflow: 315 print_overflow_msg(__func__, xdr); 316 return -EIO; 317 } 318 319 /* 320 * createverf3 321 * 322 * typedef opaque createverf3[NFS3_CREATEVERFSIZE]; 323 */ 324 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier) 325 { 326 __be32 *p; 327 328 p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE); 329 memcpy(p, verifier, NFS3_CREATEVERFSIZE); 330 } 331 332 static int decode_writeverf3(struct xdr_stream *xdr, __be32 *verifier) 333 { 334 __be32 *p; 335 336 p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE); 337 if (unlikely(p == NULL)) 338 goto out_overflow; 339 memcpy(verifier, p, NFS3_WRITEVERFSIZE); 340 return 0; 341 out_overflow: 342 print_overflow_msg(__func__, xdr); 343 return -EIO; 344 } 345 346 /* 347 * size3 348 * 349 * typedef uint64 size3; 350 */ 351 static __be32 *xdr_decode_size3(__be32 *p, u64 *size) 352 { 353 return xdr_decode_hyper(p, size); 354 } 355 356 /* 357 * nfsstat3 358 * 359 * enum nfsstat3 { 360 * NFS3_OK = 0, 361 * ... 362 * } 363 */ 364 #define NFS3_OK NFS_OK 365 366 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status) 367 { 368 __be32 *p; 369 370 p = xdr_inline_decode(xdr, 4); 371 if (unlikely(p == NULL)) 372 goto out_overflow; 373 *status = be32_to_cpup(p); 374 return 0; 375 out_overflow: 376 print_overflow_msg(__func__, xdr); 377 return -EIO; 378 } 379 380 /* 381 * ftype3 382 * 383 * enum ftype3 { 384 * NF3REG = 1, 385 * NF3DIR = 2, 386 * NF3BLK = 3, 387 * NF3CHR = 4, 388 * NF3LNK = 5, 389 * NF3SOCK = 6, 390 * NF3FIFO = 7 391 * }; 392 */ 393 static void encode_ftype3(struct xdr_stream *xdr, const u32 type) 394 { 395 BUG_ON(type > NF3FIFO); 396 encode_uint32(xdr, type); 397 } 398 399 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode) 400 { 401 u32 type; 402 403 type = be32_to_cpup(p++); 404 if (type > NF3FIFO) 405 type = NF3NON; 406 *mode = nfs_type2fmt[type]; 407 return p; 408 } 409 410 /* 411 * specdata3 412 * 413 * struct specdata3 { 414 * uint32 specdata1; 415 * uint32 specdata2; 416 * }; 417 */ 418 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev) 419 { 420 __be32 *p; 421 422 p = xdr_reserve_space(xdr, 8); 423 *p++ = cpu_to_be32(MAJOR(rdev)); 424 *p = cpu_to_be32(MINOR(rdev)); 425 } 426 427 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev) 428 { 429 unsigned int major, minor; 430 431 major = be32_to_cpup(p++); 432 minor = be32_to_cpup(p++); 433 *rdev = MKDEV(major, minor); 434 if (MAJOR(*rdev) != major || MINOR(*rdev) != minor) 435 *rdev = 0; 436 return p; 437 } 438 439 /* 440 * nfs_fh3 441 * 442 * struct nfs_fh3 { 443 * opaque data<NFS3_FHSIZE>; 444 * }; 445 */ 446 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh) 447 { 448 __be32 *p; 449 450 BUG_ON(fh->size > NFS3_FHSIZE); 451 p = xdr_reserve_space(xdr, 4 + fh->size); 452 xdr_encode_opaque(p, fh->data, fh->size); 453 } 454 455 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh) 456 { 457 u32 length; 458 __be32 *p; 459 460 p = xdr_inline_decode(xdr, 4); 461 if (unlikely(p == NULL)) 462 goto out_overflow; 463 length = be32_to_cpup(p++); 464 if (unlikely(length > NFS3_FHSIZE)) 465 goto out_toobig; 466 p = xdr_inline_decode(xdr, length); 467 if (unlikely(p == NULL)) 468 goto out_overflow; 469 fh->size = length; 470 memcpy(fh->data, p, length); 471 return 0; 472 out_toobig: 473 dprintk("NFS: file handle size (%u) too big\n", length); 474 return -E2BIG; 475 out_overflow: 476 print_overflow_msg(__func__, xdr); 477 return -EIO; 478 } 479 480 static void zero_nfs_fh3(struct nfs_fh *fh) 481 { 482 memset(fh, 0, sizeof(*fh)); 483 } 484 485 /* 486 * nfstime3 487 * 488 * struct nfstime3 { 489 * uint32 seconds; 490 * uint32 nseconds; 491 * }; 492 */ 493 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec *timep) 494 { 495 *p++ = cpu_to_be32(timep->tv_sec); 496 *p++ = cpu_to_be32(timep->tv_nsec); 497 return p; 498 } 499 500 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec *timep) 501 { 502 timep->tv_sec = be32_to_cpup(p++); 503 timep->tv_nsec = be32_to_cpup(p++); 504 return p; 505 } 506 507 /* 508 * sattr3 509 * 510 * enum time_how { 511 * DONT_CHANGE = 0, 512 * SET_TO_SERVER_TIME = 1, 513 * SET_TO_CLIENT_TIME = 2 514 * }; 515 * 516 * union set_mode3 switch (bool set_it) { 517 * case TRUE: 518 * mode3 mode; 519 * default: 520 * void; 521 * }; 522 * 523 * union set_uid3 switch (bool set_it) { 524 * case TRUE: 525 * uid3 uid; 526 * default: 527 * void; 528 * }; 529 * 530 * union set_gid3 switch (bool set_it) { 531 * case TRUE: 532 * gid3 gid; 533 * default: 534 * void; 535 * }; 536 * 537 * union set_size3 switch (bool set_it) { 538 * case TRUE: 539 * size3 size; 540 * default: 541 * void; 542 * }; 543 * 544 * union set_atime switch (time_how set_it) { 545 * case SET_TO_CLIENT_TIME: 546 * nfstime3 atime; 547 * default: 548 * void; 549 * }; 550 * 551 * union set_mtime switch (time_how set_it) { 552 * case SET_TO_CLIENT_TIME: 553 * nfstime3 mtime; 554 * default: 555 * void; 556 * }; 557 * 558 * struct sattr3 { 559 * set_mode3 mode; 560 * set_uid3 uid; 561 * set_gid3 gid; 562 * set_size3 size; 563 * set_atime atime; 564 * set_mtime mtime; 565 * }; 566 */ 567 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr) 568 { 569 u32 nbytes; 570 __be32 *p; 571 572 /* 573 * In order to make only a single xdr_reserve_space() call, 574 * pre-compute the total number of bytes to be reserved. 575 * Six boolean values, one for each set_foo field, are always 576 * present in the encoded result, so start there. 577 */ 578 nbytes = 6 * 4; 579 if (attr->ia_valid & ATTR_MODE) 580 nbytes += 4; 581 if (attr->ia_valid & ATTR_UID) 582 nbytes += 4; 583 if (attr->ia_valid & ATTR_GID) 584 nbytes += 4; 585 if (attr->ia_valid & ATTR_SIZE) 586 nbytes += 8; 587 if (attr->ia_valid & ATTR_ATIME_SET) 588 nbytes += 8; 589 if (attr->ia_valid & ATTR_MTIME_SET) 590 nbytes += 8; 591 p = xdr_reserve_space(xdr, nbytes); 592 593 if (attr->ia_valid & ATTR_MODE) { 594 *p++ = xdr_one; 595 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO); 596 } else 597 *p++ = xdr_zero; 598 599 if (attr->ia_valid & ATTR_UID) { 600 *p++ = xdr_one; 601 *p++ = cpu_to_be32(attr->ia_uid); 602 } else 603 *p++ = xdr_zero; 604 605 if (attr->ia_valid & ATTR_GID) { 606 *p++ = xdr_one; 607 *p++ = cpu_to_be32(attr->ia_gid); 608 } else 609 *p++ = xdr_zero; 610 611 if (attr->ia_valid & ATTR_SIZE) { 612 *p++ = xdr_one; 613 p = xdr_encode_hyper(p, (u64)attr->ia_size); 614 } else 615 *p++ = xdr_zero; 616 617 if (attr->ia_valid & ATTR_ATIME_SET) { 618 *p++ = xdr_two; 619 p = xdr_encode_nfstime3(p, &attr->ia_atime); 620 } else if (attr->ia_valid & ATTR_ATIME) { 621 *p++ = xdr_one; 622 } else 623 *p++ = xdr_zero; 624 625 if (attr->ia_valid & ATTR_MTIME_SET) { 626 *p++ = xdr_two; 627 xdr_encode_nfstime3(p, &attr->ia_mtime); 628 } else if (attr->ia_valid & ATTR_MTIME) { 629 *p = xdr_one; 630 } else 631 *p = xdr_zero; 632 } 633 634 /* 635 * fattr3 636 * 637 * struct fattr3 { 638 * ftype3 type; 639 * mode3 mode; 640 * uint32 nlink; 641 * uid3 uid; 642 * gid3 gid; 643 * size3 size; 644 * size3 used; 645 * specdata3 rdev; 646 * uint64 fsid; 647 * fileid3 fileid; 648 * nfstime3 atime; 649 * nfstime3 mtime; 650 * nfstime3 ctime; 651 * }; 652 */ 653 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr) 654 { 655 umode_t fmode; 656 __be32 *p; 657 658 p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2); 659 if (unlikely(p == NULL)) 660 goto out_overflow; 661 662 p = xdr_decode_ftype3(p, &fmode); 663 664 fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode; 665 fattr->nlink = be32_to_cpup(p++); 666 fattr->uid = be32_to_cpup(p++); 667 fattr->gid = be32_to_cpup(p++); 668 669 p = xdr_decode_size3(p, &fattr->size); 670 p = xdr_decode_size3(p, &fattr->du.nfs3.used); 671 p = xdr_decode_specdata3(p, &fattr->rdev); 672 673 p = xdr_decode_hyper(p, &fattr->fsid.major); 674 fattr->fsid.minor = 0; 675 676 p = xdr_decode_fileid3(p, &fattr->fileid); 677 p = xdr_decode_nfstime3(p, &fattr->atime); 678 p = xdr_decode_nfstime3(p, &fattr->mtime); 679 xdr_decode_nfstime3(p, &fattr->ctime); 680 fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime); 681 682 fattr->valid |= NFS_ATTR_FATTR_V3; 683 return 0; 684 out_overflow: 685 print_overflow_msg(__func__, xdr); 686 return -EIO; 687 } 688 689 /* 690 * post_op_attr 691 * 692 * union post_op_attr switch (bool attributes_follow) { 693 * case TRUE: 694 * fattr3 attributes; 695 * case FALSE: 696 * void; 697 * }; 698 */ 699 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr) 700 { 701 __be32 *p; 702 703 p = xdr_inline_decode(xdr, 4); 704 if (unlikely(p == NULL)) 705 goto out_overflow; 706 if (*p != xdr_zero) 707 return decode_fattr3(xdr, fattr); 708 return 0; 709 out_overflow: 710 print_overflow_msg(__func__, xdr); 711 return -EIO; 712 } 713 714 /* 715 * wcc_attr 716 * struct wcc_attr { 717 * size3 size; 718 * nfstime3 mtime; 719 * nfstime3 ctime; 720 * }; 721 */ 722 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr) 723 { 724 __be32 *p; 725 726 p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2); 727 if (unlikely(p == NULL)) 728 goto out_overflow; 729 730 fattr->valid |= NFS_ATTR_FATTR_PRESIZE 731 | NFS_ATTR_FATTR_PRECHANGE 732 | NFS_ATTR_FATTR_PREMTIME 733 | NFS_ATTR_FATTR_PRECTIME; 734 735 p = xdr_decode_size3(p, &fattr->pre_size); 736 p = xdr_decode_nfstime3(p, &fattr->pre_mtime); 737 xdr_decode_nfstime3(p, &fattr->pre_ctime); 738 fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime); 739 740 return 0; 741 out_overflow: 742 print_overflow_msg(__func__, xdr); 743 return -EIO; 744 } 745 746 /* 747 * pre_op_attr 748 * union pre_op_attr switch (bool attributes_follow) { 749 * case TRUE: 750 * wcc_attr attributes; 751 * case FALSE: 752 * void; 753 * }; 754 * 755 * wcc_data 756 * 757 * struct wcc_data { 758 * pre_op_attr before; 759 * post_op_attr after; 760 * }; 761 */ 762 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr) 763 { 764 __be32 *p; 765 766 p = xdr_inline_decode(xdr, 4); 767 if (unlikely(p == NULL)) 768 goto out_overflow; 769 if (*p != xdr_zero) 770 return decode_wcc_attr(xdr, fattr); 771 return 0; 772 out_overflow: 773 print_overflow_msg(__func__, xdr); 774 return -EIO; 775 } 776 777 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr) 778 { 779 int error; 780 781 error = decode_pre_op_attr(xdr, fattr); 782 if (unlikely(error)) 783 goto out; 784 error = decode_post_op_attr(xdr, fattr); 785 out: 786 return error; 787 } 788 789 /* 790 * post_op_fh3 791 * 792 * union post_op_fh3 switch (bool handle_follows) { 793 * case TRUE: 794 * nfs_fh3 handle; 795 * case FALSE: 796 * void; 797 * }; 798 */ 799 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh) 800 { 801 __be32 *p = xdr_inline_decode(xdr, 4); 802 if (unlikely(p == NULL)) 803 goto out_overflow; 804 if (*p != xdr_zero) 805 return decode_nfs_fh3(xdr, fh); 806 zero_nfs_fh3(fh); 807 return 0; 808 out_overflow: 809 print_overflow_msg(__func__, xdr); 810 return -EIO; 811 } 812 813 /* 814 * diropargs3 815 * 816 * struct diropargs3 { 817 * nfs_fh3 dir; 818 * filename3 name; 819 * }; 820 */ 821 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh, 822 const char *name, u32 length) 823 { 824 encode_nfs_fh3(xdr, fh); 825 encode_filename3(xdr, name, length); 826 } 827 828 829 /* 830 * NFSv3 XDR encode functions 831 * 832 * NFSv3 argument types are defined in section 3.3 of RFC 1813: 833 * "NFS Version 3 Protocol Specification". 834 */ 835 836 /* 837 * 3.3.1 GETATTR3args 838 * 839 * struct GETATTR3args { 840 * nfs_fh3 object; 841 * }; 842 */ 843 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req, 844 struct xdr_stream *xdr, 845 const struct nfs_fh *fh) 846 { 847 encode_nfs_fh3(xdr, fh); 848 } 849 850 /* 851 * 3.3.2 SETATTR3args 852 * 853 * union sattrguard3 switch (bool check) { 854 * case TRUE: 855 * nfstime3 obj_ctime; 856 * case FALSE: 857 * void; 858 * }; 859 * 860 * struct SETATTR3args { 861 * nfs_fh3 object; 862 * sattr3 new_attributes; 863 * sattrguard3 guard; 864 * }; 865 */ 866 static void encode_sattrguard3(struct xdr_stream *xdr, 867 const struct nfs3_sattrargs *args) 868 { 869 __be32 *p; 870 871 if (args->guard) { 872 p = xdr_reserve_space(xdr, 4 + 8); 873 *p++ = xdr_one; 874 xdr_encode_nfstime3(p, &args->guardtime); 875 } else { 876 p = xdr_reserve_space(xdr, 4); 877 *p = xdr_zero; 878 } 879 } 880 881 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req, 882 struct xdr_stream *xdr, 883 const struct nfs3_sattrargs *args) 884 { 885 encode_nfs_fh3(xdr, args->fh); 886 encode_sattr3(xdr, args->sattr); 887 encode_sattrguard3(xdr, args); 888 } 889 890 /* 891 * 3.3.3 LOOKUP3args 892 * 893 * struct LOOKUP3args { 894 * diropargs3 what; 895 * }; 896 */ 897 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req, 898 struct xdr_stream *xdr, 899 const struct nfs3_diropargs *args) 900 { 901 encode_diropargs3(xdr, args->fh, args->name, args->len); 902 } 903 904 /* 905 * 3.3.4 ACCESS3args 906 * 907 * struct ACCESS3args { 908 * nfs_fh3 object; 909 * uint32 access; 910 * }; 911 */ 912 static void encode_access3args(struct xdr_stream *xdr, 913 const struct nfs3_accessargs *args) 914 { 915 encode_nfs_fh3(xdr, args->fh); 916 encode_uint32(xdr, args->access); 917 } 918 919 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req, 920 struct xdr_stream *xdr, 921 const struct nfs3_accessargs *args) 922 { 923 encode_access3args(xdr, args); 924 } 925 926 /* 927 * 3.3.5 READLINK3args 928 * 929 * struct READLINK3args { 930 * nfs_fh3 symlink; 931 * }; 932 */ 933 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req, 934 struct xdr_stream *xdr, 935 const struct nfs3_readlinkargs *args) 936 { 937 encode_nfs_fh3(xdr, args->fh); 938 prepare_reply_buffer(req, args->pages, args->pgbase, 939 args->pglen, NFS3_readlinkres_sz); 940 } 941 942 /* 943 * 3.3.6 READ3args 944 * 945 * struct READ3args { 946 * nfs_fh3 file; 947 * offset3 offset; 948 * count3 count; 949 * }; 950 */ 951 static void encode_read3args(struct xdr_stream *xdr, 952 const struct nfs_readargs *args) 953 { 954 __be32 *p; 955 956 encode_nfs_fh3(xdr, args->fh); 957 958 p = xdr_reserve_space(xdr, 8 + 4); 959 p = xdr_encode_hyper(p, args->offset); 960 *p = cpu_to_be32(args->count); 961 } 962 963 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req, 964 struct xdr_stream *xdr, 965 const struct nfs_readargs *args) 966 { 967 encode_read3args(xdr, args); 968 prepare_reply_buffer(req, args->pages, args->pgbase, 969 args->count, NFS3_readres_sz); 970 req->rq_rcv_buf.flags |= XDRBUF_READ; 971 } 972 973 /* 974 * 3.3.7 WRITE3args 975 * 976 * enum stable_how { 977 * UNSTABLE = 0, 978 * DATA_SYNC = 1, 979 * FILE_SYNC = 2 980 * }; 981 * 982 * struct WRITE3args { 983 * nfs_fh3 file; 984 * offset3 offset; 985 * count3 count; 986 * stable_how stable; 987 * opaque data<>; 988 * }; 989 */ 990 static void encode_write3args(struct xdr_stream *xdr, 991 const struct nfs_writeargs *args) 992 { 993 __be32 *p; 994 995 encode_nfs_fh3(xdr, args->fh); 996 997 p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4); 998 p = xdr_encode_hyper(p, args->offset); 999 *p++ = cpu_to_be32(args->count); 1000 *p++ = cpu_to_be32(args->stable); 1001 *p = cpu_to_be32(args->count); 1002 xdr_write_pages(xdr, args->pages, args->pgbase, args->count); 1003 } 1004 1005 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req, 1006 struct xdr_stream *xdr, 1007 const struct nfs_writeargs *args) 1008 { 1009 encode_write3args(xdr, args); 1010 xdr->buf->flags |= XDRBUF_WRITE; 1011 } 1012 1013 /* 1014 * 3.3.8 CREATE3args 1015 * 1016 * enum createmode3 { 1017 * UNCHECKED = 0, 1018 * GUARDED = 1, 1019 * EXCLUSIVE = 2 1020 * }; 1021 * 1022 * union createhow3 switch (createmode3 mode) { 1023 * case UNCHECKED: 1024 * case GUARDED: 1025 * sattr3 obj_attributes; 1026 * case EXCLUSIVE: 1027 * createverf3 verf; 1028 * }; 1029 * 1030 * struct CREATE3args { 1031 * diropargs3 where; 1032 * createhow3 how; 1033 * }; 1034 */ 1035 static void encode_createhow3(struct xdr_stream *xdr, 1036 const struct nfs3_createargs *args) 1037 { 1038 encode_uint32(xdr, args->createmode); 1039 switch (args->createmode) { 1040 case NFS3_CREATE_UNCHECKED: 1041 case NFS3_CREATE_GUARDED: 1042 encode_sattr3(xdr, args->sattr); 1043 break; 1044 case NFS3_CREATE_EXCLUSIVE: 1045 encode_createverf3(xdr, args->verifier); 1046 break; 1047 default: 1048 BUG(); 1049 } 1050 } 1051 1052 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req, 1053 struct xdr_stream *xdr, 1054 const struct nfs3_createargs *args) 1055 { 1056 encode_diropargs3(xdr, args->fh, args->name, args->len); 1057 encode_createhow3(xdr, args); 1058 } 1059 1060 /* 1061 * 3.3.9 MKDIR3args 1062 * 1063 * struct MKDIR3args { 1064 * diropargs3 where; 1065 * sattr3 attributes; 1066 * }; 1067 */ 1068 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req, 1069 struct xdr_stream *xdr, 1070 const struct nfs3_mkdirargs *args) 1071 { 1072 encode_diropargs3(xdr, args->fh, args->name, args->len); 1073 encode_sattr3(xdr, args->sattr); 1074 } 1075 1076 /* 1077 * 3.3.10 SYMLINK3args 1078 * 1079 * struct symlinkdata3 { 1080 * sattr3 symlink_attributes; 1081 * nfspath3 symlink_data; 1082 * }; 1083 * 1084 * struct SYMLINK3args { 1085 * diropargs3 where; 1086 * symlinkdata3 symlink; 1087 * }; 1088 */ 1089 static void encode_symlinkdata3(struct xdr_stream *xdr, 1090 const struct nfs3_symlinkargs *args) 1091 { 1092 encode_sattr3(xdr, args->sattr); 1093 encode_nfspath3(xdr, args->pages, args->pathlen); 1094 } 1095 1096 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req, 1097 struct xdr_stream *xdr, 1098 const struct nfs3_symlinkargs *args) 1099 { 1100 encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen); 1101 encode_symlinkdata3(xdr, args); 1102 } 1103 1104 /* 1105 * 3.3.11 MKNOD3args 1106 * 1107 * struct devicedata3 { 1108 * sattr3 dev_attributes; 1109 * specdata3 spec; 1110 * }; 1111 * 1112 * union mknoddata3 switch (ftype3 type) { 1113 * case NF3CHR: 1114 * case NF3BLK: 1115 * devicedata3 device; 1116 * case NF3SOCK: 1117 * case NF3FIFO: 1118 * sattr3 pipe_attributes; 1119 * default: 1120 * void; 1121 * }; 1122 * 1123 * struct MKNOD3args { 1124 * diropargs3 where; 1125 * mknoddata3 what; 1126 * }; 1127 */ 1128 static void encode_devicedata3(struct xdr_stream *xdr, 1129 const struct nfs3_mknodargs *args) 1130 { 1131 encode_sattr3(xdr, args->sattr); 1132 encode_specdata3(xdr, args->rdev); 1133 } 1134 1135 static void encode_mknoddata3(struct xdr_stream *xdr, 1136 const struct nfs3_mknodargs *args) 1137 { 1138 encode_ftype3(xdr, args->type); 1139 switch (args->type) { 1140 case NF3CHR: 1141 case NF3BLK: 1142 encode_devicedata3(xdr, args); 1143 break; 1144 case NF3SOCK: 1145 case NF3FIFO: 1146 encode_sattr3(xdr, args->sattr); 1147 break; 1148 case NF3REG: 1149 case NF3DIR: 1150 break; 1151 default: 1152 BUG(); 1153 } 1154 } 1155 1156 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req, 1157 struct xdr_stream *xdr, 1158 const struct nfs3_mknodargs *args) 1159 { 1160 encode_diropargs3(xdr, args->fh, args->name, args->len); 1161 encode_mknoddata3(xdr, args); 1162 } 1163 1164 /* 1165 * 3.3.12 REMOVE3args 1166 * 1167 * struct REMOVE3args { 1168 * diropargs3 object; 1169 * }; 1170 */ 1171 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req, 1172 struct xdr_stream *xdr, 1173 const struct nfs_removeargs *args) 1174 { 1175 encode_diropargs3(xdr, args->fh, args->name.name, args->name.len); 1176 } 1177 1178 /* 1179 * 3.3.14 RENAME3args 1180 * 1181 * struct RENAME3args { 1182 * diropargs3 from; 1183 * diropargs3 to; 1184 * }; 1185 */ 1186 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req, 1187 struct xdr_stream *xdr, 1188 const struct nfs_renameargs *args) 1189 { 1190 const struct qstr *old = args->old_name; 1191 const struct qstr *new = args->new_name; 1192 1193 encode_diropargs3(xdr, args->old_dir, old->name, old->len); 1194 encode_diropargs3(xdr, args->new_dir, new->name, new->len); 1195 } 1196 1197 /* 1198 * 3.3.15 LINK3args 1199 * 1200 * struct LINK3args { 1201 * nfs_fh3 file; 1202 * diropargs3 link; 1203 * }; 1204 */ 1205 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req, 1206 struct xdr_stream *xdr, 1207 const struct nfs3_linkargs *args) 1208 { 1209 encode_nfs_fh3(xdr, args->fromfh); 1210 encode_diropargs3(xdr, args->tofh, args->toname, args->tolen); 1211 } 1212 1213 /* 1214 * 3.3.16 READDIR3args 1215 * 1216 * struct READDIR3args { 1217 * nfs_fh3 dir; 1218 * cookie3 cookie; 1219 * cookieverf3 cookieverf; 1220 * count3 count; 1221 * }; 1222 */ 1223 static void encode_readdir3args(struct xdr_stream *xdr, 1224 const struct nfs3_readdirargs *args) 1225 { 1226 __be32 *p; 1227 1228 encode_nfs_fh3(xdr, args->fh); 1229 1230 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4); 1231 p = xdr_encode_cookie3(p, args->cookie); 1232 p = xdr_encode_cookieverf3(p, args->verf); 1233 *p = cpu_to_be32(args->count); 1234 } 1235 1236 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req, 1237 struct xdr_stream *xdr, 1238 const struct nfs3_readdirargs *args) 1239 { 1240 encode_readdir3args(xdr, args); 1241 prepare_reply_buffer(req, args->pages, 0, 1242 args->count, NFS3_readdirres_sz); 1243 } 1244 1245 /* 1246 * 3.3.17 READDIRPLUS3args 1247 * 1248 * struct READDIRPLUS3args { 1249 * nfs_fh3 dir; 1250 * cookie3 cookie; 1251 * cookieverf3 cookieverf; 1252 * count3 dircount; 1253 * count3 maxcount; 1254 * }; 1255 */ 1256 static void encode_readdirplus3args(struct xdr_stream *xdr, 1257 const struct nfs3_readdirargs *args) 1258 { 1259 __be32 *p; 1260 1261 encode_nfs_fh3(xdr, args->fh); 1262 1263 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4); 1264 p = xdr_encode_cookie3(p, args->cookie); 1265 p = xdr_encode_cookieverf3(p, args->verf); 1266 1267 /* 1268 * readdirplus: need dircount + buffer size. 1269 * We just make sure we make dircount big enough 1270 */ 1271 *p++ = cpu_to_be32(args->count >> 3); 1272 1273 *p = cpu_to_be32(args->count); 1274 } 1275 1276 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req, 1277 struct xdr_stream *xdr, 1278 const struct nfs3_readdirargs *args) 1279 { 1280 encode_readdirplus3args(xdr, args); 1281 prepare_reply_buffer(req, args->pages, 0, 1282 args->count, NFS3_readdirres_sz); 1283 } 1284 1285 /* 1286 * 3.3.21 COMMIT3args 1287 * 1288 * struct COMMIT3args { 1289 * nfs_fh3 file; 1290 * offset3 offset; 1291 * count3 count; 1292 * }; 1293 */ 1294 static void encode_commit3args(struct xdr_stream *xdr, 1295 const struct nfs_commitargs *args) 1296 { 1297 __be32 *p; 1298 1299 encode_nfs_fh3(xdr, args->fh); 1300 1301 p = xdr_reserve_space(xdr, 8 + 4); 1302 p = xdr_encode_hyper(p, args->offset); 1303 *p = cpu_to_be32(args->count); 1304 } 1305 1306 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req, 1307 struct xdr_stream *xdr, 1308 const struct nfs_commitargs *args) 1309 { 1310 encode_commit3args(xdr, args); 1311 } 1312 1313 #ifdef CONFIG_NFS_V3_ACL 1314 1315 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req, 1316 struct xdr_stream *xdr, 1317 const struct nfs3_getaclargs *args) 1318 { 1319 encode_nfs_fh3(xdr, args->fh); 1320 encode_uint32(xdr, args->mask); 1321 if (args->mask & (NFS_ACL | NFS_DFACL)) 1322 prepare_reply_buffer(req, args->pages, 0, 1323 NFSACL_MAXPAGES << PAGE_SHIFT, 1324 ACL3_getaclres_sz); 1325 } 1326 1327 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req, 1328 struct xdr_stream *xdr, 1329 const struct nfs3_setaclargs *args) 1330 { 1331 unsigned int base; 1332 int error; 1333 1334 encode_nfs_fh3(xdr, NFS_FH(args->inode)); 1335 encode_uint32(xdr, args->mask); 1336 1337 base = req->rq_slen; 1338 if (args->npages != 0) 1339 xdr_write_pages(xdr, args->pages, 0, args->len); 1340 else 1341 xdr_reserve_space(xdr, NFS_ACL_INLINE_BUFSIZE); 1342 1343 error = nfsacl_encode(xdr->buf, base, args->inode, 1344 (args->mask & NFS_ACL) ? 1345 args->acl_access : NULL, 1, 0); 1346 BUG_ON(error < 0); 1347 error = nfsacl_encode(xdr->buf, base + error, args->inode, 1348 (args->mask & NFS_DFACL) ? 1349 args->acl_default : NULL, 1, 1350 NFS_ACL_DEFAULT); 1351 BUG_ON(error < 0); 1352 } 1353 1354 #endif /* CONFIG_NFS_V3_ACL */ 1355 1356 /* 1357 * NFSv3 XDR decode functions 1358 * 1359 * NFSv3 result types are defined in section 3.3 of RFC 1813: 1360 * "NFS Version 3 Protocol Specification". 1361 */ 1362 1363 /* 1364 * 3.3.1 GETATTR3res 1365 * 1366 * struct GETATTR3resok { 1367 * fattr3 obj_attributes; 1368 * }; 1369 * 1370 * union GETATTR3res switch (nfsstat3 status) { 1371 * case NFS3_OK: 1372 * GETATTR3resok resok; 1373 * default: 1374 * void; 1375 * }; 1376 */ 1377 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req, 1378 struct xdr_stream *xdr, 1379 struct nfs_fattr *result) 1380 { 1381 enum nfs_stat status; 1382 int error; 1383 1384 error = decode_nfsstat3(xdr, &status); 1385 if (unlikely(error)) 1386 goto out; 1387 if (status != NFS3_OK) 1388 goto out_default; 1389 error = decode_fattr3(xdr, result); 1390 out: 1391 return error; 1392 out_default: 1393 return nfs3_stat_to_errno(status); 1394 } 1395 1396 /* 1397 * 3.3.2 SETATTR3res 1398 * 1399 * struct SETATTR3resok { 1400 * wcc_data obj_wcc; 1401 * }; 1402 * 1403 * struct SETATTR3resfail { 1404 * wcc_data obj_wcc; 1405 * }; 1406 * 1407 * union SETATTR3res switch (nfsstat3 status) { 1408 * case NFS3_OK: 1409 * SETATTR3resok resok; 1410 * default: 1411 * SETATTR3resfail resfail; 1412 * }; 1413 */ 1414 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req, 1415 struct xdr_stream *xdr, 1416 struct nfs_fattr *result) 1417 { 1418 enum nfs_stat status; 1419 int error; 1420 1421 error = decode_nfsstat3(xdr, &status); 1422 if (unlikely(error)) 1423 goto out; 1424 error = decode_wcc_data(xdr, result); 1425 if (unlikely(error)) 1426 goto out; 1427 if (status != NFS3_OK) 1428 goto out_status; 1429 out: 1430 return error; 1431 out_status: 1432 return nfs3_stat_to_errno(status); 1433 } 1434 1435 /* 1436 * 3.3.3 LOOKUP3res 1437 * 1438 * struct LOOKUP3resok { 1439 * nfs_fh3 object; 1440 * post_op_attr obj_attributes; 1441 * post_op_attr dir_attributes; 1442 * }; 1443 * 1444 * struct LOOKUP3resfail { 1445 * post_op_attr dir_attributes; 1446 * }; 1447 * 1448 * union LOOKUP3res switch (nfsstat3 status) { 1449 * case NFS3_OK: 1450 * LOOKUP3resok resok; 1451 * default: 1452 * LOOKUP3resfail resfail; 1453 * }; 1454 */ 1455 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req, 1456 struct xdr_stream *xdr, 1457 struct nfs3_diropres *result) 1458 { 1459 enum nfs_stat status; 1460 int error; 1461 1462 error = decode_nfsstat3(xdr, &status); 1463 if (unlikely(error)) 1464 goto out; 1465 if (status != NFS3_OK) 1466 goto out_default; 1467 error = decode_nfs_fh3(xdr, result->fh); 1468 if (unlikely(error)) 1469 goto out; 1470 error = decode_post_op_attr(xdr, result->fattr); 1471 if (unlikely(error)) 1472 goto out; 1473 error = decode_post_op_attr(xdr, result->dir_attr); 1474 out: 1475 return error; 1476 out_default: 1477 error = decode_post_op_attr(xdr, result->dir_attr); 1478 if (unlikely(error)) 1479 goto out; 1480 return nfs3_stat_to_errno(status); 1481 } 1482 1483 /* 1484 * 3.3.4 ACCESS3res 1485 * 1486 * struct ACCESS3resok { 1487 * post_op_attr obj_attributes; 1488 * uint32 access; 1489 * }; 1490 * 1491 * struct ACCESS3resfail { 1492 * post_op_attr obj_attributes; 1493 * }; 1494 * 1495 * union ACCESS3res switch (nfsstat3 status) { 1496 * case NFS3_OK: 1497 * ACCESS3resok resok; 1498 * default: 1499 * ACCESS3resfail resfail; 1500 * }; 1501 */ 1502 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req, 1503 struct xdr_stream *xdr, 1504 struct nfs3_accessres *result) 1505 { 1506 enum nfs_stat status; 1507 int error; 1508 1509 error = decode_nfsstat3(xdr, &status); 1510 if (unlikely(error)) 1511 goto out; 1512 error = decode_post_op_attr(xdr, result->fattr); 1513 if (unlikely(error)) 1514 goto out; 1515 if (status != NFS3_OK) 1516 goto out_default; 1517 error = decode_uint32(xdr, &result->access); 1518 out: 1519 return error; 1520 out_default: 1521 return nfs3_stat_to_errno(status); 1522 } 1523 1524 /* 1525 * 3.3.5 READLINK3res 1526 * 1527 * struct READLINK3resok { 1528 * post_op_attr symlink_attributes; 1529 * nfspath3 data; 1530 * }; 1531 * 1532 * struct READLINK3resfail { 1533 * post_op_attr symlink_attributes; 1534 * }; 1535 * 1536 * union READLINK3res switch (nfsstat3 status) { 1537 * case NFS3_OK: 1538 * READLINK3resok resok; 1539 * default: 1540 * READLINK3resfail resfail; 1541 * }; 1542 */ 1543 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req, 1544 struct xdr_stream *xdr, 1545 struct nfs_fattr *result) 1546 { 1547 enum nfs_stat status; 1548 int error; 1549 1550 error = decode_nfsstat3(xdr, &status); 1551 if (unlikely(error)) 1552 goto out; 1553 error = decode_post_op_attr(xdr, result); 1554 if (unlikely(error)) 1555 goto out; 1556 if (status != NFS3_OK) 1557 goto out_default; 1558 error = decode_nfspath3(xdr); 1559 out: 1560 return error; 1561 out_default: 1562 return nfs3_stat_to_errno(status); 1563 } 1564 1565 /* 1566 * 3.3.6 READ3res 1567 * 1568 * struct READ3resok { 1569 * post_op_attr file_attributes; 1570 * count3 count; 1571 * bool eof; 1572 * opaque data<>; 1573 * }; 1574 * 1575 * struct READ3resfail { 1576 * post_op_attr file_attributes; 1577 * }; 1578 * 1579 * union READ3res switch (nfsstat3 status) { 1580 * case NFS3_OK: 1581 * READ3resok resok; 1582 * default: 1583 * READ3resfail resfail; 1584 * }; 1585 */ 1586 static int decode_read3resok(struct xdr_stream *xdr, 1587 struct nfs_readres *result) 1588 { 1589 u32 eof, count, ocount, recvd; 1590 size_t hdrlen; 1591 __be32 *p; 1592 1593 p = xdr_inline_decode(xdr, 4 + 4 + 4); 1594 if (unlikely(p == NULL)) 1595 goto out_overflow; 1596 count = be32_to_cpup(p++); 1597 eof = be32_to_cpup(p++); 1598 ocount = be32_to_cpup(p++); 1599 if (unlikely(ocount != count)) 1600 goto out_mismatch; 1601 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; 1602 recvd = xdr->buf->len - hdrlen; 1603 if (unlikely(count > recvd)) 1604 goto out_cheating; 1605 1606 out: 1607 xdr_read_pages(xdr, count); 1608 result->eof = eof; 1609 result->count = count; 1610 return count; 1611 out_mismatch: 1612 dprintk("NFS: READ count doesn't match length of opaque: " 1613 "count %u != ocount %u\n", count, ocount); 1614 return -EIO; 1615 out_cheating: 1616 dprintk("NFS: server cheating in read result: " 1617 "count %u > recvd %u\n", count, recvd); 1618 count = recvd; 1619 eof = 0; 1620 goto out; 1621 out_overflow: 1622 print_overflow_msg(__func__, xdr); 1623 return -EIO; 1624 } 1625 1626 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr, 1627 struct nfs_readres *result) 1628 { 1629 enum nfs_stat status; 1630 int error; 1631 1632 error = decode_nfsstat3(xdr, &status); 1633 if (unlikely(error)) 1634 goto out; 1635 error = decode_post_op_attr(xdr, result->fattr); 1636 if (unlikely(error)) 1637 goto out; 1638 if (status != NFS3_OK) 1639 goto out_status; 1640 error = decode_read3resok(xdr, result); 1641 out: 1642 return error; 1643 out_status: 1644 return nfs3_stat_to_errno(status); 1645 } 1646 1647 /* 1648 * 3.3.7 WRITE3res 1649 * 1650 * enum stable_how { 1651 * UNSTABLE = 0, 1652 * DATA_SYNC = 1, 1653 * FILE_SYNC = 2 1654 * }; 1655 * 1656 * struct WRITE3resok { 1657 * wcc_data file_wcc; 1658 * count3 count; 1659 * stable_how committed; 1660 * writeverf3 verf; 1661 * }; 1662 * 1663 * struct WRITE3resfail { 1664 * wcc_data file_wcc; 1665 * }; 1666 * 1667 * union WRITE3res switch (nfsstat3 status) { 1668 * case NFS3_OK: 1669 * WRITE3resok resok; 1670 * default: 1671 * WRITE3resfail resfail; 1672 * }; 1673 */ 1674 static int decode_write3resok(struct xdr_stream *xdr, 1675 struct nfs_writeres *result) 1676 { 1677 __be32 *p; 1678 1679 p = xdr_inline_decode(xdr, 4 + 4 + NFS3_WRITEVERFSIZE); 1680 if (unlikely(p == NULL)) 1681 goto out_overflow; 1682 result->count = be32_to_cpup(p++); 1683 result->verf->committed = be32_to_cpup(p++); 1684 if (unlikely(result->verf->committed > NFS_FILE_SYNC)) 1685 goto out_badvalue; 1686 memcpy(result->verf->verifier, p, NFS3_WRITEVERFSIZE); 1687 return result->count; 1688 out_badvalue: 1689 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed); 1690 return -EIO; 1691 out_overflow: 1692 print_overflow_msg(__func__, xdr); 1693 return -EIO; 1694 } 1695 1696 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr, 1697 struct nfs_writeres *result) 1698 { 1699 enum nfs_stat status; 1700 int error; 1701 1702 error = decode_nfsstat3(xdr, &status); 1703 if (unlikely(error)) 1704 goto out; 1705 error = decode_wcc_data(xdr, result->fattr); 1706 if (unlikely(error)) 1707 goto out; 1708 if (status != NFS3_OK) 1709 goto out_status; 1710 error = decode_write3resok(xdr, result); 1711 out: 1712 return error; 1713 out_status: 1714 return nfs3_stat_to_errno(status); 1715 } 1716 1717 /* 1718 * 3.3.8 CREATE3res 1719 * 1720 * struct CREATE3resok { 1721 * post_op_fh3 obj; 1722 * post_op_attr obj_attributes; 1723 * wcc_data dir_wcc; 1724 * }; 1725 * 1726 * struct CREATE3resfail { 1727 * wcc_data dir_wcc; 1728 * }; 1729 * 1730 * union CREATE3res switch (nfsstat3 status) { 1731 * case NFS3_OK: 1732 * CREATE3resok resok; 1733 * default: 1734 * CREATE3resfail resfail; 1735 * }; 1736 */ 1737 static int decode_create3resok(struct xdr_stream *xdr, 1738 struct nfs3_diropres *result) 1739 { 1740 int error; 1741 1742 error = decode_post_op_fh3(xdr, result->fh); 1743 if (unlikely(error)) 1744 goto out; 1745 error = decode_post_op_attr(xdr, result->fattr); 1746 if (unlikely(error)) 1747 goto out; 1748 /* The server isn't required to return a file handle. 1749 * If it didn't, force the client to perform a LOOKUP 1750 * to determine the correct file handle and attribute 1751 * values for the new object. */ 1752 if (result->fh->size == 0) 1753 result->fattr->valid = 0; 1754 error = decode_wcc_data(xdr, result->dir_attr); 1755 out: 1756 return error; 1757 } 1758 1759 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req, 1760 struct xdr_stream *xdr, 1761 struct nfs3_diropres *result) 1762 { 1763 enum nfs_stat status; 1764 int error; 1765 1766 error = decode_nfsstat3(xdr, &status); 1767 if (unlikely(error)) 1768 goto out; 1769 if (status != NFS3_OK) 1770 goto out_default; 1771 error = decode_create3resok(xdr, result); 1772 out: 1773 return error; 1774 out_default: 1775 error = decode_wcc_data(xdr, result->dir_attr); 1776 if (unlikely(error)) 1777 goto out; 1778 return nfs3_stat_to_errno(status); 1779 } 1780 1781 /* 1782 * 3.3.12 REMOVE3res 1783 * 1784 * struct REMOVE3resok { 1785 * wcc_data dir_wcc; 1786 * }; 1787 * 1788 * struct REMOVE3resfail { 1789 * wcc_data dir_wcc; 1790 * }; 1791 * 1792 * union REMOVE3res switch (nfsstat3 status) { 1793 * case NFS3_OK: 1794 * REMOVE3resok resok; 1795 * default: 1796 * REMOVE3resfail resfail; 1797 * }; 1798 */ 1799 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req, 1800 struct xdr_stream *xdr, 1801 struct nfs_removeres *result) 1802 { 1803 enum nfs_stat status; 1804 int error; 1805 1806 error = decode_nfsstat3(xdr, &status); 1807 if (unlikely(error)) 1808 goto out; 1809 error = decode_wcc_data(xdr, result->dir_attr); 1810 if (unlikely(error)) 1811 goto out; 1812 if (status != NFS3_OK) 1813 goto out_status; 1814 out: 1815 return error; 1816 out_status: 1817 return nfs3_stat_to_errno(status); 1818 } 1819 1820 /* 1821 * 3.3.14 RENAME3res 1822 * 1823 * struct RENAME3resok { 1824 * wcc_data fromdir_wcc; 1825 * wcc_data todir_wcc; 1826 * }; 1827 * 1828 * struct RENAME3resfail { 1829 * wcc_data fromdir_wcc; 1830 * wcc_data todir_wcc; 1831 * }; 1832 * 1833 * union RENAME3res switch (nfsstat3 status) { 1834 * case NFS3_OK: 1835 * RENAME3resok resok; 1836 * default: 1837 * RENAME3resfail resfail; 1838 * }; 1839 */ 1840 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req, 1841 struct xdr_stream *xdr, 1842 struct nfs_renameres *result) 1843 { 1844 enum nfs_stat status; 1845 int error; 1846 1847 error = decode_nfsstat3(xdr, &status); 1848 if (unlikely(error)) 1849 goto out; 1850 error = decode_wcc_data(xdr, result->old_fattr); 1851 if (unlikely(error)) 1852 goto out; 1853 error = decode_wcc_data(xdr, result->new_fattr); 1854 if (unlikely(error)) 1855 goto out; 1856 if (status != NFS3_OK) 1857 goto out_status; 1858 out: 1859 return error; 1860 out_status: 1861 return nfs3_stat_to_errno(status); 1862 } 1863 1864 /* 1865 * 3.3.15 LINK3res 1866 * 1867 * struct LINK3resok { 1868 * post_op_attr file_attributes; 1869 * wcc_data linkdir_wcc; 1870 * }; 1871 * 1872 * struct LINK3resfail { 1873 * post_op_attr file_attributes; 1874 * wcc_data linkdir_wcc; 1875 * }; 1876 * 1877 * union LINK3res switch (nfsstat3 status) { 1878 * case NFS3_OK: 1879 * LINK3resok resok; 1880 * default: 1881 * LINK3resfail resfail; 1882 * }; 1883 */ 1884 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr, 1885 struct nfs3_linkres *result) 1886 { 1887 enum nfs_stat status; 1888 int error; 1889 1890 error = decode_nfsstat3(xdr, &status); 1891 if (unlikely(error)) 1892 goto out; 1893 error = decode_post_op_attr(xdr, result->fattr); 1894 if (unlikely(error)) 1895 goto out; 1896 error = decode_wcc_data(xdr, result->dir_attr); 1897 if (unlikely(error)) 1898 goto out; 1899 if (status != NFS3_OK) 1900 goto out_status; 1901 out: 1902 return error; 1903 out_status: 1904 return nfs3_stat_to_errno(status); 1905 } 1906 1907 /** 1908 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in 1909 * the local page cache 1910 * @xdr: XDR stream where entry resides 1911 * @entry: buffer to fill in with entry data 1912 * @plus: boolean indicating whether this should be a readdirplus entry 1913 * 1914 * Returns zero if successful, otherwise a negative errno value is 1915 * returned. 1916 * 1917 * This function is not invoked during READDIR reply decoding, but 1918 * rather whenever an application invokes the getdents(2) system call 1919 * on a directory already in our cache. 1920 * 1921 * 3.3.16 entry3 1922 * 1923 * struct entry3 { 1924 * fileid3 fileid; 1925 * filename3 name; 1926 * cookie3 cookie; 1927 * fhandle3 filehandle; 1928 * post_op_attr3 attributes; 1929 * entry3 *nextentry; 1930 * }; 1931 * 1932 * 3.3.17 entryplus3 1933 * struct entryplus3 { 1934 * fileid3 fileid; 1935 * filename3 name; 1936 * cookie3 cookie; 1937 * post_op_attr name_attributes; 1938 * post_op_fh3 name_handle; 1939 * entryplus3 *nextentry; 1940 * }; 1941 */ 1942 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, 1943 int plus) 1944 { 1945 struct nfs_entry old = *entry; 1946 __be32 *p; 1947 int error; 1948 1949 p = xdr_inline_decode(xdr, 4); 1950 if (unlikely(p == NULL)) 1951 goto out_overflow; 1952 if (*p == xdr_zero) { 1953 p = xdr_inline_decode(xdr, 4); 1954 if (unlikely(p == NULL)) 1955 goto out_overflow; 1956 if (*p == xdr_zero) 1957 return -EAGAIN; 1958 entry->eof = 1; 1959 return -EBADCOOKIE; 1960 } 1961 1962 error = decode_fileid3(xdr, &entry->ino); 1963 if (unlikely(error)) 1964 return error; 1965 1966 error = decode_inline_filename3(xdr, &entry->name, &entry->len); 1967 if (unlikely(error)) 1968 return error; 1969 1970 entry->prev_cookie = entry->cookie; 1971 error = decode_cookie3(xdr, &entry->cookie); 1972 if (unlikely(error)) 1973 return error; 1974 1975 entry->d_type = DT_UNKNOWN; 1976 1977 if (plus) { 1978 entry->fattr->valid = 0; 1979 error = decode_post_op_attr(xdr, entry->fattr); 1980 if (unlikely(error)) 1981 return error; 1982 if (entry->fattr->valid & NFS_ATTR_FATTR_V3) 1983 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode); 1984 1985 /* In fact, a post_op_fh3: */ 1986 p = xdr_inline_decode(xdr, 4); 1987 if (unlikely(p == NULL)) 1988 goto out_overflow; 1989 if (*p != xdr_zero) { 1990 error = decode_nfs_fh3(xdr, entry->fh); 1991 if (unlikely(error)) { 1992 if (error == -E2BIG) 1993 goto out_truncated; 1994 return error; 1995 } 1996 } else 1997 zero_nfs_fh3(entry->fh); 1998 } 1999 2000 return 0; 2001 2002 out_overflow: 2003 print_overflow_msg(__func__, xdr); 2004 return -EAGAIN; 2005 out_truncated: 2006 dprintk("NFS: directory entry contains invalid file handle\n"); 2007 *entry = old; 2008 return -EAGAIN; 2009 } 2010 2011 /* 2012 * 3.3.16 READDIR3res 2013 * 2014 * struct dirlist3 { 2015 * entry3 *entries; 2016 * bool eof; 2017 * }; 2018 * 2019 * struct READDIR3resok { 2020 * post_op_attr dir_attributes; 2021 * cookieverf3 cookieverf; 2022 * dirlist3 reply; 2023 * }; 2024 * 2025 * struct READDIR3resfail { 2026 * post_op_attr dir_attributes; 2027 * }; 2028 * 2029 * union READDIR3res switch (nfsstat3 status) { 2030 * case NFS3_OK: 2031 * READDIR3resok resok; 2032 * default: 2033 * READDIR3resfail resfail; 2034 * }; 2035 * 2036 * Read the directory contents into the page cache, but otherwise 2037 * don't touch them. The actual decoding is done by nfs3_decode_entry() 2038 * during subsequent nfs_readdir() calls. 2039 */ 2040 static int decode_dirlist3(struct xdr_stream *xdr) 2041 { 2042 u32 recvd, pglen; 2043 size_t hdrlen; 2044 2045 pglen = xdr->buf->page_len; 2046 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; 2047 recvd = xdr->buf->len - hdrlen; 2048 if (pglen > recvd) 2049 pglen = recvd; 2050 xdr_read_pages(xdr, pglen); 2051 return pglen; 2052 } 2053 2054 static int decode_readdir3resok(struct xdr_stream *xdr, 2055 struct nfs3_readdirres *result) 2056 { 2057 int error; 2058 2059 error = decode_post_op_attr(xdr, result->dir_attr); 2060 if (unlikely(error)) 2061 goto out; 2062 /* XXX: do we need to check if result->verf != NULL ? */ 2063 error = decode_cookieverf3(xdr, result->verf); 2064 if (unlikely(error)) 2065 goto out; 2066 error = decode_dirlist3(xdr); 2067 out: 2068 return error; 2069 } 2070 2071 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req, 2072 struct xdr_stream *xdr, 2073 struct nfs3_readdirres *result) 2074 { 2075 enum nfs_stat status; 2076 int error; 2077 2078 error = decode_nfsstat3(xdr, &status); 2079 if (unlikely(error)) 2080 goto out; 2081 if (status != NFS3_OK) 2082 goto out_default; 2083 error = decode_readdir3resok(xdr, result); 2084 out: 2085 return error; 2086 out_default: 2087 error = decode_post_op_attr(xdr, result->dir_attr); 2088 if (unlikely(error)) 2089 goto out; 2090 return nfs3_stat_to_errno(status); 2091 } 2092 2093 /* 2094 * 3.3.18 FSSTAT3res 2095 * 2096 * struct FSSTAT3resok { 2097 * post_op_attr obj_attributes; 2098 * size3 tbytes; 2099 * size3 fbytes; 2100 * size3 abytes; 2101 * size3 tfiles; 2102 * size3 ffiles; 2103 * size3 afiles; 2104 * uint32 invarsec; 2105 * }; 2106 * 2107 * struct FSSTAT3resfail { 2108 * post_op_attr obj_attributes; 2109 * }; 2110 * 2111 * union FSSTAT3res switch (nfsstat3 status) { 2112 * case NFS3_OK: 2113 * FSSTAT3resok resok; 2114 * default: 2115 * FSSTAT3resfail resfail; 2116 * }; 2117 */ 2118 static int decode_fsstat3resok(struct xdr_stream *xdr, 2119 struct nfs_fsstat *result) 2120 { 2121 __be32 *p; 2122 2123 p = xdr_inline_decode(xdr, 8 * 6 + 4); 2124 if (unlikely(p == NULL)) 2125 goto out_overflow; 2126 p = xdr_decode_size3(p, &result->tbytes); 2127 p = xdr_decode_size3(p, &result->fbytes); 2128 p = xdr_decode_size3(p, &result->abytes); 2129 p = xdr_decode_size3(p, &result->tfiles); 2130 p = xdr_decode_size3(p, &result->ffiles); 2131 xdr_decode_size3(p, &result->afiles); 2132 /* ignore invarsec */ 2133 return 0; 2134 out_overflow: 2135 print_overflow_msg(__func__, xdr); 2136 return -EIO; 2137 } 2138 2139 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req, 2140 struct xdr_stream *xdr, 2141 struct nfs_fsstat *result) 2142 { 2143 enum nfs_stat status; 2144 int error; 2145 2146 error = decode_nfsstat3(xdr, &status); 2147 if (unlikely(error)) 2148 goto out; 2149 error = decode_post_op_attr(xdr, result->fattr); 2150 if (unlikely(error)) 2151 goto out; 2152 if (status != NFS3_OK) 2153 goto out_status; 2154 error = decode_fsstat3resok(xdr, result); 2155 out: 2156 return error; 2157 out_status: 2158 return nfs3_stat_to_errno(status); 2159 } 2160 2161 /* 2162 * 3.3.19 FSINFO3res 2163 * 2164 * struct FSINFO3resok { 2165 * post_op_attr obj_attributes; 2166 * uint32 rtmax; 2167 * uint32 rtpref; 2168 * uint32 rtmult; 2169 * uint32 wtmax; 2170 * uint32 wtpref; 2171 * uint32 wtmult; 2172 * uint32 dtpref; 2173 * size3 maxfilesize; 2174 * nfstime3 time_delta; 2175 * uint32 properties; 2176 * }; 2177 * 2178 * struct FSINFO3resfail { 2179 * post_op_attr obj_attributes; 2180 * }; 2181 * 2182 * union FSINFO3res switch (nfsstat3 status) { 2183 * case NFS3_OK: 2184 * FSINFO3resok resok; 2185 * default: 2186 * FSINFO3resfail resfail; 2187 * }; 2188 */ 2189 static int decode_fsinfo3resok(struct xdr_stream *xdr, 2190 struct nfs_fsinfo *result) 2191 { 2192 __be32 *p; 2193 2194 p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4); 2195 if (unlikely(p == NULL)) 2196 goto out_overflow; 2197 result->rtmax = be32_to_cpup(p++); 2198 result->rtpref = be32_to_cpup(p++); 2199 result->rtmult = be32_to_cpup(p++); 2200 result->wtmax = be32_to_cpup(p++); 2201 result->wtpref = be32_to_cpup(p++); 2202 result->wtmult = be32_to_cpup(p++); 2203 result->dtpref = be32_to_cpup(p++); 2204 p = xdr_decode_size3(p, &result->maxfilesize); 2205 xdr_decode_nfstime3(p, &result->time_delta); 2206 2207 /* ignore properties */ 2208 result->lease_time = 0; 2209 return 0; 2210 out_overflow: 2211 print_overflow_msg(__func__, xdr); 2212 return -EIO; 2213 } 2214 2215 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req, 2216 struct xdr_stream *xdr, 2217 struct nfs_fsinfo *result) 2218 { 2219 enum nfs_stat status; 2220 int error; 2221 2222 error = decode_nfsstat3(xdr, &status); 2223 if (unlikely(error)) 2224 goto out; 2225 error = decode_post_op_attr(xdr, result->fattr); 2226 if (unlikely(error)) 2227 goto out; 2228 if (status != NFS3_OK) 2229 goto out_status; 2230 error = decode_fsinfo3resok(xdr, result); 2231 out: 2232 return error; 2233 out_status: 2234 return nfs3_stat_to_errno(status); 2235 } 2236 2237 /* 2238 * 3.3.20 PATHCONF3res 2239 * 2240 * struct PATHCONF3resok { 2241 * post_op_attr obj_attributes; 2242 * uint32 linkmax; 2243 * uint32 name_max; 2244 * bool no_trunc; 2245 * bool chown_restricted; 2246 * bool case_insensitive; 2247 * bool case_preserving; 2248 * }; 2249 * 2250 * struct PATHCONF3resfail { 2251 * post_op_attr obj_attributes; 2252 * }; 2253 * 2254 * union PATHCONF3res switch (nfsstat3 status) { 2255 * case NFS3_OK: 2256 * PATHCONF3resok resok; 2257 * default: 2258 * PATHCONF3resfail resfail; 2259 * }; 2260 */ 2261 static int decode_pathconf3resok(struct xdr_stream *xdr, 2262 struct nfs_pathconf *result) 2263 { 2264 __be32 *p; 2265 2266 p = xdr_inline_decode(xdr, 4 * 6); 2267 if (unlikely(p == NULL)) 2268 goto out_overflow; 2269 result->max_link = be32_to_cpup(p++); 2270 result->max_namelen = be32_to_cpup(p); 2271 /* ignore remaining fields */ 2272 return 0; 2273 out_overflow: 2274 print_overflow_msg(__func__, xdr); 2275 return -EIO; 2276 } 2277 2278 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req, 2279 struct xdr_stream *xdr, 2280 struct nfs_pathconf *result) 2281 { 2282 enum nfs_stat status; 2283 int error; 2284 2285 error = decode_nfsstat3(xdr, &status); 2286 if (unlikely(error)) 2287 goto out; 2288 error = decode_post_op_attr(xdr, result->fattr); 2289 if (unlikely(error)) 2290 goto out; 2291 if (status != NFS3_OK) 2292 goto out_status; 2293 error = decode_pathconf3resok(xdr, result); 2294 out: 2295 return error; 2296 out_status: 2297 return nfs3_stat_to_errno(status); 2298 } 2299 2300 /* 2301 * 3.3.21 COMMIT3res 2302 * 2303 * struct COMMIT3resok { 2304 * wcc_data file_wcc; 2305 * writeverf3 verf; 2306 * }; 2307 * 2308 * struct COMMIT3resfail { 2309 * wcc_data file_wcc; 2310 * }; 2311 * 2312 * union COMMIT3res switch (nfsstat3 status) { 2313 * case NFS3_OK: 2314 * COMMIT3resok resok; 2315 * default: 2316 * COMMIT3resfail resfail; 2317 * }; 2318 */ 2319 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req, 2320 struct xdr_stream *xdr, 2321 struct nfs_commitres *result) 2322 { 2323 enum nfs_stat status; 2324 int error; 2325 2326 error = decode_nfsstat3(xdr, &status); 2327 if (unlikely(error)) 2328 goto out; 2329 error = decode_wcc_data(xdr, result->fattr); 2330 if (unlikely(error)) 2331 goto out; 2332 if (status != NFS3_OK) 2333 goto out_status; 2334 error = decode_writeverf3(xdr, result->verf->verifier); 2335 out: 2336 return error; 2337 out_status: 2338 return nfs3_stat_to_errno(status); 2339 } 2340 2341 #ifdef CONFIG_NFS_V3_ACL 2342 2343 static inline int decode_getacl3resok(struct xdr_stream *xdr, 2344 struct nfs3_getaclres *result) 2345 { 2346 struct posix_acl **acl; 2347 unsigned int *aclcnt; 2348 size_t hdrlen; 2349 int error; 2350 2351 error = decode_post_op_attr(xdr, result->fattr); 2352 if (unlikely(error)) 2353 goto out; 2354 error = decode_uint32(xdr, &result->mask); 2355 if (unlikely(error)) 2356 goto out; 2357 error = -EINVAL; 2358 if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) 2359 goto out; 2360 2361 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base; 2362 2363 acl = NULL; 2364 if (result->mask & NFS_ACL) 2365 acl = &result->acl_access; 2366 aclcnt = NULL; 2367 if (result->mask & NFS_ACLCNT) 2368 aclcnt = &result->acl_access_count; 2369 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl); 2370 if (unlikely(error <= 0)) 2371 goto out; 2372 2373 acl = NULL; 2374 if (result->mask & NFS_DFACL) 2375 acl = &result->acl_default; 2376 aclcnt = NULL; 2377 if (result->mask & NFS_DFACLCNT) 2378 aclcnt = &result->acl_default_count; 2379 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl); 2380 if (unlikely(error <= 0)) 2381 return error; 2382 error = 0; 2383 out: 2384 return error; 2385 } 2386 2387 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req, 2388 struct xdr_stream *xdr, 2389 struct nfs3_getaclres *result) 2390 { 2391 enum nfs_stat status; 2392 int error; 2393 2394 error = decode_nfsstat3(xdr, &status); 2395 if (unlikely(error)) 2396 goto out; 2397 if (status != NFS3_OK) 2398 goto out_default; 2399 error = decode_getacl3resok(xdr, result); 2400 out: 2401 return error; 2402 out_default: 2403 return nfs3_stat_to_errno(status); 2404 } 2405 2406 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req, 2407 struct xdr_stream *xdr, 2408 struct nfs_fattr *result) 2409 { 2410 enum nfs_stat status; 2411 int error; 2412 2413 error = decode_nfsstat3(xdr, &status); 2414 if (unlikely(error)) 2415 goto out; 2416 if (status != NFS3_OK) 2417 goto out_default; 2418 error = decode_post_op_attr(xdr, result); 2419 out: 2420 return error; 2421 out_default: 2422 return nfs3_stat_to_errno(status); 2423 } 2424 2425 #endif /* CONFIG_NFS_V3_ACL */ 2426 2427 2428 /* 2429 * We need to translate between nfs status return values and 2430 * the local errno values which may not be the same. 2431 */ 2432 static const struct { 2433 int stat; 2434 int errno; 2435 } nfs_errtbl[] = { 2436 { NFS_OK, 0 }, 2437 { NFSERR_PERM, -EPERM }, 2438 { NFSERR_NOENT, -ENOENT }, 2439 { NFSERR_IO, -errno_NFSERR_IO}, 2440 { NFSERR_NXIO, -ENXIO }, 2441 /* { NFSERR_EAGAIN, -EAGAIN }, */ 2442 { NFSERR_ACCES, -EACCES }, 2443 { NFSERR_EXIST, -EEXIST }, 2444 { NFSERR_XDEV, -EXDEV }, 2445 { NFSERR_NODEV, -ENODEV }, 2446 { NFSERR_NOTDIR, -ENOTDIR }, 2447 { NFSERR_ISDIR, -EISDIR }, 2448 { NFSERR_INVAL, -EINVAL }, 2449 { NFSERR_FBIG, -EFBIG }, 2450 { NFSERR_NOSPC, -ENOSPC }, 2451 { NFSERR_ROFS, -EROFS }, 2452 { NFSERR_MLINK, -EMLINK }, 2453 { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, 2454 { NFSERR_NOTEMPTY, -ENOTEMPTY }, 2455 { NFSERR_DQUOT, -EDQUOT }, 2456 { NFSERR_STALE, -ESTALE }, 2457 { NFSERR_REMOTE, -EREMOTE }, 2458 #ifdef EWFLUSH 2459 { NFSERR_WFLUSH, -EWFLUSH }, 2460 #endif 2461 { NFSERR_BADHANDLE, -EBADHANDLE }, 2462 { NFSERR_NOT_SYNC, -ENOTSYNC }, 2463 { NFSERR_BAD_COOKIE, -EBADCOOKIE }, 2464 { NFSERR_NOTSUPP, -ENOTSUPP }, 2465 { NFSERR_TOOSMALL, -ETOOSMALL }, 2466 { NFSERR_SERVERFAULT, -EREMOTEIO }, 2467 { NFSERR_BADTYPE, -EBADTYPE }, 2468 { NFSERR_JUKEBOX, -EJUKEBOX }, 2469 { -1, -EIO } 2470 }; 2471 2472 /** 2473 * nfs3_stat_to_errno - convert an NFS status code to a local errno 2474 * @status: NFS status code to convert 2475 * 2476 * Returns a local errno value, or -EIO if the NFS status code is 2477 * not recognized. This function is used jointly by NFSv2 and NFSv3. 2478 */ 2479 static int nfs3_stat_to_errno(enum nfs_stat status) 2480 { 2481 int i; 2482 2483 for (i = 0; nfs_errtbl[i].stat != -1; i++) { 2484 if (nfs_errtbl[i].stat == (int)status) 2485 return nfs_errtbl[i].errno; 2486 } 2487 dprintk("NFS: Unrecognized nfs status value: %u\n", status); 2488 return nfs_errtbl[i].errno; 2489 } 2490 2491 2492 #define PROC(proc, argtype, restype, timer) \ 2493 [NFS3PROC_##proc] = { \ 2494 .p_proc = NFS3PROC_##proc, \ 2495 .p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \ 2496 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res, \ 2497 .p_arglen = NFS3_##argtype##args_sz, \ 2498 .p_replen = NFS3_##restype##res_sz, \ 2499 .p_timer = timer, \ 2500 .p_statidx = NFS3PROC_##proc, \ 2501 .p_name = #proc, \ 2502 } 2503 2504 struct rpc_procinfo nfs3_procedures[] = { 2505 PROC(GETATTR, getattr, getattr, 1), 2506 PROC(SETATTR, setattr, setattr, 0), 2507 PROC(LOOKUP, lookup, lookup, 2), 2508 PROC(ACCESS, access, access, 1), 2509 PROC(READLINK, readlink, readlink, 3), 2510 PROC(READ, read, read, 3), 2511 PROC(WRITE, write, write, 4), 2512 PROC(CREATE, create, create, 0), 2513 PROC(MKDIR, mkdir, create, 0), 2514 PROC(SYMLINK, symlink, create, 0), 2515 PROC(MKNOD, mknod, create, 0), 2516 PROC(REMOVE, remove, remove, 0), 2517 PROC(RMDIR, lookup, setattr, 0), 2518 PROC(RENAME, rename, rename, 0), 2519 PROC(LINK, link, link, 0), 2520 PROC(READDIR, readdir, readdir, 3), 2521 PROC(READDIRPLUS, readdirplus, readdir, 3), 2522 PROC(FSSTAT, getattr, fsstat, 0), 2523 PROC(FSINFO, getattr, fsinfo, 0), 2524 PROC(PATHCONF, getattr, pathconf, 0), 2525 PROC(COMMIT, commit, commit, 5), 2526 }; 2527 2528 const struct rpc_version nfs_version3 = { 2529 .number = 3, 2530 .nrprocs = ARRAY_SIZE(nfs3_procedures), 2531 .procs = nfs3_procedures 2532 }; 2533 2534 #ifdef CONFIG_NFS_V3_ACL 2535 static struct rpc_procinfo nfs3_acl_procedures[] = { 2536 [ACLPROC3_GETACL] = { 2537 .p_proc = ACLPROC3_GETACL, 2538 .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args, 2539 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_getacl3res, 2540 .p_arglen = ACL3_getaclargs_sz, 2541 .p_replen = ACL3_getaclres_sz, 2542 .p_timer = 1, 2543 .p_name = "GETACL", 2544 }, 2545 [ACLPROC3_SETACL] = { 2546 .p_proc = ACLPROC3_SETACL, 2547 .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args, 2548 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_setacl3res, 2549 .p_arglen = ACL3_setaclargs_sz, 2550 .p_replen = ACL3_setaclres_sz, 2551 .p_timer = 0, 2552 .p_name = "SETACL", 2553 }, 2554 }; 2555 2556 const struct rpc_version nfsacl_version3 = { 2557 .number = 3, 2558 .nrprocs = sizeof(nfs3_acl_procedures)/ 2559 sizeof(nfs3_acl_procedures[0]), 2560 .procs = nfs3_acl_procedures, 2561 }; 2562 #endif /* CONFIG_NFS_V3_ACL */ 2563