1 /* 2 * Server-side XDR for NFSv4 3 * 4 * Copyright (c) 2002 The Regents of the University of Michigan. 5 * All rights reserved. 6 * 7 * Kendrick Smith <kmsmith@umich.edu> 8 * Andy Adamson <andros@umich.edu> 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the University nor the names of its 20 * contributors may be used to endorse or promote products derived 21 * from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 24 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 * 35 * TODO: Neil Brown made the following observation: We currently 36 * initially reserve NFSD_BUFSIZE space on the transmit queue and 37 * never release any of that until the request is complete. 38 * It would be good to calculate a new maximum response size while 39 * decoding the COMPOUND, and call svc_reserve with this number 40 * at the end of nfs4svc_decode_compoundargs. 41 */ 42 43 #include <linux/slab.h> 44 #include <linux/namei.h> 45 #include <linux/statfs.h> 46 #include <linux/utsname.h> 47 #include <linux/pagemap.h> 48 #include <linux/sunrpc/svcauth_gss.h> 49 50 #include "idmap.h" 51 #include "acl.h" 52 #include "xdr4.h" 53 #include "vfs.h" 54 #include "state.h" 55 #include "cache.h" 56 #include "netns.h" 57 58 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 59 #include <linux/security.h> 60 #endif 61 62 63 #define NFSDDBG_FACILITY NFSDDBG_XDR 64 65 /* 66 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing 67 * directory in order to indicate to the client that a filesystem boundary is present 68 * We use a fixed fsid for a referral 69 */ 70 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL 71 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL 72 73 static __be32 74 check_filename(char *str, int len) 75 { 76 int i; 77 78 if (len == 0) 79 return nfserr_inval; 80 if (isdotent(str, len)) 81 return nfserr_badname; 82 for (i = 0; i < len; i++) 83 if (str[i] == '/') 84 return nfserr_badname; 85 return 0; 86 } 87 88 #define DECODE_HEAD \ 89 __be32 *p; \ 90 __be32 status 91 #define DECODE_TAIL \ 92 status = 0; \ 93 out: \ 94 return status; \ 95 xdr_error: \ 96 dprintk("NFSD: xdr error (%s:%d)\n", \ 97 __FILE__, __LINE__); \ 98 status = nfserr_bad_xdr; \ 99 goto out 100 101 #define READ32(x) (x) = ntohl(*p++) 102 #define READ64(x) do { \ 103 (x) = (u64)ntohl(*p++) << 32; \ 104 (x) |= ntohl(*p++); \ 105 } while (0) 106 #define READMEM(x,nbytes) do { \ 107 x = (char *)p; \ 108 p += XDR_QUADLEN(nbytes); \ 109 } while (0) 110 #define SAVEMEM(x,nbytes) do { \ 111 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \ 112 savemem(argp, p, nbytes) : \ 113 (char *)p)) { \ 114 dprintk("NFSD: xdr error (%s:%d)\n", \ 115 __FILE__, __LINE__); \ 116 goto xdr_error; \ 117 } \ 118 p += XDR_QUADLEN(nbytes); \ 119 } while (0) 120 #define COPYMEM(x,nbytes) do { \ 121 memcpy((x), p, nbytes); \ 122 p += XDR_QUADLEN(nbytes); \ 123 } while (0) 124 125 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */ 126 #define READ_BUF(nbytes) do { \ 127 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \ 128 p = argp->p; \ 129 argp->p += XDR_QUADLEN(nbytes); \ 130 } else if (!(p = read_buf(argp, nbytes))) { \ 131 dprintk("NFSD: xdr error (%s:%d)\n", \ 132 __FILE__, __LINE__); \ 133 goto xdr_error; \ 134 } \ 135 } while (0) 136 137 static void next_decode_page(struct nfsd4_compoundargs *argp) 138 { 139 argp->p = page_address(argp->pagelist[0]); 140 argp->pagelist++; 141 if (argp->pagelen < PAGE_SIZE) { 142 argp->end = argp->p + (argp->pagelen>>2); 143 argp->pagelen = 0; 144 } else { 145 argp->end = argp->p + (PAGE_SIZE>>2); 146 argp->pagelen -= PAGE_SIZE; 147 } 148 } 149 150 static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes) 151 { 152 /* We want more bytes than seem to be available. 153 * Maybe we need a new page, maybe we have just run out 154 */ 155 unsigned int avail = (char *)argp->end - (char *)argp->p; 156 __be32 *p; 157 if (avail + argp->pagelen < nbytes) 158 return NULL; 159 if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */ 160 return NULL; 161 /* ok, we can do it with the current plus the next page */ 162 if (nbytes <= sizeof(argp->tmp)) 163 p = argp->tmp; 164 else { 165 kfree(argp->tmpp); 166 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL); 167 if (!p) 168 return NULL; 169 170 } 171 /* 172 * The following memcpy is safe because read_buf is always 173 * called with nbytes > avail, and the two cases above both 174 * guarantee p points to at least nbytes bytes. 175 */ 176 memcpy(p, argp->p, avail); 177 next_decode_page(argp); 178 memcpy(((char*)p)+avail, argp->p, (nbytes - avail)); 179 argp->p += XDR_QUADLEN(nbytes - avail); 180 return p; 181 } 182 183 static int zero_clientid(clientid_t *clid) 184 { 185 return (clid->cl_boot == 0) && (clid->cl_id == 0); 186 } 187 188 /** 189 * defer_free - mark an allocation as deferred freed 190 * @argp: NFSv4 compound argument structure to be freed with 191 * @release: release callback to free @p, typically kfree() 192 * @p: pointer to be freed 193 * 194 * Marks @p to be freed when processing the compound operation 195 * described in @argp finishes. 196 */ 197 static int 198 defer_free(struct nfsd4_compoundargs *argp, 199 void (*release)(const void *), void *p) 200 { 201 struct tmpbuf *tb; 202 203 tb = kmalloc(sizeof(*tb), GFP_KERNEL); 204 if (!tb) 205 return -ENOMEM; 206 tb->buf = p; 207 tb->release = release; 208 tb->next = argp->to_free; 209 argp->to_free = tb; 210 return 0; 211 } 212 213 /** 214 * savemem - duplicate a chunk of memory for later processing 215 * @argp: NFSv4 compound argument structure to be freed with 216 * @p: pointer to be duplicated 217 * @nbytes: length to be duplicated 218 * 219 * Returns a pointer to a copy of @nbytes bytes of memory at @p 220 * that are preserved until processing of the NFSv4 compound 221 * operation described by @argp finishes. 222 */ 223 static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes) 224 { 225 if (p == argp->tmp) { 226 p = kmemdup(argp->tmp, nbytes, GFP_KERNEL); 227 if (!p) 228 return NULL; 229 } else { 230 BUG_ON(p != argp->tmpp); 231 argp->tmpp = NULL; 232 } 233 if (defer_free(argp, kfree, p)) { 234 kfree(p); 235 return NULL; 236 } else 237 return (char *)p; 238 } 239 240 static __be32 241 nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval) 242 { 243 u32 bmlen; 244 DECODE_HEAD; 245 246 bmval[0] = 0; 247 bmval[1] = 0; 248 bmval[2] = 0; 249 250 READ_BUF(4); 251 READ32(bmlen); 252 if (bmlen > 1000) 253 goto xdr_error; 254 255 READ_BUF(bmlen << 2); 256 if (bmlen > 0) 257 READ32(bmval[0]); 258 if (bmlen > 1) 259 READ32(bmval[1]); 260 if (bmlen > 2) 261 READ32(bmval[2]); 262 263 DECODE_TAIL; 264 } 265 266 static __be32 267 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval, 268 struct iattr *iattr, struct nfs4_acl **acl, 269 struct xdr_netobj *label) 270 { 271 int expected_len, len = 0; 272 u32 dummy32; 273 char *buf; 274 275 DECODE_HEAD; 276 iattr->ia_valid = 0; 277 if ((status = nfsd4_decode_bitmap(argp, bmval))) 278 return status; 279 280 READ_BUF(4); 281 READ32(expected_len); 282 283 if (bmval[0] & FATTR4_WORD0_SIZE) { 284 READ_BUF(8); 285 len += 8; 286 READ64(iattr->ia_size); 287 iattr->ia_valid |= ATTR_SIZE; 288 } 289 if (bmval[0] & FATTR4_WORD0_ACL) { 290 u32 nace; 291 struct nfs4_ace *ace; 292 293 READ_BUF(4); len += 4; 294 READ32(nace); 295 296 if (nace > NFS4_ACL_MAX) 297 return nfserr_fbig; 298 299 *acl = nfs4_acl_new(nace); 300 if (*acl == NULL) 301 return nfserr_jukebox; 302 303 defer_free(argp, kfree, *acl); 304 305 (*acl)->naces = nace; 306 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) { 307 READ_BUF(16); len += 16; 308 READ32(ace->type); 309 READ32(ace->flag); 310 READ32(ace->access_mask); 311 READ32(dummy32); 312 READ_BUF(dummy32); 313 len += XDR_QUADLEN(dummy32) << 2; 314 READMEM(buf, dummy32); 315 ace->whotype = nfs4_acl_get_whotype(buf, dummy32); 316 status = nfs_ok; 317 if (ace->whotype != NFS4_ACL_WHO_NAMED) 318 ; 319 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) 320 status = nfsd_map_name_to_gid(argp->rqstp, 321 buf, dummy32, &ace->who_gid); 322 else 323 status = nfsd_map_name_to_uid(argp->rqstp, 324 buf, dummy32, &ace->who_uid); 325 if (status) 326 return status; 327 } 328 } else 329 *acl = NULL; 330 if (bmval[1] & FATTR4_WORD1_MODE) { 331 READ_BUF(4); 332 len += 4; 333 READ32(iattr->ia_mode); 334 iattr->ia_mode &= (S_IFMT | S_IALLUGO); 335 iattr->ia_valid |= ATTR_MODE; 336 } 337 if (bmval[1] & FATTR4_WORD1_OWNER) { 338 READ_BUF(4); 339 len += 4; 340 READ32(dummy32); 341 READ_BUF(dummy32); 342 len += (XDR_QUADLEN(dummy32) << 2); 343 READMEM(buf, dummy32); 344 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid))) 345 return status; 346 iattr->ia_valid |= ATTR_UID; 347 } 348 if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) { 349 READ_BUF(4); 350 len += 4; 351 READ32(dummy32); 352 READ_BUF(dummy32); 353 len += (XDR_QUADLEN(dummy32) << 2); 354 READMEM(buf, dummy32); 355 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid))) 356 return status; 357 iattr->ia_valid |= ATTR_GID; 358 } 359 if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) { 360 READ_BUF(4); 361 len += 4; 362 READ32(dummy32); 363 switch (dummy32) { 364 case NFS4_SET_TO_CLIENT_TIME: 365 /* We require the high 32 bits of 'seconds' to be 0, and we ignore 366 all 32 bits of 'nseconds'. */ 367 READ_BUF(12); 368 len += 12; 369 READ64(iattr->ia_atime.tv_sec); 370 READ32(iattr->ia_atime.tv_nsec); 371 if (iattr->ia_atime.tv_nsec >= (u32)1000000000) 372 return nfserr_inval; 373 iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); 374 break; 375 case NFS4_SET_TO_SERVER_TIME: 376 iattr->ia_valid |= ATTR_ATIME; 377 break; 378 default: 379 goto xdr_error; 380 } 381 } 382 if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) { 383 READ_BUF(4); 384 len += 4; 385 READ32(dummy32); 386 switch (dummy32) { 387 case NFS4_SET_TO_CLIENT_TIME: 388 /* We require the high 32 bits of 'seconds' to be 0, and we ignore 389 all 32 bits of 'nseconds'. */ 390 READ_BUF(12); 391 len += 12; 392 READ64(iattr->ia_mtime.tv_sec); 393 READ32(iattr->ia_mtime.tv_nsec); 394 if (iattr->ia_mtime.tv_nsec >= (u32)1000000000) 395 return nfserr_inval; 396 iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); 397 break; 398 case NFS4_SET_TO_SERVER_TIME: 399 iattr->ia_valid |= ATTR_MTIME; 400 break; 401 default: 402 goto xdr_error; 403 } 404 } 405 406 label->len = 0; 407 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 408 if (bmval[2] & FATTR4_WORD2_SECURITY_LABEL) { 409 READ_BUF(4); 410 len += 4; 411 READ32(dummy32); /* lfs: we don't use it */ 412 READ_BUF(4); 413 len += 4; 414 READ32(dummy32); /* pi: we don't use it either */ 415 READ_BUF(4); 416 len += 4; 417 READ32(dummy32); 418 READ_BUF(dummy32); 419 if (dummy32 > NFSD4_MAX_SEC_LABEL_LEN) 420 return nfserr_badlabel; 421 len += (XDR_QUADLEN(dummy32) << 2); 422 READMEM(buf, dummy32); 423 label->data = kzalloc(dummy32 + 1, GFP_KERNEL); 424 if (!label->data) 425 return nfserr_jukebox; 426 label->len = dummy32; 427 defer_free(argp, kfree, label->data); 428 memcpy(label->data, buf, dummy32); 429 } 430 #endif 431 432 if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0 433 || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1 434 || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) 435 READ_BUF(expected_len - len); 436 else if (len != expected_len) 437 goto xdr_error; 438 439 DECODE_TAIL; 440 } 441 442 static __be32 443 nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid) 444 { 445 DECODE_HEAD; 446 447 READ_BUF(sizeof(stateid_t)); 448 READ32(sid->si_generation); 449 COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); 450 451 DECODE_TAIL; 452 } 453 454 static __be32 455 nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access) 456 { 457 DECODE_HEAD; 458 459 READ_BUF(4); 460 READ32(access->ac_req_access); 461 462 DECODE_TAIL; 463 } 464 465 static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs) 466 { 467 DECODE_HEAD; 468 u32 dummy, uid, gid; 469 char *machine_name; 470 int i; 471 int nr_secflavs; 472 473 /* callback_sec_params4 */ 474 READ_BUF(4); 475 READ32(nr_secflavs); 476 if (nr_secflavs) 477 cbs->flavor = (u32)(-1); 478 else 479 /* Is this legal? Be generous, take it to mean AUTH_NONE: */ 480 cbs->flavor = 0; 481 for (i = 0; i < nr_secflavs; ++i) { 482 READ_BUF(4); 483 READ32(dummy); 484 switch (dummy) { 485 case RPC_AUTH_NULL: 486 /* Nothing to read */ 487 if (cbs->flavor == (u32)(-1)) 488 cbs->flavor = RPC_AUTH_NULL; 489 break; 490 case RPC_AUTH_UNIX: 491 READ_BUF(8); 492 /* stamp */ 493 READ32(dummy); 494 495 /* machine name */ 496 READ32(dummy); 497 READ_BUF(dummy); 498 SAVEMEM(machine_name, dummy); 499 500 /* uid, gid */ 501 READ_BUF(8); 502 READ32(uid); 503 READ32(gid); 504 505 /* more gids */ 506 READ_BUF(4); 507 READ32(dummy); 508 READ_BUF(dummy * 4); 509 if (cbs->flavor == (u32)(-1)) { 510 kuid_t kuid = make_kuid(&init_user_ns, uid); 511 kgid_t kgid = make_kgid(&init_user_ns, gid); 512 if (uid_valid(kuid) && gid_valid(kgid)) { 513 cbs->uid = kuid; 514 cbs->gid = kgid; 515 cbs->flavor = RPC_AUTH_UNIX; 516 } else { 517 dprintk("RPC_AUTH_UNIX with invalid" 518 "uid or gid ignoring!\n"); 519 } 520 } 521 break; 522 case RPC_AUTH_GSS: 523 dprintk("RPC_AUTH_GSS callback secflavor " 524 "not supported!\n"); 525 READ_BUF(8); 526 /* gcbp_service */ 527 READ32(dummy); 528 /* gcbp_handle_from_server */ 529 READ32(dummy); 530 READ_BUF(dummy); 531 p += XDR_QUADLEN(dummy); 532 /* gcbp_handle_from_client */ 533 READ_BUF(4); 534 READ32(dummy); 535 READ_BUF(dummy); 536 break; 537 default: 538 dprintk("Illegal callback secflavor\n"); 539 return nfserr_inval; 540 } 541 } 542 DECODE_TAIL; 543 } 544 545 static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc) 546 { 547 DECODE_HEAD; 548 549 READ_BUF(4); 550 READ32(bc->bc_cb_program); 551 nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); 552 553 DECODE_TAIL; 554 } 555 556 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts) 557 { 558 DECODE_HEAD; 559 560 READ_BUF(NFS4_MAX_SESSIONID_LEN + 8); 561 COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); 562 READ32(bcts->dir); 563 /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker 564 * could help us figure out we should be using it. */ 565 DECODE_TAIL; 566 } 567 568 static __be32 569 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close) 570 { 571 DECODE_HEAD; 572 573 READ_BUF(4); 574 READ32(close->cl_seqid); 575 return nfsd4_decode_stateid(argp, &close->cl_stateid); 576 577 DECODE_TAIL; 578 } 579 580 581 static __be32 582 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit) 583 { 584 DECODE_HEAD; 585 586 READ_BUF(12); 587 READ64(commit->co_offset); 588 READ32(commit->co_count); 589 590 DECODE_TAIL; 591 } 592 593 static __be32 594 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create) 595 { 596 DECODE_HEAD; 597 598 READ_BUF(4); 599 READ32(create->cr_type); 600 switch (create->cr_type) { 601 case NF4LNK: 602 READ_BUF(4); 603 READ32(create->cr_linklen); 604 READ_BUF(create->cr_linklen); 605 SAVEMEM(create->cr_linkname, create->cr_linklen); 606 break; 607 case NF4BLK: 608 case NF4CHR: 609 READ_BUF(8); 610 READ32(create->cr_specdata1); 611 READ32(create->cr_specdata2); 612 break; 613 case NF4SOCK: 614 case NF4FIFO: 615 case NF4DIR: 616 default: 617 break; 618 } 619 620 READ_BUF(4); 621 READ32(create->cr_namelen); 622 READ_BUF(create->cr_namelen); 623 SAVEMEM(create->cr_name, create->cr_namelen); 624 if ((status = check_filename(create->cr_name, create->cr_namelen))) 625 return status; 626 627 status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr, 628 &create->cr_acl, &create->cr_label); 629 if (status) 630 goto out; 631 632 DECODE_TAIL; 633 } 634 635 static inline __be32 636 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr) 637 { 638 return nfsd4_decode_stateid(argp, &dr->dr_stateid); 639 } 640 641 static inline __be32 642 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr) 643 { 644 return nfsd4_decode_bitmap(argp, getattr->ga_bmval); 645 } 646 647 static __be32 648 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link) 649 { 650 DECODE_HEAD; 651 652 READ_BUF(4); 653 READ32(link->li_namelen); 654 READ_BUF(link->li_namelen); 655 SAVEMEM(link->li_name, link->li_namelen); 656 if ((status = check_filename(link->li_name, link->li_namelen))) 657 return status; 658 659 DECODE_TAIL; 660 } 661 662 static __be32 663 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock) 664 { 665 DECODE_HEAD; 666 667 /* 668 * type, reclaim(boolean), offset, length, new_lock_owner(boolean) 669 */ 670 READ_BUF(28); 671 READ32(lock->lk_type); 672 if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) 673 goto xdr_error; 674 READ32(lock->lk_reclaim); 675 READ64(lock->lk_offset); 676 READ64(lock->lk_length); 677 READ32(lock->lk_is_new); 678 679 if (lock->lk_is_new) { 680 READ_BUF(4); 681 READ32(lock->lk_new_open_seqid); 682 status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid); 683 if (status) 684 return status; 685 READ_BUF(8 + sizeof(clientid_t)); 686 READ32(lock->lk_new_lock_seqid); 687 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t)); 688 READ32(lock->lk_new_owner.len); 689 READ_BUF(lock->lk_new_owner.len); 690 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len); 691 } else { 692 status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid); 693 if (status) 694 return status; 695 READ_BUF(4); 696 READ32(lock->lk_old_lock_seqid); 697 } 698 699 DECODE_TAIL; 700 } 701 702 static __be32 703 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt) 704 { 705 DECODE_HEAD; 706 707 READ_BUF(32); 708 READ32(lockt->lt_type); 709 if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) 710 goto xdr_error; 711 READ64(lockt->lt_offset); 712 READ64(lockt->lt_length); 713 COPYMEM(&lockt->lt_clientid, 8); 714 READ32(lockt->lt_owner.len); 715 READ_BUF(lockt->lt_owner.len); 716 READMEM(lockt->lt_owner.data, lockt->lt_owner.len); 717 718 DECODE_TAIL; 719 } 720 721 static __be32 722 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku) 723 { 724 DECODE_HEAD; 725 726 READ_BUF(8); 727 READ32(locku->lu_type); 728 if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) 729 goto xdr_error; 730 READ32(locku->lu_seqid); 731 status = nfsd4_decode_stateid(argp, &locku->lu_stateid); 732 if (status) 733 return status; 734 READ_BUF(16); 735 READ64(locku->lu_offset); 736 READ64(locku->lu_length); 737 738 DECODE_TAIL; 739 } 740 741 static __be32 742 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup) 743 { 744 DECODE_HEAD; 745 746 READ_BUF(4); 747 READ32(lookup->lo_len); 748 READ_BUF(lookup->lo_len); 749 SAVEMEM(lookup->lo_name, lookup->lo_len); 750 if ((status = check_filename(lookup->lo_name, lookup->lo_len))) 751 return status; 752 753 DECODE_TAIL; 754 } 755 756 static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when) 757 { 758 __be32 *p; 759 u32 w; 760 761 READ_BUF(4); 762 READ32(w); 763 *share_access = w & NFS4_SHARE_ACCESS_MASK; 764 *deleg_want = w & NFS4_SHARE_WANT_MASK; 765 if (deleg_when) 766 *deleg_when = w & NFS4_SHARE_WHEN_MASK; 767 768 switch (w & NFS4_SHARE_ACCESS_MASK) { 769 case NFS4_SHARE_ACCESS_READ: 770 case NFS4_SHARE_ACCESS_WRITE: 771 case NFS4_SHARE_ACCESS_BOTH: 772 break; 773 default: 774 return nfserr_bad_xdr; 775 } 776 w &= ~NFS4_SHARE_ACCESS_MASK; 777 if (!w) 778 return nfs_ok; 779 if (!argp->minorversion) 780 return nfserr_bad_xdr; 781 switch (w & NFS4_SHARE_WANT_MASK) { 782 case NFS4_SHARE_WANT_NO_PREFERENCE: 783 case NFS4_SHARE_WANT_READ_DELEG: 784 case NFS4_SHARE_WANT_WRITE_DELEG: 785 case NFS4_SHARE_WANT_ANY_DELEG: 786 case NFS4_SHARE_WANT_NO_DELEG: 787 case NFS4_SHARE_WANT_CANCEL: 788 break; 789 default: 790 return nfserr_bad_xdr; 791 } 792 w &= ~NFS4_SHARE_WANT_MASK; 793 if (!w) 794 return nfs_ok; 795 796 if (!deleg_when) /* open_downgrade */ 797 return nfserr_inval; 798 switch (w) { 799 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL: 800 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED: 801 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL | 802 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED): 803 return nfs_ok; 804 } 805 xdr_error: 806 return nfserr_bad_xdr; 807 } 808 809 static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x) 810 { 811 __be32 *p; 812 813 READ_BUF(4); 814 READ32(*x); 815 /* Note: unlinke access bits, deny bits may be zero. */ 816 if (*x & ~NFS4_SHARE_DENY_BOTH) 817 return nfserr_bad_xdr; 818 return nfs_ok; 819 xdr_error: 820 return nfserr_bad_xdr; 821 } 822 823 static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o) 824 { 825 __be32 *p; 826 827 READ_BUF(4); 828 READ32(o->len); 829 830 if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT) 831 return nfserr_bad_xdr; 832 833 READ_BUF(o->len); 834 SAVEMEM(o->data, o->len); 835 return nfs_ok; 836 xdr_error: 837 return nfserr_bad_xdr; 838 } 839 840 static __be32 841 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) 842 { 843 DECODE_HEAD; 844 u32 dummy; 845 846 memset(open->op_bmval, 0, sizeof(open->op_bmval)); 847 open->op_iattr.ia_valid = 0; 848 open->op_openowner = NULL; 849 850 open->op_xdr_error = 0; 851 /* seqid, share_access, share_deny, clientid, ownerlen */ 852 READ_BUF(4); 853 READ32(open->op_seqid); 854 /* decode, yet ignore deleg_when until supported */ 855 status = nfsd4_decode_share_access(argp, &open->op_share_access, 856 &open->op_deleg_want, &dummy); 857 if (status) 858 goto xdr_error; 859 status = nfsd4_decode_share_deny(argp, &open->op_share_deny); 860 if (status) 861 goto xdr_error; 862 READ_BUF(sizeof(clientid_t)); 863 COPYMEM(&open->op_clientid, sizeof(clientid_t)); 864 status = nfsd4_decode_opaque(argp, &open->op_owner); 865 if (status) 866 goto xdr_error; 867 READ_BUF(4); 868 READ32(open->op_create); 869 switch (open->op_create) { 870 case NFS4_OPEN_NOCREATE: 871 break; 872 case NFS4_OPEN_CREATE: 873 READ_BUF(4); 874 READ32(open->op_createmode); 875 switch (open->op_createmode) { 876 case NFS4_CREATE_UNCHECKED: 877 case NFS4_CREATE_GUARDED: 878 status = nfsd4_decode_fattr(argp, open->op_bmval, 879 &open->op_iattr, &open->op_acl, &open->op_label); 880 if (status) 881 goto out; 882 break; 883 case NFS4_CREATE_EXCLUSIVE: 884 READ_BUF(NFS4_VERIFIER_SIZE); 885 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); 886 break; 887 case NFS4_CREATE_EXCLUSIVE4_1: 888 if (argp->minorversion < 1) 889 goto xdr_error; 890 READ_BUF(NFS4_VERIFIER_SIZE); 891 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); 892 status = nfsd4_decode_fattr(argp, open->op_bmval, 893 &open->op_iattr, &open->op_acl, &open->op_label); 894 if (status) 895 goto out; 896 break; 897 default: 898 goto xdr_error; 899 } 900 break; 901 default: 902 goto xdr_error; 903 } 904 905 /* open_claim */ 906 READ_BUF(4); 907 READ32(open->op_claim_type); 908 switch (open->op_claim_type) { 909 case NFS4_OPEN_CLAIM_NULL: 910 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 911 READ_BUF(4); 912 READ32(open->op_fname.len); 913 READ_BUF(open->op_fname.len); 914 SAVEMEM(open->op_fname.data, open->op_fname.len); 915 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) 916 return status; 917 break; 918 case NFS4_OPEN_CLAIM_PREVIOUS: 919 READ_BUF(4); 920 READ32(open->op_delegate_type); 921 break; 922 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 923 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); 924 if (status) 925 return status; 926 READ_BUF(4); 927 READ32(open->op_fname.len); 928 READ_BUF(open->op_fname.len); 929 SAVEMEM(open->op_fname.data, open->op_fname.len); 930 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) 931 return status; 932 break; 933 case NFS4_OPEN_CLAIM_FH: 934 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 935 if (argp->minorversion < 1) 936 goto xdr_error; 937 /* void */ 938 break; 939 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 940 if (argp->minorversion < 1) 941 goto xdr_error; 942 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); 943 if (status) 944 return status; 945 break; 946 default: 947 goto xdr_error; 948 } 949 950 DECODE_TAIL; 951 } 952 953 static __be32 954 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf) 955 { 956 DECODE_HEAD; 957 958 if (argp->minorversion >= 1) 959 return nfserr_notsupp; 960 961 status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid); 962 if (status) 963 return status; 964 READ_BUF(4); 965 READ32(open_conf->oc_seqid); 966 967 DECODE_TAIL; 968 } 969 970 static __be32 971 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down) 972 { 973 DECODE_HEAD; 974 975 status = nfsd4_decode_stateid(argp, &open_down->od_stateid); 976 if (status) 977 return status; 978 READ_BUF(4); 979 READ32(open_down->od_seqid); 980 status = nfsd4_decode_share_access(argp, &open_down->od_share_access, 981 &open_down->od_deleg_want, NULL); 982 if (status) 983 return status; 984 status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny); 985 if (status) 986 return status; 987 DECODE_TAIL; 988 } 989 990 static __be32 991 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh) 992 { 993 DECODE_HEAD; 994 995 READ_BUF(4); 996 READ32(putfh->pf_fhlen); 997 if (putfh->pf_fhlen > NFS4_FHSIZE) 998 goto xdr_error; 999 READ_BUF(putfh->pf_fhlen); 1000 SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen); 1001 1002 DECODE_TAIL; 1003 } 1004 1005 static __be32 1006 nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p) 1007 { 1008 if (argp->minorversion == 0) 1009 return nfs_ok; 1010 return nfserr_notsupp; 1011 } 1012 1013 static __be32 1014 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read) 1015 { 1016 DECODE_HEAD; 1017 1018 status = nfsd4_decode_stateid(argp, &read->rd_stateid); 1019 if (status) 1020 return status; 1021 READ_BUF(12); 1022 READ64(read->rd_offset); 1023 READ32(read->rd_length); 1024 1025 DECODE_TAIL; 1026 } 1027 1028 static __be32 1029 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir) 1030 { 1031 DECODE_HEAD; 1032 1033 READ_BUF(24); 1034 READ64(readdir->rd_cookie); 1035 COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data)); 1036 READ32(readdir->rd_dircount); /* just in case you needed a useless field... */ 1037 READ32(readdir->rd_maxcount); 1038 if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval))) 1039 goto out; 1040 1041 DECODE_TAIL; 1042 } 1043 1044 static __be32 1045 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove) 1046 { 1047 DECODE_HEAD; 1048 1049 READ_BUF(4); 1050 READ32(remove->rm_namelen); 1051 READ_BUF(remove->rm_namelen); 1052 SAVEMEM(remove->rm_name, remove->rm_namelen); 1053 if ((status = check_filename(remove->rm_name, remove->rm_namelen))) 1054 return status; 1055 1056 DECODE_TAIL; 1057 } 1058 1059 static __be32 1060 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename) 1061 { 1062 DECODE_HEAD; 1063 1064 READ_BUF(4); 1065 READ32(rename->rn_snamelen); 1066 READ_BUF(rename->rn_snamelen + 4); 1067 SAVEMEM(rename->rn_sname, rename->rn_snamelen); 1068 READ32(rename->rn_tnamelen); 1069 READ_BUF(rename->rn_tnamelen); 1070 SAVEMEM(rename->rn_tname, rename->rn_tnamelen); 1071 if ((status = check_filename(rename->rn_sname, rename->rn_snamelen))) 1072 return status; 1073 if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen))) 1074 return status; 1075 1076 DECODE_TAIL; 1077 } 1078 1079 static __be32 1080 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid) 1081 { 1082 DECODE_HEAD; 1083 1084 if (argp->minorversion >= 1) 1085 return nfserr_notsupp; 1086 1087 READ_BUF(sizeof(clientid_t)); 1088 COPYMEM(clientid, sizeof(clientid_t)); 1089 1090 DECODE_TAIL; 1091 } 1092 1093 static __be32 1094 nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp, 1095 struct nfsd4_secinfo *secinfo) 1096 { 1097 DECODE_HEAD; 1098 1099 READ_BUF(4); 1100 READ32(secinfo->si_namelen); 1101 READ_BUF(secinfo->si_namelen); 1102 SAVEMEM(secinfo->si_name, secinfo->si_namelen); 1103 status = check_filename(secinfo->si_name, secinfo->si_namelen); 1104 if (status) 1105 return status; 1106 DECODE_TAIL; 1107 } 1108 1109 static __be32 1110 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp, 1111 struct nfsd4_secinfo_no_name *sin) 1112 { 1113 DECODE_HEAD; 1114 1115 READ_BUF(4); 1116 READ32(sin->sin_style); 1117 DECODE_TAIL; 1118 } 1119 1120 static __be32 1121 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr) 1122 { 1123 __be32 status; 1124 1125 status = nfsd4_decode_stateid(argp, &setattr->sa_stateid); 1126 if (status) 1127 return status; 1128 return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr, 1129 &setattr->sa_acl, &setattr->sa_label); 1130 } 1131 1132 static __be32 1133 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid) 1134 { 1135 DECODE_HEAD; 1136 1137 if (argp->minorversion >= 1) 1138 return nfserr_notsupp; 1139 1140 READ_BUF(NFS4_VERIFIER_SIZE); 1141 COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE); 1142 1143 status = nfsd4_decode_opaque(argp, &setclientid->se_name); 1144 if (status) 1145 return nfserr_bad_xdr; 1146 READ_BUF(8); 1147 READ32(setclientid->se_callback_prog); 1148 READ32(setclientid->se_callback_netid_len); 1149 1150 READ_BUF(setclientid->se_callback_netid_len + 4); 1151 SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len); 1152 READ32(setclientid->se_callback_addr_len); 1153 1154 READ_BUF(setclientid->se_callback_addr_len + 4); 1155 SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len); 1156 READ32(setclientid->se_callback_ident); 1157 1158 DECODE_TAIL; 1159 } 1160 1161 static __be32 1162 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c) 1163 { 1164 DECODE_HEAD; 1165 1166 if (argp->minorversion >= 1) 1167 return nfserr_notsupp; 1168 1169 READ_BUF(8 + NFS4_VERIFIER_SIZE); 1170 COPYMEM(&scd_c->sc_clientid, 8); 1171 COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE); 1172 1173 DECODE_TAIL; 1174 } 1175 1176 /* Also used for NVERIFY */ 1177 static __be32 1178 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify) 1179 { 1180 DECODE_HEAD; 1181 1182 if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval))) 1183 goto out; 1184 1185 /* For convenience's sake, we compare raw xdr'd attributes in 1186 * nfsd4_proc_verify */ 1187 1188 READ_BUF(4); 1189 READ32(verify->ve_attrlen); 1190 READ_BUF(verify->ve_attrlen); 1191 SAVEMEM(verify->ve_attrval, verify->ve_attrlen); 1192 1193 DECODE_TAIL; 1194 } 1195 1196 static __be32 1197 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write) 1198 { 1199 int avail; 1200 int len; 1201 DECODE_HEAD; 1202 1203 status = nfsd4_decode_stateid(argp, &write->wr_stateid); 1204 if (status) 1205 return status; 1206 READ_BUF(16); 1207 READ64(write->wr_offset); 1208 READ32(write->wr_stable_how); 1209 if (write->wr_stable_how > 2) 1210 goto xdr_error; 1211 READ32(write->wr_buflen); 1212 1213 /* Sorry .. no magic macros for this.. * 1214 * READ_BUF(write->wr_buflen); 1215 * SAVEMEM(write->wr_buf, write->wr_buflen); 1216 */ 1217 avail = (char*)argp->end - (char*)argp->p; 1218 if (avail + argp->pagelen < write->wr_buflen) { 1219 dprintk("NFSD: xdr error (%s:%d)\n", 1220 __FILE__, __LINE__); 1221 goto xdr_error; 1222 } 1223 write->wr_head.iov_base = p; 1224 write->wr_head.iov_len = avail; 1225 write->wr_pagelist = argp->pagelist; 1226 1227 len = XDR_QUADLEN(write->wr_buflen) << 2; 1228 if (len >= avail) { 1229 int pages; 1230 1231 len -= avail; 1232 1233 pages = len >> PAGE_SHIFT; 1234 argp->pagelist += pages; 1235 argp->pagelen -= pages * PAGE_SIZE; 1236 len -= pages * PAGE_SIZE; 1237 1238 argp->p = (__be32 *)page_address(argp->pagelist[0]); 1239 argp->pagelist++; 1240 argp->end = argp->p + XDR_QUADLEN(PAGE_SIZE); 1241 } 1242 argp->p += XDR_QUADLEN(len); 1243 1244 DECODE_TAIL; 1245 } 1246 1247 static __be32 1248 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner) 1249 { 1250 DECODE_HEAD; 1251 1252 if (argp->minorversion >= 1) 1253 return nfserr_notsupp; 1254 1255 READ_BUF(12); 1256 COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t)); 1257 READ32(rlockowner->rl_owner.len); 1258 READ_BUF(rlockowner->rl_owner.len); 1259 READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len); 1260 1261 if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) 1262 return nfserr_inval; 1263 DECODE_TAIL; 1264 } 1265 1266 static __be32 1267 nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp, 1268 struct nfsd4_exchange_id *exid) 1269 { 1270 int dummy, tmp; 1271 DECODE_HEAD; 1272 1273 READ_BUF(NFS4_VERIFIER_SIZE); 1274 COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE); 1275 1276 status = nfsd4_decode_opaque(argp, &exid->clname); 1277 if (status) 1278 return nfserr_bad_xdr; 1279 1280 READ_BUF(4); 1281 READ32(exid->flags); 1282 1283 /* Ignore state_protect4_a */ 1284 READ_BUF(4); 1285 READ32(exid->spa_how); 1286 switch (exid->spa_how) { 1287 case SP4_NONE: 1288 break; 1289 case SP4_MACH_CRED: 1290 /* spo_must_enforce */ 1291 READ_BUF(4); 1292 READ32(dummy); 1293 READ_BUF(dummy * 4); 1294 p += dummy; 1295 1296 /* spo_must_allow */ 1297 READ_BUF(4); 1298 READ32(dummy); 1299 READ_BUF(dummy * 4); 1300 p += dummy; 1301 break; 1302 case SP4_SSV: 1303 /* ssp_ops */ 1304 READ_BUF(4); 1305 READ32(dummy); 1306 READ_BUF(dummy * 4); 1307 p += dummy; 1308 1309 READ_BUF(4); 1310 READ32(dummy); 1311 READ_BUF(dummy * 4); 1312 p += dummy; 1313 1314 /* ssp_hash_algs<> */ 1315 READ_BUF(4); 1316 READ32(tmp); 1317 while (tmp--) { 1318 READ_BUF(4); 1319 READ32(dummy); 1320 READ_BUF(dummy); 1321 p += XDR_QUADLEN(dummy); 1322 } 1323 1324 /* ssp_encr_algs<> */ 1325 READ_BUF(4); 1326 READ32(tmp); 1327 while (tmp--) { 1328 READ_BUF(4); 1329 READ32(dummy); 1330 READ_BUF(dummy); 1331 p += XDR_QUADLEN(dummy); 1332 } 1333 1334 /* ssp_window and ssp_num_gss_handles */ 1335 READ_BUF(8); 1336 READ32(dummy); 1337 READ32(dummy); 1338 break; 1339 default: 1340 goto xdr_error; 1341 } 1342 1343 /* Ignore Implementation ID */ 1344 READ_BUF(4); /* nfs_impl_id4 array length */ 1345 READ32(dummy); 1346 1347 if (dummy > 1) 1348 goto xdr_error; 1349 1350 if (dummy == 1) { 1351 /* nii_domain */ 1352 READ_BUF(4); 1353 READ32(dummy); 1354 READ_BUF(dummy); 1355 p += XDR_QUADLEN(dummy); 1356 1357 /* nii_name */ 1358 READ_BUF(4); 1359 READ32(dummy); 1360 READ_BUF(dummy); 1361 p += XDR_QUADLEN(dummy); 1362 1363 /* nii_date */ 1364 READ_BUF(12); 1365 p += 3; 1366 } 1367 DECODE_TAIL; 1368 } 1369 1370 static __be32 1371 nfsd4_decode_create_session(struct nfsd4_compoundargs *argp, 1372 struct nfsd4_create_session *sess) 1373 { 1374 DECODE_HEAD; 1375 u32 dummy; 1376 1377 READ_BUF(16); 1378 COPYMEM(&sess->clientid, 8); 1379 READ32(sess->seqid); 1380 READ32(sess->flags); 1381 1382 /* Fore channel attrs */ 1383 READ_BUF(28); 1384 READ32(dummy); /* headerpadsz is always 0 */ 1385 READ32(sess->fore_channel.maxreq_sz); 1386 READ32(sess->fore_channel.maxresp_sz); 1387 READ32(sess->fore_channel.maxresp_cached); 1388 READ32(sess->fore_channel.maxops); 1389 READ32(sess->fore_channel.maxreqs); 1390 READ32(sess->fore_channel.nr_rdma_attrs); 1391 if (sess->fore_channel.nr_rdma_attrs == 1) { 1392 READ_BUF(4); 1393 READ32(sess->fore_channel.rdma_attrs); 1394 } else if (sess->fore_channel.nr_rdma_attrs > 1) { 1395 dprintk("Too many fore channel attr bitmaps!\n"); 1396 goto xdr_error; 1397 } 1398 1399 /* Back channel attrs */ 1400 READ_BUF(28); 1401 READ32(dummy); /* headerpadsz is always 0 */ 1402 READ32(sess->back_channel.maxreq_sz); 1403 READ32(sess->back_channel.maxresp_sz); 1404 READ32(sess->back_channel.maxresp_cached); 1405 READ32(sess->back_channel.maxops); 1406 READ32(sess->back_channel.maxreqs); 1407 READ32(sess->back_channel.nr_rdma_attrs); 1408 if (sess->back_channel.nr_rdma_attrs == 1) { 1409 READ_BUF(4); 1410 READ32(sess->back_channel.rdma_attrs); 1411 } else if (sess->back_channel.nr_rdma_attrs > 1) { 1412 dprintk("Too many back channel attr bitmaps!\n"); 1413 goto xdr_error; 1414 } 1415 1416 READ_BUF(4); 1417 READ32(sess->callback_prog); 1418 nfsd4_decode_cb_sec(argp, &sess->cb_sec); 1419 DECODE_TAIL; 1420 } 1421 1422 static __be32 1423 nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp, 1424 struct nfsd4_destroy_session *destroy_session) 1425 { 1426 DECODE_HEAD; 1427 READ_BUF(NFS4_MAX_SESSIONID_LEN); 1428 COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN); 1429 1430 DECODE_TAIL; 1431 } 1432 1433 static __be32 1434 nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp, 1435 struct nfsd4_free_stateid *free_stateid) 1436 { 1437 DECODE_HEAD; 1438 1439 READ_BUF(sizeof(stateid_t)); 1440 READ32(free_stateid->fr_stateid.si_generation); 1441 COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t)); 1442 1443 DECODE_TAIL; 1444 } 1445 1446 static __be32 1447 nfsd4_decode_sequence(struct nfsd4_compoundargs *argp, 1448 struct nfsd4_sequence *seq) 1449 { 1450 DECODE_HEAD; 1451 1452 READ_BUF(NFS4_MAX_SESSIONID_LEN + 16); 1453 COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); 1454 READ32(seq->seqid); 1455 READ32(seq->slotid); 1456 READ32(seq->maxslots); 1457 READ32(seq->cachethis); 1458 1459 DECODE_TAIL; 1460 } 1461 1462 static __be32 1463 nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid) 1464 { 1465 int i; 1466 __be32 *p, status; 1467 struct nfsd4_test_stateid_id *stateid; 1468 1469 READ_BUF(4); 1470 test_stateid->ts_num_ids = ntohl(*p++); 1471 1472 INIT_LIST_HEAD(&test_stateid->ts_stateid_list); 1473 1474 for (i = 0; i < test_stateid->ts_num_ids; i++) { 1475 stateid = kmalloc(sizeof(struct nfsd4_test_stateid_id), GFP_KERNEL); 1476 if (!stateid) { 1477 status = nfserrno(-ENOMEM); 1478 goto out; 1479 } 1480 1481 defer_free(argp, kfree, stateid); 1482 INIT_LIST_HEAD(&stateid->ts_id_list); 1483 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); 1484 1485 status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid); 1486 if (status) 1487 goto out; 1488 } 1489 1490 status = 0; 1491 out: 1492 return status; 1493 xdr_error: 1494 dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__); 1495 status = nfserr_bad_xdr; 1496 goto out; 1497 } 1498 1499 static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc) 1500 { 1501 DECODE_HEAD; 1502 1503 READ_BUF(8); 1504 COPYMEM(&dc->clientid, 8); 1505 1506 DECODE_TAIL; 1507 } 1508 1509 static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc) 1510 { 1511 DECODE_HEAD; 1512 1513 READ_BUF(4); 1514 READ32(rc->rca_one_fs); 1515 1516 DECODE_TAIL; 1517 } 1518 1519 static __be32 1520 nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p) 1521 { 1522 return nfs_ok; 1523 } 1524 1525 static __be32 1526 nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p) 1527 { 1528 return nfserr_notsupp; 1529 } 1530 1531 typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *); 1532 1533 static nfsd4_dec nfsd4_dec_ops[] = { 1534 [OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access, 1535 [OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close, 1536 [OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit, 1537 [OP_CREATE] = (nfsd4_dec)nfsd4_decode_create, 1538 [OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp, 1539 [OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn, 1540 [OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr, 1541 [OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop, 1542 [OP_LINK] = (nfsd4_dec)nfsd4_decode_link, 1543 [OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock, 1544 [OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt, 1545 [OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku, 1546 [OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup, 1547 [OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop, 1548 [OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify, 1549 [OP_OPEN] = (nfsd4_dec)nfsd4_decode_open, 1550 [OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp, 1551 [OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm, 1552 [OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade, 1553 [OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh, 1554 [OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_putpubfh, 1555 [OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop, 1556 [OP_READ] = (nfsd4_dec)nfsd4_decode_read, 1557 [OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir, 1558 [OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop, 1559 [OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove, 1560 [OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename, 1561 [OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew, 1562 [OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop, 1563 [OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop, 1564 [OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo, 1565 [OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr, 1566 [OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid, 1567 [OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm, 1568 [OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify, 1569 [OP_WRITE] = (nfsd4_dec)nfsd4_decode_write, 1570 [OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner, 1571 1572 /* new operations for NFSv4.1 */ 1573 [OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl, 1574 [OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session, 1575 [OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id, 1576 [OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session, 1577 [OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session, 1578 [OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid, 1579 [OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, 1580 [OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp, 1581 [OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp, 1582 [OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp, 1583 [OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp, 1584 [OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp, 1585 [OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name, 1586 [OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence, 1587 [OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp, 1588 [OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid, 1589 [OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, 1590 [OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid, 1591 [OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete, 1592 }; 1593 1594 static inline bool 1595 nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op) 1596 { 1597 if (op->opnum < FIRST_NFS4_OP) 1598 return false; 1599 else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) 1600 return false; 1601 else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) 1602 return false; 1603 else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) 1604 return false; 1605 return true; 1606 } 1607 1608 /* 1609 * Return a rough estimate of the maximum possible reply size. Note the 1610 * estimate includes rpc headers so is meant to be passed to 1611 * svc_reserve, not svc_reserve_auth. 1612 * 1613 * Also note the current compound encoding permits only one operation to 1614 * use pages beyond the first one, so the maximum possible length is the 1615 * maximum over these values, not the sum. 1616 */ 1617 static int nfsd4_max_reply(u32 opnum) 1618 { 1619 switch (opnum) { 1620 case OP_READLINK: 1621 case OP_READDIR: 1622 /* 1623 * Both of these ops take a single page for data and put 1624 * the head and tail in another page: 1625 */ 1626 return 2 * PAGE_SIZE; 1627 case OP_READ: 1628 return INT_MAX; 1629 default: 1630 return PAGE_SIZE; 1631 } 1632 } 1633 1634 static __be32 1635 nfsd4_decode_compound(struct nfsd4_compoundargs *argp) 1636 { 1637 DECODE_HEAD; 1638 struct nfsd4_op *op; 1639 bool cachethis = false; 1640 int max_reply = PAGE_SIZE; 1641 int i; 1642 1643 READ_BUF(4); 1644 READ32(argp->taglen); 1645 READ_BUF(argp->taglen + 8); 1646 SAVEMEM(argp->tag, argp->taglen); 1647 READ32(argp->minorversion); 1648 READ32(argp->opcnt); 1649 1650 if (argp->taglen > NFSD4_MAX_TAGLEN) 1651 goto xdr_error; 1652 if (argp->opcnt > 100) 1653 goto xdr_error; 1654 1655 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { 1656 argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL); 1657 if (!argp->ops) { 1658 argp->ops = argp->iops; 1659 dprintk("nfsd: couldn't allocate room for COMPOUND\n"); 1660 goto xdr_error; 1661 } 1662 } 1663 1664 if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) 1665 argp->opcnt = 0; 1666 1667 for (i = 0; i < argp->opcnt; i++) { 1668 op = &argp->ops[i]; 1669 op->replay = NULL; 1670 1671 READ_BUF(4); 1672 READ32(op->opnum); 1673 1674 if (nfsd4_opnum_in_range(argp, op)) 1675 op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); 1676 else { 1677 op->opnum = OP_ILLEGAL; 1678 op->status = nfserr_op_illegal; 1679 } 1680 1681 if (op->status) { 1682 argp->opcnt = i+1; 1683 break; 1684 } 1685 /* 1686 * We'll try to cache the result in the DRC if any one 1687 * op in the compound wants to be cached: 1688 */ 1689 cachethis |= nfsd4_cache_this_op(op); 1690 1691 max_reply = max(max_reply, nfsd4_max_reply(op->opnum)); 1692 } 1693 /* Sessions make the DRC unnecessary: */ 1694 if (argp->minorversion) 1695 cachethis = false; 1696 if (max_reply != INT_MAX) 1697 svc_reserve(argp->rqstp, max_reply); 1698 argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; 1699 1700 DECODE_TAIL; 1701 } 1702 1703 #define WRITE32(n) *p++ = htonl(n) 1704 #define WRITE64(n) do { \ 1705 *p++ = htonl((u32)((n) >> 32)); \ 1706 *p++ = htonl((u32)(n)); \ 1707 } while (0) 1708 #define WRITEMEM(ptr,nbytes) do { if (nbytes > 0) { \ 1709 *(p + XDR_QUADLEN(nbytes) -1) = 0; \ 1710 memcpy(p, ptr, nbytes); \ 1711 p += XDR_QUADLEN(nbytes); \ 1712 }} while (0) 1713 1714 static void write32(__be32 **p, u32 n) 1715 { 1716 *(*p)++ = htonl(n); 1717 } 1718 1719 static void write64(__be32 **p, u64 n) 1720 { 1721 write32(p, (n >> 32)); 1722 write32(p, (u32)n); 1723 } 1724 1725 static void write_change(__be32 **p, struct kstat *stat, struct inode *inode) 1726 { 1727 if (IS_I_VERSION(inode)) { 1728 write64(p, inode->i_version); 1729 } else { 1730 write32(p, stat->ctime.tv_sec); 1731 write32(p, stat->ctime.tv_nsec); 1732 } 1733 } 1734 1735 static void write_cinfo(__be32 **p, struct nfsd4_change_info *c) 1736 { 1737 write32(p, c->atomic); 1738 if (c->change_supported) { 1739 write64(p, c->before_change); 1740 write64(p, c->after_change); 1741 } else { 1742 write32(p, c->before_ctime_sec); 1743 write32(p, c->before_ctime_nsec); 1744 write32(p, c->after_ctime_sec); 1745 write32(p, c->after_ctime_nsec); 1746 } 1747 } 1748 1749 #define RESERVE_SPACE(nbytes) do { \ 1750 p = resp->p; \ 1751 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \ 1752 } while (0) 1753 #define ADJUST_ARGS() resp->p = p 1754 1755 /* Encode as an array of strings the string given with components 1756 * separated @sep, escaped with esc_enter and esc_exit. 1757 */ 1758 static __be32 nfsd4_encode_components_esc(char sep, char *components, 1759 __be32 **pp, int *buflen, 1760 char esc_enter, char esc_exit) 1761 { 1762 __be32 *p = *pp; 1763 __be32 *countp = p; 1764 int strlen, count=0; 1765 char *str, *end, *next; 1766 1767 dprintk("nfsd4_encode_components(%s)\n", components); 1768 if ((*buflen -= 4) < 0) 1769 return nfserr_resource; 1770 WRITE32(0); /* We will fill this in with @count later */ 1771 end = str = components; 1772 while (*end) { 1773 bool found_esc = false; 1774 1775 /* try to parse as esc_start, ..., esc_end, sep */ 1776 if (*str == esc_enter) { 1777 for (; *end && (*end != esc_exit); end++) 1778 /* find esc_exit or end of string */; 1779 next = end + 1; 1780 if (*end && (!*next || *next == sep)) { 1781 str++; 1782 found_esc = true; 1783 } 1784 } 1785 1786 if (!found_esc) 1787 for (; *end && (*end != sep); end++) 1788 /* find sep or end of string */; 1789 1790 strlen = end - str; 1791 if (strlen) { 1792 if ((*buflen -= ((XDR_QUADLEN(strlen) << 2) + 4)) < 0) 1793 return nfserr_resource; 1794 WRITE32(strlen); 1795 WRITEMEM(str, strlen); 1796 count++; 1797 } 1798 else 1799 end++; 1800 str = end; 1801 } 1802 *pp = p; 1803 p = countp; 1804 WRITE32(count); 1805 return 0; 1806 } 1807 1808 /* Encode as an array of strings the string given with components 1809 * separated @sep. 1810 */ 1811 static __be32 nfsd4_encode_components(char sep, char *components, 1812 __be32 **pp, int *buflen) 1813 { 1814 return nfsd4_encode_components_esc(sep, components, pp, buflen, 0, 0); 1815 } 1816 1817 /* 1818 * encode a location element of a fs_locations structure 1819 */ 1820 static __be32 nfsd4_encode_fs_location4(struct nfsd4_fs_location *location, 1821 __be32 **pp, int *buflen) 1822 { 1823 __be32 status; 1824 __be32 *p = *pp; 1825 1826 status = nfsd4_encode_components_esc(':', location->hosts, &p, buflen, 1827 '[', ']'); 1828 if (status) 1829 return status; 1830 status = nfsd4_encode_components('/', location->path, &p, buflen); 1831 if (status) 1832 return status; 1833 *pp = p; 1834 return 0; 1835 } 1836 1837 /* 1838 * Encode a path in RFC3530 'pathname4' format 1839 */ 1840 static __be32 nfsd4_encode_path(const struct path *root, 1841 const struct path *path, __be32 **pp, int *buflen) 1842 { 1843 struct path cur = *path; 1844 __be32 *p = *pp; 1845 struct dentry **components = NULL; 1846 unsigned int ncomponents = 0; 1847 __be32 err = nfserr_jukebox; 1848 1849 dprintk("nfsd4_encode_components("); 1850 1851 path_get(&cur); 1852 /* First walk the path up to the nfsd root, and store the 1853 * dentries/path components in an array. 1854 */ 1855 for (;;) { 1856 if (cur.dentry == root->dentry && cur.mnt == root->mnt) 1857 break; 1858 if (cur.dentry == cur.mnt->mnt_root) { 1859 if (follow_up(&cur)) 1860 continue; 1861 goto out_free; 1862 } 1863 if ((ncomponents & 15) == 0) { 1864 struct dentry **new; 1865 new = krealloc(components, 1866 sizeof(*new) * (ncomponents + 16), 1867 GFP_KERNEL); 1868 if (!new) 1869 goto out_free; 1870 components = new; 1871 } 1872 components[ncomponents++] = cur.dentry; 1873 cur.dentry = dget_parent(cur.dentry); 1874 } 1875 1876 *buflen -= 4; 1877 if (*buflen < 0) 1878 goto out_free; 1879 WRITE32(ncomponents); 1880 1881 while (ncomponents) { 1882 struct dentry *dentry = components[ncomponents - 1]; 1883 unsigned int len; 1884 1885 spin_lock(&dentry->d_lock); 1886 len = dentry->d_name.len; 1887 *buflen -= 4 + (XDR_QUADLEN(len) << 2); 1888 if (*buflen < 0) { 1889 spin_unlock(&dentry->d_lock); 1890 goto out_free; 1891 } 1892 WRITE32(len); 1893 WRITEMEM(dentry->d_name.name, len); 1894 dprintk("/%s", dentry->d_name.name); 1895 spin_unlock(&dentry->d_lock); 1896 dput(dentry); 1897 ncomponents--; 1898 } 1899 1900 *pp = p; 1901 err = 0; 1902 out_free: 1903 dprintk(")\n"); 1904 while (ncomponents) 1905 dput(components[--ncomponents]); 1906 kfree(components); 1907 path_put(&cur); 1908 return err; 1909 } 1910 1911 static __be32 nfsd4_encode_fsloc_fsroot(struct svc_rqst *rqstp, 1912 const struct path *path, __be32 **pp, int *buflen) 1913 { 1914 struct svc_export *exp_ps; 1915 __be32 res; 1916 1917 exp_ps = rqst_find_fsidzero_export(rqstp); 1918 if (IS_ERR(exp_ps)) 1919 return nfserrno(PTR_ERR(exp_ps)); 1920 res = nfsd4_encode_path(&exp_ps->ex_path, path, pp, buflen); 1921 exp_put(exp_ps); 1922 return res; 1923 } 1924 1925 /* 1926 * encode a fs_locations structure 1927 */ 1928 static __be32 nfsd4_encode_fs_locations(struct svc_rqst *rqstp, 1929 struct svc_export *exp, 1930 __be32 **pp, int *buflen) 1931 { 1932 __be32 status; 1933 int i; 1934 __be32 *p = *pp; 1935 struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; 1936 1937 status = nfsd4_encode_fsloc_fsroot(rqstp, &exp->ex_path, &p, buflen); 1938 if (status) 1939 return status; 1940 if ((*buflen -= 4) < 0) 1941 return nfserr_resource; 1942 WRITE32(fslocs->locations_count); 1943 for (i=0; i<fslocs->locations_count; i++) { 1944 status = nfsd4_encode_fs_location4(&fslocs->locations[i], 1945 &p, buflen); 1946 if (status) 1947 return status; 1948 } 1949 *pp = p; 1950 return 0; 1951 } 1952 1953 static u32 nfs4_file_type(umode_t mode) 1954 { 1955 switch (mode & S_IFMT) { 1956 case S_IFIFO: return NF4FIFO; 1957 case S_IFCHR: return NF4CHR; 1958 case S_IFDIR: return NF4DIR; 1959 case S_IFBLK: return NF4BLK; 1960 case S_IFLNK: return NF4LNK; 1961 case S_IFREG: return NF4REG; 1962 case S_IFSOCK: return NF4SOCK; 1963 default: return NF4BAD; 1964 }; 1965 } 1966 1967 static inline __be32 1968 nfsd4_encode_aclname(struct svc_rqst *rqstp, struct nfs4_ace *ace, 1969 __be32 **p, int *buflen) 1970 { 1971 if (ace->whotype != NFS4_ACL_WHO_NAMED) 1972 return nfs4_acl_write_who(ace->whotype, p, buflen); 1973 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) 1974 return nfsd4_encode_group(rqstp, ace->who_gid, p, buflen); 1975 else 1976 return nfsd4_encode_user(rqstp, ace->who_uid, p, buflen); 1977 } 1978 1979 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \ 1980 FATTR4_WORD0_RDATTR_ERROR) 1981 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID 1982 1983 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 1984 static inline __be32 1985 nfsd4_encode_security_label(struct svc_rqst *rqstp, void *context, int len, __be32 **pp, int *buflen) 1986 { 1987 __be32 *p = *pp; 1988 1989 if (*buflen < ((XDR_QUADLEN(len) << 2) + 4 + 4 + 4)) 1990 return nfserr_resource; 1991 1992 /* 1993 * For now we use a 0 here to indicate the null translation; in 1994 * the future we may place a call to translation code here. 1995 */ 1996 if ((*buflen -= 8) < 0) 1997 return nfserr_resource; 1998 1999 WRITE32(0); /* lfs */ 2000 WRITE32(0); /* pi */ 2001 p = xdr_encode_opaque(p, context, len); 2002 *buflen -= (XDR_QUADLEN(len) << 2) + 4; 2003 2004 *pp = p; 2005 return 0; 2006 } 2007 #else 2008 static inline __be32 2009 nfsd4_encode_security_label(struct svc_rqst *rqstp, void *context, int len, __be32 **pp, int *buflen) 2010 { return 0; } 2011 #endif 2012 2013 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *rdattr_err) 2014 { 2015 /* As per referral draft: */ 2016 if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS || 2017 *bmval1 & ~WORD1_ABSENT_FS_ATTRS) { 2018 if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR || 2019 *bmval0 & FATTR4_WORD0_FS_LOCATIONS) 2020 *rdattr_err = NFSERR_MOVED; 2021 else 2022 return nfserr_moved; 2023 } 2024 *bmval0 &= WORD0_ABSENT_FS_ATTRS; 2025 *bmval1 &= WORD1_ABSENT_FS_ATTRS; 2026 return 0; 2027 } 2028 2029 2030 static int get_parent_attributes(struct svc_export *exp, struct kstat *stat) 2031 { 2032 struct path path = exp->ex_path; 2033 int err; 2034 2035 path_get(&path); 2036 while (follow_up(&path)) { 2037 if (path.dentry != path.mnt->mnt_root) 2038 break; 2039 } 2040 err = vfs_getattr(&path, stat); 2041 path_put(&path); 2042 return err; 2043 } 2044 2045 /* 2046 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle 2047 * ourselves. 2048 * 2049 * countp is the buffer size in _words_ 2050 */ 2051 __be32 2052 nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp, 2053 struct dentry *dentry, __be32 **buffer, int count, u32 *bmval, 2054 struct svc_rqst *rqstp, int ignore_crossmnt) 2055 { 2056 u32 bmval0 = bmval[0]; 2057 u32 bmval1 = bmval[1]; 2058 u32 bmval2 = bmval[2]; 2059 struct kstat stat; 2060 struct svc_fh *tempfh = NULL; 2061 struct kstatfs statfs; 2062 int buflen = count << 2; 2063 __be32 *attrlenp; 2064 u32 dummy; 2065 u64 dummy64; 2066 u32 rdattr_err = 0; 2067 __be32 *p = *buffer; 2068 __be32 status; 2069 int err; 2070 int aclsupport = 0; 2071 struct nfs4_acl *acl = NULL; 2072 void *context = NULL; 2073 int contextlen; 2074 bool contextsupport = false; 2075 struct nfsd4_compoundres *resp = rqstp->rq_resp; 2076 u32 minorversion = resp->cstate.minorversion; 2077 struct path path = { 2078 .mnt = exp->ex_path.mnt, 2079 .dentry = dentry, 2080 }; 2081 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2082 2083 BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1); 2084 BUG_ON(bmval0 & ~nfsd_suppattrs0(minorversion)); 2085 BUG_ON(bmval1 & ~nfsd_suppattrs1(minorversion)); 2086 BUG_ON(bmval2 & ~nfsd_suppattrs2(minorversion)); 2087 2088 if (exp->ex_fslocs.migrated) { 2089 BUG_ON(bmval[2]); 2090 status = fattr_handle_absent_fs(&bmval0, &bmval1, &rdattr_err); 2091 if (status) 2092 goto out; 2093 } 2094 2095 err = vfs_getattr(&path, &stat); 2096 if (err) 2097 goto out_nfserr; 2098 if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL | 2099 FATTR4_WORD0_MAXNAME)) || 2100 (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | 2101 FATTR4_WORD1_SPACE_TOTAL))) { 2102 err = vfs_statfs(&path, &statfs); 2103 if (err) 2104 goto out_nfserr; 2105 } 2106 if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) { 2107 tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL); 2108 status = nfserr_jukebox; 2109 if (!tempfh) 2110 goto out; 2111 fh_init(tempfh, NFS4_FHSIZE); 2112 status = fh_compose(tempfh, exp, dentry, NULL); 2113 if (status) 2114 goto out; 2115 fhp = tempfh; 2116 } 2117 if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT 2118 | FATTR4_WORD0_SUPPORTED_ATTRS)) { 2119 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl); 2120 aclsupport = (err == 0); 2121 if (bmval0 & FATTR4_WORD0_ACL) { 2122 if (err == -EOPNOTSUPP) 2123 bmval0 &= ~FATTR4_WORD0_ACL; 2124 else if (err == -EINVAL) { 2125 status = nfserr_attrnotsupp; 2126 goto out; 2127 } else if (err != 0) 2128 goto out_nfserr; 2129 } 2130 } 2131 2132 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2133 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) || 2134 bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) { 2135 err = security_inode_getsecctx(dentry->d_inode, 2136 &context, &contextlen); 2137 contextsupport = (err == 0); 2138 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { 2139 if (err == -EOPNOTSUPP) 2140 bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL; 2141 else if (err) 2142 goto out_nfserr; 2143 } 2144 } 2145 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ 2146 2147 if (bmval2) { 2148 if ((buflen -= 16) < 0) 2149 goto out_resource; 2150 WRITE32(3); 2151 WRITE32(bmval0); 2152 WRITE32(bmval1); 2153 WRITE32(bmval2); 2154 } else if (bmval1) { 2155 if ((buflen -= 12) < 0) 2156 goto out_resource; 2157 WRITE32(2); 2158 WRITE32(bmval0); 2159 WRITE32(bmval1); 2160 } else { 2161 if ((buflen -= 8) < 0) 2162 goto out_resource; 2163 WRITE32(1); 2164 WRITE32(bmval0); 2165 } 2166 attrlenp = p++; /* to be backfilled later */ 2167 2168 if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) { 2169 u32 word0 = nfsd_suppattrs0(minorversion); 2170 u32 word1 = nfsd_suppattrs1(minorversion); 2171 u32 word2 = nfsd_suppattrs2(minorversion); 2172 2173 if (!aclsupport) 2174 word0 &= ~FATTR4_WORD0_ACL; 2175 if (!contextsupport) 2176 word2 &= ~FATTR4_WORD2_SECURITY_LABEL; 2177 if (!word2) { 2178 if ((buflen -= 12) < 0) 2179 goto out_resource; 2180 WRITE32(2); 2181 WRITE32(word0); 2182 WRITE32(word1); 2183 } else { 2184 if ((buflen -= 16) < 0) 2185 goto out_resource; 2186 WRITE32(3); 2187 WRITE32(word0); 2188 WRITE32(word1); 2189 WRITE32(word2); 2190 } 2191 } 2192 if (bmval0 & FATTR4_WORD0_TYPE) { 2193 if ((buflen -= 4) < 0) 2194 goto out_resource; 2195 dummy = nfs4_file_type(stat.mode); 2196 if (dummy == NF4BAD) { 2197 status = nfserr_serverfault; 2198 goto out; 2199 } 2200 WRITE32(dummy); 2201 } 2202 if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) { 2203 if ((buflen -= 4) < 0) 2204 goto out_resource; 2205 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) 2206 WRITE32(NFS4_FH_PERSISTENT); 2207 else 2208 WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME); 2209 } 2210 if (bmval0 & FATTR4_WORD0_CHANGE) { 2211 if ((buflen -= 8) < 0) 2212 goto out_resource; 2213 write_change(&p, &stat, dentry->d_inode); 2214 } 2215 if (bmval0 & FATTR4_WORD0_SIZE) { 2216 if ((buflen -= 8) < 0) 2217 goto out_resource; 2218 WRITE64(stat.size); 2219 } 2220 if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) { 2221 if ((buflen -= 4) < 0) 2222 goto out_resource; 2223 WRITE32(1); 2224 } 2225 if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) { 2226 if ((buflen -= 4) < 0) 2227 goto out_resource; 2228 WRITE32(1); 2229 } 2230 if (bmval0 & FATTR4_WORD0_NAMED_ATTR) { 2231 if ((buflen -= 4) < 0) 2232 goto out_resource; 2233 WRITE32(0); 2234 } 2235 if (bmval0 & FATTR4_WORD0_FSID) { 2236 if ((buflen -= 16) < 0) 2237 goto out_resource; 2238 if (exp->ex_fslocs.migrated) { 2239 WRITE64(NFS4_REFERRAL_FSID_MAJOR); 2240 WRITE64(NFS4_REFERRAL_FSID_MINOR); 2241 } else switch(fsid_source(fhp)) { 2242 case FSIDSOURCE_FSID: 2243 WRITE64((u64)exp->ex_fsid); 2244 WRITE64((u64)0); 2245 break; 2246 case FSIDSOURCE_DEV: 2247 WRITE32(0); 2248 WRITE32(MAJOR(stat.dev)); 2249 WRITE32(0); 2250 WRITE32(MINOR(stat.dev)); 2251 break; 2252 case FSIDSOURCE_UUID: 2253 WRITEMEM(exp->ex_uuid, 16); 2254 break; 2255 } 2256 } 2257 if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) { 2258 if ((buflen -= 4) < 0) 2259 goto out_resource; 2260 WRITE32(0); 2261 } 2262 if (bmval0 & FATTR4_WORD0_LEASE_TIME) { 2263 if ((buflen -= 4) < 0) 2264 goto out_resource; 2265 WRITE32(nn->nfsd4_lease); 2266 } 2267 if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) { 2268 if ((buflen -= 4) < 0) 2269 goto out_resource; 2270 WRITE32(rdattr_err); 2271 } 2272 if (bmval0 & FATTR4_WORD0_ACL) { 2273 struct nfs4_ace *ace; 2274 2275 if (acl == NULL) { 2276 if ((buflen -= 4) < 0) 2277 goto out_resource; 2278 2279 WRITE32(0); 2280 goto out_acl; 2281 } 2282 if ((buflen -= 4) < 0) 2283 goto out_resource; 2284 WRITE32(acl->naces); 2285 2286 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { 2287 if ((buflen -= 4*3) < 0) 2288 goto out_resource; 2289 WRITE32(ace->type); 2290 WRITE32(ace->flag); 2291 WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL); 2292 status = nfsd4_encode_aclname(rqstp, ace, &p, &buflen); 2293 if (status) 2294 goto out; 2295 } 2296 } 2297 out_acl: 2298 if (bmval0 & FATTR4_WORD0_ACLSUPPORT) { 2299 if ((buflen -= 4) < 0) 2300 goto out_resource; 2301 WRITE32(aclsupport ? 2302 ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0); 2303 } 2304 if (bmval0 & FATTR4_WORD0_CANSETTIME) { 2305 if ((buflen -= 4) < 0) 2306 goto out_resource; 2307 WRITE32(1); 2308 } 2309 if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { 2310 if ((buflen -= 4) < 0) 2311 goto out_resource; 2312 WRITE32(0); 2313 } 2314 if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { 2315 if ((buflen -= 4) < 0) 2316 goto out_resource; 2317 WRITE32(1); 2318 } 2319 if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) { 2320 if ((buflen -= 4) < 0) 2321 goto out_resource; 2322 WRITE32(1); 2323 } 2324 if (bmval0 & FATTR4_WORD0_FILEHANDLE) { 2325 buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4; 2326 if (buflen < 0) 2327 goto out_resource; 2328 WRITE32(fhp->fh_handle.fh_size); 2329 WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size); 2330 } 2331 if (bmval0 & FATTR4_WORD0_FILEID) { 2332 if ((buflen -= 8) < 0) 2333 goto out_resource; 2334 WRITE64(stat.ino); 2335 } 2336 if (bmval0 & FATTR4_WORD0_FILES_AVAIL) { 2337 if ((buflen -= 8) < 0) 2338 goto out_resource; 2339 WRITE64((u64) statfs.f_ffree); 2340 } 2341 if (bmval0 & FATTR4_WORD0_FILES_FREE) { 2342 if ((buflen -= 8) < 0) 2343 goto out_resource; 2344 WRITE64((u64) statfs.f_ffree); 2345 } 2346 if (bmval0 & FATTR4_WORD0_FILES_TOTAL) { 2347 if ((buflen -= 8) < 0) 2348 goto out_resource; 2349 WRITE64((u64) statfs.f_files); 2350 } 2351 if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) { 2352 status = nfsd4_encode_fs_locations(rqstp, exp, &p, &buflen); 2353 if (status) 2354 goto out; 2355 } 2356 if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) { 2357 if ((buflen -= 4) < 0) 2358 goto out_resource; 2359 WRITE32(1); 2360 } 2361 if (bmval0 & FATTR4_WORD0_MAXFILESIZE) { 2362 if ((buflen -= 8) < 0) 2363 goto out_resource; 2364 WRITE64(exp->ex_path.mnt->mnt_sb->s_maxbytes); 2365 } 2366 if (bmval0 & FATTR4_WORD0_MAXLINK) { 2367 if ((buflen -= 4) < 0) 2368 goto out_resource; 2369 WRITE32(255); 2370 } 2371 if (bmval0 & FATTR4_WORD0_MAXNAME) { 2372 if ((buflen -= 4) < 0) 2373 goto out_resource; 2374 WRITE32(statfs.f_namelen); 2375 } 2376 if (bmval0 & FATTR4_WORD0_MAXREAD) { 2377 if ((buflen -= 8) < 0) 2378 goto out_resource; 2379 WRITE64((u64) svc_max_payload(rqstp)); 2380 } 2381 if (bmval0 & FATTR4_WORD0_MAXWRITE) { 2382 if ((buflen -= 8) < 0) 2383 goto out_resource; 2384 WRITE64((u64) svc_max_payload(rqstp)); 2385 } 2386 if (bmval1 & FATTR4_WORD1_MODE) { 2387 if ((buflen -= 4) < 0) 2388 goto out_resource; 2389 WRITE32(stat.mode & S_IALLUGO); 2390 } 2391 if (bmval1 & FATTR4_WORD1_NO_TRUNC) { 2392 if ((buflen -= 4) < 0) 2393 goto out_resource; 2394 WRITE32(1); 2395 } 2396 if (bmval1 & FATTR4_WORD1_NUMLINKS) { 2397 if ((buflen -= 4) < 0) 2398 goto out_resource; 2399 WRITE32(stat.nlink); 2400 } 2401 if (bmval1 & FATTR4_WORD1_OWNER) { 2402 status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen); 2403 if (status) 2404 goto out; 2405 } 2406 if (bmval1 & FATTR4_WORD1_OWNER_GROUP) { 2407 status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen); 2408 if (status) 2409 goto out; 2410 } 2411 if (bmval1 & FATTR4_WORD1_RAWDEV) { 2412 if ((buflen -= 8) < 0) 2413 goto out_resource; 2414 WRITE32((u32) MAJOR(stat.rdev)); 2415 WRITE32((u32) MINOR(stat.rdev)); 2416 } 2417 if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) { 2418 if ((buflen -= 8) < 0) 2419 goto out_resource; 2420 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize; 2421 WRITE64(dummy64); 2422 } 2423 if (bmval1 & FATTR4_WORD1_SPACE_FREE) { 2424 if ((buflen -= 8) < 0) 2425 goto out_resource; 2426 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize; 2427 WRITE64(dummy64); 2428 } 2429 if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) { 2430 if ((buflen -= 8) < 0) 2431 goto out_resource; 2432 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize; 2433 WRITE64(dummy64); 2434 } 2435 if (bmval1 & FATTR4_WORD1_SPACE_USED) { 2436 if ((buflen -= 8) < 0) 2437 goto out_resource; 2438 dummy64 = (u64)stat.blocks << 9; 2439 WRITE64(dummy64); 2440 } 2441 if (bmval1 & FATTR4_WORD1_TIME_ACCESS) { 2442 if ((buflen -= 12) < 0) 2443 goto out_resource; 2444 WRITE64((s64)stat.atime.tv_sec); 2445 WRITE32(stat.atime.tv_nsec); 2446 } 2447 if (bmval1 & FATTR4_WORD1_TIME_DELTA) { 2448 if ((buflen -= 12) < 0) 2449 goto out_resource; 2450 WRITE32(0); 2451 WRITE32(1); 2452 WRITE32(0); 2453 } 2454 if (bmval1 & FATTR4_WORD1_TIME_METADATA) { 2455 if ((buflen -= 12) < 0) 2456 goto out_resource; 2457 WRITE64((s64)stat.ctime.tv_sec); 2458 WRITE32(stat.ctime.tv_nsec); 2459 } 2460 if (bmval1 & FATTR4_WORD1_TIME_MODIFY) { 2461 if ((buflen -= 12) < 0) 2462 goto out_resource; 2463 WRITE64((s64)stat.mtime.tv_sec); 2464 WRITE32(stat.mtime.tv_nsec); 2465 } 2466 if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) { 2467 if ((buflen -= 8) < 0) 2468 goto out_resource; 2469 /* 2470 * Get parent's attributes if not ignoring crossmount 2471 * and this is the root of a cross-mounted filesystem. 2472 */ 2473 if (ignore_crossmnt == 0 && 2474 dentry == exp->ex_path.mnt->mnt_root) 2475 get_parent_attributes(exp, &stat); 2476 WRITE64(stat.ino); 2477 } 2478 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { 2479 status = nfsd4_encode_security_label(rqstp, context, 2480 contextlen, &p, &buflen); 2481 if (status) 2482 goto out; 2483 } 2484 if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) { 2485 if ((buflen -= 16) < 0) 2486 goto out_resource; 2487 WRITE32(3); 2488 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD0); 2489 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD1); 2490 WRITE32(NFSD_SUPPATTR_EXCLCREAT_WORD2); 2491 } 2492 2493 *attrlenp = htonl((char *)p - (char *)attrlenp - 4); 2494 *buffer = p; 2495 status = nfs_ok; 2496 2497 out: 2498 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2499 if (context) 2500 security_release_secctx(context, contextlen); 2501 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ 2502 kfree(acl); 2503 if (tempfh) { 2504 fh_put(tempfh); 2505 kfree(tempfh); 2506 } 2507 return status; 2508 out_nfserr: 2509 status = nfserrno(err); 2510 goto out; 2511 out_resource: 2512 status = nfserr_resource; 2513 goto out; 2514 } 2515 2516 static inline int attributes_need_mount(u32 *bmval) 2517 { 2518 if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME)) 2519 return 1; 2520 if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID) 2521 return 1; 2522 return 0; 2523 } 2524 2525 static __be32 2526 nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd, 2527 const char *name, int namlen, __be32 **p, int buflen) 2528 { 2529 struct svc_export *exp = cd->rd_fhp->fh_export; 2530 struct dentry *dentry; 2531 __be32 nfserr; 2532 int ignore_crossmnt = 0; 2533 2534 dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen); 2535 if (IS_ERR(dentry)) 2536 return nfserrno(PTR_ERR(dentry)); 2537 if (!dentry->d_inode) { 2538 /* 2539 * nfsd_buffered_readdir drops the i_mutex between 2540 * readdir and calling this callback, leaving a window 2541 * where this directory entry could have gone away. 2542 */ 2543 dput(dentry); 2544 return nfserr_noent; 2545 } 2546 2547 exp_get(exp); 2548 /* 2549 * In the case of a mountpoint, the client may be asking for 2550 * attributes that are only properties of the underlying filesystem 2551 * as opposed to the cross-mounted file system. In such a case, 2552 * we will not follow the cross mount and will fill the attribtutes 2553 * directly from the mountpoint dentry. 2554 */ 2555 if (nfsd_mountpoint(dentry, exp)) { 2556 int err; 2557 2558 if (!(exp->ex_flags & NFSEXP_V4ROOT) 2559 && !attributes_need_mount(cd->rd_bmval)) { 2560 ignore_crossmnt = 1; 2561 goto out_encode; 2562 } 2563 /* 2564 * Why the heck aren't we just using nfsd_lookup?? 2565 * Different "."/".." handling? Something else? 2566 * At least, add a comment here to explain.... 2567 */ 2568 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); 2569 if (err) { 2570 nfserr = nfserrno(err); 2571 goto out_put; 2572 } 2573 nfserr = check_nfsd_access(exp, cd->rd_rqstp); 2574 if (nfserr) 2575 goto out_put; 2576 2577 } 2578 out_encode: 2579 nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval, 2580 cd->rd_rqstp, ignore_crossmnt); 2581 out_put: 2582 dput(dentry); 2583 exp_put(exp); 2584 return nfserr; 2585 } 2586 2587 static __be32 * 2588 nfsd4_encode_rdattr_error(__be32 *p, int buflen, __be32 nfserr) 2589 { 2590 if (buflen < 6) 2591 return NULL; 2592 *p++ = htonl(2); 2593 *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */ 2594 *p++ = htonl(0); /* bmval1 */ 2595 2596 *p++ = htonl(4); /* attribute length */ 2597 *p++ = nfserr; /* no htonl */ 2598 return p; 2599 } 2600 2601 static int 2602 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen, 2603 loff_t offset, u64 ino, unsigned int d_type) 2604 { 2605 struct readdir_cd *ccd = ccdv; 2606 struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); 2607 int buflen; 2608 __be32 *p = cd->buffer; 2609 __be32 *cookiep; 2610 __be32 nfserr = nfserr_toosmall; 2611 2612 /* In nfsv4, "." and ".." never make it onto the wire.. */ 2613 if (name && isdotent(name, namlen)) { 2614 cd->common.err = nfs_ok; 2615 return 0; 2616 } 2617 2618 if (cd->offset) 2619 xdr_encode_hyper(cd->offset, (u64) offset); 2620 2621 buflen = cd->buflen - 4 - XDR_QUADLEN(namlen); 2622 if (buflen < 0) 2623 goto fail; 2624 2625 *p++ = xdr_one; /* mark entry present */ 2626 cookiep = p; 2627 p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */ 2628 p = xdr_encode_array(p, name, namlen); /* name length & name */ 2629 2630 nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, &p, buflen); 2631 switch (nfserr) { 2632 case nfs_ok: 2633 break; 2634 case nfserr_resource: 2635 nfserr = nfserr_toosmall; 2636 goto fail; 2637 case nfserr_noent: 2638 goto skip_entry; 2639 default: 2640 /* 2641 * If the client requested the RDATTR_ERROR attribute, 2642 * we stuff the error code into this attribute 2643 * and continue. If this attribute was not requested, 2644 * then in accordance with the spec, we fail the 2645 * entire READDIR operation(!) 2646 */ 2647 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) 2648 goto fail; 2649 p = nfsd4_encode_rdattr_error(p, buflen, nfserr); 2650 if (p == NULL) { 2651 nfserr = nfserr_toosmall; 2652 goto fail; 2653 } 2654 } 2655 cd->buflen -= (p - cd->buffer); 2656 cd->buffer = p; 2657 cd->offset = cookiep; 2658 skip_entry: 2659 cd->common.err = nfs_ok; 2660 return 0; 2661 fail: 2662 cd->common.err = nfserr; 2663 return -EINVAL; 2664 } 2665 2666 static void 2667 nfsd4_encode_stateid(struct nfsd4_compoundres *resp, stateid_t *sid) 2668 { 2669 __be32 *p; 2670 2671 RESERVE_SPACE(sizeof(stateid_t)); 2672 WRITE32(sid->si_generation); 2673 WRITEMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); 2674 ADJUST_ARGS(); 2675 } 2676 2677 static __be32 2678 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access) 2679 { 2680 __be32 *p; 2681 2682 if (!nfserr) { 2683 RESERVE_SPACE(8); 2684 WRITE32(access->ac_supported); 2685 WRITE32(access->ac_resp_access); 2686 ADJUST_ARGS(); 2687 } 2688 return nfserr; 2689 } 2690 2691 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts) 2692 { 2693 __be32 *p; 2694 2695 if (!nfserr) { 2696 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 8); 2697 WRITEMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); 2698 WRITE32(bcts->dir); 2699 /* Sorry, we do not yet support RDMA over 4.1: */ 2700 WRITE32(0); 2701 ADJUST_ARGS(); 2702 } 2703 return nfserr; 2704 } 2705 2706 static __be32 2707 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close) 2708 { 2709 if (!nfserr) 2710 nfsd4_encode_stateid(resp, &close->cl_stateid); 2711 2712 return nfserr; 2713 } 2714 2715 2716 static __be32 2717 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit) 2718 { 2719 __be32 *p; 2720 2721 if (!nfserr) { 2722 RESERVE_SPACE(NFS4_VERIFIER_SIZE); 2723 WRITEMEM(commit->co_verf.data, NFS4_VERIFIER_SIZE); 2724 ADJUST_ARGS(); 2725 } 2726 return nfserr; 2727 } 2728 2729 static __be32 2730 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create) 2731 { 2732 __be32 *p; 2733 2734 if (!nfserr) { 2735 RESERVE_SPACE(32); 2736 write_cinfo(&p, &create->cr_cinfo); 2737 WRITE32(2); 2738 WRITE32(create->cr_bmval[0]); 2739 WRITE32(create->cr_bmval[1]); 2740 ADJUST_ARGS(); 2741 } 2742 return nfserr; 2743 } 2744 2745 static __be32 2746 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr) 2747 { 2748 struct svc_fh *fhp = getattr->ga_fhp; 2749 int buflen; 2750 2751 if (nfserr) 2752 return nfserr; 2753 2754 buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2); 2755 nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry, 2756 &resp->p, buflen, getattr->ga_bmval, 2757 resp->rqstp, 0); 2758 return nfserr; 2759 } 2760 2761 static __be32 2762 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp) 2763 { 2764 struct svc_fh *fhp = *fhpp; 2765 unsigned int len; 2766 __be32 *p; 2767 2768 if (!nfserr) { 2769 len = fhp->fh_handle.fh_size; 2770 RESERVE_SPACE(len + 4); 2771 WRITE32(len); 2772 WRITEMEM(&fhp->fh_handle.fh_base, len); 2773 ADJUST_ARGS(); 2774 } 2775 return nfserr; 2776 } 2777 2778 /* 2779 * Including all fields other than the name, a LOCK4denied structure requires 2780 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes. 2781 */ 2782 static void 2783 nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld) 2784 { 2785 struct xdr_netobj *conf = &ld->ld_owner; 2786 __be32 *p; 2787 2788 RESERVE_SPACE(32 + XDR_LEN(conf->len)); 2789 WRITE64(ld->ld_start); 2790 WRITE64(ld->ld_length); 2791 WRITE32(ld->ld_type); 2792 if (conf->len) { 2793 WRITEMEM(&ld->ld_clientid, 8); 2794 WRITE32(conf->len); 2795 WRITEMEM(conf->data, conf->len); 2796 kfree(conf->data); 2797 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ 2798 WRITE64((u64)0); /* clientid */ 2799 WRITE32(0); /* length of owner name */ 2800 } 2801 ADJUST_ARGS(); 2802 } 2803 2804 static __be32 2805 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock) 2806 { 2807 if (!nfserr) 2808 nfsd4_encode_stateid(resp, &lock->lk_resp_stateid); 2809 else if (nfserr == nfserr_denied) 2810 nfsd4_encode_lock_denied(resp, &lock->lk_denied); 2811 2812 return nfserr; 2813 } 2814 2815 static __be32 2816 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt) 2817 { 2818 if (nfserr == nfserr_denied) 2819 nfsd4_encode_lock_denied(resp, &lockt->lt_denied); 2820 return nfserr; 2821 } 2822 2823 static __be32 2824 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku) 2825 { 2826 if (!nfserr) 2827 nfsd4_encode_stateid(resp, &locku->lu_stateid); 2828 2829 return nfserr; 2830 } 2831 2832 2833 static __be32 2834 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link) 2835 { 2836 __be32 *p; 2837 2838 if (!nfserr) { 2839 RESERVE_SPACE(20); 2840 write_cinfo(&p, &link->li_cinfo); 2841 ADJUST_ARGS(); 2842 } 2843 return nfserr; 2844 } 2845 2846 2847 static __be32 2848 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open) 2849 { 2850 __be32 *p; 2851 2852 if (nfserr) 2853 goto out; 2854 2855 nfsd4_encode_stateid(resp, &open->op_stateid); 2856 RESERVE_SPACE(40); 2857 write_cinfo(&p, &open->op_cinfo); 2858 WRITE32(open->op_rflags); 2859 WRITE32(2); 2860 WRITE32(open->op_bmval[0]); 2861 WRITE32(open->op_bmval[1]); 2862 WRITE32(open->op_delegate_type); 2863 ADJUST_ARGS(); 2864 2865 switch (open->op_delegate_type) { 2866 case NFS4_OPEN_DELEGATE_NONE: 2867 break; 2868 case NFS4_OPEN_DELEGATE_READ: 2869 nfsd4_encode_stateid(resp, &open->op_delegate_stateid); 2870 RESERVE_SPACE(20); 2871 WRITE32(open->op_recall); 2872 2873 /* 2874 * TODO: ACE's in delegations 2875 */ 2876 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 2877 WRITE32(0); 2878 WRITE32(0); 2879 WRITE32(0); /* XXX: is NULL principal ok? */ 2880 ADJUST_ARGS(); 2881 break; 2882 case NFS4_OPEN_DELEGATE_WRITE: 2883 nfsd4_encode_stateid(resp, &open->op_delegate_stateid); 2884 RESERVE_SPACE(32); 2885 WRITE32(0); 2886 2887 /* 2888 * TODO: space_limit's in delegations 2889 */ 2890 WRITE32(NFS4_LIMIT_SIZE); 2891 WRITE32(~(u32)0); 2892 WRITE32(~(u32)0); 2893 2894 /* 2895 * TODO: ACE's in delegations 2896 */ 2897 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 2898 WRITE32(0); 2899 WRITE32(0); 2900 WRITE32(0); /* XXX: is NULL principal ok? */ 2901 ADJUST_ARGS(); 2902 break; 2903 case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */ 2904 switch (open->op_why_no_deleg) { 2905 case WND4_CONTENTION: 2906 case WND4_RESOURCE: 2907 RESERVE_SPACE(8); 2908 WRITE32(open->op_why_no_deleg); 2909 WRITE32(0); /* deleg signaling not supported yet */ 2910 break; 2911 default: 2912 RESERVE_SPACE(4); 2913 WRITE32(open->op_why_no_deleg); 2914 } 2915 ADJUST_ARGS(); 2916 break; 2917 default: 2918 BUG(); 2919 } 2920 /* XXX save filehandle here */ 2921 out: 2922 return nfserr; 2923 } 2924 2925 static __be32 2926 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc) 2927 { 2928 if (!nfserr) 2929 nfsd4_encode_stateid(resp, &oc->oc_resp_stateid); 2930 2931 return nfserr; 2932 } 2933 2934 static __be32 2935 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od) 2936 { 2937 if (!nfserr) 2938 nfsd4_encode_stateid(resp, &od->od_stateid); 2939 2940 return nfserr; 2941 } 2942 2943 static __be32 2944 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, 2945 struct nfsd4_read *read) 2946 { 2947 u32 eof; 2948 int v; 2949 struct page *page; 2950 unsigned long maxcount; 2951 long len; 2952 __be32 *p; 2953 2954 if (nfserr) 2955 return nfserr; 2956 if (resp->xbuf->page_len) 2957 return nfserr_resource; 2958 2959 RESERVE_SPACE(8); /* eof flag and byte count */ 2960 2961 maxcount = svc_max_payload(resp->rqstp); 2962 if (maxcount > read->rd_length) 2963 maxcount = read->rd_length; 2964 2965 len = maxcount; 2966 v = 0; 2967 while (len > 0) { 2968 page = *(resp->rqstp->rq_next_page); 2969 if (!page) { /* ran out of pages */ 2970 maxcount -= len; 2971 break; 2972 } 2973 resp->rqstp->rq_vec[v].iov_base = page_address(page); 2974 resp->rqstp->rq_vec[v].iov_len = 2975 len < PAGE_SIZE ? len : PAGE_SIZE; 2976 resp->rqstp->rq_next_page++; 2977 v++; 2978 len -= PAGE_SIZE; 2979 } 2980 read->rd_vlen = v; 2981 2982 nfserr = nfsd_read_file(read->rd_rqstp, read->rd_fhp, read->rd_filp, 2983 read->rd_offset, resp->rqstp->rq_vec, read->rd_vlen, 2984 &maxcount); 2985 2986 if (nfserr) 2987 return nfserr; 2988 eof = (read->rd_offset + maxcount >= 2989 read->rd_fhp->fh_dentry->d_inode->i_size); 2990 2991 WRITE32(eof); 2992 WRITE32(maxcount); 2993 ADJUST_ARGS(); 2994 resp->xbuf->head[0].iov_len = (char*)p 2995 - (char*)resp->xbuf->head[0].iov_base; 2996 resp->xbuf->page_len = maxcount; 2997 2998 /* Use rest of head for padding and remaining ops: */ 2999 resp->xbuf->tail[0].iov_base = p; 3000 resp->xbuf->tail[0].iov_len = 0; 3001 if (maxcount&3) { 3002 RESERVE_SPACE(4); 3003 WRITE32(0); 3004 resp->xbuf->tail[0].iov_base += maxcount&3; 3005 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3); 3006 ADJUST_ARGS(); 3007 } 3008 return 0; 3009 } 3010 3011 static __be32 3012 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink) 3013 { 3014 int maxcount; 3015 char *page; 3016 __be32 *p; 3017 3018 if (nfserr) 3019 return nfserr; 3020 if (resp->xbuf->page_len) 3021 return nfserr_resource; 3022 if (!*resp->rqstp->rq_next_page) 3023 return nfserr_resource; 3024 3025 page = page_address(*(resp->rqstp->rq_next_page++)); 3026 3027 maxcount = PAGE_SIZE; 3028 RESERVE_SPACE(4); 3029 3030 /* 3031 * XXX: By default, the ->readlink() VFS op will truncate symlinks 3032 * if they would overflow the buffer. Is this kosher in NFSv4? If 3033 * not, one easy fix is: if ->readlink() precisely fills the buffer, 3034 * assume that truncation occurred, and return NFS4ERR_RESOURCE. 3035 */ 3036 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount); 3037 if (nfserr == nfserr_isdir) 3038 return nfserr_inval; 3039 if (nfserr) 3040 return nfserr; 3041 3042 WRITE32(maxcount); 3043 ADJUST_ARGS(); 3044 resp->xbuf->head[0].iov_len = (char*)p 3045 - (char*)resp->xbuf->head[0].iov_base; 3046 resp->xbuf->page_len = maxcount; 3047 3048 /* Use rest of head for padding and remaining ops: */ 3049 resp->xbuf->tail[0].iov_base = p; 3050 resp->xbuf->tail[0].iov_len = 0; 3051 if (maxcount&3) { 3052 RESERVE_SPACE(4); 3053 WRITE32(0); 3054 resp->xbuf->tail[0].iov_base += maxcount&3; 3055 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3); 3056 ADJUST_ARGS(); 3057 } 3058 return 0; 3059 } 3060 3061 static __be32 3062 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir) 3063 { 3064 int maxcount; 3065 loff_t offset; 3066 __be32 *page, *savep, *tailbase; 3067 __be32 *p; 3068 3069 if (nfserr) 3070 return nfserr; 3071 if (resp->xbuf->page_len) 3072 return nfserr_resource; 3073 if (!*resp->rqstp->rq_next_page) 3074 return nfserr_resource; 3075 3076 RESERVE_SPACE(NFS4_VERIFIER_SIZE); 3077 savep = p; 3078 3079 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */ 3080 WRITE32(0); 3081 WRITE32(0); 3082 ADJUST_ARGS(); 3083 resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base; 3084 tailbase = p; 3085 3086 maxcount = PAGE_SIZE; 3087 if (maxcount > readdir->rd_maxcount) 3088 maxcount = readdir->rd_maxcount; 3089 3090 /* 3091 * Convert from bytes to words, account for the two words already 3092 * written, make sure to leave two words at the end for the next 3093 * pointer and eof field. 3094 */ 3095 maxcount = (maxcount >> 2) - 4; 3096 if (maxcount < 0) { 3097 nfserr = nfserr_toosmall; 3098 goto err_no_verf; 3099 } 3100 3101 page = page_address(*(resp->rqstp->rq_next_page++)); 3102 readdir->common.err = 0; 3103 readdir->buflen = maxcount; 3104 readdir->buffer = page; 3105 readdir->offset = NULL; 3106 3107 offset = readdir->rd_cookie; 3108 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, 3109 &offset, 3110 &readdir->common, nfsd4_encode_dirent); 3111 if (nfserr == nfs_ok && 3112 readdir->common.err == nfserr_toosmall && 3113 readdir->buffer == page) 3114 nfserr = nfserr_toosmall; 3115 if (nfserr) 3116 goto err_no_verf; 3117 3118 if (readdir->offset) 3119 xdr_encode_hyper(readdir->offset, offset); 3120 3121 p = readdir->buffer; 3122 *p++ = 0; /* no more entries */ 3123 *p++ = htonl(readdir->common.err == nfserr_eof); 3124 resp->xbuf->page_len = ((char*)p) - 3125 (char*)page_address(*(resp->rqstp->rq_next_page-1)); 3126 3127 /* Use rest of head for padding and remaining ops: */ 3128 resp->xbuf->tail[0].iov_base = tailbase; 3129 resp->xbuf->tail[0].iov_len = 0; 3130 resp->p = resp->xbuf->tail[0].iov_base; 3131 resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4; 3132 3133 return 0; 3134 err_no_verf: 3135 p = savep; 3136 ADJUST_ARGS(); 3137 return nfserr; 3138 } 3139 3140 static __be32 3141 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove) 3142 { 3143 __be32 *p; 3144 3145 if (!nfserr) { 3146 RESERVE_SPACE(20); 3147 write_cinfo(&p, &remove->rm_cinfo); 3148 ADJUST_ARGS(); 3149 } 3150 return nfserr; 3151 } 3152 3153 static __be32 3154 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename) 3155 { 3156 __be32 *p; 3157 3158 if (!nfserr) { 3159 RESERVE_SPACE(40); 3160 write_cinfo(&p, &rename->rn_sinfo); 3161 write_cinfo(&p, &rename->rn_tinfo); 3162 ADJUST_ARGS(); 3163 } 3164 return nfserr; 3165 } 3166 3167 static __be32 3168 nfsd4_do_encode_secinfo(struct nfsd4_compoundres *resp, 3169 __be32 nfserr, struct svc_export *exp) 3170 { 3171 u32 i, nflavs, supported; 3172 struct exp_flavor_info *flavs; 3173 struct exp_flavor_info def_flavs[2]; 3174 __be32 *p, *flavorsp; 3175 static bool report = true; 3176 3177 if (nfserr) 3178 goto out; 3179 if (exp->ex_nflavors) { 3180 flavs = exp->ex_flavors; 3181 nflavs = exp->ex_nflavors; 3182 } else { /* Handling of some defaults in absence of real secinfo: */ 3183 flavs = def_flavs; 3184 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { 3185 nflavs = 2; 3186 flavs[0].pseudoflavor = RPC_AUTH_UNIX; 3187 flavs[1].pseudoflavor = RPC_AUTH_NULL; 3188 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { 3189 nflavs = 1; 3190 flavs[0].pseudoflavor 3191 = svcauth_gss_flavor(exp->ex_client); 3192 } else { 3193 nflavs = 1; 3194 flavs[0].pseudoflavor 3195 = exp->ex_client->flavour->flavour; 3196 } 3197 } 3198 3199 supported = 0; 3200 RESERVE_SPACE(4); 3201 flavorsp = p++; /* to be backfilled later */ 3202 ADJUST_ARGS(); 3203 3204 for (i = 0; i < nflavs; i++) { 3205 rpc_authflavor_t pf = flavs[i].pseudoflavor; 3206 struct rpcsec_gss_info info; 3207 3208 if (rpcauth_get_gssinfo(pf, &info) == 0) { 3209 supported++; 3210 RESERVE_SPACE(4 + 4 + XDR_LEN(info.oid.len) + 4 + 4); 3211 WRITE32(RPC_AUTH_GSS); 3212 WRITE32(info.oid.len); 3213 WRITEMEM(info.oid.data, info.oid.len); 3214 WRITE32(info.qop); 3215 WRITE32(info.service); 3216 ADJUST_ARGS(); 3217 } else if (pf < RPC_AUTH_MAXFLAVOR) { 3218 supported++; 3219 RESERVE_SPACE(4); 3220 WRITE32(pf); 3221 ADJUST_ARGS(); 3222 } else { 3223 if (report) 3224 pr_warn("NFS: SECINFO: security flavor %u " 3225 "is not supported\n", pf); 3226 } 3227 } 3228 3229 if (nflavs != supported) 3230 report = false; 3231 *flavorsp = htonl(supported); 3232 3233 out: 3234 if (exp) 3235 exp_put(exp); 3236 return nfserr; 3237 } 3238 3239 static __be32 3240 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 3241 struct nfsd4_secinfo *secinfo) 3242 { 3243 return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->si_exp); 3244 } 3245 3246 static __be32 3247 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, 3248 struct nfsd4_secinfo_no_name *secinfo) 3249 { 3250 return nfsd4_do_encode_secinfo(resp, nfserr, secinfo->sin_exp); 3251 } 3252 3253 /* 3254 * The SETATTR encode routine is special -- it always encodes a bitmap, 3255 * regardless of the error status. 3256 */ 3257 static __be32 3258 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr) 3259 { 3260 __be32 *p; 3261 3262 RESERVE_SPACE(16); 3263 if (nfserr) { 3264 WRITE32(3); 3265 WRITE32(0); 3266 WRITE32(0); 3267 WRITE32(0); 3268 } 3269 else { 3270 WRITE32(3); 3271 WRITE32(setattr->sa_bmval[0]); 3272 WRITE32(setattr->sa_bmval[1]); 3273 WRITE32(setattr->sa_bmval[2]); 3274 } 3275 ADJUST_ARGS(); 3276 return nfserr; 3277 } 3278 3279 static __be32 3280 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd) 3281 { 3282 __be32 *p; 3283 3284 if (!nfserr) { 3285 RESERVE_SPACE(8 + NFS4_VERIFIER_SIZE); 3286 WRITEMEM(&scd->se_clientid, 8); 3287 WRITEMEM(&scd->se_confirm, NFS4_VERIFIER_SIZE); 3288 ADJUST_ARGS(); 3289 } 3290 else if (nfserr == nfserr_clid_inuse) { 3291 RESERVE_SPACE(8); 3292 WRITE32(0); 3293 WRITE32(0); 3294 ADJUST_ARGS(); 3295 } 3296 return nfserr; 3297 } 3298 3299 static __be32 3300 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write) 3301 { 3302 __be32 *p; 3303 3304 if (!nfserr) { 3305 RESERVE_SPACE(16); 3306 WRITE32(write->wr_bytes_written); 3307 WRITE32(write->wr_how_written); 3308 WRITEMEM(write->wr_verifier.data, NFS4_VERIFIER_SIZE); 3309 ADJUST_ARGS(); 3310 } 3311 return nfserr; 3312 } 3313 3314 static const u32 nfs4_minimal_spo_must_enforce[2] = { 3315 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | 3316 1 << (OP_EXCHANGE_ID - 32) | 3317 1 << (OP_CREATE_SESSION - 32) | 3318 1 << (OP_DESTROY_SESSION - 32) | 3319 1 << (OP_DESTROY_CLIENTID - 32) 3320 }; 3321 3322 static __be32 3323 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, 3324 struct nfsd4_exchange_id *exid) 3325 { 3326 __be32 *p; 3327 char *major_id; 3328 char *server_scope; 3329 int major_id_sz; 3330 int server_scope_sz; 3331 uint64_t minor_id = 0; 3332 3333 if (nfserr) 3334 return nfserr; 3335 3336 major_id = utsname()->nodename; 3337 major_id_sz = strlen(major_id); 3338 server_scope = utsname()->nodename; 3339 server_scope_sz = strlen(server_scope); 3340 3341 RESERVE_SPACE( 3342 8 /* eir_clientid */ + 3343 4 /* eir_sequenceid */ + 3344 4 /* eir_flags */ + 3345 4 /* spr_how */); 3346 3347 WRITEMEM(&exid->clientid, 8); 3348 WRITE32(exid->seqid); 3349 WRITE32(exid->flags); 3350 3351 WRITE32(exid->spa_how); 3352 ADJUST_ARGS(); 3353 3354 switch (exid->spa_how) { 3355 case SP4_NONE: 3356 break; 3357 case SP4_MACH_CRED: 3358 /* spo_must_enforce, spo_must_allow */ 3359 RESERVE_SPACE(16); 3360 3361 /* spo_must_enforce bitmap: */ 3362 WRITE32(2); 3363 WRITE32(nfs4_minimal_spo_must_enforce[0]); 3364 WRITE32(nfs4_minimal_spo_must_enforce[1]); 3365 /* empty spo_must_allow bitmap: */ 3366 WRITE32(0); 3367 3368 ADJUST_ARGS(); 3369 break; 3370 default: 3371 WARN_ON_ONCE(1); 3372 } 3373 3374 RESERVE_SPACE( 3375 8 /* so_minor_id */ + 3376 4 /* so_major_id.len */ + 3377 (XDR_QUADLEN(major_id_sz) * 4) + 3378 4 /* eir_server_scope.len */ + 3379 (XDR_QUADLEN(server_scope_sz) * 4) + 3380 4 /* eir_server_impl_id.count (0) */); 3381 3382 /* The server_owner struct */ 3383 WRITE64(minor_id); /* Minor id */ 3384 /* major id */ 3385 WRITE32(major_id_sz); 3386 WRITEMEM(major_id, major_id_sz); 3387 3388 /* Server scope */ 3389 WRITE32(server_scope_sz); 3390 WRITEMEM(server_scope, server_scope_sz); 3391 3392 /* Implementation id */ 3393 WRITE32(0); /* zero length nfs_impl_id4 array */ 3394 ADJUST_ARGS(); 3395 return 0; 3396 } 3397 3398 static __be32 3399 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, 3400 struct nfsd4_create_session *sess) 3401 { 3402 __be32 *p; 3403 3404 if (nfserr) 3405 return nfserr; 3406 3407 RESERVE_SPACE(24); 3408 WRITEMEM(sess->sessionid.data, NFS4_MAX_SESSIONID_LEN); 3409 WRITE32(sess->seqid); 3410 WRITE32(sess->flags); 3411 ADJUST_ARGS(); 3412 3413 RESERVE_SPACE(28); 3414 WRITE32(0); /* headerpadsz */ 3415 WRITE32(sess->fore_channel.maxreq_sz); 3416 WRITE32(sess->fore_channel.maxresp_sz); 3417 WRITE32(sess->fore_channel.maxresp_cached); 3418 WRITE32(sess->fore_channel.maxops); 3419 WRITE32(sess->fore_channel.maxreqs); 3420 WRITE32(sess->fore_channel.nr_rdma_attrs); 3421 ADJUST_ARGS(); 3422 3423 if (sess->fore_channel.nr_rdma_attrs) { 3424 RESERVE_SPACE(4); 3425 WRITE32(sess->fore_channel.rdma_attrs); 3426 ADJUST_ARGS(); 3427 } 3428 3429 RESERVE_SPACE(28); 3430 WRITE32(0); /* headerpadsz */ 3431 WRITE32(sess->back_channel.maxreq_sz); 3432 WRITE32(sess->back_channel.maxresp_sz); 3433 WRITE32(sess->back_channel.maxresp_cached); 3434 WRITE32(sess->back_channel.maxops); 3435 WRITE32(sess->back_channel.maxreqs); 3436 WRITE32(sess->back_channel.nr_rdma_attrs); 3437 ADJUST_ARGS(); 3438 3439 if (sess->back_channel.nr_rdma_attrs) { 3440 RESERVE_SPACE(4); 3441 WRITE32(sess->back_channel.rdma_attrs); 3442 ADJUST_ARGS(); 3443 } 3444 return 0; 3445 } 3446 3447 static __be32 3448 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, 3449 struct nfsd4_sequence *seq) 3450 { 3451 __be32 *p; 3452 3453 if (nfserr) 3454 return nfserr; 3455 3456 RESERVE_SPACE(NFS4_MAX_SESSIONID_LEN + 20); 3457 WRITEMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); 3458 WRITE32(seq->seqid); 3459 WRITE32(seq->slotid); 3460 /* Note slotid's are numbered from zero: */ 3461 WRITE32(seq->maxslots - 1); /* sr_highest_slotid */ 3462 WRITE32(seq->maxslots - 1); /* sr_target_highest_slotid */ 3463 WRITE32(seq->status_flags); 3464 3465 ADJUST_ARGS(); 3466 resp->cstate.datap = p; /* DRC cache data pointer */ 3467 return 0; 3468 } 3469 3470 static __be32 3471 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, 3472 struct nfsd4_test_stateid *test_stateid) 3473 { 3474 struct nfsd4_test_stateid_id *stateid, *next; 3475 __be32 *p; 3476 3477 if (nfserr) 3478 return nfserr; 3479 3480 RESERVE_SPACE(4 + (4 * test_stateid->ts_num_ids)); 3481 *p++ = htonl(test_stateid->ts_num_ids); 3482 3483 list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { 3484 *p++ = stateid->ts_id_status; 3485 } 3486 3487 ADJUST_ARGS(); 3488 return nfserr; 3489 } 3490 3491 static __be32 3492 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p) 3493 { 3494 return nfserr; 3495 } 3496 3497 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *); 3498 3499 /* 3500 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1 3501 * since we don't need to filter out obsolete ops as this is 3502 * done in the decoding phase. 3503 */ 3504 static nfsd4_enc nfsd4_enc_ops[] = { 3505 [OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access, 3506 [OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close, 3507 [OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit, 3508 [OP_CREATE] = (nfsd4_enc)nfsd4_encode_create, 3509 [OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop, 3510 [OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop, 3511 [OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr, 3512 [OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh, 3513 [OP_LINK] = (nfsd4_enc)nfsd4_encode_link, 3514 [OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock, 3515 [OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt, 3516 [OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku, 3517 [OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop, 3518 [OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop, 3519 [OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop, 3520 [OP_OPEN] = (nfsd4_enc)nfsd4_encode_open, 3521 [OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop, 3522 [OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm, 3523 [OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade, 3524 [OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop, 3525 [OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop, 3526 [OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop, 3527 [OP_READ] = (nfsd4_enc)nfsd4_encode_read, 3528 [OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir, 3529 [OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink, 3530 [OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove, 3531 [OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename, 3532 [OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop, 3533 [OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop, 3534 [OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop, 3535 [OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo, 3536 [OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr, 3537 [OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid, 3538 [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop, 3539 [OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop, 3540 [OP_WRITE] = (nfsd4_enc)nfsd4_encode_write, 3541 [OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop, 3542 3543 /* NFSv4.1 operations */ 3544 [OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop, 3545 [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session, 3546 [OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id, 3547 [OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session, 3548 [OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_noop, 3549 [OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_noop, 3550 [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, 3551 [OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop, 3552 [OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop, 3553 [OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop, 3554 [OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop, 3555 [OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop, 3556 [OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name, 3557 [OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence, 3558 [OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop, 3559 [OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid, 3560 [OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, 3561 [OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop, 3562 [OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop, 3563 }; 3564 3565 /* 3566 * Calculate the total amount of memory that the compound response has taken 3567 * after encoding the current operation with pad. 3568 * 3569 * pad: if operation is non-idempotent, pad was calculate by op_rsize_bop() 3570 * which was specified at nfsd4_operation, else pad is zero. 3571 * 3572 * Compare this length to the session se_fmaxresp_sz and se_fmaxresp_cached. 3573 * 3574 * Our se_fmaxresp_cached will always be a multiple of PAGE_SIZE, and so 3575 * will be at least a page and will therefore hold the xdr_buf head. 3576 */ 3577 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 pad) 3578 { 3579 struct xdr_buf *xb = &resp->rqstp->rq_res; 3580 struct nfsd4_session *session = NULL; 3581 struct nfsd4_slot *slot = resp->cstate.slot; 3582 u32 length, tlen = 0; 3583 3584 if (!nfsd4_has_session(&resp->cstate)) 3585 return 0; 3586 3587 session = resp->cstate.session; 3588 3589 if (xb->page_len == 0) { 3590 length = (char *)resp->p - (char *)xb->head[0].iov_base + pad; 3591 } else { 3592 if (xb->tail[0].iov_base && xb->tail[0].iov_len > 0) 3593 tlen = (char *)resp->p - (char *)xb->tail[0].iov_base; 3594 3595 length = xb->head[0].iov_len + xb->page_len + tlen + pad; 3596 } 3597 dprintk("%s length %u, xb->page_len %u tlen %u pad %u\n", __func__, 3598 length, xb->page_len, tlen, pad); 3599 3600 if (length > session->se_fchannel.maxresp_sz) 3601 return nfserr_rep_too_big; 3602 3603 if ((slot->sl_flags & NFSD4_SLOT_CACHETHIS) && 3604 length > session->se_fchannel.maxresp_cached) 3605 return nfserr_rep_too_big_to_cache; 3606 3607 return 0; 3608 } 3609 3610 void 3611 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 3612 { 3613 struct nfs4_stateowner *so = resp->cstate.replay_owner; 3614 __be32 *statp; 3615 __be32 *p; 3616 3617 RESERVE_SPACE(8); 3618 WRITE32(op->opnum); 3619 statp = p++; /* to be backfilled at the end */ 3620 ADJUST_ARGS(); 3621 3622 if (op->opnum == OP_ILLEGAL) 3623 goto status; 3624 BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || 3625 !nfsd4_enc_ops[op->opnum]); 3626 op->status = nfsd4_enc_ops[op->opnum](resp, op->status, &op->u); 3627 /* nfsd4_check_resp_size guarantees enough room for error status */ 3628 if (!op->status) 3629 op->status = nfsd4_check_resp_size(resp, 0); 3630 if (so) { 3631 so->so_replay.rp_status = op->status; 3632 so->so_replay.rp_buflen = (char *)resp->p - (char *)(statp+1); 3633 memcpy(so->so_replay.rp_buf, statp+1, so->so_replay.rp_buflen); 3634 } 3635 status: 3636 /* 3637 * Note: We write the status directly, instead of using WRITE32(), 3638 * since it is already in network byte order. 3639 */ 3640 *statp = op->status; 3641 } 3642 3643 /* 3644 * Encode the reply stored in the stateowner reply cache 3645 * 3646 * XDR note: do not encode rp->rp_buflen: the buffer contains the 3647 * previously sent already encoded operation. 3648 * 3649 * called with nfs4_lock_state() held 3650 */ 3651 void 3652 nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 3653 { 3654 __be32 *p; 3655 struct nfs4_replay *rp = op->replay; 3656 3657 BUG_ON(!rp); 3658 3659 RESERVE_SPACE(8); 3660 WRITE32(op->opnum); 3661 *p++ = rp->rp_status; /* already xdr'ed */ 3662 ADJUST_ARGS(); 3663 3664 RESERVE_SPACE(rp->rp_buflen); 3665 WRITEMEM(rp->rp_buf, rp->rp_buflen); 3666 ADJUST_ARGS(); 3667 } 3668 3669 int 3670 nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p, void *dummy) 3671 { 3672 return xdr_ressize_check(rqstp, p); 3673 } 3674 3675 int nfsd4_release_compoundargs(void *rq, __be32 *p, void *resp) 3676 { 3677 struct svc_rqst *rqstp = rq; 3678 struct nfsd4_compoundargs *args = rqstp->rq_argp; 3679 3680 if (args->ops != args->iops) { 3681 kfree(args->ops); 3682 args->ops = args->iops; 3683 } 3684 kfree(args->tmpp); 3685 args->tmpp = NULL; 3686 while (args->to_free) { 3687 struct tmpbuf *tb = args->to_free; 3688 args->to_free = tb->next; 3689 tb->release(tb->buf); 3690 kfree(tb); 3691 } 3692 return 1; 3693 } 3694 3695 int 3696 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundargs *args) 3697 { 3698 if (rqstp->rq_arg.head[0].iov_len % 4) { 3699 /* client is nuts */ 3700 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)", 3701 __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid)); 3702 return 0; 3703 } 3704 args->p = p; 3705 args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len; 3706 args->pagelist = rqstp->rq_arg.pages; 3707 args->pagelen = rqstp->rq_arg.page_len; 3708 args->tmpp = NULL; 3709 args->to_free = NULL; 3710 args->ops = args->iops; 3711 args->rqstp = rqstp; 3712 3713 return !nfsd4_decode_compound(args); 3714 } 3715 3716 int 3717 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p, struct nfsd4_compoundres *resp) 3718 { 3719 /* 3720 * All that remains is to write the tag and operation count... 3721 */ 3722 struct nfsd4_compound_state *cs = &resp->cstate; 3723 struct kvec *iov; 3724 p = resp->tagp; 3725 *p++ = htonl(resp->taglen); 3726 memcpy(p, resp->tag, resp->taglen); 3727 p += XDR_QUADLEN(resp->taglen); 3728 *p++ = htonl(resp->opcnt); 3729 3730 if (rqstp->rq_res.page_len) 3731 iov = &rqstp->rq_res.tail[0]; 3732 else 3733 iov = &rqstp->rq_res.head[0]; 3734 iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base; 3735 BUG_ON(iov->iov_len > PAGE_SIZE); 3736 if (nfsd4_has_session(cs)) { 3737 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 3738 struct nfs4_client *clp = cs->session->se_client; 3739 if (cs->status != nfserr_replay_cache) { 3740 nfsd4_store_cache_entry(resp); 3741 cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE; 3742 } 3743 /* Renew the clientid on success and on replay */ 3744 spin_lock(&nn->client_lock); 3745 nfsd4_put_session(cs->session); 3746 spin_unlock(&nn->client_lock); 3747 put_client_renew(clp); 3748 } 3749 return 1; 3750 } 3751 3752 /* 3753 * Local variables: 3754 * c-basic-offset: 8 3755 * End: 3756 */ 3757