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 36 #include <linux/file.h> 37 #include <linux/slab.h> 38 #include <linux/namei.h> 39 #include <linux/statfs.h> 40 #include <linux/utsname.h> 41 #include <linux/pagemap.h> 42 #include <linux/sunrpc/svcauth_gss.h> 43 44 #include "idmap.h" 45 #include "acl.h" 46 #include "xdr4.h" 47 #include "vfs.h" 48 #include "state.h" 49 #include "cache.h" 50 #include "netns.h" 51 #include "pnfs.h" 52 53 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 54 #include <linux/security.h> 55 #endif 56 57 58 #define NFSDDBG_FACILITY NFSDDBG_XDR 59 60 const u32 nfsd_suppattrs[3][3] = { 61 {NFSD4_SUPPORTED_ATTRS_WORD0, 62 NFSD4_SUPPORTED_ATTRS_WORD1, 63 NFSD4_SUPPORTED_ATTRS_WORD2}, 64 65 {NFSD4_1_SUPPORTED_ATTRS_WORD0, 66 NFSD4_1_SUPPORTED_ATTRS_WORD1, 67 NFSD4_1_SUPPORTED_ATTRS_WORD2}, 68 69 {NFSD4_1_SUPPORTED_ATTRS_WORD0, 70 NFSD4_1_SUPPORTED_ATTRS_WORD1, 71 NFSD4_2_SUPPORTED_ATTRS_WORD2}, 72 }; 73 74 /* 75 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing 76 * directory in order to indicate to the client that a filesystem boundary is present 77 * We use a fixed fsid for a referral 78 */ 79 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL 80 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL 81 82 static __be32 83 check_filename(char *str, int len) 84 { 85 int i; 86 87 if (len == 0) 88 return nfserr_inval; 89 if (isdotent(str, len)) 90 return nfserr_badname; 91 for (i = 0; i < len; i++) 92 if (str[i] == '/') 93 return nfserr_badname; 94 return 0; 95 } 96 97 #define DECODE_HEAD \ 98 __be32 *p; \ 99 __be32 status 100 #define DECODE_TAIL \ 101 status = 0; \ 102 out: \ 103 return status; \ 104 xdr_error: \ 105 dprintk("NFSD: xdr error (%s:%d)\n", \ 106 __FILE__, __LINE__); \ 107 status = nfserr_bad_xdr; \ 108 goto out 109 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 dprintk("NFSD: xdr error (%s:%d)\n", \ 119 __FILE__, __LINE__); \ 120 goto xdr_error; \ 121 } \ 122 p += XDR_QUADLEN(nbytes); \ 123 } while (0) 124 #define COPYMEM(x,nbytes) do { \ 125 memcpy((x), p, nbytes); \ 126 p += XDR_QUADLEN(nbytes); \ 127 } while (0) 128 129 /* READ_BUF, read_buf(): nbytes must be <= PAGE_SIZE */ 130 #define READ_BUF(nbytes) do { \ 131 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \ 132 p = argp->p; \ 133 argp->p += XDR_QUADLEN(nbytes); \ 134 } else if (!(p = read_buf(argp, nbytes))) { \ 135 dprintk("NFSD: xdr error (%s:%d)\n", \ 136 __FILE__, __LINE__); \ 137 goto xdr_error; \ 138 } \ 139 } while (0) 140 141 static void next_decode_page(struct nfsd4_compoundargs *argp) 142 { 143 argp->p = page_address(argp->pagelist[0]); 144 argp->pagelist++; 145 if (argp->pagelen < PAGE_SIZE) { 146 argp->end = argp->p + XDR_QUADLEN(argp->pagelen); 147 argp->pagelen = 0; 148 } else { 149 argp->end = argp->p + (PAGE_SIZE>>2); 150 argp->pagelen -= PAGE_SIZE; 151 } 152 } 153 154 static __be32 *read_buf(struct nfsd4_compoundargs *argp, u32 nbytes) 155 { 156 /* We want more bytes than seem to be available. 157 * Maybe we need a new page, maybe we have just run out 158 */ 159 unsigned int avail = (char *)argp->end - (char *)argp->p; 160 __be32 *p; 161 162 if (argp->pagelen == 0) { 163 struct kvec *vec = &argp->rqstp->rq_arg.tail[0]; 164 165 if (!argp->tail) { 166 argp->tail = true; 167 avail = vec->iov_len; 168 argp->p = vec->iov_base; 169 argp->end = vec->iov_base + avail; 170 } 171 172 if (avail < nbytes) 173 return NULL; 174 175 p = argp->p; 176 argp->p += XDR_QUADLEN(nbytes); 177 return p; 178 } 179 180 if (avail + argp->pagelen < nbytes) 181 return NULL; 182 if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */ 183 return NULL; 184 /* ok, we can do it with the current plus the next page */ 185 if (nbytes <= sizeof(argp->tmp)) 186 p = argp->tmp; 187 else { 188 kfree(argp->tmpp); 189 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL); 190 if (!p) 191 return NULL; 192 193 } 194 /* 195 * The following memcpy is safe because read_buf is always 196 * called with nbytes > avail, and the two cases above both 197 * guarantee p points to at least nbytes bytes. 198 */ 199 memcpy(p, argp->p, avail); 200 next_decode_page(argp); 201 memcpy(((char*)p)+avail, argp->p, (nbytes - avail)); 202 argp->p += XDR_QUADLEN(nbytes - avail); 203 return p; 204 } 205 206 static int zero_clientid(clientid_t *clid) 207 { 208 return (clid->cl_boot == 0) && (clid->cl_id == 0); 209 } 210 211 /** 212 * svcxdr_tmpalloc - allocate memory to be freed after compound processing 213 * @argp: NFSv4 compound argument structure 214 * @p: pointer to be freed (with kfree()) 215 * 216 * Marks @p to be freed when processing the compound operation 217 * described in @argp finishes. 218 */ 219 static void * 220 svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len) 221 { 222 struct svcxdr_tmpbuf *tb; 223 224 tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL); 225 if (!tb) 226 return NULL; 227 tb->next = argp->to_free; 228 argp->to_free = tb; 229 return tb->buf; 230 } 231 232 /* 233 * For xdr strings that need to be passed to other kernel api's 234 * as null-terminated strings. 235 * 236 * Note null-terminating in place usually isn't safe since the 237 * buffer might end on a page boundary. 238 */ 239 static char * 240 svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len) 241 { 242 char *p = svcxdr_tmpalloc(argp, len + 1); 243 244 if (!p) 245 return NULL; 246 memcpy(p, buf, len); 247 p[len] = '\0'; 248 return p; 249 } 250 251 /** 252 * savemem - duplicate a chunk of memory for later processing 253 * @argp: NFSv4 compound argument structure to be freed with 254 * @p: pointer to be duplicated 255 * @nbytes: length to be duplicated 256 * 257 * Returns a pointer to a copy of @nbytes bytes of memory at @p 258 * that are preserved until processing of the NFSv4 compound 259 * operation described by @argp finishes. 260 */ 261 static char *savemem(struct nfsd4_compoundargs *argp, __be32 *p, int nbytes) 262 { 263 void *ret; 264 265 ret = svcxdr_tmpalloc(argp, nbytes); 266 if (!ret) 267 return NULL; 268 memcpy(ret, p, nbytes); 269 return ret; 270 } 271 272 /* 273 * We require the high 32 bits of 'seconds' to be 0, and 274 * we ignore all 32 bits of 'nseconds'. 275 */ 276 static __be32 277 nfsd4_decode_time(struct nfsd4_compoundargs *argp, struct timespec *tv) 278 { 279 DECODE_HEAD; 280 u64 sec; 281 282 READ_BUF(12); 283 p = xdr_decode_hyper(p, &sec); 284 tv->tv_sec = sec; 285 tv->tv_nsec = be32_to_cpup(p++); 286 if (tv->tv_nsec >= (u32)1000000000) 287 return nfserr_inval; 288 289 DECODE_TAIL; 290 } 291 292 static __be32 293 nfsd4_decode_bitmap(struct nfsd4_compoundargs *argp, u32 *bmval) 294 { 295 u32 bmlen; 296 DECODE_HEAD; 297 298 bmval[0] = 0; 299 bmval[1] = 0; 300 bmval[2] = 0; 301 302 READ_BUF(4); 303 bmlen = be32_to_cpup(p++); 304 if (bmlen > 1000) 305 goto xdr_error; 306 307 READ_BUF(bmlen << 2); 308 if (bmlen > 0) 309 bmval[0] = be32_to_cpup(p++); 310 if (bmlen > 1) 311 bmval[1] = be32_to_cpup(p++); 312 if (bmlen > 2) 313 bmval[2] = be32_to_cpup(p++); 314 315 DECODE_TAIL; 316 } 317 318 static __be32 319 nfsd4_decode_fattr(struct nfsd4_compoundargs *argp, u32 *bmval, 320 struct iattr *iattr, struct nfs4_acl **acl, 321 struct xdr_netobj *label, int *umask) 322 { 323 struct timespec ts; 324 int expected_len, len = 0; 325 u32 dummy32; 326 char *buf; 327 328 DECODE_HEAD; 329 iattr->ia_valid = 0; 330 if ((status = nfsd4_decode_bitmap(argp, bmval))) 331 return status; 332 333 if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0 334 || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1 335 || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) { 336 if (nfsd_attrs_supported(argp->minorversion, bmval)) 337 return nfserr_inval; 338 return nfserr_attrnotsupp; 339 } 340 341 READ_BUF(4); 342 expected_len = be32_to_cpup(p++); 343 344 if (bmval[0] & FATTR4_WORD0_SIZE) { 345 READ_BUF(8); 346 len += 8; 347 p = xdr_decode_hyper(p, &iattr->ia_size); 348 iattr->ia_valid |= ATTR_SIZE; 349 } 350 if (bmval[0] & FATTR4_WORD0_ACL) { 351 u32 nace; 352 struct nfs4_ace *ace; 353 354 READ_BUF(4); len += 4; 355 nace = be32_to_cpup(p++); 356 357 if (nace > NFS4_ACL_MAX) 358 return nfserr_fbig; 359 360 *acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(nace)); 361 if (*acl == NULL) 362 return nfserr_jukebox; 363 364 (*acl)->naces = nace; 365 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) { 366 READ_BUF(16); len += 16; 367 ace->type = be32_to_cpup(p++); 368 ace->flag = be32_to_cpup(p++); 369 ace->access_mask = be32_to_cpup(p++); 370 dummy32 = be32_to_cpup(p++); 371 READ_BUF(dummy32); 372 len += XDR_QUADLEN(dummy32) << 2; 373 READMEM(buf, dummy32); 374 ace->whotype = nfs4_acl_get_whotype(buf, dummy32); 375 status = nfs_ok; 376 if (ace->whotype != NFS4_ACL_WHO_NAMED) 377 ; 378 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) 379 status = nfsd_map_name_to_gid(argp->rqstp, 380 buf, dummy32, &ace->who_gid); 381 else 382 status = nfsd_map_name_to_uid(argp->rqstp, 383 buf, dummy32, &ace->who_uid); 384 if (status) 385 return status; 386 } 387 } else 388 *acl = NULL; 389 if (bmval[1] & FATTR4_WORD1_MODE) { 390 READ_BUF(4); 391 len += 4; 392 iattr->ia_mode = be32_to_cpup(p++); 393 iattr->ia_mode &= (S_IFMT | S_IALLUGO); 394 iattr->ia_valid |= ATTR_MODE; 395 } 396 if (bmval[1] & FATTR4_WORD1_OWNER) { 397 READ_BUF(4); 398 len += 4; 399 dummy32 = be32_to_cpup(p++); 400 READ_BUF(dummy32); 401 len += (XDR_QUADLEN(dummy32) << 2); 402 READMEM(buf, dummy32); 403 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid))) 404 return status; 405 iattr->ia_valid |= ATTR_UID; 406 } 407 if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) { 408 READ_BUF(4); 409 len += 4; 410 dummy32 = be32_to_cpup(p++); 411 READ_BUF(dummy32); 412 len += (XDR_QUADLEN(dummy32) << 2); 413 READMEM(buf, dummy32); 414 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid))) 415 return status; 416 iattr->ia_valid |= ATTR_GID; 417 } 418 if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) { 419 READ_BUF(4); 420 len += 4; 421 dummy32 = be32_to_cpup(p++); 422 switch (dummy32) { 423 case NFS4_SET_TO_CLIENT_TIME: 424 len += 12; 425 status = nfsd4_decode_time(argp, &ts); 426 iattr->ia_atime = timespec_to_timespec64(ts); 427 if (status) 428 return status; 429 iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); 430 break; 431 case NFS4_SET_TO_SERVER_TIME: 432 iattr->ia_valid |= ATTR_ATIME; 433 break; 434 default: 435 goto xdr_error; 436 } 437 } 438 if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) { 439 READ_BUF(4); 440 len += 4; 441 dummy32 = be32_to_cpup(p++); 442 switch (dummy32) { 443 case NFS4_SET_TO_CLIENT_TIME: 444 len += 12; 445 status = nfsd4_decode_time(argp, &ts); 446 iattr->ia_mtime = timespec_to_timespec64(ts); 447 if (status) 448 return status; 449 iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); 450 break; 451 case NFS4_SET_TO_SERVER_TIME: 452 iattr->ia_valid |= ATTR_MTIME; 453 break; 454 default: 455 goto xdr_error; 456 } 457 } 458 459 label->len = 0; 460 if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) && 461 bmval[2] & FATTR4_WORD2_SECURITY_LABEL) { 462 READ_BUF(4); 463 len += 4; 464 dummy32 = be32_to_cpup(p++); /* lfs: we don't use it */ 465 READ_BUF(4); 466 len += 4; 467 dummy32 = be32_to_cpup(p++); /* pi: we don't use it either */ 468 READ_BUF(4); 469 len += 4; 470 dummy32 = be32_to_cpup(p++); 471 READ_BUF(dummy32); 472 if (dummy32 > NFS4_MAXLABELLEN) 473 return nfserr_badlabel; 474 len += (XDR_QUADLEN(dummy32) << 2); 475 READMEM(buf, dummy32); 476 label->len = dummy32; 477 label->data = svcxdr_dupstr(argp, buf, dummy32); 478 if (!label->data) 479 return nfserr_jukebox; 480 } 481 if (bmval[2] & FATTR4_WORD2_MODE_UMASK) { 482 if (!umask) 483 goto xdr_error; 484 READ_BUF(8); 485 len += 8; 486 dummy32 = be32_to_cpup(p++); 487 iattr->ia_mode = dummy32 & (S_IFMT | S_IALLUGO); 488 dummy32 = be32_to_cpup(p++); 489 *umask = dummy32 & S_IRWXUGO; 490 iattr->ia_valid |= ATTR_MODE; 491 } 492 if (len != expected_len) 493 goto xdr_error; 494 495 DECODE_TAIL; 496 } 497 498 static __be32 499 nfsd4_decode_stateid(struct nfsd4_compoundargs *argp, stateid_t *sid) 500 { 501 DECODE_HEAD; 502 503 READ_BUF(sizeof(stateid_t)); 504 sid->si_generation = be32_to_cpup(p++); 505 COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); 506 507 DECODE_TAIL; 508 } 509 510 static __be32 511 nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access) 512 { 513 DECODE_HEAD; 514 515 READ_BUF(4); 516 access->ac_req_access = be32_to_cpup(p++); 517 518 DECODE_TAIL; 519 } 520 521 static __be32 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs) 522 { 523 DECODE_HEAD; 524 u32 dummy, uid, gid; 525 char *machine_name; 526 int i; 527 int nr_secflavs; 528 529 /* callback_sec_params4 */ 530 READ_BUF(4); 531 nr_secflavs = be32_to_cpup(p++); 532 if (nr_secflavs) 533 cbs->flavor = (u32)(-1); 534 else 535 /* Is this legal? Be generous, take it to mean AUTH_NONE: */ 536 cbs->flavor = 0; 537 for (i = 0; i < nr_secflavs; ++i) { 538 READ_BUF(4); 539 dummy = be32_to_cpup(p++); 540 switch (dummy) { 541 case RPC_AUTH_NULL: 542 /* Nothing to read */ 543 if (cbs->flavor == (u32)(-1)) 544 cbs->flavor = RPC_AUTH_NULL; 545 break; 546 case RPC_AUTH_UNIX: 547 READ_BUF(8); 548 /* stamp */ 549 dummy = be32_to_cpup(p++); 550 551 /* machine name */ 552 dummy = be32_to_cpup(p++); 553 READ_BUF(dummy); 554 SAVEMEM(machine_name, dummy); 555 556 /* uid, gid */ 557 READ_BUF(8); 558 uid = be32_to_cpup(p++); 559 gid = be32_to_cpup(p++); 560 561 /* more gids */ 562 READ_BUF(4); 563 dummy = be32_to_cpup(p++); 564 READ_BUF(dummy * 4); 565 if (cbs->flavor == (u32)(-1)) { 566 kuid_t kuid = make_kuid(&init_user_ns, uid); 567 kgid_t kgid = make_kgid(&init_user_ns, gid); 568 if (uid_valid(kuid) && gid_valid(kgid)) { 569 cbs->uid = kuid; 570 cbs->gid = kgid; 571 cbs->flavor = RPC_AUTH_UNIX; 572 } else { 573 dprintk("RPC_AUTH_UNIX with invalid" 574 "uid or gid ignoring!\n"); 575 } 576 } 577 break; 578 case RPC_AUTH_GSS: 579 dprintk("RPC_AUTH_GSS callback secflavor " 580 "not supported!\n"); 581 READ_BUF(8); 582 /* gcbp_service */ 583 dummy = be32_to_cpup(p++); 584 /* gcbp_handle_from_server */ 585 dummy = be32_to_cpup(p++); 586 READ_BUF(dummy); 587 p += XDR_QUADLEN(dummy); 588 /* gcbp_handle_from_client */ 589 READ_BUF(4); 590 dummy = be32_to_cpup(p++); 591 READ_BUF(dummy); 592 break; 593 default: 594 dprintk("Illegal callback secflavor\n"); 595 return nfserr_inval; 596 } 597 } 598 DECODE_TAIL; 599 } 600 601 static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc) 602 { 603 DECODE_HEAD; 604 605 READ_BUF(4); 606 bc->bc_cb_program = be32_to_cpup(p++); 607 nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); 608 609 DECODE_TAIL; 610 } 611 612 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts) 613 { 614 DECODE_HEAD; 615 616 READ_BUF(NFS4_MAX_SESSIONID_LEN + 8); 617 COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); 618 bcts->dir = be32_to_cpup(p++); 619 /* XXX: skipping ctsa_use_conn_in_rdma_mode. Perhaps Tom Tucker 620 * could help us figure out we should be using it. */ 621 DECODE_TAIL; 622 } 623 624 static __be32 625 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close) 626 { 627 DECODE_HEAD; 628 629 READ_BUF(4); 630 close->cl_seqid = be32_to_cpup(p++); 631 return nfsd4_decode_stateid(argp, &close->cl_stateid); 632 633 DECODE_TAIL; 634 } 635 636 637 static __be32 638 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit) 639 { 640 DECODE_HEAD; 641 642 READ_BUF(12); 643 p = xdr_decode_hyper(p, &commit->co_offset); 644 commit->co_count = be32_to_cpup(p++); 645 646 DECODE_TAIL; 647 } 648 649 static __be32 650 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create) 651 { 652 DECODE_HEAD; 653 654 READ_BUF(4); 655 create->cr_type = be32_to_cpup(p++); 656 switch (create->cr_type) { 657 case NF4LNK: 658 READ_BUF(4); 659 create->cr_datalen = be32_to_cpup(p++); 660 READ_BUF(create->cr_datalen); 661 create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen); 662 if (!create->cr_data) 663 return nfserr_jukebox; 664 break; 665 case NF4BLK: 666 case NF4CHR: 667 READ_BUF(8); 668 create->cr_specdata1 = be32_to_cpup(p++); 669 create->cr_specdata2 = be32_to_cpup(p++); 670 break; 671 case NF4SOCK: 672 case NF4FIFO: 673 case NF4DIR: 674 default: 675 break; 676 } 677 678 READ_BUF(4); 679 create->cr_namelen = be32_to_cpup(p++); 680 READ_BUF(create->cr_namelen); 681 SAVEMEM(create->cr_name, create->cr_namelen); 682 if ((status = check_filename(create->cr_name, create->cr_namelen))) 683 return status; 684 685 status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr, 686 &create->cr_acl, &create->cr_label, 687 &create->cr_umask); 688 if (status) 689 goto out; 690 691 DECODE_TAIL; 692 } 693 694 static inline __be32 695 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr) 696 { 697 return nfsd4_decode_stateid(argp, &dr->dr_stateid); 698 } 699 700 static inline __be32 701 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr) 702 { 703 return nfsd4_decode_bitmap(argp, getattr->ga_bmval); 704 } 705 706 static __be32 707 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link) 708 { 709 DECODE_HEAD; 710 711 READ_BUF(4); 712 link->li_namelen = be32_to_cpup(p++); 713 READ_BUF(link->li_namelen); 714 SAVEMEM(link->li_name, link->li_namelen); 715 if ((status = check_filename(link->li_name, link->li_namelen))) 716 return status; 717 718 DECODE_TAIL; 719 } 720 721 static __be32 722 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock) 723 { 724 DECODE_HEAD; 725 726 /* 727 * type, reclaim(boolean), offset, length, new_lock_owner(boolean) 728 */ 729 READ_BUF(28); 730 lock->lk_type = be32_to_cpup(p++); 731 if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) 732 goto xdr_error; 733 lock->lk_reclaim = be32_to_cpup(p++); 734 p = xdr_decode_hyper(p, &lock->lk_offset); 735 p = xdr_decode_hyper(p, &lock->lk_length); 736 lock->lk_is_new = be32_to_cpup(p++); 737 738 if (lock->lk_is_new) { 739 READ_BUF(4); 740 lock->lk_new_open_seqid = be32_to_cpup(p++); 741 status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid); 742 if (status) 743 return status; 744 READ_BUF(8 + sizeof(clientid_t)); 745 lock->lk_new_lock_seqid = be32_to_cpup(p++); 746 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t)); 747 lock->lk_new_owner.len = be32_to_cpup(p++); 748 READ_BUF(lock->lk_new_owner.len); 749 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len); 750 } else { 751 status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid); 752 if (status) 753 return status; 754 READ_BUF(4); 755 lock->lk_old_lock_seqid = be32_to_cpup(p++); 756 } 757 758 DECODE_TAIL; 759 } 760 761 static __be32 762 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt) 763 { 764 DECODE_HEAD; 765 766 READ_BUF(32); 767 lockt->lt_type = be32_to_cpup(p++); 768 if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) 769 goto xdr_error; 770 p = xdr_decode_hyper(p, &lockt->lt_offset); 771 p = xdr_decode_hyper(p, &lockt->lt_length); 772 COPYMEM(&lockt->lt_clientid, 8); 773 lockt->lt_owner.len = be32_to_cpup(p++); 774 READ_BUF(lockt->lt_owner.len); 775 READMEM(lockt->lt_owner.data, lockt->lt_owner.len); 776 777 DECODE_TAIL; 778 } 779 780 static __be32 781 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku) 782 { 783 DECODE_HEAD; 784 785 READ_BUF(8); 786 locku->lu_type = be32_to_cpup(p++); 787 if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) 788 goto xdr_error; 789 locku->lu_seqid = be32_to_cpup(p++); 790 status = nfsd4_decode_stateid(argp, &locku->lu_stateid); 791 if (status) 792 return status; 793 READ_BUF(16); 794 p = xdr_decode_hyper(p, &locku->lu_offset); 795 p = xdr_decode_hyper(p, &locku->lu_length); 796 797 DECODE_TAIL; 798 } 799 800 static __be32 801 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup) 802 { 803 DECODE_HEAD; 804 805 READ_BUF(4); 806 lookup->lo_len = be32_to_cpup(p++); 807 READ_BUF(lookup->lo_len); 808 SAVEMEM(lookup->lo_name, lookup->lo_len); 809 if ((status = check_filename(lookup->lo_name, lookup->lo_len))) 810 return status; 811 812 DECODE_TAIL; 813 } 814 815 static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when) 816 { 817 __be32 *p; 818 u32 w; 819 820 READ_BUF(4); 821 w = be32_to_cpup(p++); 822 *share_access = w & NFS4_SHARE_ACCESS_MASK; 823 *deleg_want = w & NFS4_SHARE_WANT_MASK; 824 if (deleg_when) 825 *deleg_when = w & NFS4_SHARE_WHEN_MASK; 826 827 switch (w & NFS4_SHARE_ACCESS_MASK) { 828 case NFS4_SHARE_ACCESS_READ: 829 case NFS4_SHARE_ACCESS_WRITE: 830 case NFS4_SHARE_ACCESS_BOTH: 831 break; 832 default: 833 return nfserr_bad_xdr; 834 } 835 w &= ~NFS4_SHARE_ACCESS_MASK; 836 if (!w) 837 return nfs_ok; 838 if (!argp->minorversion) 839 return nfserr_bad_xdr; 840 switch (w & NFS4_SHARE_WANT_MASK) { 841 case NFS4_SHARE_WANT_NO_PREFERENCE: 842 case NFS4_SHARE_WANT_READ_DELEG: 843 case NFS4_SHARE_WANT_WRITE_DELEG: 844 case NFS4_SHARE_WANT_ANY_DELEG: 845 case NFS4_SHARE_WANT_NO_DELEG: 846 case NFS4_SHARE_WANT_CANCEL: 847 break; 848 default: 849 return nfserr_bad_xdr; 850 } 851 w &= ~NFS4_SHARE_WANT_MASK; 852 if (!w) 853 return nfs_ok; 854 855 if (!deleg_when) /* open_downgrade */ 856 return nfserr_inval; 857 switch (w) { 858 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL: 859 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED: 860 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL | 861 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED): 862 return nfs_ok; 863 } 864 xdr_error: 865 return nfserr_bad_xdr; 866 } 867 868 static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x) 869 { 870 __be32 *p; 871 872 READ_BUF(4); 873 *x = be32_to_cpup(p++); 874 /* Note: unlinke access bits, deny bits may be zero. */ 875 if (*x & ~NFS4_SHARE_DENY_BOTH) 876 return nfserr_bad_xdr; 877 return nfs_ok; 878 xdr_error: 879 return nfserr_bad_xdr; 880 } 881 882 static __be32 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o) 883 { 884 __be32 *p; 885 886 READ_BUF(4); 887 o->len = be32_to_cpup(p++); 888 889 if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT) 890 return nfserr_bad_xdr; 891 892 READ_BUF(o->len); 893 SAVEMEM(o->data, o->len); 894 return nfs_ok; 895 xdr_error: 896 return nfserr_bad_xdr; 897 } 898 899 static __be32 900 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open) 901 { 902 DECODE_HEAD; 903 u32 dummy; 904 905 memset(open->op_bmval, 0, sizeof(open->op_bmval)); 906 open->op_iattr.ia_valid = 0; 907 open->op_openowner = NULL; 908 909 open->op_xdr_error = 0; 910 /* seqid, share_access, share_deny, clientid, ownerlen */ 911 READ_BUF(4); 912 open->op_seqid = be32_to_cpup(p++); 913 /* decode, yet ignore deleg_when until supported */ 914 status = nfsd4_decode_share_access(argp, &open->op_share_access, 915 &open->op_deleg_want, &dummy); 916 if (status) 917 goto xdr_error; 918 status = nfsd4_decode_share_deny(argp, &open->op_share_deny); 919 if (status) 920 goto xdr_error; 921 READ_BUF(sizeof(clientid_t)); 922 COPYMEM(&open->op_clientid, sizeof(clientid_t)); 923 status = nfsd4_decode_opaque(argp, &open->op_owner); 924 if (status) 925 goto xdr_error; 926 READ_BUF(4); 927 open->op_create = be32_to_cpup(p++); 928 switch (open->op_create) { 929 case NFS4_OPEN_NOCREATE: 930 break; 931 case NFS4_OPEN_CREATE: 932 READ_BUF(4); 933 open->op_createmode = be32_to_cpup(p++); 934 switch (open->op_createmode) { 935 case NFS4_CREATE_UNCHECKED: 936 case NFS4_CREATE_GUARDED: 937 status = nfsd4_decode_fattr(argp, open->op_bmval, 938 &open->op_iattr, &open->op_acl, &open->op_label, 939 &open->op_umask); 940 if (status) 941 goto out; 942 break; 943 case NFS4_CREATE_EXCLUSIVE: 944 READ_BUF(NFS4_VERIFIER_SIZE); 945 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); 946 break; 947 case NFS4_CREATE_EXCLUSIVE4_1: 948 if (argp->minorversion < 1) 949 goto xdr_error; 950 READ_BUF(NFS4_VERIFIER_SIZE); 951 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); 952 status = nfsd4_decode_fattr(argp, open->op_bmval, 953 &open->op_iattr, &open->op_acl, &open->op_label, 954 &open->op_umask); 955 if (status) 956 goto out; 957 break; 958 default: 959 goto xdr_error; 960 } 961 break; 962 default: 963 goto xdr_error; 964 } 965 966 /* open_claim */ 967 READ_BUF(4); 968 open->op_claim_type = be32_to_cpup(p++); 969 switch (open->op_claim_type) { 970 case NFS4_OPEN_CLAIM_NULL: 971 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 972 READ_BUF(4); 973 open->op_fname.len = be32_to_cpup(p++); 974 READ_BUF(open->op_fname.len); 975 SAVEMEM(open->op_fname.data, open->op_fname.len); 976 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) 977 return status; 978 break; 979 case NFS4_OPEN_CLAIM_PREVIOUS: 980 READ_BUF(4); 981 open->op_delegate_type = be32_to_cpup(p++); 982 break; 983 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 984 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); 985 if (status) 986 return status; 987 READ_BUF(4); 988 open->op_fname.len = be32_to_cpup(p++); 989 READ_BUF(open->op_fname.len); 990 SAVEMEM(open->op_fname.data, open->op_fname.len); 991 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) 992 return status; 993 break; 994 case NFS4_OPEN_CLAIM_FH: 995 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 996 if (argp->minorversion < 1) 997 goto xdr_error; 998 /* void */ 999 break; 1000 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1001 if (argp->minorversion < 1) 1002 goto xdr_error; 1003 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); 1004 if (status) 1005 return status; 1006 break; 1007 default: 1008 goto xdr_error; 1009 } 1010 1011 DECODE_TAIL; 1012 } 1013 1014 static __be32 1015 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf) 1016 { 1017 DECODE_HEAD; 1018 1019 if (argp->minorversion >= 1) 1020 return nfserr_notsupp; 1021 1022 status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid); 1023 if (status) 1024 return status; 1025 READ_BUF(4); 1026 open_conf->oc_seqid = be32_to_cpup(p++); 1027 1028 DECODE_TAIL; 1029 } 1030 1031 static __be32 1032 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down) 1033 { 1034 DECODE_HEAD; 1035 1036 status = nfsd4_decode_stateid(argp, &open_down->od_stateid); 1037 if (status) 1038 return status; 1039 READ_BUF(4); 1040 open_down->od_seqid = be32_to_cpup(p++); 1041 status = nfsd4_decode_share_access(argp, &open_down->od_share_access, 1042 &open_down->od_deleg_want, NULL); 1043 if (status) 1044 return status; 1045 status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny); 1046 if (status) 1047 return status; 1048 DECODE_TAIL; 1049 } 1050 1051 static __be32 1052 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh) 1053 { 1054 DECODE_HEAD; 1055 1056 READ_BUF(4); 1057 putfh->pf_fhlen = be32_to_cpup(p++); 1058 if (putfh->pf_fhlen > NFS4_FHSIZE) 1059 goto xdr_error; 1060 READ_BUF(putfh->pf_fhlen); 1061 SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen); 1062 1063 DECODE_TAIL; 1064 } 1065 1066 static __be32 1067 nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p) 1068 { 1069 if (argp->minorversion == 0) 1070 return nfs_ok; 1071 return nfserr_notsupp; 1072 } 1073 1074 static __be32 1075 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read) 1076 { 1077 DECODE_HEAD; 1078 1079 status = nfsd4_decode_stateid(argp, &read->rd_stateid); 1080 if (status) 1081 return status; 1082 READ_BUF(12); 1083 p = xdr_decode_hyper(p, &read->rd_offset); 1084 read->rd_length = be32_to_cpup(p++); 1085 1086 DECODE_TAIL; 1087 } 1088 1089 static __be32 1090 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir) 1091 { 1092 DECODE_HEAD; 1093 1094 READ_BUF(24); 1095 p = xdr_decode_hyper(p, &readdir->rd_cookie); 1096 COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data)); 1097 readdir->rd_dircount = be32_to_cpup(p++); 1098 readdir->rd_maxcount = be32_to_cpup(p++); 1099 if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval))) 1100 goto out; 1101 1102 DECODE_TAIL; 1103 } 1104 1105 static __be32 1106 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove) 1107 { 1108 DECODE_HEAD; 1109 1110 READ_BUF(4); 1111 remove->rm_namelen = be32_to_cpup(p++); 1112 READ_BUF(remove->rm_namelen); 1113 SAVEMEM(remove->rm_name, remove->rm_namelen); 1114 if ((status = check_filename(remove->rm_name, remove->rm_namelen))) 1115 return status; 1116 1117 DECODE_TAIL; 1118 } 1119 1120 static __be32 1121 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename) 1122 { 1123 DECODE_HEAD; 1124 1125 READ_BUF(4); 1126 rename->rn_snamelen = be32_to_cpup(p++); 1127 READ_BUF(rename->rn_snamelen); 1128 SAVEMEM(rename->rn_sname, rename->rn_snamelen); 1129 READ_BUF(4); 1130 rename->rn_tnamelen = be32_to_cpup(p++); 1131 READ_BUF(rename->rn_tnamelen); 1132 SAVEMEM(rename->rn_tname, rename->rn_tnamelen); 1133 if ((status = check_filename(rename->rn_sname, rename->rn_snamelen))) 1134 return status; 1135 if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen))) 1136 return status; 1137 1138 DECODE_TAIL; 1139 } 1140 1141 static __be32 1142 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid) 1143 { 1144 DECODE_HEAD; 1145 1146 if (argp->minorversion >= 1) 1147 return nfserr_notsupp; 1148 1149 READ_BUF(sizeof(clientid_t)); 1150 COPYMEM(clientid, sizeof(clientid_t)); 1151 1152 DECODE_TAIL; 1153 } 1154 1155 static __be32 1156 nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp, 1157 struct nfsd4_secinfo *secinfo) 1158 { 1159 DECODE_HEAD; 1160 1161 READ_BUF(4); 1162 secinfo->si_namelen = be32_to_cpup(p++); 1163 READ_BUF(secinfo->si_namelen); 1164 SAVEMEM(secinfo->si_name, secinfo->si_namelen); 1165 status = check_filename(secinfo->si_name, secinfo->si_namelen); 1166 if (status) 1167 return status; 1168 DECODE_TAIL; 1169 } 1170 1171 static __be32 1172 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp, 1173 struct nfsd4_secinfo_no_name *sin) 1174 { 1175 DECODE_HEAD; 1176 1177 READ_BUF(4); 1178 sin->sin_style = be32_to_cpup(p++); 1179 DECODE_TAIL; 1180 } 1181 1182 static __be32 1183 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr) 1184 { 1185 __be32 status; 1186 1187 status = nfsd4_decode_stateid(argp, &setattr->sa_stateid); 1188 if (status) 1189 return status; 1190 return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr, 1191 &setattr->sa_acl, &setattr->sa_label, NULL); 1192 } 1193 1194 static __be32 1195 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid) 1196 { 1197 DECODE_HEAD; 1198 1199 if (argp->minorversion >= 1) 1200 return nfserr_notsupp; 1201 1202 READ_BUF(NFS4_VERIFIER_SIZE); 1203 COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE); 1204 1205 status = nfsd4_decode_opaque(argp, &setclientid->se_name); 1206 if (status) 1207 return nfserr_bad_xdr; 1208 READ_BUF(8); 1209 setclientid->se_callback_prog = be32_to_cpup(p++); 1210 setclientid->se_callback_netid_len = be32_to_cpup(p++); 1211 READ_BUF(setclientid->se_callback_netid_len); 1212 SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len); 1213 READ_BUF(4); 1214 setclientid->se_callback_addr_len = be32_to_cpup(p++); 1215 1216 READ_BUF(setclientid->se_callback_addr_len); 1217 SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len); 1218 READ_BUF(4); 1219 setclientid->se_callback_ident = be32_to_cpup(p++); 1220 1221 DECODE_TAIL; 1222 } 1223 1224 static __be32 1225 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c) 1226 { 1227 DECODE_HEAD; 1228 1229 if (argp->minorversion >= 1) 1230 return nfserr_notsupp; 1231 1232 READ_BUF(8 + NFS4_VERIFIER_SIZE); 1233 COPYMEM(&scd_c->sc_clientid, 8); 1234 COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE); 1235 1236 DECODE_TAIL; 1237 } 1238 1239 /* Also used for NVERIFY */ 1240 static __be32 1241 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify) 1242 { 1243 DECODE_HEAD; 1244 1245 if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval))) 1246 goto out; 1247 1248 /* For convenience's sake, we compare raw xdr'd attributes in 1249 * nfsd4_proc_verify */ 1250 1251 READ_BUF(4); 1252 verify->ve_attrlen = be32_to_cpup(p++); 1253 READ_BUF(verify->ve_attrlen); 1254 SAVEMEM(verify->ve_attrval, verify->ve_attrlen); 1255 1256 DECODE_TAIL; 1257 } 1258 1259 static __be32 1260 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write) 1261 { 1262 int avail; 1263 int len; 1264 DECODE_HEAD; 1265 1266 status = nfsd4_decode_stateid(argp, &write->wr_stateid); 1267 if (status) 1268 return status; 1269 READ_BUF(16); 1270 p = xdr_decode_hyper(p, &write->wr_offset); 1271 write->wr_stable_how = be32_to_cpup(p++); 1272 if (write->wr_stable_how > NFS_FILE_SYNC) 1273 goto xdr_error; 1274 write->wr_buflen = be32_to_cpup(p++); 1275 1276 /* Sorry .. no magic macros for this.. * 1277 * READ_BUF(write->wr_buflen); 1278 * SAVEMEM(write->wr_buf, write->wr_buflen); 1279 */ 1280 avail = (char*)argp->end - (char*)argp->p; 1281 if (avail + argp->pagelen < write->wr_buflen) { 1282 dprintk("NFSD: xdr error (%s:%d)\n", 1283 __FILE__, __LINE__); 1284 goto xdr_error; 1285 } 1286 write->wr_head.iov_base = p; 1287 write->wr_head.iov_len = avail; 1288 write->wr_pagelist = argp->pagelist; 1289 1290 len = XDR_QUADLEN(write->wr_buflen) << 2; 1291 if (len >= avail) { 1292 int pages; 1293 1294 len -= avail; 1295 1296 pages = len >> PAGE_SHIFT; 1297 argp->pagelist += pages; 1298 argp->pagelen -= pages * PAGE_SIZE; 1299 len -= pages * PAGE_SIZE; 1300 1301 next_decode_page(argp); 1302 } 1303 argp->p += XDR_QUADLEN(len); 1304 1305 DECODE_TAIL; 1306 } 1307 1308 static __be32 1309 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner) 1310 { 1311 DECODE_HEAD; 1312 1313 if (argp->minorversion >= 1) 1314 return nfserr_notsupp; 1315 1316 READ_BUF(12); 1317 COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t)); 1318 rlockowner->rl_owner.len = be32_to_cpup(p++); 1319 READ_BUF(rlockowner->rl_owner.len); 1320 READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len); 1321 1322 if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) 1323 return nfserr_inval; 1324 DECODE_TAIL; 1325 } 1326 1327 static __be32 1328 nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp, 1329 struct nfsd4_exchange_id *exid) 1330 { 1331 int dummy, tmp; 1332 DECODE_HEAD; 1333 1334 READ_BUF(NFS4_VERIFIER_SIZE); 1335 COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE); 1336 1337 status = nfsd4_decode_opaque(argp, &exid->clname); 1338 if (status) 1339 return nfserr_bad_xdr; 1340 1341 READ_BUF(4); 1342 exid->flags = be32_to_cpup(p++); 1343 1344 /* Ignore state_protect4_a */ 1345 READ_BUF(4); 1346 exid->spa_how = be32_to_cpup(p++); 1347 switch (exid->spa_how) { 1348 case SP4_NONE: 1349 break; 1350 case SP4_MACH_CRED: 1351 /* spo_must_enforce */ 1352 status = nfsd4_decode_bitmap(argp, 1353 exid->spo_must_enforce); 1354 if (status) 1355 goto out; 1356 /* spo_must_allow */ 1357 status = nfsd4_decode_bitmap(argp, exid->spo_must_allow); 1358 if (status) 1359 goto out; 1360 break; 1361 case SP4_SSV: 1362 /* ssp_ops */ 1363 READ_BUF(4); 1364 dummy = be32_to_cpup(p++); 1365 READ_BUF(dummy * 4); 1366 p += dummy; 1367 1368 READ_BUF(4); 1369 dummy = be32_to_cpup(p++); 1370 READ_BUF(dummy * 4); 1371 p += dummy; 1372 1373 /* ssp_hash_algs<> */ 1374 READ_BUF(4); 1375 tmp = be32_to_cpup(p++); 1376 while (tmp--) { 1377 READ_BUF(4); 1378 dummy = be32_to_cpup(p++); 1379 READ_BUF(dummy); 1380 p += XDR_QUADLEN(dummy); 1381 } 1382 1383 /* ssp_encr_algs<> */ 1384 READ_BUF(4); 1385 tmp = be32_to_cpup(p++); 1386 while (tmp--) { 1387 READ_BUF(4); 1388 dummy = be32_to_cpup(p++); 1389 READ_BUF(dummy); 1390 p += XDR_QUADLEN(dummy); 1391 } 1392 1393 /* ssp_window and ssp_num_gss_handles */ 1394 READ_BUF(8); 1395 dummy = be32_to_cpup(p++); 1396 dummy = be32_to_cpup(p++); 1397 break; 1398 default: 1399 goto xdr_error; 1400 } 1401 1402 /* Ignore Implementation ID */ 1403 READ_BUF(4); /* nfs_impl_id4 array length */ 1404 dummy = be32_to_cpup(p++); 1405 1406 if (dummy > 1) 1407 goto xdr_error; 1408 1409 if (dummy == 1) { 1410 /* nii_domain */ 1411 READ_BUF(4); 1412 dummy = be32_to_cpup(p++); 1413 READ_BUF(dummy); 1414 p += XDR_QUADLEN(dummy); 1415 1416 /* nii_name */ 1417 READ_BUF(4); 1418 dummy = be32_to_cpup(p++); 1419 READ_BUF(dummy); 1420 p += XDR_QUADLEN(dummy); 1421 1422 /* nii_date */ 1423 READ_BUF(12); 1424 p += 3; 1425 } 1426 DECODE_TAIL; 1427 } 1428 1429 static __be32 1430 nfsd4_decode_create_session(struct nfsd4_compoundargs *argp, 1431 struct nfsd4_create_session *sess) 1432 { 1433 DECODE_HEAD; 1434 u32 dummy; 1435 1436 READ_BUF(16); 1437 COPYMEM(&sess->clientid, 8); 1438 sess->seqid = be32_to_cpup(p++); 1439 sess->flags = be32_to_cpup(p++); 1440 1441 /* Fore channel attrs */ 1442 READ_BUF(28); 1443 dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */ 1444 sess->fore_channel.maxreq_sz = be32_to_cpup(p++); 1445 sess->fore_channel.maxresp_sz = be32_to_cpup(p++); 1446 sess->fore_channel.maxresp_cached = be32_to_cpup(p++); 1447 sess->fore_channel.maxops = be32_to_cpup(p++); 1448 sess->fore_channel.maxreqs = be32_to_cpup(p++); 1449 sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++); 1450 if (sess->fore_channel.nr_rdma_attrs == 1) { 1451 READ_BUF(4); 1452 sess->fore_channel.rdma_attrs = be32_to_cpup(p++); 1453 } else if (sess->fore_channel.nr_rdma_attrs > 1) { 1454 dprintk("Too many fore channel attr bitmaps!\n"); 1455 goto xdr_error; 1456 } 1457 1458 /* Back channel attrs */ 1459 READ_BUF(28); 1460 dummy = be32_to_cpup(p++); /* headerpadsz is always 0 */ 1461 sess->back_channel.maxreq_sz = be32_to_cpup(p++); 1462 sess->back_channel.maxresp_sz = be32_to_cpup(p++); 1463 sess->back_channel.maxresp_cached = be32_to_cpup(p++); 1464 sess->back_channel.maxops = be32_to_cpup(p++); 1465 sess->back_channel.maxreqs = be32_to_cpup(p++); 1466 sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++); 1467 if (sess->back_channel.nr_rdma_attrs == 1) { 1468 READ_BUF(4); 1469 sess->back_channel.rdma_attrs = be32_to_cpup(p++); 1470 } else if (sess->back_channel.nr_rdma_attrs > 1) { 1471 dprintk("Too many back channel attr bitmaps!\n"); 1472 goto xdr_error; 1473 } 1474 1475 READ_BUF(4); 1476 sess->callback_prog = be32_to_cpup(p++); 1477 nfsd4_decode_cb_sec(argp, &sess->cb_sec); 1478 DECODE_TAIL; 1479 } 1480 1481 static __be32 1482 nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp, 1483 struct nfsd4_destroy_session *destroy_session) 1484 { 1485 DECODE_HEAD; 1486 READ_BUF(NFS4_MAX_SESSIONID_LEN); 1487 COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN); 1488 1489 DECODE_TAIL; 1490 } 1491 1492 static __be32 1493 nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp, 1494 struct nfsd4_free_stateid *free_stateid) 1495 { 1496 DECODE_HEAD; 1497 1498 READ_BUF(sizeof(stateid_t)); 1499 free_stateid->fr_stateid.si_generation = be32_to_cpup(p++); 1500 COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t)); 1501 1502 DECODE_TAIL; 1503 } 1504 1505 static __be32 1506 nfsd4_decode_sequence(struct nfsd4_compoundargs *argp, 1507 struct nfsd4_sequence *seq) 1508 { 1509 DECODE_HEAD; 1510 1511 READ_BUF(NFS4_MAX_SESSIONID_LEN + 16); 1512 COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); 1513 seq->seqid = be32_to_cpup(p++); 1514 seq->slotid = be32_to_cpup(p++); 1515 seq->maxslots = be32_to_cpup(p++); 1516 seq->cachethis = be32_to_cpup(p++); 1517 1518 DECODE_TAIL; 1519 } 1520 1521 static __be32 1522 nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid) 1523 { 1524 int i; 1525 __be32 *p, status; 1526 struct nfsd4_test_stateid_id *stateid; 1527 1528 READ_BUF(4); 1529 test_stateid->ts_num_ids = ntohl(*p++); 1530 1531 INIT_LIST_HEAD(&test_stateid->ts_stateid_list); 1532 1533 for (i = 0; i < test_stateid->ts_num_ids; i++) { 1534 stateid = svcxdr_tmpalloc(argp, sizeof(*stateid)); 1535 if (!stateid) { 1536 status = nfserrno(-ENOMEM); 1537 goto out; 1538 } 1539 1540 INIT_LIST_HEAD(&stateid->ts_id_list); 1541 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); 1542 1543 status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid); 1544 if (status) 1545 goto out; 1546 } 1547 1548 status = 0; 1549 out: 1550 return status; 1551 xdr_error: 1552 dprintk("NFSD: xdr error (%s:%d)\n", __FILE__, __LINE__); 1553 status = nfserr_bad_xdr; 1554 goto out; 1555 } 1556 1557 static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp, struct nfsd4_destroy_clientid *dc) 1558 { 1559 DECODE_HEAD; 1560 1561 READ_BUF(8); 1562 COPYMEM(&dc->clientid, 8); 1563 1564 DECODE_TAIL; 1565 } 1566 1567 static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp, struct nfsd4_reclaim_complete *rc) 1568 { 1569 DECODE_HEAD; 1570 1571 READ_BUF(4); 1572 rc->rca_one_fs = be32_to_cpup(p++); 1573 1574 DECODE_TAIL; 1575 } 1576 1577 #ifdef CONFIG_NFSD_PNFS 1578 static __be32 1579 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp, 1580 struct nfsd4_getdeviceinfo *gdev) 1581 { 1582 DECODE_HEAD; 1583 u32 num, i; 1584 1585 READ_BUF(sizeof(struct nfsd4_deviceid) + 3 * 4); 1586 COPYMEM(&gdev->gd_devid, sizeof(struct nfsd4_deviceid)); 1587 gdev->gd_layout_type = be32_to_cpup(p++); 1588 gdev->gd_maxcount = be32_to_cpup(p++); 1589 num = be32_to_cpup(p++); 1590 if (num) { 1591 if (num > 1000) 1592 goto xdr_error; 1593 READ_BUF(4 * num); 1594 gdev->gd_notify_types = be32_to_cpup(p++); 1595 for (i = 1; i < num; i++) { 1596 if (be32_to_cpup(p++)) { 1597 status = nfserr_inval; 1598 goto out; 1599 } 1600 } 1601 } 1602 DECODE_TAIL; 1603 } 1604 1605 static __be32 1606 nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp, 1607 struct nfsd4_layoutget *lgp) 1608 { 1609 DECODE_HEAD; 1610 1611 READ_BUF(36); 1612 lgp->lg_signal = be32_to_cpup(p++); 1613 lgp->lg_layout_type = be32_to_cpup(p++); 1614 lgp->lg_seg.iomode = be32_to_cpup(p++); 1615 p = xdr_decode_hyper(p, &lgp->lg_seg.offset); 1616 p = xdr_decode_hyper(p, &lgp->lg_seg.length); 1617 p = xdr_decode_hyper(p, &lgp->lg_minlength); 1618 1619 status = nfsd4_decode_stateid(argp, &lgp->lg_sid); 1620 if (status) 1621 return status; 1622 1623 READ_BUF(4); 1624 lgp->lg_maxcount = be32_to_cpup(p++); 1625 1626 DECODE_TAIL; 1627 } 1628 1629 static __be32 1630 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp, 1631 struct nfsd4_layoutcommit *lcp) 1632 { 1633 DECODE_HEAD; 1634 u32 timechange; 1635 1636 READ_BUF(20); 1637 p = xdr_decode_hyper(p, &lcp->lc_seg.offset); 1638 p = xdr_decode_hyper(p, &lcp->lc_seg.length); 1639 lcp->lc_reclaim = be32_to_cpup(p++); 1640 1641 status = nfsd4_decode_stateid(argp, &lcp->lc_sid); 1642 if (status) 1643 return status; 1644 1645 READ_BUF(4); 1646 lcp->lc_newoffset = be32_to_cpup(p++); 1647 if (lcp->lc_newoffset) { 1648 READ_BUF(8); 1649 p = xdr_decode_hyper(p, &lcp->lc_last_wr); 1650 } else 1651 lcp->lc_last_wr = 0; 1652 READ_BUF(4); 1653 timechange = be32_to_cpup(p++); 1654 if (timechange) { 1655 status = nfsd4_decode_time(argp, &lcp->lc_mtime); 1656 if (status) 1657 return status; 1658 } else { 1659 lcp->lc_mtime.tv_nsec = UTIME_NOW; 1660 } 1661 READ_BUF(8); 1662 lcp->lc_layout_type = be32_to_cpup(p++); 1663 1664 /* 1665 * Save the layout update in XDR format and let the layout driver deal 1666 * with it later. 1667 */ 1668 lcp->lc_up_len = be32_to_cpup(p++); 1669 if (lcp->lc_up_len > 0) { 1670 READ_BUF(lcp->lc_up_len); 1671 READMEM(lcp->lc_up_layout, lcp->lc_up_len); 1672 } 1673 1674 DECODE_TAIL; 1675 } 1676 1677 static __be32 1678 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp, 1679 struct nfsd4_layoutreturn *lrp) 1680 { 1681 DECODE_HEAD; 1682 1683 READ_BUF(16); 1684 lrp->lr_reclaim = be32_to_cpup(p++); 1685 lrp->lr_layout_type = be32_to_cpup(p++); 1686 lrp->lr_seg.iomode = be32_to_cpup(p++); 1687 lrp->lr_return_type = be32_to_cpup(p++); 1688 if (lrp->lr_return_type == RETURN_FILE) { 1689 READ_BUF(16); 1690 p = xdr_decode_hyper(p, &lrp->lr_seg.offset); 1691 p = xdr_decode_hyper(p, &lrp->lr_seg.length); 1692 1693 status = nfsd4_decode_stateid(argp, &lrp->lr_sid); 1694 if (status) 1695 return status; 1696 1697 READ_BUF(4); 1698 lrp->lrf_body_len = be32_to_cpup(p++); 1699 if (lrp->lrf_body_len > 0) { 1700 READ_BUF(lrp->lrf_body_len); 1701 READMEM(lrp->lrf_body, lrp->lrf_body_len); 1702 } 1703 } else { 1704 lrp->lr_seg.offset = 0; 1705 lrp->lr_seg.length = NFS4_MAX_UINT64; 1706 } 1707 1708 DECODE_TAIL; 1709 } 1710 #endif /* CONFIG_NFSD_PNFS */ 1711 1712 static __be32 1713 nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp, 1714 struct nfsd4_fallocate *fallocate) 1715 { 1716 DECODE_HEAD; 1717 1718 status = nfsd4_decode_stateid(argp, &fallocate->falloc_stateid); 1719 if (status) 1720 return status; 1721 1722 READ_BUF(16); 1723 p = xdr_decode_hyper(p, &fallocate->falloc_offset); 1724 xdr_decode_hyper(p, &fallocate->falloc_length); 1725 1726 DECODE_TAIL; 1727 } 1728 1729 static __be32 1730 nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone) 1731 { 1732 DECODE_HEAD; 1733 1734 status = nfsd4_decode_stateid(argp, &clone->cl_src_stateid); 1735 if (status) 1736 return status; 1737 status = nfsd4_decode_stateid(argp, &clone->cl_dst_stateid); 1738 if (status) 1739 return status; 1740 1741 READ_BUF(8 + 8 + 8); 1742 p = xdr_decode_hyper(p, &clone->cl_src_pos); 1743 p = xdr_decode_hyper(p, &clone->cl_dst_pos); 1744 p = xdr_decode_hyper(p, &clone->cl_count); 1745 DECODE_TAIL; 1746 } 1747 1748 static __be32 1749 nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy) 1750 { 1751 DECODE_HEAD; 1752 unsigned int tmp; 1753 1754 status = nfsd4_decode_stateid(argp, ©->cp_src_stateid); 1755 if (status) 1756 return status; 1757 status = nfsd4_decode_stateid(argp, ©->cp_dst_stateid); 1758 if (status) 1759 return status; 1760 1761 READ_BUF(8 + 8 + 8 + 4 + 4 + 4); 1762 p = xdr_decode_hyper(p, ©->cp_src_pos); 1763 p = xdr_decode_hyper(p, ©->cp_dst_pos); 1764 p = xdr_decode_hyper(p, ©->cp_count); 1765 p++; /* ca_consecutive: we always do consecutive copies */ 1766 copy->cp_synchronous = be32_to_cpup(p++); 1767 tmp = be32_to_cpup(p); /* Source server list not supported */ 1768 1769 DECODE_TAIL; 1770 } 1771 1772 static __be32 1773 nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek) 1774 { 1775 DECODE_HEAD; 1776 1777 status = nfsd4_decode_stateid(argp, &seek->seek_stateid); 1778 if (status) 1779 return status; 1780 1781 READ_BUF(8 + 4); 1782 p = xdr_decode_hyper(p, &seek->seek_offset); 1783 seek->seek_whence = be32_to_cpup(p); 1784 1785 DECODE_TAIL; 1786 } 1787 1788 static __be32 1789 nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p) 1790 { 1791 return nfs_ok; 1792 } 1793 1794 static __be32 1795 nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p) 1796 { 1797 return nfserr_notsupp; 1798 } 1799 1800 typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *); 1801 1802 static const nfsd4_dec nfsd4_dec_ops[] = { 1803 [OP_ACCESS] = (nfsd4_dec)nfsd4_decode_access, 1804 [OP_CLOSE] = (nfsd4_dec)nfsd4_decode_close, 1805 [OP_COMMIT] = (nfsd4_dec)nfsd4_decode_commit, 1806 [OP_CREATE] = (nfsd4_dec)nfsd4_decode_create, 1807 [OP_DELEGPURGE] = (nfsd4_dec)nfsd4_decode_notsupp, 1808 [OP_DELEGRETURN] = (nfsd4_dec)nfsd4_decode_delegreturn, 1809 [OP_GETATTR] = (nfsd4_dec)nfsd4_decode_getattr, 1810 [OP_GETFH] = (nfsd4_dec)nfsd4_decode_noop, 1811 [OP_LINK] = (nfsd4_dec)nfsd4_decode_link, 1812 [OP_LOCK] = (nfsd4_dec)nfsd4_decode_lock, 1813 [OP_LOCKT] = (nfsd4_dec)nfsd4_decode_lockt, 1814 [OP_LOCKU] = (nfsd4_dec)nfsd4_decode_locku, 1815 [OP_LOOKUP] = (nfsd4_dec)nfsd4_decode_lookup, 1816 [OP_LOOKUPP] = (nfsd4_dec)nfsd4_decode_noop, 1817 [OP_NVERIFY] = (nfsd4_dec)nfsd4_decode_verify, 1818 [OP_OPEN] = (nfsd4_dec)nfsd4_decode_open, 1819 [OP_OPENATTR] = (nfsd4_dec)nfsd4_decode_notsupp, 1820 [OP_OPEN_CONFIRM] = (nfsd4_dec)nfsd4_decode_open_confirm, 1821 [OP_OPEN_DOWNGRADE] = (nfsd4_dec)nfsd4_decode_open_downgrade, 1822 [OP_PUTFH] = (nfsd4_dec)nfsd4_decode_putfh, 1823 [OP_PUTPUBFH] = (nfsd4_dec)nfsd4_decode_putpubfh, 1824 [OP_PUTROOTFH] = (nfsd4_dec)nfsd4_decode_noop, 1825 [OP_READ] = (nfsd4_dec)nfsd4_decode_read, 1826 [OP_READDIR] = (nfsd4_dec)nfsd4_decode_readdir, 1827 [OP_READLINK] = (nfsd4_dec)nfsd4_decode_noop, 1828 [OP_REMOVE] = (nfsd4_dec)nfsd4_decode_remove, 1829 [OP_RENAME] = (nfsd4_dec)nfsd4_decode_rename, 1830 [OP_RENEW] = (nfsd4_dec)nfsd4_decode_renew, 1831 [OP_RESTOREFH] = (nfsd4_dec)nfsd4_decode_noop, 1832 [OP_SAVEFH] = (nfsd4_dec)nfsd4_decode_noop, 1833 [OP_SECINFO] = (nfsd4_dec)nfsd4_decode_secinfo, 1834 [OP_SETATTR] = (nfsd4_dec)nfsd4_decode_setattr, 1835 [OP_SETCLIENTID] = (nfsd4_dec)nfsd4_decode_setclientid, 1836 [OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm, 1837 [OP_VERIFY] = (nfsd4_dec)nfsd4_decode_verify, 1838 [OP_WRITE] = (nfsd4_dec)nfsd4_decode_write, 1839 [OP_RELEASE_LOCKOWNER] = (nfsd4_dec)nfsd4_decode_release_lockowner, 1840 1841 /* new operations for NFSv4.1 */ 1842 [OP_BACKCHANNEL_CTL] = (nfsd4_dec)nfsd4_decode_backchannel_ctl, 1843 [OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session, 1844 [OP_EXCHANGE_ID] = (nfsd4_dec)nfsd4_decode_exchange_id, 1845 [OP_CREATE_SESSION] = (nfsd4_dec)nfsd4_decode_create_session, 1846 [OP_DESTROY_SESSION] = (nfsd4_dec)nfsd4_decode_destroy_session, 1847 [OP_FREE_STATEID] = (nfsd4_dec)nfsd4_decode_free_stateid, 1848 [OP_GET_DIR_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, 1849 #ifdef CONFIG_NFSD_PNFS 1850 [OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_getdeviceinfo, 1851 [OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp, 1852 [OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_layoutcommit, 1853 [OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_layoutget, 1854 [OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_layoutreturn, 1855 #else 1856 [OP_GETDEVICEINFO] = (nfsd4_dec)nfsd4_decode_notsupp, 1857 [OP_GETDEVICELIST] = (nfsd4_dec)nfsd4_decode_notsupp, 1858 [OP_LAYOUTCOMMIT] = (nfsd4_dec)nfsd4_decode_notsupp, 1859 [OP_LAYOUTGET] = (nfsd4_dec)nfsd4_decode_notsupp, 1860 [OP_LAYOUTRETURN] = (nfsd4_dec)nfsd4_decode_notsupp, 1861 #endif 1862 [OP_SECINFO_NO_NAME] = (nfsd4_dec)nfsd4_decode_secinfo_no_name, 1863 [OP_SEQUENCE] = (nfsd4_dec)nfsd4_decode_sequence, 1864 [OP_SET_SSV] = (nfsd4_dec)nfsd4_decode_notsupp, 1865 [OP_TEST_STATEID] = (nfsd4_dec)nfsd4_decode_test_stateid, 1866 [OP_WANT_DELEGATION] = (nfsd4_dec)nfsd4_decode_notsupp, 1867 [OP_DESTROY_CLIENTID] = (nfsd4_dec)nfsd4_decode_destroy_clientid, 1868 [OP_RECLAIM_COMPLETE] = (nfsd4_dec)nfsd4_decode_reclaim_complete, 1869 1870 /* new operations for NFSv4.2 */ 1871 [OP_ALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate, 1872 [OP_COPY] = (nfsd4_dec)nfsd4_decode_copy, 1873 [OP_COPY_NOTIFY] = (nfsd4_dec)nfsd4_decode_notsupp, 1874 [OP_DEALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate, 1875 [OP_IO_ADVISE] = (nfsd4_dec)nfsd4_decode_notsupp, 1876 [OP_LAYOUTERROR] = (nfsd4_dec)nfsd4_decode_notsupp, 1877 [OP_LAYOUTSTATS] = (nfsd4_dec)nfsd4_decode_notsupp, 1878 [OP_OFFLOAD_CANCEL] = (nfsd4_dec)nfsd4_decode_notsupp, 1879 [OP_OFFLOAD_STATUS] = (nfsd4_dec)nfsd4_decode_notsupp, 1880 [OP_READ_PLUS] = (nfsd4_dec)nfsd4_decode_notsupp, 1881 [OP_SEEK] = (nfsd4_dec)nfsd4_decode_seek, 1882 [OP_WRITE_SAME] = (nfsd4_dec)nfsd4_decode_notsupp, 1883 [OP_CLONE] = (nfsd4_dec)nfsd4_decode_clone, 1884 }; 1885 1886 static inline bool 1887 nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op) 1888 { 1889 if (op->opnum < FIRST_NFS4_OP) 1890 return false; 1891 else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) 1892 return false; 1893 else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) 1894 return false; 1895 else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) 1896 return false; 1897 return true; 1898 } 1899 1900 static __be32 1901 nfsd4_decode_compound(struct nfsd4_compoundargs *argp) 1902 { 1903 DECODE_HEAD; 1904 struct nfsd4_op *op; 1905 bool cachethis = false; 1906 int auth_slack= argp->rqstp->rq_auth_slack; 1907 int max_reply = auth_slack + 8; /* opcnt, status */ 1908 int readcount = 0; 1909 int readbytes = 0; 1910 int i; 1911 1912 READ_BUF(4); 1913 argp->taglen = be32_to_cpup(p++); 1914 READ_BUF(argp->taglen); 1915 SAVEMEM(argp->tag, argp->taglen); 1916 READ_BUF(8); 1917 argp->minorversion = be32_to_cpup(p++); 1918 argp->opcnt = be32_to_cpup(p++); 1919 max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2); 1920 1921 if (argp->taglen > NFSD4_MAX_TAGLEN) 1922 goto xdr_error; 1923 /* 1924 * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS 1925 * here, so we return success at the xdr level so that 1926 * nfsd4_proc can handle this is an NFS-level error. 1927 */ 1928 if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND) 1929 return 0; 1930 1931 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { 1932 argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL); 1933 if (!argp->ops) { 1934 argp->ops = argp->iops; 1935 dprintk("nfsd: couldn't allocate room for COMPOUND\n"); 1936 goto xdr_error; 1937 } 1938 } 1939 1940 if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) 1941 argp->opcnt = 0; 1942 1943 for (i = 0; i < argp->opcnt; i++) { 1944 op = &argp->ops[i]; 1945 op->replay = NULL; 1946 1947 READ_BUF(4); 1948 op->opnum = be32_to_cpup(p++); 1949 1950 if (nfsd4_opnum_in_range(argp, op)) 1951 op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); 1952 else { 1953 op->opnum = OP_ILLEGAL; 1954 op->status = nfserr_op_illegal; 1955 } 1956 op->opdesc = OPDESC(op); 1957 /* 1958 * We'll try to cache the result in the DRC if any one 1959 * op in the compound wants to be cached: 1960 */ 1961 cachethis |= nfsd4_cache_this_op(op); 1962 1963 if (op->opnum == OP_READ) { 1964 readcount++; 1965 readbytes += nfsd4_max_reply(argp->rqstp, op); 1966 } else 1967 max_reply += nfsd4_max_reply(argp->rqstp, op); 1968 /* 1969 * OP_LOCK and OP_LOCKT may return a conflicting lock. 1970 * (Special case because it will just skip encoding this 1971 * if it runs out of xdr buffer space, and it is the only 1972 * operation that behaves this way.) 1973 */ 1974 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT) 1975 max_reply += NFS4_OPAQUE_LIMIT; 1976 1977 if (op->status) { 1978 argp->opcnt = i+1; 1979 break; 1980 } 1981 } 1982 /* Sessions make the DRC unnecessary: */ 1983 if (argp->minorversion) 1984 cachethis = false; 1985 svc_reserve(argp->rqstp, max_reply + readbytes); 1986 argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; 1987 1988 if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) 1989 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags); 1990 1991 DECODE_TAIL; 1992 } 1993 1994 static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode, 1995 struct svc_export *exp) 1996 { 1997 if (exp->ex_flags & NFSEXP_V4ROOT) { 1998 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time)); 1999 *p++ = 0; 2000 } else if (IS_I_VERSION(inode)) { 2001 p = xdr_encode_hyper(p, nfsd4_change_attribute(stat, inode)); 2002 } else { 2003 *p++ = cpu_to_be32(stat->ctime.tv_sec); 2004 *p++ = cpu_to_be32(stat->ctime.tv_nsec); 2005 } 2006 return p; 2007 } 2008 2009 static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c) 2010 { 2011 *p++ = cpu_to_be32(c->atomic); 2012 if (c->change_supported) { 2013 p = xdr_encode_hyper(p, c->before_change); 2014 p = xdr_encode_hyper(p, c->after_change); 2015 } else { 2016 *p++ = cpu_to_be32(c->before_ctime_sec); 2017 *p++ = cpu_to_be32(c->before_ctime_nsec); 2018 *p++ = cpu_to_be32(c->after_ctime_sec); 2019 *p++ = cpu_to_be32(c->after_ctime_nsec); 2020 } 2021 return p; 2022 } 2023 2024 /* Encode as an array of strings the string given with components 2025 * separated @sep, escaped with esc_enter and esc_exit. 2026 */ 2027 static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep, 2028 char *components, char esc_enter, 2029 char esc_exit) 2030 { 2031 __be32 *p; 2032 __be32 pathlen; 2033 int pathlen_offset; 2034 int strlen, count=0; 2035 char *str, *end, *next; 2036 2037 dprintk("nfsd4_encode_components(%s)\n", components); 2038 2039 pathlen_offset = xdr->buf->len; 2040 p = xdr_reserve_space(xdr, 4); 2041 if (!p) 2042 return nfserr_resource; 2043 p++; /* We will fill this in with @count later */ 2044 2045 end = str = components; 2046 while (*end) { 2047 bool found_esc = false; 2048 2049 /* try to parse as esc_start, ..., esc_end, sep */ 2050 if (*str == esc_enter) { 2051 for (; *end && (*end != esc_exit); end++) 2052 /* find esc_exit or end of string */; 2053 next = end + 1; 2054 if (*end && (!*next || *next == sep)) { 2055 str++; 2056 found_esc = true; 2057 } 2058 } 2059 2060 if (!found_esc) 2061 for (; *end && (*end != sep); end++) 2062 /* find sep or end of string */; 2063 2064 strlen = end - str; 2065 if (strlen) { 2066 p = xdr_reserve_space(xdr, strlen + 4); 2067 if (!p) 2068 return nfserr_resource; 2069 p = xdr_encode_opaque(p, str, strlen); 2070 count++; 2071 } 2072 else 2073 end++; 2074 if (found_esc) 2075 end = next; 2076 2077 str = end; 2078 } 2079 pathlen = htonl(count); 2080 write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); 2081 return 0; 2082 } 2083 2084 /* Encode as an array of strings the string given with components 2085 * separated @sep. 2086 */ 2087 static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep, 2088 char *components) 2089 { 2090 return nfsd4_encode_components_esc(xdr, sep, components, 0, 0); 2091 } 2092 2093 /* 2094 * encode a location element of a fs_locations structure 2095 */ 2096 static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr, 2097 struct nfsd4_fs_location *location) 2098 { 2099 __be32 status; 2100 2101 status = nfsd4_encode_components_esc(xdr, ':', location->hosts, 2102 '[', ']'); 2103 if (status) 2104 return status; 2105 status = nfsd4_encode_components(xdr, '/', location->path); 2106 if (status) 2107 return status; 2108 return 0; 2109 } 2110 2111 /* 2112 * Encode a path in RFC3530 'pathname4' format 2113 */ 2114 static __be32 nfsd4_encode_path(struct xdr_stream *xdr, 2115 const struct path *root, 2116 const struct path *path) 2117 { 2118 struct path cur = *path; 2119 __be32 *p; 2120 struct dentry **components = NULL; 2121 unsigned int ncomponents = 0; 2122 __be32 err = nfserr_jukebox; 2123 2124 dprintk("nfsd4_encode_components("); 2125 2126 path_get(&cur); 2127 /* First walk the path up to the nfsd root, and store the 2128 * dentries/path components in an array. 2129 */ 2130 for (;;) { 2131 if (path_equal(&cur, root)) 2132 break; 2133 if (cur.dentry == cur.mnt->mnt_root) { 2134 if (follow_up(&cur)) 2135 continue; 2136 goto out_free; 2137 } 2138 if ((ncomponents & 15) == 0) { 2139 struct dentry **new; 2140 new = krealloc(components, 2141 sizeof(*new) * (ncomponents + 16), 2142 GFP_KERNEL); 2143 if (!new) 2144 goto out_free; 2145 components = new; 2146 } 2147 components[ncomponents++] = cur.dentry; 2148 cur.dentry = dget_parent(cur.dentry); 2149 } 2150 err = nfserr_resource; 2151 p = xdr_reserve_space(xdr, 4); 2152 if (!p) 2153 goto out_free; 2154 *p++ = cpu_to_be32(ncomponents); 2155 2156 while (ncomponents) { 2157 struct dentry *dentry = components[ncomponents - 1]; 2158 unsigned int len; 2159 2160 spin_lock(&dentry->d_lock); 2161 len = dentry->d_name.len; 2162 p = xdr_reserve_space(xdr, len + 4); 2163 if (!p) { 2164 spin_unlock(&dentry->d_lock); 2165 goto out_free; 2166 } 2167 p = xdr_encode_opaque(p, dentry->d_name.name, len); 2168 dprintk("/%pd", dentry); 2169 spin_unlock(&dentry->d_lock); 2170 dput(dentry); 2171 ncomponents--; 2172 } 2173 2174 err = 0; 2175 out_free: 2176 dprintk(")\n"); 2177 while (ncomponents) 2178 dput(components[--ncomponents]); 2179 kfree(components); 2180 path_put(&cur); 2181 return err; 2182 } 2183 2184 static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr, 2185 struct svc_rqst *rqstp, const struct path *path) 2186 { 2187 struct svc_export *exp_ps; 2188 __be32 res; 2189 2190 exp_ps = rqst_find_fsidzero_export(rqstp); 2191 if (IS_ERR(exp_ps)) 2192 return nfserrno(PTR_ERR(exp_ps)); 2193 res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path); 2194 exp_put(exp_ps); 2195 return res; 2196 } 2197 2198 /* 2199 * encode a fs_locations structure 2200 */ 2201 static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr, 2202 struct svc_rqst *rqstp, struct svc_export *exp) 2203 { 2204 __be32 status; 2205 int i; 2206 __be32 *p; 2207 struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; 2208 2209 status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path); 2210 if (status) 2211 return status; 2212 p = xdr_reserve_space(xdr, 4); 2213 if (!p) 2214 return nfserr_resource; 2215 *p++ = cpu_to_be32(fslocs->locations_count); 2216 for (i=0; i<fslocs->locations_count; i++) { 2217 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); 2218 if (status) 2219 return status; 2220 } 2221 return 0; 2222 } 2223 2224 static u32 nfs4_file_type(umode_t mode) 2225 { 2226 switch (mode & S_IFMT) { 2227 case S_IFIFO: return NF4FIFO; 2228 case S_IFCHR: return NF4CHR; 2229 case S_IFDIR: return NF4DIR; 2230 case S_IFBLK: return NF4BLK; 2231 case S_IFLNK: return NF4LNK; 2232 case S_IFREG: return NF4REG; 2233 case S_IFSOCK: return NF4SOCK; 2234 default: return NF4BAD; 2235 }; 2236 } 2237 2238 static inline __be32 2239 nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp, 2240 struct nfs4_ace *ace) 2241 { 2242 if (ace->whotype != NFS4_ACL_WHO_NAMED) 2243 return nfs4_acl_write_who(xdr, ace->whotype); 2244 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) 2245 return nfsd4_encode_group(xdr, rqstp, ace->who_gid); 2246 else 2247 return nfsd4_encode_user(xdr, rqstp, ace->who_uid); 2248 } 2249 2250 static inline __be32 2251 nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types) 2252 { 2253 __be32 *p; 2254 unsigned long i = hweight_long(layout_types); 2255 2256 p = xdr_reserve_space(xdr, 4 + 4 * i); 2257 if (!p) 2258 return nfserr_resource; 2259 2260 *p++ = cpu_to_be32(i); 2261 2262 for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i) 2263 if (layout_types & (1 << i)) 2264 *p++ = cpu_to_be32(i); 2265 2266 return 0; 2267 } 2268 2269 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \ 2270 FATTR4_WORD0_RDATTR_ERROR) 2271 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID 2272 #define WORD2_ABSENT_FS_ATTRS 0 2273 2274 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2275 static inline __be32 2276 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, 2277 void *context, int len) 2278 { 2279 __be32 *p; 2280 2281 p = xdr_reserve_space(xdr, len + 4 + 4 + 4); 2282 if (!p) 2283 return nfserr_resource; 2284 2285 /* 2286 * For now we use a 0 here to indicate the null translation; in 2287 * the future we may place a call to translation code here. 2288 */ 2289 *p++ = cpu_to_be32(0); /* lfs */ 2290 *p++ = cpu_to_be32(0); /* pi */ 2291 p = xdr_encode_opaque(p, context, len); 2292 return 0; 2293 } 2294 #else 2295 static inline __be32 2296 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp, 2297 void *context, int len) 2298 { return 0; } 2299 #endif 2300 2301 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err) 2302 { 2303 /* As per referral draft: */ 2304 if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS || 2305 *bmval1 & ~WORD1_ABSENT_FS_ATTRS) { 2306 if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR || 2307 *bmval0 & FATTR4_WORD0_FS_LOCATIONS) 2308 *rdattr_err = NFSERR_MOVED; 2309 else 2310 return nfserr_moved; 2311 } 2312 *bmval0 &= WORD0_ABSENT_FS_ATTRS; 2313 *bmval1 &= WORD1_ABSENT_FS_ATTRS; 2314 *bmval2 &= WORD2_ABSENT_FS_ATTRS; 2315 return 0; 2316 } 2317 2318 2319 static int get_parent_attributes(struct svc_export *exp, struct kstat *stat) 2320 { 2321 struct path path = exp->ex_path; 2322 int err; 2323 2324 path_get(&path); 2325 while (follow_up(&path)) { 2326 if (path.dentry != path.mnt->mnt_root) 2327 break; 2328 } 2329 err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); 2330 path_put(&path); 2331 return err; 2332 } 2333 2334 static __be32 2335 nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2) 2336 { 2337 __be32 *p; 2338 2339 if (bmval2) { 2340 p = xdr_reserve_space(xdr, 16); 2341 if (!p) 2342 goto out_resource; 2343 *p++ = cpu_to_be32(3); 2344 *p++ = cpu_to_be32(bmval0); 2345 *p++ = cpu_to_be32(bmval1); 2346 *p++ = cpu_to_be32(bmval2); 2347 } else if (bmval1) { 2348 p = xdr_reserve_space(xdr, 12); 2349 if (!p) 2350 goto out_resource; 2351 *p++ = cpu_to_be32(2); 2352 *p++ = cpu_to_be32(bmval0); 2353 *p++ = cpu_to_be32(bmval1); 2354 } else { 2355 p = xdr_reserve_space(xdr, 8); 2356 if (!p) 2357 goto out_resource; 2358 *p++ = cpu_to_be32(1); 2359 *p++ = cpu_to_be32(bmval0); 2360 } 2361 2362 return 0; 2363 out_resource: 2364 return nfserr_resource; 2365 } 2366 2367 /* 2368 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle 2369 * ourselves. 2370 */ 2371 static __be32 2372 nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, 2373 struct svc_export *exp, 2374 struct dentry *dentry, u32 *bmval, 2375 struct svc_rqst *rqstp, int ignore_crossmnt) 2376 { 2377 u32 bmval0 = bmval[0]; 2378 u32 bmval1 = bmval[1]; 2379 u32 bmval2 = bmval[2]; 2380 struct kstat stat; 2381 struct svc_fh *tempfh = NULL; 2382 struct kstatfs statfs; 2383 __be32 *p; 2384 int starting_len = xdr->buf->len; 2385 int attrlen_offset; 2386 __be32 attrlen; 2387 u32 dummy; 2388 u64 dummy64; 2389 u32 rdattr_err = 0; 2390 __be32 status; 2391 int err; 2392 struct nfs4_acl *acl = NULL; 2393 void *context = NULL; 2394 int contextlen; 2395 bool contextsupport = false; 2396 struct nfsd4_compoundres *resp = rqstp->rq_resp; 2397 u32 minorversion = resp->cstate.minorversion; 2398 struct path path = { 2399 .mnt = exp->ex_path.mnt, 2400 .dentry = dentry, 2401 }; 2402 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 2403 2404 BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1); 2405 BUG_ON(!nfsd_attrs_supported(minorversion, bmval)); 2406 2407 if (exp->ex_fslocs.migrated) { 2408 status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err); 2409 if (status) 2410 goto out; 2411 } 2412 2413 err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); 2414 if (err) 2415 goto out_nfserr; 2416 if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE | 2417 FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) || 2418 (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE | 2419 FATTR4_WORD1_SPACE_TOTAL))) { 2420 err = vfs_statfs(&path, &statfs); 2421 if (err) 2422 goto out_nfserr; 2423 } 2424 if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) { 2425 tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL); 2426 status = nfserr_jukebox; 2427 if (!tempfh) 2428 goto out; 2429 fh_init(tempfh, NFS4_FHSIZE); 2430 status = fh_compose(tempfh, exp, dentry, NULL); 2431 if (status) 2432 goto out; 2433 fhp = tempfh; 2434 } 2435 if (bmval0 & FATTR4_WORD0_ACL) { 2436 err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl); 2437 if (err == -EOPNOTSUPP) 2438 bmval0 &= ~FATTR4_WORD0_ACL; 2439 else if (err == -EINVAL) { 2440 status = nfserr_attrnotsupp; 2441 goto out; 2442 } else if (err != 0) 2443 goto out_nfserr; 2444 } 2445 2446 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2447 if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) || 2448 bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) { 2449 if (exp->ex_flags & NFSEXP_SECURITY_LABEL) 2450 err = security_inode_getsecctx(d_inode(dentry), 2451 &context, &contextlen); 2452 else 2453 err = -EOPNOTSUPP; 2454 contextsupport = (err == 0); 2455 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { 2456 if (err == -EOPNOTSUPP) 2457 bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL; 2458 else if (err) 2459 goto out_nfserr; 2460 } 2461 } 2462 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ 2463 2464 status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2); 2465 if (status) 2466 goto out; 2467 2468 attrlen_offset = xdr->buf->len; 2469 p = xdr_reserve_space(xdr, 4); 2470 if (!p) 2471 goto out_resource; 2472 p++; /* to be backfilled later */ 2473 2474 if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) { 2475 u32 supp[3]; 2476 2477 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp)); 2478 2479 if (!IS_POSIXACL(dentry->d_inode)) 2480 supp[0] &= ~FATTR4_WORD0_ACL; 2481 if (!contextsupport) 2482 supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL; 2483 if (!supp[2]) { 2484 p = xdr_reserve_space(xdr, 12); 2485 if (!p) 2486 goto out_resource; 2487 *p++ = cpu_to_be32(2); 2488 *p++ = cpu_to_be32(supp[0]); 2489 *p++ = cpu_to_be32(supp[1]); 2490 } else { 2491 p = xdr_reserve_space(xdr, 16); 2492 if (!p) 2493 goto out_resource; 2494 *p++ = cpu_to_be32(3); 2495 *p++ = cpu_to_be32(supp[0]); 2496 *p++ = cpu_to_be32(supp[1]); 2497 *p++ = cpu_to_be32(supp[2]); 2498 } 2499 } 2500 if (bmval0 & FATTR4_WORD0_TYPE) { 2501 p = xdr_reserve_space(xdr, 4); 2502 if (!p) 2503 goto out_resource; 2504 dummy = nfs4_file_type(stat.mode); 2505 if (dummy == NF4BAD) { 2506 status = nfserr_serverfault; 2507 goto out; 2508 } 2509 *p++ = cpu_to_be32(dummy); 2510 } 2511 if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) { 2512 p = xdr_reserve_space(xdr, 4); 2513 if (!p) 2514 goto out_resource; 2515 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) 2516 *p++ = cpu_to_be32(NFS4_FH_PERSISTENT); 2517 else 2518 *p++ = cpu_to_be32(NFS4_FH_PERSISTENT| 2519 NFS4_FH_VOL_RENAME); 2520 } 2521 if (bmval0 & FATTR4_WORD0_CHANGE) { 2522 p = xdr_reserve_space(xdr, 8); 2523 if (!p) 2524 goto out_resource; 2525 p = encode_change(p, &stat, d_inode(dentry), exp); 2526 } 2527 if (bmval0 & FATTR4_WORD0_SIZE) { 2528 p = xdr_reserve_space(xdr, 8); 2529 if (!p) 2530 goto out_resource; 2531 p = xdr_encode_hyper(p, stat.size); 2532 } 2533 if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) { 2534 p = xdr_reserve_space(xdr, 4); 2535 if (!p) 2536 goto out_resource; 2537 *p++ = cpu_to_be32(1); 2538 } 2539 if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) { 2540 p = xdr_reserve_space(xdr, 4); 2541 if (!p) 2542 goto out_resource; 2543 *p++ = cpu_to_be32(1); 2544 } 2545 if (bmval0 & FATTR4_WORD0_NAMED_ATTR) { 2546 p = xdr_reserve_space(xdr, 4); 2547 if (!p) 2548 goto out_resource; 2549 *p++ = cpu_to_be32(0); 2550 } 2551 if (bmval0 & FATTR4_WORD0_FSID) { 2552 p = xdr_reserve_space(xdr, 16); 2553 if (!p) 2554 goto out_resource; 2555 if (exp->ex_fslocs.migrated) { 2556 p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR); 2557 p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR); 2558 } else switch(fsid_source(fhp)) { 2559 case FSIDSOURCE_FSID: 2560 p = xdr_encode_hyper(p, (u64)exp->ex_fsid); 2561 p = xdr_encode_hyper(p, (u64)0); 2562 break; 2563 case FSIDSOURCE_DEV: 2564 *p++ = cpu_to_be32(0); 2565 *p++ = cpu_to_be32(MAJOR(stat.dev)); 2566 *p++ = cpu_to_be32(0); 2567 *p++ = cpu_to_be32(MINOR(stat.dev)); 2568 break; 2569 case FSIDSOURCE_UUID: 2570 p = xdr_encode_opaque_fixed(p, exp->ex_uuid, 2571 EX_UUID_LEN); 2572 break; 2573 } 2574 } 2575 if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) { 2576 p = xdr_reserve_space(xdr, 4); 2577 if (!p) 2578 goto out_resource; 2579 *p++ = cpu_to_be32(0); 2580 } 2581 if (bmval0 & FATTR4_WORD0_LEASE_TIME) { 2582 p = xdr_reserve_space(xdr, 4); 2583 if (!p) 2584 goto out_resource; 2585 *p++ = cpu_to_be32(nn->nfsd4_lease); 2586 } 2587 if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) { 2588 p = xdr_reserve_space(xdr, 4); 2589 if (!p) 2590 goto out_resource; 2591 *p++ = cpu_to_be32(rdattr_err); 2592 } 2593 if (bmval0 & FATTR4_WORD0_ACL) { 2594 struct nfs4_ace *ace; 2595 2596 if (acl == NULL) { 2597 p = xdr_reserve_space(xdr, 4); 2598 if (!p) 2599 goto out_resource; 2600 2601 *p++ = cpu_to_be32(0); 2602 goto out_acl; 2603 } 2604 p = xdr_reserve_space(xdr, 4); 2605 if (!p) 2606 goto out_resource; 2607 *p++ = cpu_to_be32(acl->naces); 2608 2609 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { 2610 p = xdr_reserve_space(xdr, 4*3); 2611 if (!p) 2612 goto out_resource; 2613 *p++ = cpu_to_be32(ace->type); 2614 *p++ = cpu_to_be32(ace->flag); 2615 *p++ = cpu_to_be32(ace->access_mask & 2616 NFS4_ACE_MASK_ALL); 2617 status = nfsd4_encode_aclname(xdr, rqstp, ace); 2618 if (status) 2619 goto out; 2620 } 2621 } 2622 out_acl: 2623 if (bmval0 & FATTR4_WORD0_ACLSUPPORT) { 2624 p = xdr_reserve_space(xdr, 4); 2625 if (!p) 2626 goto out_resource; 2627 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ? 2628 ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0); 2629 } 2630 if (bmval0 & FATTR4_WORD0_CANSETTIME) { 2631 p = xdr_reserve_space(xdr, 4); 2632 if (!p) 2633 goto out_resource; 2634 *p++ = cpu_to_be32(1); 2635 } 2636 if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { 2637 p = xdr_reserve_space(xdr, 4); 2638 if (!p) 2639 goto out_resource; 2640 *p++ = cpu_to_be32(0); 2641 } 2642 if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { 2643 p = xdr_reserve_space(xdr, 4); 2644 if (!p) 2645 goto out_resource; 2646 *p++ = cpu_to_be32(1); 2647 } 2648 if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) { 2649 p = xdr_reserve_space(xdr, 4); 2650 if (!p) 2651 goto out_resource; 2652 *p++ = cpu_to_be32(1); 2653 } 2654 if (bmval0 & FATTR4_WORD0_FILEHANDLE) { 2655 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); 2656 if (!p) 2657 goto out_resource; 2658 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, 2659 fhp->fh_handle.fh_size); 2660 } 2661 if (bmval0 & FATTR4_WORD0_FILEID) { 2662 p = xdr_reserve_space(xdr, 8); 2663 if (!p) 2664 goto out_resource; 2665 p = xdr_encode_hyper(p, stat.ino); 2666 } 2667 if (bmval0 & FATTR4_WORD0_FILES_AVAIL) { 2668 p = xdr_reserve_space(xdr, 8); 2669 if (!p) 2670 goto out_resource; 2671 p = xdr_encode_hyper(p, (u64) statfs.f_ffree); 2672 } 2673 if (bmval0 & FATTR4_WORD0_FILES_FREE) { 2674 p = xdr_reserve_space(xdr, 8); 2675 if (!p) 2676 goto out_resource; 2677 p = xdr_encode_hyper(p, (u64) statfs.f_ffree); 2678 } 2679 if (bmval0 & FATTR4_WORD0_FILES_TOTAL) { 2680 p = xdr_reserve_space(xdr, 8); 2681 if (!p) 2682 goto out_resource; 2683 p = xdr_encode_hyper(p, (u64) statfs.f_files); 2684 } 2685 if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) { 2686 status = nfsd4_encode_fs_locations(xdr, rqstp, exp); 2687 if (status) 2688 goto out; 2689 } 2690 if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) { 2691 p = xdr_reserve_space(xdr, 4); 2692 if (!p) 2693 goto out_resource; 2694 *p++ = cpu_to_be32(1); 2695 } 2696 if (bmval0 & FATTR4_WORD0_MAXFILESIZE) { 2697 p = xdr_reserve_space(xdr, 8); 2698 if (!p) 2699 goto out_resource; 2700 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes); 2701 } 2702 if (bmval0 & FATTR4_WORD0_MAXLINK) { 2703 p = xdr_reserve_space(xdr, 4); 2704 if (!p) 2705 goto out_resource; 2706 *p++ = cpu_to_be32(255); 2707 } 2708 if (bmval0 & FATTR4_WORD0_MAXNAME) { 2709 p = xdr_reserve_space(xdr, 4); 2710 if (!p) 2711 goto out_resource; 2712 *p++ = cpu_to_be32(statfs.f_namelen); 2713 } 2714 if (bmval0 & FATTR4_WORD0_MAXREAD) { 2715 p = xdr_reserve_space(xdr, 8); 2716 if (!p) 2717 goto out_resource; 2718 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp)); 2719 } 2720 if (bmval0 & FATTR4_WORD0_MAXWRITE) { 2721 p = xdr_reserve_space(xdr, 8); 2722 if (!p) 2723 goto out_resource; 2724 p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp)); 2725 } 2726 if (bmval1 & FATTR4_WORD1_MODE) { 2727 p = xdr_reserve_space(xdr, 4); 2728 if (!p) 2729 goto out_resource; 2730 *p++ = cpu_to_be32(stat.mode & S_IALLUGO); 2731 } 2732 if (bmval1 & FATTR4_WORD1_NO_TRUNC) { 2733 p = xdr_reserve_space(xdr, 4); 2734 if (!p) 2735 goto out_resource; 2736 *p++ = cpu_to_be32(1); 2737 } 2738 if (bmval1 & FATTR4_WORD1_NUMLINKS) { 2739 p = xdr_reserve_space(xdr, 4); 2740 if (!p) 2741 goto out_resource; 2742 *p++ = cpu_to_be32(stat.nlink); 2743 } 2744 if (bmval1 & FATTR4_WORD1_OWNER) { 2745 status = nfsd4_encode_user(xdr, rqstp, stat.uid); 2746 if (status) 2747 goto out; 2748 } 2749 if (bmval1 & FATTR4_WORD1_OWNER_GROUP) { 2750 status = nfsd4_encode_group(xdr, rqstp, stat.gid); 2751 if (status) 2752 goto out; 2753 } 2754 if (bmval1 & FATTR4_WORD1_RAWDEV) { 2755 p = xdr_reserve_space(xdr, 8); 2756 if (!p) 2757 goto out_resource; 2758 *p++ = cpu_to_be32((u32) MAJOR(stat.rdev)); 2759 *p++ = cpu_to_be32((u32) MINOR(stat.rdev)); 2760 } 2761 if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) { 2762 p = xdr_reserve_space(xdr, 8); 2763 if (!p) 2764 goto out_resource; 2765 dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize; 2766 p = xdr_encode_hyper(p, dummy64); 2767 } 2768 if (bmval1 & FATTR4_WORD1_SPACE_FREE) { 2769 p = xdr_reserve_space(xdr, 8); 2770 if (!p) 2771 goto out_resource; 2772 dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize; 2773 p = xdr_encode_hyper(p, dummy64); 2774 } 2775 if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) { 2776 p = xdr_reserve_space(xdr, 8); 2777 if (!p) 2778 goto out_resource; 2779 dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize; 2780 p = xdr_encode_hyper(p, dummy64); 2781 } 2782 if (bmval1 & FATTR4_WORD1_SPACE_USED) { 2783 p = xdr_reserve_space(xdr, 8); 2784 if (!p) 2785 goto out_resource; 2786 dummy64 = (u64)stat.blocks << 9; 2787 p = xdr_encode_hyper(p, dummy64); 2788 } 2789 if (bmval1 & FATTR4_WORD1_TIME_ACCESS) { 2790 p = xdr_reserve_space(xdr, 12); 2791 if (!p) 2792 goto out_resource; 2793 p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec); 2794 *p++ = cpu_to_be32(stat.atime.tv_nsec); 2795 } 2796 if (bmval1 & FATTR4_WORD1_TIME_DELTA) { 2797 p = xdr_reserve_space(xdr, 12); 2798 if (!p) 2799 goto out_resource; 2800 *p++ = cpu_to_be32(0); 2801 *p++ = cpu_to_be32(1); 2802 *p++ = cpu_to_be32(0); 2803 } 2804 if (bmval1 & FATTR4_WORD1_TIME_METADATA) { 2805 p = xdr_reserve_space(xdr, 12); 2806 if (!p) 2807 goto out_resource; 2808 p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec); 2809 *p++ = cpu_to_be32(stat.ctime.tv_nsec); 2810 } 2811 if (bmval1 & FATTR4_WORD1_TIME_MODIFY) { 2812 p = xdr_reserve_space(xdr, 12); 2813 if (!p) 2814 goto out_resource; 2815 p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec); 2816 *p++ = cpu_to_be32(stat.mtime.tv_nsec); 2817 } 2818 if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) { 2819 struct kstat parent_stat; 2820 u64 ino = stat.ino; 2821 2822 p = xdr_reserve_space(xdr, 8); 2823 if (!p) 2824 goto out_resource; 2825 /* 2826 * Get parent's attributes if not ignoring crossmount 2827 * and this is the root of a cross-mounted filesystem. 2828 */ 2829 if (ignore_crossmnt == 0 && 2830 dentry == exp->ex_path.mnt->mnt_root) { 2831 err = get_parent_attributes(exp, &parent_stat); 2832 if (err) 2833 goto out_nfserr; 2834 ino = parent_stat.ino; 2835 } 2836 p = xdr_encode_hyper(p, ino); 2837 } 2838 #ifdef CONFIG_NFSD_PNFS 2839 if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) { 2840 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); 2841 if (status) 2842 goto out; 2843 } 2844 2845 if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) { 2846 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); 2847 if (status) 2848 goto out; 2849 } 2850 2851 if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) { 2852 p = xdr_reserve_space(xdr, 4); 2853 if (!p) 2854 goto out_resource; 2855 *p++ = cpu_to_be32(stat.blksize); 2856 } 2857 #endif /* CONFIG_NFSD_PNFS */ 2858 if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) { 2859 u32 supp[3]; 2860 2861 memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp)); 2862 supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0; 2863 supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1; 2864 supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2; 2865 2866 status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]); 2867 if (status) 2868 goto out; 2869 } 2870 2871 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { 2872 status = nfsd4_encode_security_label(xdr, rqstp, context, 2873 contextlen); 2874 if (status) 2875 goto out; 2876 } 2877 2878 attrlen = htonl(xdr->buf->len - attrlen_offset - 4); 2879 write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4); 2880 status = nfs_ok; 2881 2882 out: 2883 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2884 if (context) 2885 security_release_secctx(context, contextlen); 2886 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */ 2887 kfree(acl); 2888 if (tempfh) { 2889 fh_put(tempfh); 2890 kfree(tempfh); 2891 } 2892 if (status) 2893 xdr_truncate_encode(xdr, starting_len); 2894 return status; 2895 out_nfserr: 2896 status = nfserrno(err); 2897 goto out; 2898 out_resource: 2899 status = nfserr_resource; 2900 goto out; 2901 } 2902 2903 static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr, 2904 struct xdr_buf *buf, __be32 *p, int bytes) 2905 { 2906 xdr->scratch.iov_len = 0; 2907 memset(buf, 0, sizeof(struct xdr_buf)); 2908 buf->head[0].iov_base = p; 2909 buf->head[0].iov_len = 0; 2910 buf->len = 0; 2911 xdr->buf = buf; 2912 xdr->iov = buf->head; 2913 xdr->p = p; 2914 xdr->end = (void *)p + bytes; 2915 buf->buflen = bytes; 2916 } 2917 2918 __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words, 2919 struct svc_fh *fhp, struct svc_export *exp, 2920 struct dentry *dentry, u32 *bmval, 2921 struct svc_rqst *rqstp, int ignore_crossmnt) 2922 { 2923 struct xdr_buf dummy; 2924 struct xdr_stream xdr; 2925 __be32 ret; 2926 2927 svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2); 2928 ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp, 2929 ignore_crossmnt); 2930 *p = xdr.p; 2931 return ret; 2932 } 2933 2934 static inline int attributes_need_mount(u32 *bmval) 2935 { 2936 if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME)) 2937 return 1; 2938 if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID) 2939 return 1; 2940 return 0; 2941 } 2942 2943 static __be32 2944 nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd, 2945 const char *name, int namlen) 2946 { 2947 struct svc_export *exp = cd->rd_fhp->fh_export; 2948 struct dentry *dentry; 2949 __be32 nfserr; 2950 int ignore_crossmnt = 0; 2951 2952 dentry = lookup_one_len_unlocked(name, cd->rd_fhp->fh_dentry, namlen); 2953 if (IS_ERR(dentry)) 2954 return nfserrno(PTR_ERR(dentry)); 2955 if (d_really_is_negative(dentry)) { 2956 /* 2957 * we're not holding the i_mutex here, so there's 2958 * a window where this directory entry could have gone 2959 * away. 2960 */ 2961 dput(dentry); 2962 return nfserr_noent; 2963 } 2964 2965 exp_get(exp); 2966 /* 2967 * In the case of a mountpoint, the client may be asking for 2968 * attributes that are only properties of the underlying filesystem 2969 * as opposed to the cross-mounted file system. In such a case, 2970 * we will not follow the cross mount and will fill the attribtutes 2971 * directly from the mountpoint dentry. 2972 */ 2973 if (nfsd_mountpoint(dentry, exp)) { 2974 int err; 2975 2976 if (!(exp->ex_flags & NFSEXP_V4ROOT) 2977 && !attributes_need_mount(cd->rd_bmval)) { 2978 ignore_crossmnt = 1; 2979 goto out_encode; 2980 } 2981 /* 2982 * Why the heck aren't we just using nfsd_lookup?? 2983 * Different "."/".." handling? Something else? 2984 * At least, add a comment here to explain.... 2985 */ 2986 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); 2987 if (err) { 2988 nfserr = nfserrno(err); 2989 goto out_put; 2990 } 2991 nfserr = check_nfsd_access(exp, cd->rd_rqstp); 2992 if (nfserr) 2993 goto out_put; 2994 2995 } 2996 out_encode: 2997 nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval, 2998 cd->rd_rqstp, ignore_crossmnt); 2999 out_put: 3000 dput(dentry); 3001 exp_put(exp); 3002 return nfserr; 3003 } 3004 3005 static __be32 * 3006 nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr) 3007 { 3008 __be32 *p; 3009 3010 p = xdr_reserve_space(xdr, 20); 3011 if (!p) 3012 return NULL; 3013 *p++ = htonl(2); 3014 *p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */ 3015 *p++ = htonl(0); /* bmval1 */ 3016 3017 *p++ = htonl(4); /* attribute length */ 3018 *p++ = nfserr; /* no htonl */ 3019 return p; 3020 } 3021 3022 static int 3023 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen, 3024 loff_t offset, u64 ino, unsigned int d_type) 3025 { 3026 struct readdir_cd *ccd = ccdv; 3027 struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common); 3028 struct xdr_stream *xdr = cd->xdr; 3029 int start_offset = xdr->buf->len; 3030 int cookie_offset; 3031 u32 name_and_cookie; 3032 int entry_bytes; 3033 __be32 nfserr = nfserr_toosmall; 3034 __be64 wire_offset; 3035 __be32 *p; 3036 3037 /* In nfsv4, "." and ".." never make it onto the wire.. */ 3038 if (name && isdotent(name, namlen)) { 3039 cd->common.err = nfs_ok; 3040 return 0; 3041 } 3042 3043 if (cd->cookie_offset) { 3044 wire_offset = cpu_to_be64(offset); 3045 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset, 3046 &wire_offset, 8); 3047 } 3048 3049 p = xdr_reserve_space(xdr, 4); 3050 if (!p) 3051 goto fail; 3052 *p++ = xdr_one; /* mark entry present */ 3053 cookie_offset = xdr->buf->len; 3054 p = xdr_reserve_space(xdr, 3*4 + namlen); 3055 if (!p) 3056 goto fail; 3057 p = xdr_encode_hyper(p, NFS_OFFSET_MAX); /* offset of next entry */ 3058 p = xdr_encode_array(p, name, namlen); /* name length & name */ 3059 3060 nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen); 3061 switch (nfserr) { 3062 case nfs_ok: 3063 break; 3064 case nfserr_resource: 3065 nfserr = nfserr_toosmall; 3066 goto fail; 3067 case nfserr_noent: 3068 xdr_truncate_encode(xdr, start_offset); 3069 goto skip_entry; 3070 default: 3071 /* 3072 * If the client requested the RDATTR_ERROR attribute, 3073 * we stuff the error code into this attribute 3074 * and continue. If this attribute was not requested, 3075 * then in accordance with the spec, we fail the 3076 * entire READDIR operation(!) 3077 */ 3078 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) 3079 goto fail; 3080 p = nfsd4_encode_rdattr_error(xdr, nfserr); 3081 if (p == NULL) { 3082 nfserr = nfserr_toosmall; 3083 goto fail; 3084 } 3085 } 3086 nfserr = nfserr_toosmall; 3087 entry_bytes = xdr->buf->len - start_offset; 3088 if (entry_bytes > cd->rd_maxcount) 3089 goto fail; 3090 cd->rd_maxcount -= entry_bytes; 3091 /* 3092 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so 3093 * let's always let through the first entry, at least: 3094 */ 3095 if (!cd->rd_dircount) 3096 goto fail; 3097 name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8; 3098 if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) 3099 goto fail; 3100 cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); 3101 3102 cd->cookie_offset = cookie_offset; 3103 skip_entry: 3104 cd->common.err = nfs_ok; 3105 return 0; 3106 fail: 3107 xdr_truncate_encode(xdr, start_offset); 3108 cd->common.err = nfserr; 3109 return -EINVAL; 3110 } 3111 3112 static __be32 3113 nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid) 3114 { 3115 __be32 *p; 3116 3117 p = xdr_reserve_space(xdr, sizeof(stateid_t)); 3118 if (!p) 3119 return nfserr_resource; 3120 *p++ = cpu_to_be32(sid->si_generation); 3121 p = xdr_encode_opaque_fixed(p, &sid->si_opaque, 3122 sizeof(stateid_opaque_t)); 3123 return 0; 3124 } 3125 3126 static __be32 3127 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access) 3128 { 3129 struct xdr_stream *xdr = &resp->xdr; 3130 __be32 *p; 3131 3132 p = xdr_reserve_space(xdr, 8); 3133 if (!p) 3134 return nfserr_resource; 3135 *p++ = cpu_to_be32(access->ac_supported); 3136 *p++ = cpu_to_be32(access->ac_resp_access); 3137 return 0; 3138 } 3139 3140 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts) 3141 { 3142 struct xdr_stream *xdr = &resp->xdr; 3143 __be32 *p; 3144 3145 p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8); 3146 if (!p) 3147 return nfserr_resource; 3148 p = xdr_encode_opaque_fixed(p, bcts->sessionid.data, 3149 NFS4_MAX_SESSIONID_LEN); 3150 *p++ = cpu_to_be32(bcts->dir); 3151 /* Upshifting from TCP to RDMA is not supported */ 3152 *p++ = cpu_to_be32(0); 3153 return 0; 3154 } 3155 3156 static __be32 3157 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close) 3158 { 3159 struct xdr_stream *xdr = &resp->xdr; 3160 3161 return nfsd4_encode_stateid(xdr, &close->cl_stateid); 3162 } 3163 3164 3165 static __be32 3166 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit) 3167 { 3168 struct xdr_stream *xdr = &resp->xdr; 3169 __be32 *p; 3170 3171 p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); 3172 if (!p) 3173 return nfserr_resource; 3174 p = xdr_encode_opaque_fixed(p, commit->co_verf.data, 3175 NFS4_VERIFIER_SIZE); 3176 return 0; 3177 } 3178 3179 static __be32 3180 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create) 3181 { 3182 struct xdr_stream *xdr = &resp->xdr; 3183 __be32 *p; 3184 3185 p = xdr_reserve_space(xdr, 20); 3186 if (!p) 3187 return nfserr_resource; 3188 encode_cinfo(p, &create->cr_cinfo); 3189 nfserr = nfsd4_encode_bitmap(xdr, create->cr_bmval[0], 3190 create->cr_bmval[1], create->cr_bmval[2]); 3191 return 0; 3192 } 3193 3194 static __be32 3195 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr) 3196 { 3197 struct svc_fh *fhp = getattr->ga_fhp; 3198 struct xdr_stream *xdr = &resp->xdr; 3199 3200 return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry, 3201 getattr->ga_bmval, resp->rqstp, 0); 3202 } 3203 3204 static __be32 3205 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp) 3206 { 3207 struct xdr_stream *xdr = &resp->xdr; 3208 struct svc_fh *fhp = *fhpp; 3209 unsigned int len; 3210 __be32 *p; 3211 3212 len = fhp->fh_handle.fh_size; 3213 p = xdr_reserve_space(xdr, len + 4); 3214 if (!p) 3215 return nfserr_resource; 3216 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len); 3217 return 0; 3218 } 3219 3220 /* 3221 * Including all fields other than the name, a LOCK4denied structure requires 3222 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes. 3223 */ 3224 static __be32 3225 nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld) 3226 { 3227 struct xdr_netobj *conf = &ld->ld_owner; 3228 __be32 *p; 3229 3230 again: 3231 p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len)); 3232 if (!p) { 3233 /* 3234 * Don't fail to return the result just because we can't 3235 * return the conflicting open: 3236 */ 3237 if (conf->len) { 3238 kfree(conf->data); 3239 conf->len = 0; 3240 conf->data = NULL; 3241 goto again; 3242 } 3243 return nfserr_resource; 3244 } 3245 p = xdr_encode_hyper(p, ld->ld_start); 3246 p = xdr_encode_hyper(p, ld->ld_length); 3247 *p++ = cpu_to_be32(ld->ld_type); 3248 if (conf->len) { 3249 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8); 3250 p = xdr_encode_opaque(p, conf->data, conf->len); 3251 kfree(conf->data); 3252 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ 3253 p = xdr_encode_hyper(p, (u64)0); /* clientid */ 3254 *p++ = cpu_to_be32(0); /* length of owner name */ 3255 } 3256 return nfserr_denied; 3257 } 3258 3259 static __be32 3260 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock) 3261 { 3262 struct xdr_stream *xdr = &resp->xdr; 3263 3264 if (!nfserr) 3265 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid); 3266 else if (nfserr == nfserr_denied) 3267 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied); 3268 3269 return nfserr; 3270 } 3271 3272 static __be32 3273 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt) 3274 { 3275 struct xdr_stream *xdr = &resp->xdr; 3276 3277 if (nfserr == nfserr_denied) 3278 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied); 3279 return nfserr; 3280 } 3281 3282 static __be32 3283 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku) 3284 { 3285 struct xdr_stream *xdr = &resp->xdr; 3286 3287 return nfsd4_encode_stateid(xdr, &locku->lu_stateid); 3288 } 3289 3290 3291 static __be32 3292 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link) 3293 { 3294 struct xdr_stream *xdr = &resp->xdr; 3295 __be32 *p; 3296 3297 p = xdr_reserve_space(xdr, 20); 3298 if (!p) 3299 return nfserr_resource; 3300 p = encode_cinfo(p, &link->li_cinfo); 3301 return 0; 3302 } 3303 3304 3305 static __be32 3306 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open) 3307 { 3308 struct xdr_stream *xdr = &resp->xdr; 3309 __be32 *p; 3310 3311 nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid); 3312 if (nfserr) 3313 return nfserr; 3314 p = xdr_reserve_space(xdr, 24); 3315 if (!p) 3316 return nfserr_resource; 3317 p = encode_cinfo(p, &open->op_cinfo); 3318 *p++ = cpu_to_be32(open->op_rflags); 3319 3320 nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1], 3321 open->op_bmval[2]); 3322 if (nfserr) 3323 return nfserr; 3324 3325 p = xdr_reserve_space(xdr, 4); 3326 if (!p) 3327 return nfserr_resource; 3328 3329 *p++ = cpu_to_be32(open->op_delegate_type); 3330 switch (open->op_delegate_type) { 3331 case NFS4_OPEN_DELEGATE_NONE: 3332 break; 3333 case NFS4_OPEN_DELEGATE_READ: 3334 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); 3335 if (nfserr) 3336 return nfserr; 3337 p = xdr_reserve_space(xdr, 20); 3338 if (!p) 3339 return nfserr_resource; 3340 *p++ = cpu_to_be32(open->op_recall); 3341 3342 /* 3343 * TODO: ACE's in delegations 3344 */ 3345 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 3346 *p++ = cpu_to_be32(0); 3347 *p++ = cpu_to_be32(0); 3348 *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ 3349 break; 3350 case NFS4_OPEN_DELEGATE_WRITE: 3351 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); 3352 if (nfserr) 3353 return nfserr; 3354 p = xdr_reserve_space(xdr, 32); 3355 if (!p) 3356 return nfserr_resource; 3357 *p++ = cpu_to_be32(0); 3358 3359 /* 3360 * TODO: space_limit's in delegations 3361 */ 3362 *p++ = cpu_to_be32(NFS4_LIMIT_SIZE); 3363 *p++ = cpu_to_be32(~(u32)0); 3364 *p++ = cpu_to_be32(~(u32)0); 3365 3366 /* 3367 * TODO: ACE's in delegations 3368 */ 3369 *p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE); 3370 *p++ = cpu_to_be32(0); 3371 *p++ = cpu_to_be32(0); 3372 *p++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */ 3373 break; 3374 case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */ 3375 switch (open->op_why_no_deleg) { 3376 case WND4_CONTENTION: 3377 case WND4_RESOURCE: 3378 p = xdr_reserve_space(xdr, 8); 3379 if (!p) 3380 return nfserr_resource; 3381 *p++ = cpu_to_be32(open->op_why_no_deleg); 3382 /* deleg signaling not supported yet: */ 3383 *p++ = cpu_to_be32(0); 3384 break; 3385 default: 3386 p = xdr_reserve_space(xdr, 4); 3387 if (!p) 3388 return nfserr_resource; 3389 *p++ = cpu_to_be32(open->op_why_no_deleg); 3390 } 3391 break; 3392 default: 3393 BUG(); 3394 } 3395 /* XXX save filehandle here */ 3396 return 0; 3397 } 3398 3399 static __be32 3400 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc) 3401 { 3402 struct xdr_stream *xdr = &resp->xdr; 3403 3404 return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid); 3405 } 3406 3407 static __be32 3408 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od) 3409 { 3410 struct xdr_stream *xdr = &resp->xdr; 3411 3412 return nfsd4_encode_stateid(xdr, &od->od_stateid); 3413 } 3414 3415 static __be32 nfsd4_encode_splice_read( 3416 struct nfsd4_compoundres *resp, 3417 struct nfsd4_read *read, 3418 struct file *file, unsigned long maxcount) 3419 { 3420 struct xdr_stream *xdr = &resp->xdr; 3421 struct xdr_buf *buf = xdr->buf; 3422 u32 eof; 3423 long len; 3424 int space_left; 3425 __be32 nfserr; 3426 __be32 *p = xdr->p - 2; 3427 3428 /* Make sure there will be room for padding if needed */ 3429 if (xdr->end - xdr->p < 1) 3430 return nfserr_resource; 3431 3432 len = maxcount; 3433 nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp, 3434 file, read->rd_offset, &maxcount); 3435 read->rd_length = maxcount; 3436 if (nfserr) { 3437 /* 3438 * nfsd_splice_actor may have already messed with the 3439 * page length; reset it so as not to confuse 3440 * xdr_truncate_encode: 3441 */ 3442 buf->page_len = 0; 3443 return nfserr; 3444 } 3445 3446 eof = nfsd_eof_on_read(len, maxcount, read->rd_offset, 3447 d_inode(read->rd_fhp->fh_dentry)->i_size); 3448 3449 *(p++) = htonl(eof); 3450 *(p++) = htonl(maxcount); 3451 3452 buf->page_len = maxcount; 3453 buf->len += maxcount; 3454 xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1) 3455 / PAGE_SIZE; 3456 3457 /* Use rest of head for padding and remaining ops: */ 3458 buf->tail[0].iov_base = xdr->p; 3459 buf->tail[0].iov_len = 0; 3460 xdr->iov = buf->tail; 3461 if (maxcount&3) { 3462 int pad = 4 - (maxcount&3); 3463 3464 *(xdr->p++) = 0; 3465 3466 buf->tail[0].iov_base += maxcount&3; 3467 buf->tail[0].iov_len = pad; 3468 buf->len += pad; 3469 } 3470 3471 space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, 3472 buf->buflen - buf->len); 3473 buf->buflen = buf->len + space_left; 3474 xdr->end = (__be32 *)((void *)xdr->end + space_left); 3475 3476 return 0; 3477 } 3478 3479 static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp, 3480 struct nfsd4_read *read, 3481 struct file *file, unsigned long maxcount) 3482 { 3483 struct xdr_stream *xdr = &resp->xdr; 3484 u32 eof; 3485 int v; 3486 int starting_len = xdr->buf->len - 8; 3487 long len; 3488 int thislen; 3489 __be32 nfserr; 3490 __be32 tmp; 3491 __be32 *p; 3492 u32 zzz = 0; 3493 int pad; 3494 3495 len = maxcount; 3496 v = 0; 3497 3498 thislen = min_t(long, len, ((void *)xdr->end - (void *)xdr->p)); 3499 p = xdr_reserve_space(xdr, (thislen+3)&~3); 3500 WARN_ON_ONCE(!p); 3501 resp->rqstp->rq_vec[v].iov_base = p; 3502 resp->rqstp->rq_vec[v].iov_len = thislen; 3503 v++; 3504 len -= thislen; 3505 3506 while (len) { 3507 thislen = min_t(long, len, PAGE_SIZE); 3508 p = xdr_reserve_space(xdr, (thislen+3)&~3); 3509 WARN_ON_ONCE(!p); 3510 resp->rqstp->rq_vec[v].iov_base = p; 3511 resp->rqstp->rq_vec[v].iov_len = thislen; 3512 v++; 3513 len -= thislen; 3514 } 3515 read->rd_vlen = v; 3516 3517 len = maxcount; 3518 nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset, 3519 resp->rqstp->rq_vec, read->rd_vlen, &maxcount); 3520 read->rd_length = maxcount; 3521 if (nfserr) 3522 return nfserr; 3523 xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3)); 3524 3525 eof = nfsd_eof_on_read(len, maxcount, read->rd_offset, 3526 d_inode(read->rd_fhp->fh_dentry)->i_size); 3527 3528 tmp = htonl(eof); 3529 write_bytes_to_xdr_buf(xdr->buf, starting_len , &tmp, 4); 3530 tmp = htonl(maxcount); 3531 write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4); 3532 3533 pad = (maxcount&3) ? 4 - (maxcount&3) : 0; 3534 write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount, 3535 &zzz, pad); 3536 return 0; 3537 3538 } 3539 3540 static __be32 3541 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr, 3542 struct nfsd4_read *read) 3543 { 3544 unsigned long maxcount; 3545 struct xdr_stream *xdr = &resp->xdr; 3546 struct file *file = read->rd_filp; 3547 int starting_len = xdr->buf->len; 3548 struct raparms *ra = NULL; 3549 __be32 *p; 3550 3551 p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */ 3552 if (!p) { 3553 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)); 3554 return nfserr_resource; 3555 } 3556 if (resp->xdr.buf->page_len && 3557 test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) { 3558 WARN_ON_ONCE(1); 3559 return nfserr_resource; 3560 } 3561 xdr_commit_encode(xdr); 3562 3563 maxcount = svc_max_payload(resp->rqstp); 3564 maxcount = min_t(unsigned long, maxcount, 3565 (xdr->buf->buflen - xdr->buf->len)); 3566 maxcount = min_t(unsigned long, maxcount, read->rd_length); 3567 3568 if (read->rd_tmp_file) 3569 ra = nfsd_init_raparms(file); 3570 3571 if (file->f_op->splice_read && 3572 test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) 3573 nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount); 3574 else 3575 nfserr = nfsd4_encode_readv(resp, read, file, maxcount); 3576 3577 if (ra) 3578 nfsd_put_raparams(file, ra); 3579 3580 if (nfserr) 3581 xdr_truncate_encode(xdr, starting_len); 3582 3583 return nfserr; 3584 } 3585 3586 static __be32 3587 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink) 3588 { 3589 int maxcount; 3590 __be32 wire_count; 3591 int zero = 0; 3592 struct xdr_stream *xdr = &resp->xdr; 3593 int length_offset = xdr->buf->len; 3594 __be32 *p; 3595 3596 p = xdr_reserve_space(xdr, 4); 3597 if (!p) 3598 return nfserr_resource; 3599 maxcount = PAGE_SIZE; 3600 3601 p = xdr_reserve_space(xdr, maxcount); 3602 if (!p) 3603 return nfserr_resource; 3604 /* 3605 * XXX: By default, vfs_readlink() will truncate symlinks if they 3606 * would overflow the buffer. Is this kosher in NFSv4? If not, one 3607 * easy fix is: if vfs_readlink() precisely fills the buffer, assume 3608 * that truncation occurred, and return NFS4ERR_RESOURCE. 3609 */ 3610 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, 3611 (char *)p, &maxcount); 3612 if (nfserr == nfserr_isdir) 3613 nfserr = nfserr_inval; 3614 if (nfserr) { 3615 xdr_truncate_encode(xdr, length_offset); 3616 return nfserr; 3617 } 3618 3619 wire_count = htonl(maxcount); 3620 write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4); 3621 xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4)); 3622 if (maxcount & 3) 3623 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, 3624 &zero, 4 - (maxcount&3)); 3625 return 0; 3626 } 3627 3628 static __be32 3629 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir) 3630 { 3631 int maxcount; 3632 int bytes_left; 3633 loff_t offset; 3634 __be64 wire_offset; 3635 struct xdr_stream *xdr = &resp->xdr; 3636 int starting_len = xdr->buf->len; 3637 __be32 *p; 3638 3639 p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE); 3640 if (!p) 3641 return nfserr_resource; 3642 3643 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */ 3644 *p++ = cpu_to_be32(0); 3645 *p++ = cpu_to_be32(0); 3646 resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p) 3647 - (char *)resp->xdr.buf->head[0].iov_base; 3648 3649 /* 3650 * Number of bytes left for directory entries allowing for the 3651 * final 8 bytes of the readdir and a following failed op: 3652 */ 3653 bytes_left = xdr->buf->buflen - xdr->buf->len 3654 - COMPOUND_ERR_SLACK_SPACE - 8; 3655 if (bytes_left < 0) { 3656 nfserr = nfserr_resource; 3657 goto err_no_verf; 3658 } 3659 maxcount = svc_max_payload(resp->rqstp); 3660 maxcount = min_t(u32, readdir->rd_maxcount, maxcount); 3661 /* 3662 * Note the rfc defines rd_maxcount as the size of the 3663 * READDIR4resok structure, which includes the verifier above 3664 * and the 8 bytes encoded at the end of this function: 3665 */ 3666 if (maxcount < 16) { 3667 nfserr = nfserr_toosmall; 3668 goto err_no_verf; 3669 } 3670 maxcount = min_t(int, maxcount-16, bytes_left); 3671 3672 /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */ 3673 if (!readdir->rd_dircount) 3674 readdir->rd_dircount = svc_max_payload(resp->rqstp); 3675 3676 readdir->xdr = xdr; 3677 readdir->rd_maxcount = maxcount; 3678 readdir->common.err = 0; 3679 readdir->cookie_offset = 0; 3680 3681 offset = readdir->rd_cookie; 3682 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, 3683 &offset, 3684 &readdir->common, nfsd4_encode_dirent); 3685 if (nfserr == nfs_ok && 3686 readdir->common.err == nfserr_toosmall && 3687 xdr->buf->len == starting_len + 8) { 3688 /* nothing encoded; which limit did we hit?: */ 3689 if (maxcount - 16 < bytes_left) 3690 /* It was the fault of rd_maxcount: */ 3691 nfserr = nfserr_toosmall; 3692 else 3693 /* We ran out of buffer space: */ 3694 nfserr = nfserr_resource; 3695 } 3696 if (nfserr) 3697 goto err_no_verf; 3698 3699 if (readdir->cookie_offset) { 3700 wire_offset = cpu_to_be64(offset); 3701 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, 3702 &wire_offset, 8); 3703 } 3704 3705 p = xdr_reserve_space(xdr, 8); 3706 if (!p) { 3707 WARN_ON_ONCE(1); 3708 goto err_no_verf; 3709 } 3710 *p++ = 0; /* no more entries */ 3711 *p++ = htonl(readdir->common.err == nfserr_eof); 3712 3713 return 0; 3714 err_no_verf: 3715 xdr_truncate_encode(xdr, starting_len); 3716 return nfserr; 3717 } 3718 3719 static __be32 3720 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove) 3721 { 3722 struct xdr_stream *xdr = &resp->xdr; 3723 __be32 *p; 3724 3725 p = xdr_reserve_space(xdr, 20); 3726 if (!p) 3727 return nfserr_resource; 3728 p = encode_cinfo(p, &remove->rm_cinfo); 3729 return 0; 3730 } 3731 3732 static __be32 3733 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename) 3734 { 3735 struct xdr_stream *xdr = &resp->xdr; 3736 __be32 *p; 3737 3738 p = xdr_reserve_space(xdr, 40); 3739 if (!p) 3740 return nfserr_resource; 3741 p = encode_cinfo(p, &rename->rn_sinfo); 3742 p = encode_cinfo(p, &rename->rn_tinfo); 3743 return 0; 3744 } 3745 3746 static __be32 3747 nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp) 3748 { 3749 u32 i, nflavs, supported; 3750 struct exp_flavor_info *flavs; 3751 struct exp_flavor_info def_flavs[2]; 3752 __be32 *p, *flavorsp; 3753 static bool report = true; 3754 3755 if (exp->ex_nflavors) { 3756 flavs = exp->ex_flavors; 3757 nflavs = exp->ex_nflavors; 3758 } else { /* Handling of some defaults in absence of real secinfo: */ 3759 flavs = def_flavs; 3760 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { 3761 nflavs = 2; 3762 flavs[0].pseudoflavor = RPC_AUTH_UNIX; 3763 flavs[1].pseudoflavor = RPC_AUTH_NULL; 3764 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { 3765 nflavs = 1; 3766 flavs[0].pseudoflavor 3767 = svcauth_gss_flavor(exp->ex_client); 3768 } else { 3769 nflavs = 1; 3770 flavs[0].pseudoflavor 3771 = exp->ex_client->flavour->flavour; 3772 } 3773 } 3774 3775 supported = 0; 3776 p = xdr_reserve_space(xdr, 4); 3777 if (!p) 3778 return nfserr_resource; 3779 flavorsp = p++; /* to be backfilled later */ 3780 3781 for (i = 0; i < nflavs; i++) { 3782 rpc_authflavor_t pf = flavs[i].pseudoflavor; 3783 struct rpcsec_gss_info info; 3784 3785 if (rpcauth_get_gssinfo(pf, &info) == 0) { 3786 supported++; 3787 p = xdr_reserve_space(xdr, 4 + 4 + 3788 XDR_LEN(info.oid.len) + 4 + 4); 3789 if (!p) 3790 return nfserr_resource; 3791 *p++ = cpu_to_be32(RPC_AUTH_GSS); 3792 p = xdr_encode_opaque(p, info.oid.data, info.oid.len); 3793 *p++ = cpu_to_be32(info.qop); 3794 *p++ = cpu_to_be32(info.service); 3795 } else if (pf < RPC_AUTH_MAXFLAVOR) { 3796 supported++; 3797 p = xdr_reserve_space(xdr, 4); 3798 if (!p) 3799 return nfserr_resource; 3800 *p++ = cpu_to_be32(pf); 3801 } else { 3802 if (report) 3803 pr_warn("NFS: SECINFO: security flavor %u " 3804 "is not supported\n", pf); 3805 } 3806 } 3807 3808 if (nflavs != supported) 3809 report = false; 3810 *flavorsp = htonl(supported); 3811 return 0; 3812 } 3813 3814 static __be32 3815 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 3816 struct nfsd4_secinfo *secinfo) 3817 { 3818 struct xdr_stream *xdr = &resp->xdr; 3819 3820 return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp); 3821 } 3822 3823 static __be32 3824 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr, 3825 struct nfsd4_secinfo_no_name *secinfo) 3826 { 3827 struct xdr_stream *xdr = &resp->xdr; 3828 3829 return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp); 3830 } 3831 3832 /* 3833 * The SETATTR encode routine is special -- it always encodes a bitmap, 3834 * regardless of the error status. 3835 */ 3836 static __be32 3837 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr) 3838 { 3839 struct xdr_stream *xdr = &resp->xdr; 3840 __be32 *p; 3841 3842 p = xdr_reserve_space(xdr, 16); 3843 if (!p) 3844 return nfserr_resource; 3845 if (nfserr) { 3846 *p++ = cpu_to_be32(3); 3847 *p++ = cpu_to_be32(0); 3848 *p++ = cpu_to_be32(0); 3849 *p++ = cpu_to_be32(0); 3850 } 3851 else { 3852 *p++ = cpu_to_be32(3); 3853 *p++ = cpu_to_be32(setattr->sa_bmval[0]); 3854 *p++ = cpu_to_be32(setattr->sa_bmval[1]); 3855 *p++ = cpu_to_be32(setattr->sa_bmval[2]); 3856 } 3857 return nfserr; 3858 } 3859 3860 static __be32 3861 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd) 3862 { 3863 struct xdr_stream *xdr = &resp->xdr; 3864 __be32 *p; 3865 3866 if (!nfserr) { 3867 p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE); 3868 if (!p) 3869 return nfserr_resource; 3870 p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8); 3871 p = xdr_encode_opaque_fixed(p, &scd->se_confirm, 3872 NFS4_VERIFIER_SIZE); 3873 } 3874 else if (nfserr == nfserr_clid_inuse) { 3875 p = xdr_reserve_space(xdr, 8); 3876 if (!p) 3877 return nfserr_resource; 3878 *p++ = cpu_to_be32(0); 3879 *p++ = cpu_to_be32(0); 3880 } 3881 return nfserr; 3882 } 3883 3884 static __be32 3885 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write) 3886 { 3887 struct xdr_stream *xdr = &resp->xdr; 3888 __be32 *p; 3889 3890 p = xdr_reserve_space(xdr, 16); 3891 if (!p) 3892 return nfserr_resource; 3893 *p++ = cpu_to_be32(write->wr_bytes_written); 3894 *p++ = cpu_to_be32(write->wr_how_written); 3895 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, 3896 NFS4_VERIFIER_SIZE); 3897 return 0; 3898 } 3899 3900 static __be32 3901 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr, 3902 struct nfsd4_exchange_id *exid) 3903 { 3904 struct xdr_stream *xdr = &resp->xdr; 3905 __be32 *p; 3906 char *major_id; 3907 char *server_scope; 3908 int major_id_sz; 3909 int server_scope_sz; 3910 uint64_t minor_id = 0; 3911 3912 major_id = utsname()->nodename; 3913 major_id_sz = strlen(major_id); 3914 server_scope = utsname()->nodename; 3915 server_scope_sz = strlen(server_scope); 3916 3917 p = xdr_reserve_space(xdr, 3918 8 /* eir_clientid */ + 3919 4 /* eir_sequenceid */ + 3920 4 /* eir_flags */ + 3921 4 /* spr_how */); 3922 if (!p) 3923 return nfserr_resource; 3924 3925 p = xdr_encode_opaque_fixed(p, &exid->clientid, 8); 3926 *p++ = cpu_to_be32(exid->seqid); 3927 *p++ = cpu_to_be32(exid->flags); 3928 3929 *p++ = cpu_to_be32(exid->spa_how); 3930 3931 switch (exid->spa_how) { 3932 case SP4_NONE: 3933 break; 3934 case SP4_MACH_CRED: 3935 /* spo_must_enforce bitmap: */ 3936 nfserr = nfsd4_encode_bitmap(xdr, 3937 exid->spo_must_enforce[0], 3938 exid->spo_must_enforce[1], 3939 exid->spo_must_enforce[2]); 3940 if (nfserr) 3941 return nfserr; 3942 /* spo_must_allow bitmap: */ 3943 nfserr = nfsd4_encode_bitmap(xdr, 3944 exid->spo_must_allow[0], 3945 exid->spo_must_allow[1], 3946 exid->spo_must_allow[2]); 3947 if (nfserr) 3948 return nfserr; 3949 break; 3950 default: 3951 WARN_ON_ONCE(1); 3952 } 3953 3954 p = xdr_reserve_space(xdr, 3955 8 /* so_minor_id */ + 3956 4 /* so_major_id.len */ + 3957 (XDR_QUADLEN(major_id_sz) * 4) + 3958 4 /* eir_server_scope.len */ + 3959 (XDR_QUADLEN(server_scope_sz) * 4) + 3960 4 /* eir_server_impl_id.count (0) */); 3961 if (!p) 3962 return nfserr_resource; 3963 3964 /* The server_owner struct */ 3965 p = xdr_encode_hyper(p, minor_id); /* Minor id */ 3966 /* major id */ 3967 p = xdr_encode_opaque(p, major_id, major_id_sz); 3968 3969 /* Server scope */ 3970 p = xdr_encode_opaque(p, server_scope, server_scope_sz); 3971 3972 /* Implementation id */ 3973 *p++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */ 3974 return 0; 3975 } 3976 3977 static __be32 3978 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr, 3979 struct nfsd4_create_session *sess) 3980 { 3981 struct xdr_stream *xdr = &resp->xdr; 3982 __be32 *p; 3983 3984 p = xdr_reserve_space(xdr, 24); 3985 if (!p) 3986 return nfserr_resource; 3987 p = xdr_encode_opaque_fixed(p, sess->sessionid.data, 3988 NFS4_MAX_SESSIONID_LEN); 3989 *p++ = cpu_to_be32(sess->seqid); 3990 *p++ = cpu_to_be32(sess->flags); 3991 3992 p = xdr_reserve_space(xdr, 28); 3993 if (!p) 3994 return nfserr_resource; 3995 *p++ = cpu_to_be32(0); /* headerpadsz */ 3996 *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); 3997 *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); 3998 *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); 3999 *p++ = cpu_to_be32(sess->fore_channel.maxops); 4000 *p++ = cpu_to_be32(sess->fore_channel.maxreqs); 4001 *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); 4002 4003 if (sess->fore_channel.nr_rdma_attrs) { 4004 p = xdr_reserve_space(xdr, 4); 4005 if (!p) 4006 return nfserr_resource; 4007 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); 4008 } 4009 4010 p = xdr_reserve_space(xdr, 28); 4011 if (!p) 4012 return nfserr_resource; 4013 *p++ = cpu_to_be32(0); /* headerpadsz */ 4014 *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); 4015 *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); 4016 *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); 4017 *p++ = cpu_to_be32(sess->back_channel.maxops); 4018 *p++ = cpu_to_be32(sess->back_channel.maxreqs); 4019 *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); 4020 4021 if (sess->back_channel.nr_rdma_attrs) { 4022 p = xdr_reserve_space(xdr, 4); 4023 if (!p) 4024 return nfserr_resource; 4025 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); 4026 } 4027 return 0; 4028 } 4029 4030 static __be32 4031 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr, 4032 struct nfsd4_sequence *seq) 4033 { 4034 struct xdr_stream *xdr = &resp->xdr; 4035 __be32 *p; 4036 4037 p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20); 4038 if (!p) 4039 return nfserr_resource; 4040 p = xdr_encode_opaque_fixed(p, seq->sessionid.data, 4041 NFS4_MAX_SESSIONID_LEN); 4042 *p++ = cpu_to_be32(seq->seqid); 4043 *p++ = cpu_to_be32(seq->slotid); 4044 /* Note slotid's are numbered from zero: */ 4045 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ 4046 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ 4047 *p++ = cpu_to_be32(seq->status_flags); 4048 4049 resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ 4050 return 0; 4051 } 4052 4053 static __be32 4054 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr, 4055 struct nfsd4_test_stateid *test_stateid) 4056 { 4057 struct xdr_stream *xdr = &resp->xdr; 4058 struct nfsd4_test_stateid_id *stateid, *next; 4059 __be32 *p; 4060 4061 p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids)); 4062 if (!p) 4063 return nfserr_resource; 4064 *p++ = htonl(test_stateid->ts_num_ids); 4065 4066 list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { 4067 *p++ = stateid->ts_id_status; 4068 } 4069 4070 return 0; 4071 } 4072 4073 #ifdef CONFIG_NFSD_PNFS 4074 static __be32 4075 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr, 4076 struct nfsd4_getdeviceinfo *gdev) 4077 { 4078 struct xdr_stream *xdr = &resp->xdr; 4079 const struct nfsd4_layout_ops *ops; 4080 u32 starting_len = xdr->buf->len, needed_len; 4081 __be32 *p; 4082 4083 p = xdr_reserve_space(xdr, 4); 4084 if (!p) 4085 return nfserr_resource; 4086 4087 *p++ = cpu_to_be32(gdev->gd_layout_type); 4088 4089 /* If maxcount is 0 then just update notifications */ 4090 if (gdev->gd_maxcount != 0) { 4091 ops = nfsd4_layout_ops[gdev->gd_layout_type]; 4092 nfserr = ops->encode_getdeviceinfo(xdr, gdev); 4093 if (nfserr) { 4094 /* 4095 * We don't bother to burden the layout drivers with 4096 * enforcing gd_maxcount, just tell the client to 4097 * come back with a bigger buffer if it's not enough. 4098 */ 4099 if (xdr->buf->len + 4 > gdev->gd_maxcount) 4100 goto toosmall; 4101 return nfserr; 4102 } 4103 } 4104 4105 if (gdev->gd_notify_types) { 4106 p = xdr_reserve_space(xdr, 4 + 4); 4107 if (!p) 4108 return nfserr_resource; 4109 *p++ = cpu_to_be32(1); /* bitmap length */ 4110 *p++ = cpu_to_be32(gdev->gd_notify_types); 4111 } else { 4112 p = xdr_reserve_space(xdr, 4); 4113 if (!p) 4114 return nfserr_resource; 4115 *p++ = 0; 4116 } 4117 4118 return 0; 4119 toosmall: 4120 dprintk("%s: maxcount too small\n", __func__); 4121 needed_len = xdr->buf->len + 4 /* notifications */; 4122 xdr_truncate_encode(xdr, starting_len); 4123 p = xdr_reserve_space(xdr, 4); 4124 if (!p) 4125 return nfserr_resource; 4126 *p++ = cpu_to_be32(needed_len); 4127 return nfserr_toosmall; 4128 } 4129 4130 static __be32 4131 nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr, 4132 struct nfsd4_layoutget *lgp) 4133 { 4134 struct xdr_stream *xdr = &resp->xdr; 4135 const struct nfsd4_layout_ops *ops; 4136 __be32 *p; 4137 4138 p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t)); 4139 if (!p) 4140 return nfserr_resource; 4141 4142 *p++ = cpu_to_be32(1); /* we always set return-on-close */ 4143 *p++ = cpu_to_be32(lgp->lg_sid.si_generation); 4144 p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque, 4145 sizeof(stateid_opaque_t)); 4146 4147 *p++ = cpu_to_be32(1); /* we always return a single layout */ 4148 p = xdr_encode_hyper(p, lgp->lg_seg.offset); 4149 p = xdr_encode_hyper(p, lgp->lg_seg.length); 4150 *p++ = cpu_to_be32(lgp->lg_seg.iomode); 4151 *p++ = cpu_to_be32(lgp->lg_layout_type); 4152 4153 ops = nfsd4_layout_ops[lgp->lg_layout_type]; 4154 return ops->encode_layoutget(xdr, lgp); 4155 } 4156 4157 static __be32 4158 nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr, 4159 struct nfsd4_layoutcommit *lcp) 4160 { 4161 struct xdr_stream *xdr = &resp->xdr; 4162 __be32 *p; 4163 4164 p = xdr_reserve_space(xdr, 4); 4165 if (!p) 4166 return nfserr_resource; 4167 *p++ = cpu_to_be32(lcp->lc_size_chg); 4168 if (lcp->lc_size_chg) { 4169 p = xdr_reserve_space(xdr, 8); 4170 if (!p) 4171 return nfserr_resource; 4172 p = xdr_encode_hyper(p, lcp->lc_newsize); 4173 } 4174 4175 return 0; 4176 } 4177 4178 static __be32 4179 nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr, 4180 struct nfsd4_layoutreturn *lrp) 4181 { 4182 struct xdr_stream *xdr = &resp->xdr; 4183 __be32 *p; 4184 4185 p = xdr_reserve_space(xdr, 4); 4186 if (!p) 4187 return nfserr_resource; 4188 *p++ = cpu_to_be32(lrp->lrs_present); 4189 if (lrp->lrs_present) 4190 return nfsd4_encode_stateid(xdr, &lrp->lr_sid); 4191 return 0; 4192 } 4193 #endif /* CONFIG_NFSD_PNFS */ 4194 4195 static __be32 4196 nfsd42_encode_write_res(struct nfsd4_compoundres *resp, struct nfsd42_write_res *write) 4197 { 4198 __be32 *p; 4199 4200 p = xdr_reserve_space(&resp->xdr, 4 + 8 + 4 + NFS4_VERIFIER_SIZE); 4201 if (!p) 4202 return nfserr_resource; 4203 4204 *p++ = cpu_to_be32(0); 4205 p = xdr_encode_hyper(p, write->wr_bytes_written); 4206 *p++ = cpu_to_be32(write->wr_stable_how); 4207 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, 4208 NFS4_VERIFIER_SIZE); 4209 return nfs_ok; 4210 } 4211 4212 static __be32 4213 nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, 4214 struct nfsd4_copy *copy) 4215 { 4216 __be32 *p; 4217 4218 nfserr = nfsd42_encode_write_res(resp, ©->cp_res); 4219 if (nfserr) 4220 return nfserr; 4221 4222 p = xdr_reserve_space(&resp->xdr, 4 + 4); 4223 *p++ = xdr_one; /* cr_consecutive */ 4224 *p++ = cpu_to_be32(copy->cp_synchronous); 4225 return 0; 4226 } 4227 4228 static __be32 4229 nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr, 4230 struct nfsd4_seek *seek) 4231 { 4232 __be32 *p; 4233 4234 p = xdr_reserve_space(&resp->xdr, 4 + 8); 4235 *p++ = cpu_to_be32(seek->seek_eof); 4236 p = xdr_encode_hyper(p, seek->seek_pos); 4237 4238 return 0; 4239 } 4240 4241 static __be32 4242 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p) 4243 { 4244 return nfserr; 4245 } 4246 4247 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *); 4248 4249 /* 4250 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1 4251 * since we don't need to filter out obsolete ops as this is 4252 * done in the decoding phase. 4253 */ 4254 static const nfsd4_enc nfsd4_enc_ops[] = { 4255 [OP_ACCESS] = (nfsd4_enc)nfsd4_encode_access, 4256 [OP_CLOSE] = (nfsd4_enc)nfsd4_encode_close, 4257 [OP_COMMIT] = (nfsd4_enc)nfsd4_encode_commit, 4258 [OP_CREATE] = (nfsd4_enc)nfsd4_encode_create, 4259 [OP_DELEGPURGE] = (nfsd4_enc)nfsd4_encode_noop, 4260 [OP_DELEGRETURN] = (nfsd4_enc)nfsd4_encode_noop, 4261 [OP_GETATTR] = (nfsd4_enc)nfsd4_encode_getattr, 4262 [OP_GETFH] = (nfsd4_enc)nfsd4_encode_getfh, 4263 [OP_LINK] = (nfsd4_enc)nfsd4_encode_link, 4264 [OP_LOCK] = (nfsd4_enc)nfsd4_encode_lock, 4265 [OP_LOCKT] = (nfsd4_enc)nfsd4_encode_lockt, 4266 [OP_LOCKU] = (nfsd4_enc)nfsd4_encode_locku, 4267 [OP_LOOKUP] = (nfsd4_enc)nfsd4_encode_noop, 4268 [OP_LOOKUPP] = (nfsd4_enc)nfsd4_encode_noop, 4269 [OP_NVERIFY] = (nfsd4_enc)nfsd4_encode_noop, 4270 [OP_OPEN] = (nfsd4_enc)nfsd4_encode_open, 4271 [OP_OPENATTR] = (nfsd4_enc)nfsd4_encode_noop, 4272 [OP_OPEN_CONFIRM] = (nfsd4_enc)nfsd4_encode_open_confirm, 4273 [OP_OPEN_DOWNGRADE] = (nfsd4_enc)nfsd4_encode_open_downgrade, 4274 [OP_PUTFH] = (nfsd4_enc)nfsd4_encode_noop, 4275 [OP_PUTPUBFH] = (nfsd4_enc)nfsd4_encode_noop, 4276 [OP_PUTROOTFH] = (nfsd4_enc)nfsd4_encode_noop, 4277 [OP_READ] = (nfsd4_enc)nfsd4_encode_read, 4278 [OP_READDIR] = (nfsd4_enc)nfsd4_encode_readdir, 4279 [OP_READLINK] = (nfsd4_enc)nfsd4_encode_readlink, 4280 [OP_REMOVE] = (nfsd4_enc)nfsd4_encode_remove, 4281 [OP_RENAME] = (nfsd4_enc)nfsd4_encode_rename, 4282 [OP_RENEW] = (nfsd4_enc)nfsd4_encode_noop, 4283 [OP_RESTOREFH] = (nfsd4_enc)nfsd4_encode_noop, 4284 [OP_SAVEFH] = (nfsd4_enc)nfsd4_encode_noop, 4285 [OP_SECINFO] = (nfsd4_enc)nfsd4_encode_secinfo, 4286 [OP_SETATTR] = (nfsd4_enc)nfsd4_encode_setattr, 4287 [OP_SETCLIENTID] = (nfsd4_enc)nfsd4_encode_setclientid, 4288 [OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop, 4289 [OP_VERIFY] = (nfsd4_enc)nfsd4_encode_noop, 4290 [OP_WRITE] = (nfsd4_enc)nfsd4_encode_write, 4291 [OP_RELEASE_LOCKOWNER] = (nfsd4_enc)nfsd4_encode_noop, 4292 4293 /* NFSv4.1 operations */ 4294 [OP_BACKCHANNEL_CTL] = (nfsd4_enc)nfsd4_encode_noop, 4295 [OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session, 4296 [OP_EXCHANGE_ID] = (nfsd4_enc)nfsd4_encode_exchange_id, 4297 [OP_CREATE_SESSION] = (nfsd4_enc)nfsd4_encode_create_session, 4298 [OP_DESTROY_SESSION] = (nfsd4_enc)nfsd4_encode_noop, 4299 [OP_FREE_STATEID] = (nfsd4_enc)nfsd4_encode_noop, 4300 [OP_GET_DIR_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, 4301 #ifdef CONFIG_NFSD_PNFS 4302 [OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_getdeviceinfo, 4303 [OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop, 4304 [OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_layoutcommit, 4305 [OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_layoutget, 4306 [OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_layoutreturn, 4307 #else 4308 [OP_GETDEVICEINFO] = (nfsd4_enc)nfsd4_encode_noop, 4309 [OP_GETDEVICELIST] = (nfsd4_enc)nfsd4_encode_noop, 4310 [OP_LAYOUTCOMMIT] = (nfsd4_enc)nfsd4_encode_noop, 4311 [OP_LAYOUTGET] = (nfsd4_enc)nfsd4_encode_noop, 4312 [OP_LAYOUTRETURN] = (nfsd4_enc)nfsd4_encode_noop, 4313 #endif 4314 [OP_SECINFO_NO_NAME] = (nfsd4_enc)nfsd4_encode_secinfo_no_name, 4315 [OP_SEQUENCE] = (nfsd4_enc)nfsd4_encode_sequence, 4316 [OP_SET_SSV] = (nfsd4_enc)nfsd4_encode_noop, 4317 [OP_TEST_STATEID] = (nfsd4_enc)nfsd4_encode_test_stateid, 4318 [OP_WANT_DELEGATION] = (nfsd4_enc)nfsd4_encode_noop, 4319 [OP_DESTROY_CLIENTID] = (nfsd4_enc)nfsd4_encode_noop, 4320 [OP_RECLAIM_COMPLETE] = (nfsd4_enc)nfsd4_encode_noop, 4321 4322 /* NFSv4.2 operations */ 4323 [OP_ALLOCATE] = (nfsd4_enc)nfsd4_encode_noop, 4324 [OP_COPY] = (nfsd4_enc)nfsd4_encode_copy, 4325 [OP_COPY_NOTIFY] = (nfsd4_enc)nfsd4_encode_noop, 4326 [OP_DEALLOCATE] = (nfsd4_enc)nfsd4_encode_noop, 4327 [OP_IO_ADVISE] = (nfsd4_enc)nfsd4_encode_noop, 4328 [OP_LAYOUTERROR] = (nfsd4_enc)nfsd4_encode_noop, 4329 [OP_LAYOUTSTATS] = (nfsd4_enc)nfsd4_encode_noop, 4330 [OP_OFFLOAD_CANCEL] = (nfsd4_enc)nfsd4_encode_noop, 4331 [OP_OFFLOAD_STATUS] = (nfsd4_enc)nfsd4_encode_noop, 4332 [OP_READ_PLUS] = (nfsd4_enc)nfsd4_encode_noop, 4333 [OP_SEEK] = (nfsd4_enc)nfsd4_encode_seek, 4334 [OP_WRITE_SAME] = (nfsd4_enc)nfsd4_encode_noop, 4335 [OP_CLONE] = (nfsd4_enc)nfsd4_encode_noop, 4336 }; 4337 4338 /* 4339 * Calculate whether we still have space to encode repsize bytes. 4340 * There are two considerations: 4341 * - For NFS versions >=4.1, the size of the reply must stay within 4342 * session limits 4343 * - For all NFS versions, we must stay within limited preallocated 4344 * buffer space. 4345 * 4346 * This is called before the operation is processed, so can only provide 4347 * an upper estimate. For some nonidempotent operations (such as 4348 * getattr), it's not necessarily a problem if that estimate is wrong, 4349 * as we can fail it after processing without significant side effects. 4350 */ 4351 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize) 4352 { 4353 struct xdr_buf *buf = &resp->rqstp->rq_res; 4354 struct nfsd4_slot *slot = resp->cstate.slot; 4355 4356 if (buf->len + respsize <= buf->buflen) 4357 return nfs_ok; 4358 if (!nfsd4_has_session(&resp->cstate)) 4359 return nfserr_resource; 4360 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { 4361 WARN_ON_ONCE(1); 4362 return nfserr_rep_too_big_to_cache; 4363 } 4364 return nfserr_rep_too_big; 4365 } 4366 4367 void 4368 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op) 4369 { 4370 struct xdr_stream *xdr = &resp->xdr; 4371 struct nfs4_stateowner *so = resp->cstate.replay_owner; 4372 struct svc_rqst *rqstp = resp->rqstp; 4373 const struct nfsd4_operation *opdesc = op->opdesc; 4374 int post_err_offset; 4375 nfsd4_enc encoder; 4376 __be32 *p; 4377 4378 p = xdr_reserve_space(xdr, 8); 4379 if (!p) { 4380 WARN_ON_ONCE(1); 4381 return; 4382 } 4383 *p++ = cpu_to_be32(op->opnum); 4384 post_err_offset = xdr->buf->len; 4385 4386 if (op->opnum == OP_ILLEGAL) 4387 goto status; 4388 if (op->status && opdesc && 4389 !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) 4390 goto status; 4391 BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || 4392 !nfsd4_enc_ops[op->opnum]); 4393 encoder = nfsd4_enc_ops[op->opnum]; 4394 op->status = encoder(resp, op->status, &op->u); 4395 if (opdesc && opdesc->op_release) 4396 opdesc->op_release(&op->u); 4397 xdr_commit_encode(xdr); 4398 4399 /* nfsd4_check_resp_size guarantees enough room for error status */ 4400 if (!op->status) { 4401 int space_needed = 0; 4402 if (!nfsd4_last_compound_op(rqstp)) 4403 space_needed = COMPOUND_ERR_SLACK_SPACE; 4404 op->status = nfsd4_check_resp_size(resp, space_needed); 4405 } 4406 if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) { 4407 struct nfsd4_slot *slot = resp->cstate.slot; 4408 4409 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) 4410 op->status = nfserr_rep_too_big_to_cache; 4411 else 4412 op->status = nfserr_rep_too_big; 4413 } 4414 if (op->status == nfserr_resource || 4415 op->status == nfserr_rep_too_big || 4416 op->status == nfserr_rep_too_big_to_cache) { 4417 /* 4418 * The operation may have already been encoded or 4419 * partially encoded. No op returns anything additional 4420 * in the case of one of these three errors, so we can 4421 * just truncate back to after the status. But it's a 4422 * bug if we had to do this on a non-idempotent op: 4423 */ 4424 warn_on_nonidempotent_op(op); 4425 xdr_truncate_encode(xdr, post_err_offset); 4426 } 4427 if (so) { 4428 int len = xdr->buf->len - post_err_offset; 4429 4430 so->so_replay.rp_status = op->status; 4431 so->so_replay.rp_buflen = len; 4432 read_bytes_from_xdr_buf(xdr->buf, post_err_offset, 4433 so->so_replay.rp_buf, len); 4434 } 4435 status: 4436 /* Note that op->status is already in network byte order: */ 4437 write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4); 4438 } 4439 4440 /* 4441 * Encode the reply stored in the stateowner reply cache 4442 * 4443 * XDR note: do not encode rp->rp_buflen: the buffer contains the 4444 * previously sent already encoded operation. 4445 */ 4446 void 4447 nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op) 4448 { 4449 __be32 *p; 4450 struct nfs4_replay *rp = op->replay; 4451 4452 BUG_ON(!rp); 4453 4454 p = xdr_reserve_space(xdr, 8 + rp->rp_buflen); 4455 if (!p) { 4456 WARN_ON_ONCE(1); 4457 return; 4458 } 4459 *p++ = cpu_to_be32(op->opnum); 4460 *p++ = rp->rp_status; /* already xdr'ed */ 4461 4462 p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen); 4463 } 4464 4465 int 4466 nfs4svc_encode_voidres(struct svc_rqst *rqstp, __be32 *p) 4467 { 4468 return xdr_ressize_check(rqstp, p); 4469 } 4470 4471 void nfsd4_release_compoundargs(struct svc_rqst *rqstp) 4472 { 4473 struct nfsd4_compoundargs *args = rqstp->rq_argp; 4474 4475 if (args->ops != args->iops) { 4476 kfree(args->ops); 4477 args->ops = args->iops; 4478 } 4479 kfree(args->tmpp); 4480 args->tmpp = NULL; 4481 while (args->to_free) { 4482 struct svcxdr_tmpbuf *tb = args->to_free; 4483 args->to_free = tb->next; 4484 kfree(tb); 4485 } 4486 } 4487 4488 int 4489 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, __be32 *p) 4490 { 4491 struct nfsd4_compoundargs *args = rqstp->rq_argp; 4492 4493 if (rqstp->rq_arg.head[0].iov_len % 4) { 4494 /* client is nuts */ 4495 dprintk("%s: compound not properly padded! (peeraddr=%pISc xid=0x%x)", 4496 __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid)); 4497 return 0; 4498 } 4499 args->p = p; 4500 args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len; 4501 args->pagelist = rqstp->rq_arg.pages; 4502 args->pagelen = rqstp->rq_arg.page_len; 4503 args->tail = false; 4504 args->tmpp = NULL; 4505 args->to_free = NULL; 4506 args->ops = args->iops; 4507 args->rqstp = rqstp; 4508 4509 return !nfsd4_decode_compound(args); 4510 } 4511 4512 int 4513 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, __be32 *p) 4514 { 4515 /* 4516 * All that remains is to write the tag and operation count... 4517 */ 4518 struct nfsd4_compoundres *resp = rqstp->rq_resp; 4519 struct xdr_buf *buf = resp->xdr.buf; 4520 4521 WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len + 4522 buf->tail[0].iov_len); 4523 4524 rqstp->rq_next_page = resp->xdr.page_ptr + 1; 4525 4526 p = resp->tagp; 4527 *p++ = htonl(resp->taglen); 4528 memcpy(p, resp->tag, resp->taglen); 4529 p += XDR_QUADLEN(resp->taglen); 4530 *p++ = htonl(resp->opcnt); 4531 4532 nfsd4_sequence_done(resp); 4533 return 1; 4534 } 4535 4536 /* 4537 * Local variables: 4538 * c-basic-offset: 8 4539 * End: 4540 */ 4541