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