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