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