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