1 /* 2 * fs/nfs/nfs4xdr.c 3 * 4 * Server-side XDR for NFSv4 5 * 6 * Copyright (c) 2002 The Regents of the University of Michigan. 7 * All rights reserved. 8 * 9 * Kendrick Smith <kmsmith@umich.edu> 10 * Andy Adamson <andros@umich.edu> 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 * 37 * TODO: Neil Brown made the following observation: We currently 38 * initially reserve NFSD_BUFSIZE space on the transmit queue and 39 * never release any of that until the request is complete. 40 * It would be good to calculate a new maximum response size while 41 * decoding the COMPOUND, and call svc_reserve with this number 42 * at the end of nfs4svc_decode_compoundargs. 43 */ 44 45 #include <linux/param.h> 46 #include <linux/smp.h> 47 #include <linux/smp_lock.h> 48 #include <linux/fs.h> 49 #include <linux/namei.h> 50 #include <linux/vfs.h> 51 #include <linux/sunrpc/xdr.h> 52 #include <linux/sunrpc/svc.h> 53 #include <linux/sunrpc/clnt.h> 54 #include <linux/nfsd/nfsd.h> 55 #include <linux/nfsd/state.h> 56 #include <linux/nfsd/xdr4.h> 57 #include <linux/nfsd_idmap.h> 58 #include <linux/nfs4.h> 59 #include <linux/nfs4_acl.h> 60 61 #define NFSDDBG_FACILITY NFSDDBG_XDR 62 63 static int 64 check_filename(char *str, int len, int err) 65 { 66 int i; 67 68 if (len == 0) 69 return nfserr_inval; 70 if (isdotent(str, len)) 71 return err; 72 for (i = 0; i < len; i++) 73 if (str[i] == '/') 74 return err; 75 return 0; 76 } 77 78 /* 79 * START OF "GENERIC" DECODE ROUTINES. 80 * These may look a little ugly since they are imported from a "generic" 81 * set of XDR encode/decode routines which are intended to be shared by 82 * all of our NFSv4 implementations (OpenBSD, MacOS X...). 83 * 84 * If the pain of reading these is too great, it should be a straightforward 85 * task to translate them into Linux-specific versions which are more 86 * consistent with the style used in NFSv2/v3... 87 */ 88 #define DECODE_HEAD \ 89 u32 *p; \ 90 int status 91 #define DECODE_TAIL \ 92 status = 0; \ 93 out: \ 94 return status; \ 95 xdr_error: \ 96 printk(KERN_NOTICE "xdr error! (%s:%d)\n", __FILE__, __LINE__); \ 97 status = nfserr_bad_xdr; \ 98 goto out 99 100 #define READ32(x) (x) = ntohl(*p++) 101 #define READ64(x) do { \ 102 (x) = (u64)ntohl(*p++) << 32; \ 103 (x) |= ntohl(*p++); \ 104 } while (0) 105 #define READTIME(x) do { \ 106 p++; \ 107 (x) = ntohl(*p++); \ 108 p++; \ 109 } while (0) 110 #define READMEM(x,nbytes) do { \ 111 x = (char *)p; \ 112 p += XDR_QUADLEN(nbytes); \ 113 } while (0) 114 #define SAVEMEM(x,nbytes) do { \ 115 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \ 116 savemem(argp, p, nbytes) : \ 117 (char *)p)) { \ 118 printk(KERN_NOTICE "xdr error! (%s:%d)\n", __FILE__, __LINE__); \ 119 goto xdr_error; \ 120 } \ 121 p += XDR_QUADLEN(nbytes); \ 122 } while (0) 123 #define COPYMEM(x,nbytes) do { \ 124 memcpy((x), p, nbytes); \ 125 p += XDR_QUADLEN(nbytes); \ 126 } while (0) 127 128 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */ 129 #define READ_BUF(nbytes) do { \ 130 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \ 131 p = argp->p; \ 132 argp->p += XDR_QUADLEN(nbytes); \ 133 } else if (!(p = read_buf(argp, nbytes))) { \ 134 printk(KERN_NOTICE "xdr error! (%s:%d)\n", __FILE__, __LINE__); \ 135 goto xdr_error; \ 136 } \ 137 } while (0) 138 139 static u32 *read_buf(struct nfsd4_compoundargs *argp, int nbytes) 140 { 141 /* We want more bytes than seem to be available. 142 * Maybe we need a new page, maybe we have just run out 143 */ 144 int avail = (char*)argp->end - (char*)argp->p; 145 u32 *p; 146 if (avail + argp->pagelen < nbytes) 147 return NULL; 148 if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */ 149 return NULL; 150 /* ok, we can do it with the current plus the next page */ 151 if (nbytes <= sizeof(argp->tmp)) 152 p = argp->tmp; 153 else { 154 kfree(argp->tmpp); 155 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL); 156 if (!p) 157 return NULL; 158 159 } 160 memcpy(p, argp->p, avail); 161 /* step to next page */ 162 argp->p = page_address(argp->pagelist[0]); 163 argp->pagelist++; 164 if (argp->pagelen < PAGE_SIZE) { 165 argp->end = p + (argp->pagelen>>2); 166 argp->pagelen = 0; 167 } else { 168 argp->end = p + (PAGE_SIZE>>2); 169 argp->pagelen -= PAGE_SIZE; 170 } 171 memcpy(((char*)p)+avail, argp->p, (nbytes - avail)); 172 argp->p += XDR_QUADLEN(nbytes - avail); 173 return p; 174 } 175 176 static int 177 defer_free(struct nfsd4_compoundargs *argp, 178 void (*release)(const void *), void *p) 179 { 180 struct tmpbuf *tb; 181 182 tb = kmalloc(sizeof(*tb), GFP_KERNEL); 183 if (!tb) 184 return -ENOMEM; 185 tb->buf = p; 186 tb->release = release; 187 tb->next = argp->to_free; 188 argp->to_free = tb; 189 return 0; 190 } 191 192 static char *savemem(struct nfsd4_compoundargs *argp, u32 *p, int nbytes) 193 { 194 void *new = NULL; 195 if (p == argp->tmp) { 196 new = kmalloc(nbytes, GFP_KERNEL); 197 if (!new) return NULL; 198 p = new; 199 memcpy(p, argp->tmp, nbytes); 200 } else { 201 if (p != argp->tmpp) 202 BUG(); 203 argp->tmpp = NULL; 204 } 205 if (defer_free(argp, kfree, p)) { 206 kfree(new); 207 return NULL; 208 } else 209 return (char *)p; 210 } 211 212 213 static int 214 nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval) 215 { 216 u32 bmlen; 217 DECODE_HEAD; 218 219 bmval[0] = 0; 220 bmval[1] = 0; 221 222 READ_BUF(4); 223 READ32(bmlen); 224 if (bmlen > 1000) 225 goto xdr_error; 226 227 READ_BUF(bmlen << 2); 228 if (bmlen > 0) 229 READ32(bmval[0]); 230 if (bmlen > 1) 231 READ32(bmval[1]); 232 233 DECODE_TAIL; 234 } 235 236 static int 237 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval, struct iattr *iattr, 238 struct nfs4_acl **acl) 239 { 240 int expected_len, len = 0; 241 u32 dummy32; 242 char *buf; 243 244 DECODE_HEAD; 245 iattr->ia_valid = 0; 246 if ((status = nfsd4_decode_bitmap(argp, bmval))) 247 return status; 248 249 /* 250 * According to spec, unsupported attributes return ERR_NOTSUPP; 251 * read-only attributes return ERR_INVAL. 252 */ 253 if ((bmval[0] & ~NFSD_SUPPORTED_ATTRS_WORD0) || (bmval[1] & ~NFSD_SUPPORTED_ATTRS_WORD1)) 254 return nfserr_attrnotsupp; 255 if ((bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0) || (bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1)) 256 return nfserr_inval; 257 258 READ_BUF(4); 259 READ32(expected_len); 260 261 if (bmval[0] & FATTR4_WORD0_SIZE) { 262 READ_BUF(8); 263 len += 8; 264 READ64(iattr->ia_size); 265 iattr->ia_valid |= ATTR_SIZE; 266 } 267 if (bmval[0] & FATTR4_WORD0_ACL) { 268 int nace, i; 269 struct nfs4_ace ace; 270 271 READ_BUF(4); len += 4; 272 READ32(nace); 273 274 *acl = nfs4_acl_new(); 275 if (*acl == NULL) { 276 status = -ENOMEM; 277 goto out_nfserr; 278 } 279 defer_free(argp, (void (*)(const void *))nfs4_acl_free, *acl); 280 281 for (i = 0; i < nace; i++) { 282 READ_BUF(16); len += 16; 283 READ32(ace.type); 284 READ32(ace.flag); 285 READ32(ace.access_mask); 286 READ32(dummy32); 287 READ_BUF(dummy32); 288 len += XDR_QUADLEN(dummy32) << 2; 289 READMEM(buf, dummy32); 290 ace.whotype = nfs4_acl_get_whotype(buf, dummy32); 291 status = 0; 292 if (ace.whotype != NFS4_ACL_WHO_NAMED) 293 ace.who = 0; 294 else if (ace.flag & NFS4_ACE_IDENTIFIER_GROUP) 295 status = nfsd_map_name_to_gid(argp->rqstp, 296 buf, dummy32, &ace.who); 297 else 298 status = nfsd_map_name_to_uid(argp->rqstp, 299 buf, dummy32, &ace.who); 300 if (status) 301 goto out_nfserr; 302 status = nfs4_acl_add_ace(*acl, ace.type, ace.flag, 303 ace.access_mask, ace.whotype, ace.who); 304 if (status) 305 goto out_nfserr; 306 } 307 } else 308 *acl = NULL; 309 if (bmval[1] & FATTR4_WORD1_MODE) { 310 READ_BUF(4); 311 len += 4; 312 READ32(iattr->ia_mode); 313 iattr->ia_mode &= (S_IFMT | S_IALLUGO); 314 iattr->ia_valid |= ATTR_MODE; 315 } 316 if (bmval[1] & FATTR4_WORD1_OWNER) { 317 READ_BUF(4); 318 len += 4; 319 READ32(dummy32); 320 READ_BUF(dummy32); 321 len += (XDR_QUADLEN(dummy32) << 2); 322 READMEM(buf, dummy32); 323 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid))) 324 goto out_nfserr; 325 iattr->ia_valid |= ATTR_UID; 326 } 327 if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) { 328 READ_BUF(4); 329 len += 4; 330 READ32(dummy32); 331 READ_BUF(dummy32); 332 len += (XDR_QUADLEN(dummy32) << 2); 333 READMEM(buf, dummy32); 334 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid))) 335 goto out_nfserr; 336 iattr->ia_valid |= ATTR_GID; 337 } 338 if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) { 339 READ_BUF(4); 340 len += 4; 341 READ32(dummy32); 342 switch (dummy32) { 343 case NFS4_SET_TO_CLIENT_TIME: 344 /* We require the high 32 bits of 'seconds' to be 0, and we ignore 345 all 32 bits of 'nseconds'. */ 346 READ_BUF(12); 347 len += 12; 348 READ32(dummy32); 349 if (dummy32) 350 return nfserr_inval; 351 READ32(iattr->ia_atime.tv_sec); 352 READ32(iattr->ia_atime.tv_nsec); 353 if (iattr->ia_atime.tv_nsec >= (u32)1000000000) 354 return nfserr_inval; 355 iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); 356 break; 357 case NFS4_SET_TO_SERVER_TIME: 358 iattr->ia_valid |= ATTR_ATIME; 359 break; 360 default: 361 goto xdr_error; 362 } 363 } 364 if (bmval[1] & FATTR4_WORD1_TIME_METADATA) { 365 /* We require the high 32 bits of 'seconds' to be 0, and we ignore 366 all 32 bits of 'nseconds'. */ 367 READ_BUF(12); 368 len += 12; 369 READ32(dummy32); 370 if (dummy32) 371 return nfserr_inval; 372 READ32(iattr->ia_ctime.tv_sec); 373 READ32(iattr->ia_ctime.tv_nsec); 374 if (iattr->ia_ctime.tv_nsec >= (u32)1000000000) 375 return nfserr_inval; 376 iattr->ia_valid |= ATTR_CTIME; 377 } 378 if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) { 379 READ_BUF(4); 380 len += 4; 381 READ32(dummy32); 382 switch (dummy32) { 383 case NFS4_SET_TO_CLIENT_TIME: 384 /* We require the high 32 bits of 'seconds' to be 0, and we ignore 385 all 32 bits of 'nseconds'. */ 386 READ_BUF(12); 387 len += 12; 388 READ32(dummy32); 389 if (dummy32) 390 return nfserr_inval; 391 READ32(iattr->ia_mtime.tv_sec); 392 READ32(iattr->ia_mtime.tv_nsec); 393 if (iattr->ia_mtime.tv_nsec >= (u32)1000000000) 394 return nfserr_inval; 395 iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); 396 break; 397 case NFS4_SET_TO_SERVER_TIME: 398 iattr->ia_valid |= ATTR_MTIME; 399 break; 400 default: 401 goto xdr_error; 402 } 403 } 404 if (len != expected_len) 405 goto xdr_error; 406 407 DECODE_TAIL; 408 409 out_nfserr: 410 status = nfserrno(status); 411 goto out; 412 } 413 414 static int 415 nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access) 416 { 417 DECODE_HEAD; 418 419 READ_BUF(4); 420 READ32(access->ac_req_access); 421 422 DECODE_TAIL; 423 } 424 425 static int 426 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close) 427 { 428 DECODE_HEAD; 429 430 close->cl_stateowner = NULL; 431 READ_BUF(4 + sizeof(stateid_t)); 432 READ32(close->cl_seqid); 433 READ32(close->cl_stateid.si_generation); 434 COPYMEM(&close->cl_stateid.si_opaque, sizeof(stateid_opaque_t)); 435 436 DECODE_TAIL; 437 } 438 439 440 static int 441 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit) 442 { 443 DECODE_HEAD; 444 445 READ_BUF(12); 446 READ64(commit->co_offset); 447 READ32(commit->co_count); 448 449 DECODE_TAIL; 450 } 451 452 static int 453 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create) 454 { 455 DECODE_HEAD; 456 457 READ_BUF(4); 458 READ32(create->cr_type); 459 switch (create->cr_type) { 460 case NF4LNK: 461 READ_BUF(4); 462 READ32(create->cr_linklen); 463 READ_BUF(create->cr_linklen); 464 SAVEMEM(create->cr_linkname, create->cr_linklen); 465 break; 466 case NF4BLK: 467 case NF4CHR: 468 READ_BUF(8); 469 READ32(create->cr_specdata1); 470 READ32(create->cr_specdata2); 471 break; 472 case NF4SOCK: 473 case NF4FIFO: 474 case NF4DIR: 475 default: 476 break; 477 } 478 479 READ_BUF(4); 480 READ32(create->cr_namelen); 481 READ_BUF(create->cr_namelen); 482 SAVEMEM(create->cr_name, create->cr_namelen); 483 if ((status = check_filename(create->cr_name, create->cr_namelen, nfserr_inval))) 484 return status; 485 486 if ((status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr, &create->cr_acl))) 487 goto out; 488 489 DECODE_TAIL; 490 } 491 492 static inline int 493 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr) 494 { 495 DECODE_HEAD; 496 497 READ_BUF(sizeof(stateid_t)); 498 READ32(dr->dr_stateid.si_generation); 499 COPYMEM(&dr->dr_stateid.si_opaque, sizeof(stateid_opaque_t)); 500 501 DECODE_TAIL; 502 } 503 504 static inline int 505 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr) 506 { 507 return nfsd4_decode_bitmap(argp, getattr->ga_bmval); 508 } 509 510 static int 511 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link) 512 { 513 DECODE_HEAD; 514 515 READ_BUF(4); 516 READ32(link->li_namelen); 517 READ_BUF(link->li_namelen); 518 SAVEMEM(link->li_name, link->li_namelen); 519 if ((status = check_filename(link->li_name, link->li_namelen, nfserr_inval))) 520 return status; 521 522 DECODE_TAIL; 523 } 524 525 static int 526 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock) 527 { 528 DECODE_HEAD; 529 530 lock->lk_replay_owner = NULL; 531 /* 532 * type, reclaim(boolean), offset, length, new_lock_owner(boolean) 533 */ 534 READ_BUF(28); 535 READ32(lock->lk_type); 536 if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) 537 goto xdr_error; 538 READ32(lock->lk_reclaim); 539 READ64(lock->lk_offset); 540 READ64(lock->lk_length); 541 READ32(lock->lk_is_new); 542 543 if (lock->lk_is_new) { 544 READ_BUF(36); 545 READ32(lock->lk_new_open_seqid); 546 READ32(lock->lk_new_open_stateid.si_generation); 547 548 COPYMEM(&lock->lk_new_open_stateid.si_opaque, sizeof(stateid_opaque_t)); 549 READ32(lock->lk_new_lock_seqid); 550 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t)); 551 READ32(lock->lk_new_owner.len); 552 READ_BUF(lock->lk_new_owner.len); 553 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len); 554 } else { 555 READ_BUF(20); 556 READ32(lock->lk_old_lock_stateid.si_generation); 557 COPYMEM(&lock->lk_old_lock_stateid.si_opaque, sizeof(stateid_opaque_t)); 558 READ32(lock->lk_old_lock_seqid); 559 } 560 561 DECODE_TAIL; 562 } 563 564 static int 565 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt) 566 { 567 DECODE_HEAD; 568 569 READ_BUF(32); 570 READ32(lockt->lt_type); 571 if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) 572 goto xdr_error; 573 READ64(lockt->lt_offset); 574 READ64(lockt->lt_length); 575 COPYMEM(&lockt->lt_clientid, 8); 576 READ32(lockt->lt_owner.len); 577 READ_BUF(lockt->lt_owner.len); 578 READMEM(lockt->lt_owner.data, lockt->lt_owner.len); 579 580 DECODE_TAIL; 581 } 582 583 static int 584 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku) 585 { 586 DECODE_HEAD; 587 588 locku->lu_stateowner = NULL; 589 READ_BUF(24 + sizeof(stateid_t)); 590 READ32(locku->lu_type); 591 if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) 592 goto xdr_error; 593 READ32(locku->lu_seqid); 594 READ32(locku->lu_stateid.si_generation); 595 COPYMEM(&locku->lu_stateid.si_opaque, sizeof(stateid_opaque_t)); 596 READ64(locku->lu_offset); 597 READ64(locku->lu_length); 598 599 DECODE_TAIL; 600 } 601 602 static int 603 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup) 604 { 605 DECODE_HEAD; 606 607 READ_BUF(4); 608 READ32(lookup->lo_len); 609 READ_BUF(lookup->lo_len); 610 SAVEMEM(lookup->lo_name, lookup->lo_len); 611 if ((status = check_filename(lookup->lo_name, lookup->lo_len, nfserr_noent))) 612 return status; 613 614 DECODE_TAIL; 615 } 616 617 static int 618 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) 619 { 620 DECODE_HEAD; 621 622 memset(open->op_bmval, 0, sizeof(open->op_bmval)); 623 open->op_iattr.ia_valid = 0; 624 open->op_stateowner = NULL; 625 626 /* seqid, share_access, share_deny, clientid, ownerlen */ 627 READ_BUF(16 + sizeof(clientid_t)); 628 READ32(open->op_seqid); 629 READ32(open->op_share_access); 630 READ32(open->op_share_deny); 631 COPYMEM(&open->op_clientid, sizeof(clientid_t)); 632 READ32(open->op_owner.len); 633 634 /* owner, open_flag */ 635 READ_BUF(open->op_owner.len + 4); 636 SAVEMEM(open->op_owner.data, open->op_owner.len); 637 READ32(open->op_create); 638 switch (open->op_create) { 639 case NFS4_OPEN_NOCREATE: 640 break; 641 case NFS4_OPEN_CREATE: 642 READ_BUF(4); 643 READ32(open->op_createmode); 644 switch (open->op_createmode) { 645 case NFS4_CREATE_UNCHECKED: 646 case NFS4_CREATE_GUARDED: 647 if ((status = nfsd4_decode_fattr(argp, open->op_bmval, &open->op_iattr, &open->op_acl))) 648 goto out; 649 break; 650 case NFS4_CREATE_EXCLUSIVE: 651 READ_BUF(8); 652 COPYMEM(open->op_verf.data, 8); 653 break; 654 default: 655 goto xdr_error; 656 } 657 break; 658 default: 659 goto xdr_error; 660 } 661 662 /* open_claim */ 663 READ_BUF(4); 664 READ32(open->op_claim_type); 665 switch (open->op_claim_type) { 666 case NFS4_OPEN_CLAIM_NULL: 667 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 668 READ_BUF(4); 669 READ32(open->op_fname.len); 670 READ_BUF(open->op_fname.len); 671 SAVEMEM(open->op_fname.data, open->op_fname.len); 672 if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval))) 673 return status; 674 break; 675 case NFS4_OPEN_CLAIM_PREVIOUS: 676 READ_BUF(4); 677 READ32(open->op_delegate_type); 678 break; 679 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 680 READ_BUF(sizeof(stateid_t) + 4); 681 COPYMEM(&open->op_delegate_stateid, sizeof(stateid_t)); 682 READ32(open->op_fname.len); 683 READ_BUF(open->op_fname.len); 684 SAVEMEM(open->op_fname.data, open->op_fname.len); 685 if ((status = check_filename(open->op_fname.data, open->op_fname.len, nfserr_inval))) 686 return status; 687 break; 688 default: 689 goto xdr_error; 690 } 691 692 DECODE_TAIL; 693 } 694 695 static int 696 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf) 697 { 698 DECODE_HEAD; 699 700 open_conf->oc_stateowner = NULL; 701 READ_BUF(4 + sizeof(stateid_t)); 702 READ32(open_conf->oc_req_stateid.si_generation); 703 COPYMEM(&open_conf->oc_req_stateid.si_opaque, sizeof(stateid_opaque_t)); 704 READ32(open_conf->oc_seqid); 705 706 DECODE_TAIL; 707 } 708 709 static int 710 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down) 711 { 712 DECODE_HEAD; 713 714 open_down->od_stateowner = NULL; 715 READ_BUF(12 + sizeof(stateid_t)); 716 READ32(open_down->od_stateid.si_generation); 717 COPYMEM(&open_down->od_stateid.si_opaque, sizeof(stateid_opaque_t)); 718 READ32(open_down->od_seqid); 719 READ32(open_down->od_share_access); 720 READ32(open_down->od_share_deny); 721 722 DECODE_TAIL; 723 } 724 725 static int 726 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh) 727 { 728 DECODE_HEAD; 729 730 READ_BUF(4); 731 READ32(putfh->pf_fhlen); 732 if (putfh->pf_fhlen > NFS4_FHSIZE) 733 goto xdr_error; 734 READ_BUF(putfh->pf_fhlen); 735 SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen); 736 737 DECODE_TAIL; 738 } 739 740 static int 741 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read) 742 { 743 DECODE_HEAD; 744 745 READ_BUF(sizeof(stateid_t) + 12); 746 READ32(read->rd_stateid.si_generation); 747 COPYMEM(&read->rd_stateid.si_opaque, sizeof(stateid_opaque_t)); 748 READ64(read->rd_offset); 749 READ32(read->rd_length); 750 751 DECODE_TAIL; 752 } 753 754 static int 755 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir) 756 { 757 DECODE_HEAD; 758 759 READ_BUF(24); 760 READ64(readdir->rd_cookie); 761 COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data)); 762 READ32(readdir->rd_dircount); /* just in case you needed a useless field... */ 763 READ32(readdir->rd_maxcount); 764 if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval))) 765 goto out; 766 767 DECODE_TAIL; 768 } 769 770 static int 771 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove) 772 { 773 DECODE_HEAD; 774 775 READ_BUF(4); 776 READ32(remove->rm_namelen); 777 READ_BUF(remove->rm_namelen); 778 SAVEMEM(remove->rm_name, remove->rm_namelen); 779 if ((status = check_filename(remove->rm_name, remove->rm_namelen, nfserr_noent))) 780 return status; 781 782 DECODE_TAIL; 783 } 784 785 static int 786 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename) 787 { 788 DECODE_HEAD; 789 790 READ_BUF(4); 791 READ32(rename->rn_snamelen); 792 READ_BUF(rename->rn_snamelen + 4); 793 SAVEMEM(rename->rn_sname, rename->rn_snamelen); 794 READ32(rename->rn_tnamelen); 795 READ_BUF(rename->rn_tnamelen); 796 SAVEMEM(rename->rn_tname, rename->rn_tnamelen); 797 if ((status = check_filename(rename->rn_sname, rename->rn_snamelen, nfserr_noent))) 798 return status; 799 if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen, nfserr_inval))) 800 return status; 801 802 DECODE_TAIL; 803 } 804 805 static int 806 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid) 807 { 808 DECODE_HEAD; 809 810 READ_BUF(sizeof(clientid_t)); 811 COPYMEM(clientid, sizeof(clientid_t)); 812 813 DECODE_TAIL; 814 } 815 816 static int 817 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr) 818 { 819 DECODE_HEAD; 820 821 READ_BUF(sizeof(stateid_t)); 822 READ32(setattr->sa_stateid.si_generation); 823 COPYMEM(&setattr->sa_stateid.si_opaque, sizeof(stateid_opaque_t)); 824 if ((status = nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr, &setattr->sa_acl))) 825 goto out; 826 827 DECODE_TAIL; 828 } 829 830 static int 831 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid) 832 { 833 DECODE_HEAD; 834 835 READ_BUF(12); 836 COPYMEM(setclientid->se_verf.data, 8); 837 READ32(setclientid->se_namelen); 838 839 READ_BUF(setclientid->se_namelen + 8); 840 SAVEMEM(setclientid->se_name, setclientid->se_namelen); 841 READ32(setclientid->se_callback_prog); 842 READ32(setclientid->se_callback_netid_len); 843 844 READ_BUF(setclientid->se_callback_netid_len + 4); 845 SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len); 846 READ32(setclientid->se_callback_addr_len); 847 848 READ_BUF(setclientid->se_callback_addr_len + 4); 849 SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len); 850 READ32(setclientid->se_callback_ident); 851 852 DECODE_TAIL; 853 } 854 855 static int 856 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c) 857 { 858 DECODE_HEAD; 859 860 READ_BUF(8 + sizeof(nfs4_verifier)); 861 COPYMEM(&scd_c->sc_clientid, 8); 862 COPYMEM(&scd_c->sc_confirm, sizeof(nfs4_verifier)); 863 864 DECODE_TAIL; 865 } 866 867 /* Also used for NVERIFY */ 868 static int 869 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify) 870 { 871 #if 0 872 struct nfsd4_compoundargs save = { 873 .p = argp->p, 874 .end = argp->end, 875 .rqstp = argp->rqstp, 876 }; 877 u32 ve_bmval[2]; 878 struct iattr ve_iattr; /* request */ 879 struct nfs4_acl *ve_acl; /* request */ 880 #endif 881 DECODE_HEAD; 882 883 if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval))) 884 goto out; 885 886 /* For convenience's sake, we compare raw xdr'd attributes in 887 * nfsd4_proc_verify; however we still decode here just to return 888 * correct error in case of bad xdr. */ 889 #if 0 890 status = nfsd4_decode_fattr(ve_bmval, &ve_iattr, &ve_acl); 891 if (status == nfserr_inval) { 892 status = nfserrno(status); 893 goto out; 894 } 895 #endif 896 READ_BUF(4); 897 READ32(verify->ve_attrlen); 898 READ_BUF(verify->ve_attrlen); 899 SAVEMEM(verify->ve_attrval, verify->ve_attrlen); 900 901 DECODE_TAIL; 902 } 903 904 static int 905 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write) 906 { 907 int avail; 908 int v; 909 int len; 910 DECODE_HEAD; 911 912 READ_BUF(sizeof(stateid_opaque_t) + 20); 913 READ32(write->wr_stateid.si_generation); 914 COPYMEM(&write->wr_stateid.si_opaque, sizeof(stateid_opaque_t)); 915 READ64(write->wr_offset); 916 READ32(write->wr_stable_how); 917 if (write->wr_stable_how > 2) 918 goto xdr_error; 919 READ32(write->wr_buflen); 920 921 /* Sorry .. no magic macros for this.. * 922 * READ_BUF(write->wr_buflen); 923 * SAVEMEM(write->wr_buf, write->wr_buflen); 924 */ 925 avail = (char*)argp->end - (char*)argp->p; 926 if (avail + argp->pagelen < write->wr_buflen) { 927 printk(KERN_NOTICE "xdr error! (%s:%d)\n", __FILE__, __LINE__); 928 goto xdr_error; 929 } 930 write->wr_vec[0].iov_base = p; 931 write->wr_vec[0].iov_len = avail; 932 v = 0; 933 len = write->wr_buflen; 934 while (len > write->wr_vec[v].iov_len) { 935 len -= write->wr_vec[v].iov_len; 936 v++; 937 write->wr_vec[v].iov_base = page_address(argp->pagelist[0]); 938 argp->pagelist++; 939 if (argp->pagelen >= PAGE_SIZE) { 940 write->wr_vec[v].iov_len = PAGE_SIZE; 941 argp->pagelen -= PAGE_SIZE; 942 } else { 943 write->wr_vec[v].iov_len = argp->pagelen; 944 argp->pagelen -= len; 945 } 946 } 947 argp->end = (u32*) (write->wr_vec[v].iov_base + write->wr_vec[v].iov_len); 948 argp->p = (u32*) (write->wr_vec[v].iov_base + (XDR_QUADLEN(len) << 2)); 949 write->wr_vec[v].iov_len = len; 950 write->wr_vlen = v+1; 951 952 DECODE_TAIL; 953 } 954 955 static int 956 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner) 957 { 958 DECODE_HEAD; 959 960 READ_BUF(12); 961 COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t)); 962 READ32(rlockowner->rl_owner.len); 963 READ_BUF(rlockowner->rl_owner.len); 964 READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len); 965 966 DECODE_TAIL; 967 } 968 969 static int 970 nfsd4_decode_compound(struct nfsd4_compoundargs *argp) 971 { 972 DECODE_HEAD; 973 struct nfsd4_op *op; 974 int i; 975 976 /* 977 * XXX: According to spec, we should check the tag 978 * for UTF-8 compliance. I'm postponing this for 979 * now because it seems that some clients do use 980 * binary tags. 981 */ 982 READ_BUF(4); 983 READ32(argp->taglen); 984 READ_BUF(argp->taglen + 8); 985 SAVEMEM(argp->tag, argp->taglen); 986 READ32(argp->minorversion); 987 READ32(argp->opcnt); 988 989 if (argp->taglen > NFSD4_MAX_TAGLEN) 990 goto xdr_error; 991 if (argp->opcnt > 100) 992 goto xdr_error; 993 994 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { 995 argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL); 996 if (!argp->ops) { 997 argp->ops = argp->iops; 998 printk(KERN_INFO "nfsd: couldn't allocate room for COMPOUND\n"); 999 goto xdr_error; 1000 } 1001 } 1002 1003 for (i = 0; i < argp->opcnt; i++) { 1004 op = &argp->ops[i]; 1005 op->replay = NULL; 1006 1007 /* 1008 * We can't use READ_BUF() here because we need to handle 1009 * a missing opcode as an OP_WRITE + 1. So we need to check 1010 * to see if we're truly at the end of our buffer or if there 1011 * is another page we need to flip to. 1012 */ 1013 1014 if (argp->p == argp->end) { 1015 if (argp->pagelen < 4) { 1016 /* There isn't an opcode still on the wire */ 1017 op->opnum = OP_WRITE + 1; 1018 op->status = nfserr_bad_xdr; 1019 argp->opcnt = i+1; 1020 break; 1021 } 1022 1023 /* 1024 * False alarm. We just hit a page boundary, but there 1025 * is still data available. Move pointer across page 1026 * boundary. *snip from READ_BUF* 1027 */ 1028 argp->p = page_address(argp->pagelist[0]); 1029 argp->pagelist++; 1030 if (argp->pagelen < PAGE_SIZE) { 1031 argp->end = p + (argp->pagelen>>2); 1032 argp->pagelen = 0; 1033 } else { 1034 argp->end = p + (PAGE_SIZE>>2); 1035 argp->pagelen -= PAGE_SIZE; 1036 } 1037 } 1038 op->opnum = ntohl(*argp->p++); 1039 1040 switch (op->opnum) { 1041 case 2: /* Reserved operation */ 1042 op->opnum = OP_ILLEGAL; 1043 if (argp->minorversion == 0) 1044 op->status = nfserr_op_illegal; 1045 else 1046 op->status = nfserr_minor_vers_mismatch; 1047 break; 1048 case OP_ACCESS: 1049 op->status = nfsd4_decode_access(argp, &op->u.access); 1050 break; 1051 case OP_CLOSE: 1052 op->status = nfsd4_decode_close(argp, &op->u.close); 1053 break; 1054 case OP_COMMIT: 1055 op->status = nfsd4_decode_commit(argp, &op->u.commit); 1056 break; 1057 case OP_CREATE: 1058 op->status = nfsd4_decode_create(argp, &op->u.create); 1059 break; 1060 case OP_DELEGRETURN: 1061 op->status = nfsd4_decode_delegreturn(argp, &op->u.delegreturn); 1062 break; 1063 case OP_GETATTR: 1064 op->status = nfsd4_decode_getattr(argp, &op->u.getattr); 1065 break; 1066 case OP_GETFH: 1067 op->status = nfs_ok; 1068 break; 1069 case OP_LINK: 1070 op->status = nfsd4_decode_link(argp, &op->u.link); 1071 break; 1072 case OP_LOCK: 1073 op->status = nfsd4_decode_lock(argp, &op->u.lock); 1074 break; 1075 case OP_LOCKT: 1076 op->status = nfsd4_decode_lockt(argp, &op->u.lockt); 1077 break; 1078 case OP_LOCKU: 1079 op->status = nfsd4_decode_locku(argp, &op->u.locku); 1080 break; 1081 case OP_LOOKUP: 1082 op->status = nfsd4_decode_lookup(argp, &op->u.lookup); 1083 break; 1084 case OP_LOOKUPP: 1085 op->status = nfs_ok; 1086 break; 1087 case OP_NVERIFY: 1088 op->status = nfsd4_decode_verify(argp, &op->u.nverify); 1089 break; 1090 case OP_OPEN: 1091 op->status = nfsd4_decode_open(argp, &op->u.open); 1092 break; 1093 case OP_OPEN_CONFIRM: 1094 op->status = nfsd4_decode_open_confirm(argp, &op->u.open_confirm); 1095 break; 1096 case OP_OPEN_DOWNGRADE: 1097 op->status = nfsd4_decode_open_downgrade(argp, &op->u.open_downgrade); 1098 break; 1099 case OP_PUTFH: 1100 op->status = nfsd4_decode_putfh(argp, &op->u.putfh); 1101 break; 1102 case OP_PUTROOTFH: 1103 op->status = nfs_ok; 1104 break; 1105 case OP_READ: 1106 op->status = nfsd4_decode_read(argp, &op->u.read); 1107 break; 1108 case OP_READDIR: 1109 op->status = nfsd4_decode_readdir(argp, &op->u.readdir); 1110 break; 1111 case OP_READLINK: 1112 op->status = nfs_ok; 1113 break; 1114 case OP_REMOVE: 1115 op->status = nfsd4_decode_remove(argp, &op->u.remove); 1116 break; 1117 case OP_RENAME: 1118 op->status = nfsd4_decode_rename(argp, &op->u.rename); 1119 break; 1120 case OP_RESTOREFH: 1121 op->status = nfs_ok; 1122 break; 1123 case OP_RENEW: 1124 op->status = nfsd4_decode_renew(argp, &op->u.renew); 1125 break; 1126 case OP_SAVEFH: 1127 op->status = nfs_ok; 1128 break; 1129 case OP_SETATTR: 1130 op->status = nfsd4_decode_setattr(argp, &op->u.setattr); 1131 break; 1132 case OP_SETCLIENTID: 1133 op->status = nfsd4_decode_setclientid(argp, &op->u.setclientid); 1134 break; 1135 case OP_SETCLIENTID_CONFIRM: 1136 op->status = nfsd4_decode_setclientid_confirm(argp, &op->u.setclientid_confirm); 1137 break; 1138 case OP_VERIFY: 1139 op->status = nfsd4_decode_verify(argp, &op->u.verify); 1140 break; 1141 case OP_WRITE: 1142 op->status = nfsd4_decode_write(argp, &op->u.write); 1143 break; 1144 case OP_RELEASE_LOCKOWNER: 1145 op->status = nfsd4_decode_release_lockowner(argp, &op->u.release_lockowner); 1146 break; 1147 default: 1148 op->opnum = OP_ILLEGAL; 1149 op->status = nfserr_op_illegal; 1150 break; 1151 } 1152 1153 if (op->status) { 1154 argp->opcnt = i+1; 1155 break; 1156 } 1157 } 1158 1159 DECODE_TAIL; 1160 } 1161 /* 1162 * END OF "GENERIC" DECODE ROUTINES. 1163 */ 1164 1165 /* 1166 * START OF "GENERIC" ENCODE ROUTINES. 1167 * These may look a little ugly since they are imported from a "generic" 1168 * set of XDR encode/decode routines which are intended to be shared by 1169 * all of our NFSv4 implementations (OpenBSD, MacOS X...). 1170 * 1171 * If the pain of reading these is too great, it should be a straightforward 1172 * task to translate them into Linux-specific versions which are more 1173 * consistent with the style used in NFSv2/v3... 1174 */ 1175 #define ENCODE_HEAD u32 *p 1176 1177 #define WRITE32(n) *p++ = htonl(n) 1178 #define WRITE64(n) do { \ 1179 *p++ = htonl((u32)((n) >> 32)); \ 1180 *p++ = htonl((u32)(n)); \ 1181 } while (0) 1182 #define WRITEMEM(ptr,nbytes) do { \ 1183 *(p + XDR_QUADLEN(nbytes) -1) = 0; \ 1184 memcpy(p, ptr, nbytes); \ 1185 p += XDR_QUADLEN(nbytes); \ 1186 } while (0) 1187 #define WRITECINFO(c) do { \ 1188 *p++ = htonl(c.atomic); \ 1189 *p++ = htonl(c.before_ctime_sec); \ 1190 *p++ = htonl(c.before_ctime_nsec); \ 1191 *p++ = htonl(c.after_ctime_sec); \ 1192 *p++ = htonl(c.after_ctime_nsec); \ 1193 } while (0) 1194 1195 #define RESERVE_SPACE(nbytes) do { \ 1196 p = resp->p; \ 1197 BUG_ON(p + XDR_QUADLEN(nbytes) > resp->end); \ 1198 } while (0) 1199 #define ADJUST_ARGS() resp->p = p 1200 1201 /* 1202 * Header routine to setup seqid operation replay cache 1203 */ 1204 #define ENCODE_SEQID_OP_HEAD \ 1205 u32 *p; \ 1206 u32 *save; \ 1207 \ 1208 save = resp->p; 1209 1210 /* 1211 * Routine for encoding the result of a "seqid-mutating" NFSv4 operation. This 1212 * is where sequence id's are incremented, and the replay cache is filled. 1213 * Note that we increment sequence id's here, at the last moment, so we're sure 1214 * we know whether the error to be returned is a sequence id mutating error. 1215 */ 1216 1217 #define ENCODE_SEQID_OP_TAIL(stateowner) do { \ 1218 if (seqid_mutating_err(nfserr) && stateowner) { \ 1219 stateowner->so_seqid++; \ 1220 stateowner->so_replay.rp_status = nfserr; \ 1221 stateowner->so_replay.rp_buflen = \ 1222 (((char *)(resp)->p - (char *)save)); \ 1223 memcpy(stateowner->so_replay.rp_buf, save, \ 1224 stateowner->so_replay.rp_buflen); \ 1225 } } while (0); 1226 1227 1228 static u32 nfs4_ftypes[16] = { 1229 NF4BAD, NF4FIFO, NF4CHR, NF4BAD, 1230 NF4DIR, NF4BAD, NF4BLK, NF4BAD, 1231 NF4REG, NF4BAD, NF4LNK, NF4BAD, 1232 NF4SOCK, NF4BAD, NF4LNK, NF4BAD, 1233 }; 1234 1235 static int 1236 nfsd4_encode_name(struct svc_rqst *rqstp, int whotype, uid_t id, int group, 1237 u32 **p, int *buflen) 1238 { 1239 int status; 1240 1241 if (*buflen < (XDR_QUADLEN(IDMAP_NAMESZ) << 2) + 4) 1242 return nfserr_resource; 1243 if (whotype != NFS4_ACL_WHO_NAMED) 1244 status = nfs4_acl_write_who(whotype, (u8 *)(*p + 1)); 1245 else if (group) 1246 status = nfsd_map_gid_to_name(rqstp, id, (u8 *)(*p + 1)); 1247 else 1248 status = nfsd_map_uid_to_name(rqstp, id, (u8 *)(*p + 1)); 1249 if (status < 0) 1250 return nfserrno(status); 1251 *p = xdr_encode_opaque(*p, NULL, status); 1252 *buflen -= (XDR_QUADLEN(status) << 2) + 4; 1253 BUG_ON(*buflen < 0); 1254 return 0; 1255 } 1256 1257 static inline int 1258 nfsd4_encode_user(struct svc_rqst *rqstp, uid_t uid, u32 **p, int *buflen) 1259 { 1260 return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, uid, 0, p, buflen); 1261 } 1262 1263 static inline int 1264 nfsd4_encode_group(struct svc_rqst *rqstp, uid_t gid, u32 **p, int *buflen) 1265 { 1266 return nfsd4_encode_name(rqstp, NFS4_ACL_WHO_NAMED, gid, 1, p, buflen); 1267 } 1268 1269 static inline int 1270 nfsd4_encode_aclname(struct svc_rqst *rqstp, int whotype, uid_t id, int group, 1271 u32 **p, int *buflen) 1272 { 1273 return nfsd4_encode_name(rqstp, whotype, id, group, p, buflen); 1274 } 1275 1276 1277 /* 1278 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle 1279 * ourselves. 1280 * 1281 * @countp is the buffer size in _words_; upon successful return this becomes 1282 * replaced with the number of words written. 1283 */ 1284 int 1285 nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp, 1286 struct dentry *dentry, u32 *buffer, int *countp, u32 *bmval, 1287 struct svc_rqst *rqstp) 1288 { 1289 u32 bmval0 = bmval[0]; 1290 u32 bmval1 = bmval[1]; 1291 struct kstat stat; 1292 struct svc_fh tempfh; 1293 struct kstatfs statfs; 1294 int buflen = *countp << 2; 1295 u32 *attrlenp; 1296 u32 dummy; 1297 u64 dummy64; 1298 u32 *p = buffer; 1299 int status; 1300 int aclsupport = 0; 1301 struct nfs4_acl *acl = NULL; 1302 1303 BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1); 1304 BUG_ON(bmval0 & ~NFSD_SUPPORTED_ATTRS_WORD0); 1305 BUG_ON(bmval1 & ~NFSD_SUPPORTED_ATTRS_WORD1); 1306 1307 status = vfs_getattr(exp->ex_mnt, dentry, &stat); 1308 if (status) 1309 goto out_nfserr; 1310 if ((bmval0 & (FATTR4_WORD0_FILES_FREE | FATTR4_WORD0_FILES_TOTAL)) || 1311 (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | 1312 FATTR4_WORD1_SPACE_TOTAL))) { 1313 status = vfs_statfs(dentry->d_inode->i_sb, &statfs); 1314 if (status) 1315 goto out_nfserr; 1316 } 1317 if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) { 1318 fh_init(&tempfh, NFS4_FHSIZE); 1319 status = fh_compose(&tempfh, exp, dentry, NULL); 1320 if (status) 1321 goto out; 1322 fhp = &tempfh; 1323 } 1324 if (bmval0 & (FATTR4_WORD0_ACL | FATTR4_WORD0_ACLSUPPORT 1325 | FATTR4_WORD0_SUPPORTED_ATTRS)) { 1326 status = nfsd4_get_nfs4_acl(rqstp, dentry, &acl); 1327 aclsupport = (status == 0); 1328 if (bmval0 & FATTR4_WORD0_ACL) { 1329 if (status == -EOPNOTSUPP) 1330 bmval0 &= ~FATTR4_WORD0_ACL; 1331 else if (status == -EINVAL) { 1332 status = nfserr_attrnotsupp; 1333 goto out; 1334 } else if (status != 0) 1335 goto out_nfserr; 1336 } 1337 } 1338 if ((buflen -= 16) < 0) 1339 goto out_resource; 1340 1341 WRITE32(2); 1342 WRITE32(bmval0); 1343 WRITE32(bmval1); 1344 attrlenp = p++; /* to be backfilled later */ 1345 1346 if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) { 1347 if ((buflen -= 12) < 0) 1348 goto out_resource; 1349 WRITE32(2); 1350 WRITE32(aclsupport ? 1351 NFSD_SUPPORTED_ATTRS_WORD0 : 1352 NFSD_SUPPORTED_ATTRS_WORD0 & ~FATTR4_WORD0_ACL); 1353 WRITE32(NFSD_SUPPORTED_ATTRS_WORD1); 1354 } 1355 if (bmval0 & FATTR4_WORD0_TYPE) { 1356 if ((buflen -= 4) < 0) 1357 goto out_resource; 1358 dummy = nfs4_ftypes[(stat.mode & S_IFMT) >> 12]; 1359 if (dummy == NF4BAD) 1360 goto out_serverfault; 1361 WRITE32(dummy); 1362 } 1363 if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) { 1364 if ((buflen -= 4) < 0) 1365 goto out_resource; 1366 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) 1367 WRITE32(NFS4_FH_PERSISTENT); 1368 else 1369 WRITE32(NFS4_FH_PERSISTENT|NFS4_FH_VOL_RENAME); 1370 } 1371 if (bmval0 & FATTR4_WORD0_CHANGE) { 1372 /* 1373 * Note: This _must_ be consistent with the scheme for writing 1374 * change_info, so any changes made here must be reflected there 1375 * as well. (See xdr4.h:set_change_info() and the WRITECINFO() 1376 * macro above.) 1377 */ 1378 if ((buflen -= 8) < 0) 1379 goto out_resource; 1380 WRITE32(stat.ctime.tv_sec); 1381 WRITE32(stat.ctime.tv_nsec); 1382 } 1383 if (bmval0 & FATTR4_WORD0_SIZE) { 1384 if ((buflen -= 8) < 0) 1385 goto out_resource; 1386 WRITE64(stat.size); 1387 } 1388 if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) { 1389 if ((buflen -= 4) < 0) 1390 goto out_resource; 1391 WRITE32(1); 1392 } 1393 if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) { 1394 if ((buflen -= 4) < 0) 1395 goto out_resource; 1396 WRITE32(1); 1397 } 1398 if (bmval0 & FATTR4_WORD0_NAMED_ATTR) { 1399 if ((buflen -= 4) < 0) 1400 goto out_resource; 1401 WRITE32(0); 1402 } 1403 if (bmval0 & FATTR4_WORD0_FSID) { 1404 if ((buflen -= 16) < 0) 1405 goto out_resource; 1406 if (is_fsid(fhp, rqstp->rq_reffh)) { 1407 WRITE64((u64)exp->ex_fsid); 1408 WRITE64((u64)0); 1409 } else { 1410 WRITE32(0); 1411 WRITE32(MAJOR(stat.dev)); 1412 WRITE32(0); 1413 WRITE32(MINOR(stat.dev)); 1414 } 1415 } 1416 if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) { 1417 if ((buflen -= 4) < 0) 1418 goto out_resource; 1419 WRITE32(0); 1420 } 1421 if (bmval0 & FATTR4_WORD0_LEASE_TIME) { 1422 if ((buflen -= 4) < 0) 1423 goto out_resource; 1424 WRITE32(NFSD_LEASE_TIME); 1425 } 1426 if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) { 1427 if ((buflen -= 4) < 0) 1428 goto out_resource; 1429 WRITE32(0); 1430 } 1431 if (bmval0 & FATTR4_WORD0_ACL) { 1432 struct nfs4_ace *ace; 1433 struct list_head *h; 1434 1435 if (acl == NULL) { 1436 if ((buflen -= 4) < 0) 1437 goto out_resource; 1438 1439 WRITE32(0); 1440 goto out_acl; 1441 } 1442 if ((buflen -= 4) < 0) 1443 goto out_resource; 1444 WRITE32(acl->naces); 1445 1446 list_for_each(h, &acl->ace_head) { 1447 ace = list_entry(h, struct nfs4_ace, l_ace); 1448 1449 if ((buflen -= 4*3) < 0) 1450 goto out_resource; 1451 WRITE32(ace->type); 1452 WRITE32(ace->flag); 1453 WRITE32(ace->access_mask & NFS4_ACE_MASK_ALL); 1454 status = nfsd4_encode_aclname(rqstp, ace->whotype, 1455 ace->who, ace->flag & NFS4_ACE_IDENTIFIER_GROUP, 1456 &p, &buflen); 1457 if (status == nfserr_resource) 1458 goto out_resource; 1459 if (status) 1460 goto out; 1461 } 1462 } 1463 out_acl: 1464 if (bmval0 & FATTR4_WORD0_ACLSUPPORT) { 1465 if ((buflen -= 4) < 0) 1466 goto out_resource; 1467 WRITE32(aclsupport ? 1468 ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0); 1469 } 1470 if (bmval0 & FATTR4_WORD0_CANSETTIME) { 1471 if ((buflen -= 4) < 0) 1472 goto out_resource; 1473 WRITE32(1); 1474 } 1475 if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { 1476 if ((buflen -= 4) < 0) 1477 goto out_resource; 1478 WRITE32(1); 1479 } 1480 if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { 1481 if ((buflen -= 4) < 0) 1482 goto out_resource; 1483 WRITE32(1); 1484 } 1485 if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) { 1486 if ((buflen -= 4) < 0) 1487 goto out_resource; 1488 WRITE32(1); 1489 } 1490 if (bmval0 & FATTR4_WORD0_FILEHANDLE) { 1491 buflen -= (XDR_QUADLEN(fhp->fh_handle.fh_size) << 2) + 4; 1492 if (buflen < 0) 1493 goto out_resource; 1494 WRITE32(fhp->fh_handle.fh_size); 1495 WRITEMEM(&fhp->fh_handle.fh_base, fhp->fh_handle.fh_size); 1496 } 1497 if (bmval0 & FATTR4_WORD0_FILEID) { 1498 if ((buflen -= 8) < 0) 1499 goto out_resource; 1500 WRITE64((u64) stat.ino); 1501 } 1502 if (bmval0 & FATTR4_WORD0_FILES_AVAIL) { 1503 if ((buflen -= 8) < 0) 1504 goto out_resource; 1505 WRITE64((u64) statfs.f_ffree); 1506 } 1507 if (bmval0 & FATTR4_WORD0_FILES_FREE) { 1508 if ((buflen -= 8) < 0) 1509 goto out_resource; 1510 WRITE64((u64) statfs.f_ffree); 1511 } 1512 if (bmval0 & FATTR4_WORD0_FILES_TOTAL) { 1513 if ((buflen -= 8) < 0) 1514 goto out_resource; 1515 WRITE64((u64) statfs.f_files); 1516 } 1517 if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) { 1518 if ((buflen -= 4) < 0) 1519 goto out_resource; 1520 WRITE32(1); 1521 } 1522 if (bmval0 & FATTR4_WORD0_MAXFILESIZE) { 1523 if ((buflen -= 8) < 0) 1524 goto out_resource; 1525 WRITE64(~(u64)0); 1526 } 1527 if (bmval0 & FATTR4_WORD0_MAXLINK) { 1528 if ((buflen -= 4) < 0) 1529 goto out_resource; 1530 WRITE32(255); 1531 } 1532 if (bmval0 & FATTR4_WORD0_MAXNAME) { 1533 if ((buflen -= 4) < 0) 1534 goto out_resource; 1535 WRITE32(~(u32) 0); 1536 } 1537 if (bmval0 & FATTR4_WORD0_MAXREAD) { 1538 if ((buflen -= 8) < 0) 1539 goto out_resource; 1540 WRITE64((u64) NFSSVC_MAXBLKSIZE); 1541 } 1542 if (bmval0 & FATTR4_WORD0_MAXWRITE) { 1543 if ((buflen -= 8) < 0) 1544 goto out_resource; 1545 WRITE64((u64) NFSSVC_MAXBLKSIZE); 1546 } 1547 if (bmval1 & FATTR4_WORD1_MODE) { 1548 if ((buflen -= 4) < 0) 1549 goto out_resource; 1550 WRITE32(stat.mode & S_IALLUGO); 1551 } 1552 if (bmval1 & FATTR4_WORD1_NO_TRUNC) { 1553 if ((buflen -= 4) < 0) 1554 goto out_resource; 1555 WRITE32(1); 1556 } 1557 if (bmval1 & FATTR4_WORD1_NUMLINKS) { 1558 if ((buflen -= 4) < 0) 1559 goto out_resource; 1560 WRITE32(stat.nlink); 1561 } 1562 if (bmval1 & FATTR4_WORD1_OWNER) { 1563 status = nfsd4_encode_user(rqstp, stat.uid, &p, &buflen); 1564 if (status == nfserr_resource) 1565 goto out_resource; 1566 if (status) 1567 goto out; 1568 } 1569 if (bmval1 & FATTR4_WORD1_OWNER_GROUP) { 1570 status = nfsd4_encode_group(rqstp, stat.gid, &p, &buflen); 1571 if (status == nfserr_resource) 1572 goto out_resource; 1573 if (status) 1574 goto out; 1575 } 1576 if (bmval1 & FATTR4_WORD1_RAWDEV) { 1577 if ((buflen -= 8) < 0) 1578 goto out_resource; 1579 WRITE32((u32) MAJOR(stat.rdev)); 1580 WRITE32((u32) MINOR(stat.rdev)); 1581 } 1582 if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) { 1583 if ((buflen -= 8) < 0) 1584 goto out_resource; 1585 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize; 1586 WRITE64(dummy64); 1587 } 1588 if (bmval1 & FATTR4_WORD1_SPACE_FREE) { 1589 if ((buflen -= 8) < 0) 1590 goto out_resource; 1591 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize; 1592 WRITE64(dummy64); 1593 } 1594 if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) { 1595 if ((buflen -= 8) < 0) 1596 goto out_resource; 1597 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize; 1598 WRITE64(dummy64); 1599 } 1600 if (bmval1 & FATTR4_WORD1_SPACE_USED) { 1601 if ((buflen -= 8) < 0) 1602 goto out_resource; 1603 dummy64 = (u64)stat.blocks << 9; 1604 WRITE64(dummy64); 1605 } 1606 if (bmval1 & FATTR4_WORD1_TIME_ACCESS) { 1607 if ((buflen -= 12) < 0) 1608 goto out_resource; 1609 WRITE32(0); 1610 WRITE32(stat.atime.tv_sec); 1611 WRITE32(stat.atime.tv_nsec); 1612 } 1613 if (bmval1 & FATTR4_WORD1_TIME_DELTA) { 1614 if ((buflen -= 12) < 0) 1615 goto out_resource; 1616 WRITE32(0); 1617 WRITE32(1); 1618 WRITE32(0); 1619 } 1620 if (bmval1 & FATTR4_WORD1_TIME_METADATA) { 1621 if ((buflen -= 12) < 0) 1622 goto out_resource; 1623 WRITE32(0); 1624 WRITE32(stat.ctime.tv_sec); 1625 WRITE32(stat.ctime.tv_nsec); 1626 } 1627 if (bmval1 & FATTR4_WORD1_TIME_MODIFY) { 1628 if ((buflen -= 12) < 0) 1629 goto out_resource; 1630 WRITE32(0); 1631 WRITE32(stat.mtime.tv_sec); 1632 WRITE32(stat.mtime.tv_nsec); 1633 } 1634 if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) { 1635 struct dentry *mnt_pnt, *mnt_root; 1636 1637 if ((buflen -= 8) < 0) 1638 goto out_resource; 1639 mnt_root = exp->ex_mnt->mnt_root; 1640 if (mnt_root->d_inode == dentry->d_inode) { 1641 mnt_pnt = exp->ex_mnt->mnt_mountpoint; 1642 WRITE64((u64) mnt_pnt->d_inode->i_ino); 1643 } else 1644 WRITE64((u64) stat.ino); 1645 } 1646 *attrlenp = htonl((char *)p - (char *)attrlenp - 4); 1647 *countp = p - buffer; 1648 status = nfs_ok; 1649 1650 out: 1651 nfs4_acl_free(acl); 1652 if (fhp == &tempfh) 1653 fh_put(&tempfh); 1654 return status; 1655 out_nfserr: 1656 status = nfserrno(status); 1657 goto out; 1658 out_resource: 1659 *countp = 0; 1660 status = nfserr_resource; 1661 goto out; 1662 out_serverfault: 1663 status = nfserr_serverfault; 1664 goto out; 1665 } 1666 1667 static int 1668 nfsd4_encode_dirent_fattr(struct nfsd4_readdir *cd, 1669 const char *name, int namlen, u32 *p, int *buflen) 1670 { 1671 struct svc_export *exp = cd->rd_fhp->fh_export; 1672 struct dentry *dentry; 1673 int nfserr; 1674 1675 dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen); 1676 if (IS_ERR(dentry)) 1677 return nfserrno(PTR_ERR(dentry)); 1678 1679 exp_get(exp); 1680 if (d_mountpoint(dentry)) { 1681 if (nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp)) { 1682 /* 1683 * -EAGAIN is the only error returned from 1684 * nfsd_cross_mnt() and it indicates that an 1685 * up-call has been initiated to fill in the export 1686 * options on exp. When the answer comes back, 1687 * this call will be retried. 1688 */ 1689 nfserr = nfserr_dropit; 1690 goto out_put; 1691 } 1692 1693 } 1694 nfserr = nfsd4_encode_fattr(NULL, exp, dentry, p, buflen, cd->rd_bmval, 1695 cd->rd_rqstp); 1696 out_put: 1697 dput(dentry); 1698 exp_put(exp); 1699 return nfserr; 1700 } 1701 1702 static u32 * 1703 nfsd4_encode_rdattr_error(u32 *p, int buflen, int nfserr) 1704 { 1705 u32 *attrlenp; 1706 1707 if (buflen < 6) 1708 return NULL; 1709 *p++ = htonl(2); 1710 *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */ 1711 *p++ = htonl(0); /* bmval1 */ 1712 1713 attrlenp = p++; 1714 *p++ = nfserr; /* no htonl */ 1715 *attrlenp = htonl((char *)p - (char *)attrlenp - 4); 1716 return p; 1717 } 1718 1719 static int 1720 nfsd4_encode_dirent(struct readdir_cd *ccd, const char *name, int namlen, 1721 loff_t offset, ino_t ino, unsigned int d_type) 1722 { 1723 struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); 1724 int buflen; 1725 u32 *p = cd->buffer; 1726 int nfserr = nfserr_toosmall; 1727 1728 /* In nfsv4, "." and ".." never make it onto the wire.. */ 1729 if (name && isdotent(name, namlen)) { 1730 cd->common.err = nfs_ok; 1731 return 0; 1732 } 1733 1734 if (cd->offset) 1735 xdr_encode_hyper(cd->offset, (u64) offset); 1736 1737 buflen = cd->buflen - 4 - XDR_QUADLEN(namlen); 1738 if (buflen < 0) 1739 goto fail; 1740 1741 *p++ = xdr_one; /* mark entry present */ 1742 cd->offset = p; /* remember pointer */ 1743 p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */ 1744 p = xdr_encode_array(p, name, namlen); /* name length & name */ 1745 1746 nfserr = nfsd4_encode_dirent_fattr(cd, name, namlen, p, &buflen); 1747 switch (nfserr) { 1748 case nfs_ok: 1749 p += buflen; 1750 break; 1751 case nfserr_resource: 1752 nfserr = nfserr_toosmall; 1753 goto fail; 1754 case nfserr_dropit: 1755 goto fail; 1756 default: 1757 /* 1758 * If the client requested the RDATTR_ERROR attribute, 1759 * we stuff the error code into this attribute 1760 * and continue. If this attribute was not requested, 1761 * then in accordance with the spec, we fail the 1762 * entire READDIR operation(!) 1763 */ 1764 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) 1765 goto fail; 1766 p = nfsd4_encode_rdattr_error(p, buflen, nfserr); 1767 if (p == NULL) { 1768 nfserr = nfserr_toosmall; 1769 goto fail; 1770 } 1771 } 1772 cd->buflen -= (p - cd->buffer); 1773 cd->buffer = p; 1774 cd->common.err = nfs_ok; 1775 return 0; 1776 fail: 1777 cd->common.err = nfserr; 1778 return -EINVAL; 1779 } 1780 1781 static void 1782 nfsd4_encode_access(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_access *access) 1783 { 1784 ENCODE_HEAD; 1785 1786 if (!nfserr) { 1787 RESERVE_SPACE(8); 1788 WRITE32(access->ac_supported); 1789 WRITE32(access->ac_resp_access); 1790 ADJUST_ARGS(); 1791 } 1792 } 1793 1794 static void 1795 nfsd4_encode_close(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_close *close) 1796 { 1797 ENCODE_SEQID_OP_HEAD; 1798 1799 if (!nfserr) { 1800 RESERVE_SPACE(sizeof(stateid_t)); 1801 WRITE32(close->cl_stateid.si_generation); 1802 WRITEMEM(&close->cl_stateid.si_opaque, sizeof(stateid_opaque_t)); 1803 ADJUST_ARGS(); 1804 } 1805 ENCODE_SEQID_OP_TAIL(close->cl_stateowner); 1806 } 1807 1808 1809 static void 1810 nfsd4_encode_commit(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_commit *commit) 1811 { 1812 ENCODE_HEAD; 1813 1814 if (!nfserr) { 1815 RESERVE_SPACE(8); 1816 WRITEMEM(commit->co_verf.data, 8); 1817 ADJUST_ARGS(); 1818 } 1819 } 1820 1821 static void 1822 nfsd4_encode_create(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_create *create) 1823 { 1824 ENCODE_HEAD; 1825 1826 if (!nfserr) { 1827 RESERVE_SPACE(32); 1828 WRITECINFO(create->cr_cinfo); 1829 WRITE32(2); 1830 WRITE32(create->cr_bmval[0]); 1831 WRITE32(create->cr_bmval[1]); 1832 ADJUST_ARGS(); 1833 } 1834 } 1835 1836 static int 1837 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_getattr *getattr) 1838 { 1839 struct svc_fh *fhp = getattr->ga_fhp; 1840 int buflen; 1841 1842 if (nfserr) 1843 return nfserr; 1844 1845 buflen = resp->end - resp->p - (COMPOUND_ERR_SLACK_SPACE >> 2); 1846 nfserr = nfsd4_encode_fattr(fhp, fhp->fh_export, fhp->fh_dentry, 1847 resp->p, &buflen, getattr->ga_bmval, 1848 resp->rqstp); 1849 1850 if (!nfserr) 1851 resp->p += buflen; 1852 return nfserr; 1853 } 1854 1855 static void 1856 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, int nfserr, struct svc_fh *fhp) 1857 { 1858 unsigned int len; 1859 ENCODE_HEAD; 1860 1861 if (!nfserr) { 1862 len = fhp->fh_handle.fh_size; 1863 RESERVE_SPACE(len + 4); 1864 WRITE32(len); 1865 WRITEMEM(&fhp->fh_handle.fh_base, len); 1866 ADJUST_ARGS(); 1867 } 1868 } 1869 1870 /* 1871 * Including all fields other than the name, a LOCK4denied structure requires 1872 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes. 1873 */ 1874 static void 1875 nfsd4_encode_lock_denied(struct nfsd4_compoundres *resp, struct nfsd4_lock_denied *ld) 1876 { 1877 ENCODE_HEAD; 1878 1879 RESERVE_SPACE(32 + XDR_LEN(ld->ld_sop ? ld->ld_sop->so_owner.len : 0)); 1880 WRITE64(ld->ld_start); 1881 WRITE64(ld->ld_length); 1882 WRITE32(ld->ld_type); 1883 if (ld->ld_sop) { 1884 WRITEMEM(&ld->ld_clientid, 8); 1885 WRITE32(ld->ld_sop->so_owner.len); 1886 WRITEMEM(ld->ld_sop->so_owner.data, ld->ld_sop->so_owner.len); 1887 kref_put(&ld->ld_sop->so_ref, nfs4_free_stateowner); 1888 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ 1889 WRITE64((u64)0); /* clientid */ 1890 WRITE32(0); /* length of owner name */ 1891 } 1892 ADJUST_ARGS(); 1893 } 1894 1895 static void 1896 nfsd4_encode_lock(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_lock *lock) 1897 { 1898 ENCODE_SEQID_OP_HEAD; 1899 1900 if (!nfserr) { 1901 RESERVE_SPACE(4 + sizeof(stateid_t)); 1902 WRITE32(lock->lk_resp_stateid.si_generation); 1903 WRITEMEM(&lock->lk_resp_stateid.si_opaque, sizeof(stateid_opaque_t)); 1904 ADJUST_ARGS(); 1905 } else if (nfserr == nfserr_denied) 1906 nfsd4_encode_lock_denied(resp, &lock->lk_denied); 1907 1908 ENCODE_SEQID_OP_TAIL(lock->lk_replay_owner); 1909 } 1910 1911 static void 1912 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_lockt *lockt) 1913 { 1914 if (nfserr == nfserr_denied) 1915 nfsd4_encode_lock_denied(resp, &lockt->lt_denied); 1916 } 1917 1918 static void 1919 nfsd4_encode_locku(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_locku *locku) 1920 { 1921 ENCODE_SEQID_OP_HEAD; 1922 1923 if (!nfserr) { 1924 RESERVE_SPACE(sizeof(stateid_t)); 1925 WRITE32(locku->lu_stateid.si_generation); 1926 WRITEMEM(&locku->lu_stateid.si_opaque, sizeof(stateid_opaque_t)); 1927 ADJUST_ARGS(); 1928 } 1929 1930 ENCODE_SEQID_OP_TAIL(locku->lu_stateowner); 1931 } 1932 1933 1934 static void 1935 nfsd4_encode_link(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_link *link) 1936 { 1937 ENCODE_HEAD; 1938 1939 if (!nfserr) { 1940 RESERVE_SPACE(20); 1941 WRITECINFO(link->li_cinfo); 1942 ADJUST_ARGS(); 1943 } 1944 } 1945 1946 1947 static void 1948 nfsd4_encode_open(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_open *open) 1949 { 1950 ENCODE_SEQID_OP_HEAD; 1951 1952 if (nfserr) 1953 goto out; 1954 1955 RESERVE_SPACE(36 + sizeof(stateid_t)); 1956 WRITE32(open->op_stateid.si_generation); 1957 WRITEMEM(&open->op_stateid.si_opaque, sizeof(stateid_opaque_t)); 1958 WRITECINFO(open->op_cinfo); 1959 WRITE32(open->op_rflags); 1960 WRITE32(2); 1961 WRITE32(open->op_bmval[0]); 1962 WRITE32(open->op_bmval[1]); 1963 WRITE32(open->op_delegate_type); 1964 ADJUST_ARGS(); 1965 1966 switch (open->op_delegate_type) { 1967 case NFS4_OPEN_DELEGATE_NONE: 1968 break; 1969 case NFS4_OPEN_DELEGATE_READ: 1970 RESERVE_SPACE(20 + sizeof(stateid_t)); 1971 WRITEMEM(&open->op_delegate_stateid, sizeof(stateid_t)); 1972 WRITE32(open->op_recall); 1973 1974 /* 1975 * TODO: ACE's in delegations 1976 */ 1977 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 1978 WRITE32(0); 1979 WRITE32(0); 1980 WRITE32(0); /* XXX: is NULL principal ok? */ 1981 ADJUST_ARGS(); 1982 break; 1983 case NFS4_OPEN_DELEGATE_WRITE: 1984 RESERVE_SPACE(32 + sizeof(stateid_t)); 1985 WRITEMEM(&open->op_delegate_stateid, sizeof(stateid_t)); 1986 WRITE32(0); 1987 1988 /* 1989 * TODO: space_limit's in delegations 1990 */ 1991 WRITE32(NFS4_LIMIT_SIZE); 1992 WRITE32(~(u32)0); 1993 WRITE32(~(u32)0); 1994 1995 /* 1996 * TODO: ACE's in delegations 1997 */ 1998 WRITE32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 1999 WRITE32(0); 2000 WRITE32(0); 2001 WRITE32(0); /* XXX: is NULL principal ok? */ 2002 ADJUST_ARGS(); 2003 break; 2004 default: 2005 BUG(); 2006 } 2007 /* XXX save filehandle here */ 2008 out: 2009 ENCODE_SEQID_OP_TAIL(open->op_stateowner); 2010 } 2011 2012 static void 2013 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_open_confirm *oc) 2014 { 2015 ENCODE_SEQID_OP_HEAD; 2016 2017 if (!nfserr) { 2018 RESERVE_SPACE(sizeof(stateid_t)); 2019 WRITE32(oc->oc_resp_stateid.si_generation); 2020 WRITEMEM(&oc->oc_resp_stateid.si_opaque, sizeof(stateid_opaque_t)); 2021 ADJUST_ARGS(); 2022 } 2023 2024 ENCODE_SEQID_OP_TAIL(oc->oc_stateowner); 2025 } 2026 2027 static void 2028 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_open_downgrade *od) 2029 { 2030 ENCODE_SEQID_OP_HEAD; 2031 2032 if (!nfserr) { 2033 RESERVE_SPACE(sizeof(stateid_t)); 2034 WRITE32(od->od_stateid.si_generation); 2035 WRITEMEM(&od->od_stateid.si_opaque, sizeof(stateid_opaque_t)); 2036 ADJUST_ARGS(); 2037 } 2038 2039 ENCODE_SEQID_OP_TAIL(od->od_stateowner); 2040 } 2041 2042 static int 2043 nfsd4_encode_read(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_read *read) 2044 { 2045 u32 eof; 2046 int v, pn; 2047 unsigned long maxcount; 2048 long len; 2049 ENCODE_HEAD; 2050 2051 if (nfserr) 2052 return nfserr; 2053 if (resp->xbuf->page_len) 2054 return nfserr_resource; 2055 2056 RESERVE_SPACE(8); /* eof flag and byte count */ 2057 2058 maxcount = NFSSVC_MAXBLKSIZE; 2059 if (maxcount > read->rd_length) 2060 maxcount = read->rd_length; 2061 2062 len = maxcount; 2063 v = 0; 2064 while (len > 0) { 2065 pn = resp->rqstp->rq_resused; 2066 svc_take_page(resp->rqstp); 2067 read->rd_iov[v].iov_base = page_address(resp->rqstp->rq_respages[pn]); 2068 read->rd_iov[v].iov_len = len < PAGE_SIZE ? len : PAGE_SIZE; 2069 v++; 2070 len -= PAGE_SIZE; 2071 } 2072 read->rd_vlen = v; 2073 2074 nfserr = nfsd_read(read->rd_rqstp, read->rd_fhp, read->rd_filp, 2075 read->rd_offset, read->rd_iov, read->rd_vlen, 2076 &maxcount); 2077 2078 if (nfserr == nfserr_symlink) 2079 nfserr = nfserr_inval; 2080 if (nfserr) 2081 return nfserr; 2082 eof = (read->rd_offset + maxcount >= read->rd_fhp->fh_dentry->d_inode->i_size); 2083 2084 WRITE32(eof); 2085 WRITE32(maxcount); 2086 ADJUST_ARGS(); 2087 resp->xbuf->head[0].iov_len = (char*)p 2088 - (char*)resp->xbuf->head[0].iov_base; 2089 resp->xbuf->page_len = maxcount; 2090 2091 /* Use rest of head for padding and remaining ops: */ 2092 resp->rqstp->rq_restailpage = 0; 2093 resp->xbuf->tail[0].iov_base = p; 2094 resp->xbuf->tail[0].iov_len = 0; 2095 if (maxcount&3) { 2096 RESERVE_SPACE(4); 2097 WRITE32(0); 2098 resp->xbuf->tail[0].iov_base += maxcount&3; 2099 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3); 2100 ADJUST_ARGS(); 2101 } 2102 return 0; 2103 } 2104 2105 static int 2106 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_readlink *readlink) 2107 { 2108 int maxcount; 2109 char *page; 2110 ENCODE_HEAD; 2111 2112 if (nfserr) 2113 return nfserr; 2114 if (resp->xbuf->page_len) 2115 return nfserr_resource; 2116 2117 svc_take_page(resp->rqstp); 2118 page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]); 2119 2120 maxcount = PAGE_SIZE; 2121 RESERVE_SPACE(4); 2122 2123 /* 2124 * XXX: By default, the ->readlink() VFS op will truncate symlinks 2125 * if they would overflow the buffer. Is this kosher in NFSv4? If 2126 * not, one easy fix is: if ->readlink() precisely fills the buffer, 2127 * assume that truncation occurred, and return NFS4ERR_RESOURCE. 2128 */ 2129 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, page, &maxcount); 2130 if (nfserr == nfserr_isdir) 2131 return nfserr_inval; 2132 if (nfserr) 2133 return nfserr; 2134 2135 WRITE32(maxcount); 2136 ADJUST_ARGS(); 2137 resp->xbuf->head[0].iov_len = (char*)p 2138 - (char*)resp->xbuf->head[0].iov_base; 2139 resp->xbuf->page_len = maxcount; 2140 2141 /* Use rest of head for padding and remaining ops: */ 2142 resp->rqstp->rq_restailpage = 0; 2143 resp->xbuf->tail[0].iov_base = p; 2144 resp->xbuf->tail[0].iov_len = 0; 2145 if (maxcount&3) { 2146 RESERVE_SPACE(4); 2147 WRITE32(0); 2148 resp->xbuf->tail[0].iov_base += maxcount&3; 2149 resp->xbuf->tail[0].iov_len = 4 - (maxcount&3); 2150 ADJUST_ARGS(); 2151 } 2152 return 0; 2153 } 2154 2155 static int 2156 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_readdir *readdir) 2157 { 2158 int maxcount; 2159 loff_t offset; 2160 u32 *page, *savep, *tailbase; 2161 ENCODE_HEAD; 2162 2163 if (nfserr) 2164 return nfserr; 2165 if (resp->xbuf->page_len) 2166 return nfserr_resource; 2167 2168 RESERVE_SPACE(8); /* verifier */ 2169 savep = p; 2170 2171 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */ 2172 WRITE32(0); 2173 WRITE32(0); 2174 ADJUST_ARGS(); 2175 resp->xbuf->head[0].iov_len = ((char*)resp->p) - (char*)resp->xbuf->head[0].iov_base; 2176 tailbase = p; 2177 2178 maxcount = PAGE_SIZE; 2179 if (maxcount > readdir->rd_maxcount) 2180 maxcount = readdir->rd_maxcount; 2181 2182 /* 2183 * Convert from bytes to words, account for the two words already 2184 * written, make sure to leave two words at the end for the next 2185 * pointer and eof field. 2186 */ 2187 maxcount = (maxcount >> 2) - 4; 2188 if (maxcount < 0) { 2189 nfserr = nfserr_toosmall; 2190 goto err_no_verf; 2191 } 2192 2193 svc_take_page(resp->rqstp); 2194 page = page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]); 2195 readdir->common.err = 0; 2196 readdir->buflen = maxcount; 2197 readdir->buffer = page; 2198 readdir->offset = NULL; 2199 2200 offset = readdir->rd_cookie; 2201 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, 2202 &offset, 2203 &readdir->common, nfsd4_encode_dirent); 2204 if (nfserr == nfs_ok && 2205 readdir->common.err == nfserr_toosmall && 2206 readdir->buffer == page) 2207 nfserr = nfserr_toosmall; 2208 if (nfserr == nfserr_symlink) 2209 nfserr = nfserr_notdir; 2210 if (nfserr) 2211 goto err_no_verf; 2212 2213 if (readdir->offset) 2214 xdr_encode_hyper(readdir->offset, offset); 2215 2216 p = readdir->buffer; 2217 *p++ = 0; /* no more entries */ 2218 *p++ = htonl(readdir->common.err == nfserr_eof); 2219 resp->xbuf->page_len = ((char*)p) - (char*)page_address(resp->rqstp->rq_respages[resp->rqstp->rq_resused-1]); 2220 2221 /* Use rest of head for padding and remaining ops: */ 2222 resp->rqstp->rq_restailpage = 0; 2223 resp->xbuf->tail[0].iov_base = tailbase; 2224 resp->xbuf->tail[0].iov_len = 0; 2225 resp->p = resp->xbuf->tail[0].iov_base; 2226 resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4; 2227 2228 return 0; 2229 err_no_verf: 2230 p = savep; 2231 ADJUST_ARGS(); 2232 return nfserr; 2233 } 2234 2235 static void 2236 nfsd4_encode_remove(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_remove *remove) 2237 { 2238 ENCODE_HEAD; 2239 2240 if (!nfserr) { 2241 RESERVE_SPACE(20); 2242 WRITECINFO(remove->rm_cinfo); 2243 ADJUST_ARGS(); 2244 } 2245 } 2246 2247 static void 2248 nfsd4_encode_rename(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_rename *rename) 2249 { 2250 ENCODE_HEAD; 2251 2252 if (!nfserr) { 2253 RESERVE_SPACE(40); 2254 WRITECINFO(rename->rn_sinfo); 2255 WRITECINFO(rename->rn_tinfo); 2256 ADJUST_ARGS(); 2257 } 2258 } 2259 2260 /* 2261 * The SETATTR encode routine is special -- it always encodes a bitmap, 2262 * regardless of the error status. 2263 */ 2264 static void 2265 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_setattr *setattr) 2266 { 2267 ENCODE_HEAD; 2268 2269 RESERVE_SPACE(12); 2270 if (nfserr) { 2271 WRITE32(2); 2272 WRITE32(0); 2273 WRITE32(0); 2274 } 2275 else { 2276 WRITE32(2); 2277 WRITE32(setattr->sa_bmval[0]); 2278 WRITE32(setattr->sa_bmval[1]); 2279 } 2280 ADJUST_ARGS(); 2281 } 2282 2283 static void 2284 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_setclientid *scd) 2285 { 2286 ENCODE_HEAD; 2287 2288 if (!nfserr) { 2289 RESERVE_SPACE(8 + sizeof(nfs4_verifier)); 2290 WRITEMEM(&scd->se_clientid, 8); 2291 WRITEMEM(&scd->se_confirm, sizeof(nfs4_verifier)); 2292 ADJUST_ARGS(); 2293 } 2294 else if (nfserr == nfserr_clid_inuse) { 2295 RESERVE_SPACE(8); 2296 WRITE32(0); 2297 WRITE32(0); 2298 ADJUST_ARGS(); 2299 } 2300 } 2301 2302 static void 2303 nfsd4_encode_write(struct nfsd4_compoundres *resp, int nfserr, struct nfsd4_write *write) 2304 { 2305 ENCODE_HEAD; 2306 2307 if (!nfserr) { 2308 RESERVE_SPACE(16); 2309 WRITE32(write->wr_bytes_written); 2310 WRITE32(write->wr_how_written); 2311 WRITEMEM(write->wr_verifier.data, 8); 2312 ADJUST_ARGS(); 2313 } 2314 } 2315 2316 void 2317 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 2318 { 2319 u32 *statp; 2320 ENCODE_HEAD; 2321 2322 RESERVE_SPACE(8); 2323 WRITE32(op->opnum); 2324 statp = p++; /* to be backfilled at the end */ 2325 ADJUST_ARGS(); 2326 2327 switch (op->opnum) { 2328 case OP_ACCESS: 2329 nfsd4_encode_access(resp, op->status, &op->u.access); 2330 break; 2331 case OP_CLOSE: 2332 nfsd4_encode_close(resp, op->status, &op->u.close); 2333 break; 2334 case OP_COMMIT: 2335 nfsd4_encode_commit(resp, op->status, &op->u.commit); 2336 break; 2337 case OP_CREATE: 2338 nfsd4_encode_create(resp, op->status, &op->u.create); 2339 break; 2340 case OP_DELEGRETURN: 2341 break; 2342 case OP_GETATTR: 2343 op->status = nfsd4_encode_getattr(resp, op->status, &op->u.getattr); 2344 break; 2345 case OP_GETFH: 2346 nfsd4_encode_getfh(resp, op->status, op->u.getfh); 2347 break; 2348 case OP_LINK: 2349 nfsd4_encode_link(resp, op->status, &op->u.link); 2350 break; 2351 case OP_LOCK: 2352 nfsd4_encode_lock(resp, op->status, &op->u.lock); 2353 break; 2354 case OP_LOCKT: 2355 nfsd4_encode_lockt(resp, op->status, &op->u.lockt); 2356 break; 2357 case OP_LOCKU: 2358 nfsd4_encode_locku(resp, op->status, &op->u.locku); 2359 break; 2360 case OP_LOOKUP: 2361 break; 2362 case OP_LOOKUPP: 2363 break; 2364 case OP_NVERIFY: 2365 break; 2366 case OP_OPEN: 2367 nfsd4_encode_open(resp, op->status, &op->u.open); 2368 break; 2369 case OP_OPEN_CONFIRM: 2370 nfsd4_encode_open_confirm(resp, op->status, &op->u.open_confirm); 2371 break; 2372 case OP_OPEN_DOWNGRADE: 2373 nfsd4_encode_open_downgrade(resp, op->status, &op->u.open_downgrade); 2374 break; 2375 case OP_PUTFH: 2376 break; 2377 case OP_PUTROOTFH: 2378 break; 2379 case OP_READ: 2380 op->status = nfsd4_encode_read(resp, op->status, &op->u.read); 2381 break; 2382 case OP_READDIR: 2383 op->status = nfsd4_encode_readdir(resp, op->status, &op->u.readdir); 2384 break; 2385 case OP_READLINK: 2386 op->status = nfsd4_encode_readlink(resp, op->status, &op->u.readlink); 2387 break; 2388 case OP_REMOVE: 2389 nfsd4_encode_remove(resp, op->status, &op->u.remove); 2390 break; 2391 case OP_RENAME: 2392 nfsd4_encode_rename(resp, op->status, &op->u.rename); 2393 break; 2394 case OP_RENEW: 2395 break; 2396 case OP_RESTOREFH: 2397 break; 2398 case OP_SAVEFH: 2399 break; 2400 case OP_SETATTR: 2401 nfsd4_encode_setattr(resp, op->status, &op->u.setattr); 2402 break; 2403 case OP_SETCLIENTID: 2404 nfsd4_encode_setclientid(resp, op->status, &op->u.setclientid); 2405 break; 2406 case OP_SETCLIENTID_CONFIRM: 2407 break; 2408 case OP_VERIFY: 2409 break; 2410 case OP_WRITE: 2411 nfsd4_encode_write(resp, op->status, &op->u.write); 2412 break; 2413 case OP_RELEASE_LOCKOWNER: 2414 break; 2415 default: 2416 break; 2417 } 2418 2419 /* 2420 * Note: We write the status directly, instead of using WRITE32(), 2421 * since it is already in network byte order. 2422 */ 2423 *statp = op->status; 2424 } 2425 2426 /* 2427 * Encode the reply stored in the stateowner reply cache 2428 * 2429 * XDR note: do not encode rp->rp_buflen: the buffer contains the 2430 * previously sent already encoded operation. 2431 * 2432 * called with nfs4_lock_state() held 2433 */ 2434 void 2435 nfsd4_encode_replay(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 2436 { 2437 ENCODE_HEAD; 2438 struct nfs4_replay *rp = op->replay; 2439 2440 BUG_ON(!rp); 2441 2442 RESERVE_SPACE(8); 2443 WRITE32(op->opnum); 2444 *p++ = rp->rp_status; /* already xdr'ed */ 2445 ADJUST_ARGS(); 2446 2447 RESERVE_SPACE(rp->rp_buflen); 2448 WRITEMEM(rp->rp_buf, rp->rp_buflen); 2449 ADJUST_ARGS(); 2450 } 2451 2452 /* 2453 * END OF "GENERIC" ENCODE ROUTINES. 2454 */ 2455 2456 int 2457 nfs4svc_encode_voidres(struct svc_rqst *rqstp, u32 *p, void *dummy) 2458 { 2459 return xdr_ressize_check(rqstp, p); 2460 } 2461 2462 void nfsd4_release_compoundargs(struct nfsd4_compoundargs *args) 2463 { 2464 if (args->ops != args->iops) { 2465 kfree(args->ops); 2466 args->ops = args->iops; 2467 } 2468 kfree(args->tmpp); 2469 args->tmpp = NULL; 2470 while (args->to_free) { 2471 struct tmpbuf *tb = args->to_free; 2472 args->to_free = tb->next; 2473 tb->release(tb->buf); 2474 kfree(tb); 2475 } 2476 } 2477 2478 int 2479 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, u32 *p, struct nfsd4_compoundargs *args) 2480 { 2481 int status; 2482 2483 args->p = p; 2484 args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len; 2485 args->pagelist = rqstp->rq_arg.pages; 2486 args->pagelen = rqstp->rq_arg.page_len; 2487 args->tmpp = NULL; 2488 args->to_free = NULL; 2489 args->ops = args->iops; 2490 args->rqstp = rqstp; 2491 2492 status = nfsd4_decode_compound(args); 2493 if (status) { 2494 nfsd4_release_compoundargs(args); 2495 } 2496 return !status; 2497 } 2498 2499 int 2500 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, u32 *p, struct nfsd4_compoundres *resp) 2501 { 2502 /* 2503 * All that remains is to write the tag and operation count... 2504 */ 2505 struct kvec *iov; 2506 p = resp->tagp; 2507 *p++ = htonl(resp->taglen); 2508 memcpy(p, resp->tag, resp->taglen); 2509 p += XDR_QUADLEN(resp->taglen); 2510 *p++ = htonl(resp->opcnt); 2511 2512 if (rqstp->rq_res.page_len) 2513 iov = &rqstp->rq_res.tail[0]; 2514 else 2515 iov = &rqstp->rq_res.head[0]; 2516 iov->iov_len = ((char*)resp->p) - (char*)iov->iov_base; 2517 BUG_ON(iov->iov_len > PAGE_SIZE); 2518 return 1; 2519 } 2520 2521 /* 2522 * Local variables: 2523 * c-basic-offset: 8 2524 * End: 2525 */ 2526