1 /* 2 * fs/nfsd/nfs4proc.c 3 * 4 * Server-side procedures for NFSv4. 5 * 6 * Copyright (c) 2002 The Regents of the University of Michigan. 7 * All rights reserved. 8 * 9 * Kendrick Smith <kmsmith@umich.edu> 10 * Andy Adamson <andros@umich.edu> 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 #include <linux/param.h> 39 #include <linux/major.h> 40 #include <linux/slab.h> 41 #include <linux/file.h> 42 43 #include <linux/sunrpc/svc.h> 44 #include <linux/nfsd/nfsd.h> 45 #include <linux/nfsd/cache.h> 46 #include <linux/nfs4.h> 47 #include <linux/nfsd/state.h> 48 #include <linux/nfsd/xdr4.h> 49 #include <linux/nfs4_acl.h> 50 #include <linux/sunrpc/gss_api.h> 51 52 #define NFSDDBG_FACILITY NFSDDBG_PROC 53 54 static u32 nfsd_attrmask[] = { 55 NFSD_WRITEABLE_ATTRS_WORD0, 56 NFSD_WRITEABLE_ATTRS_WORD1, 57 NFSD_WRITEABLE_ATTRS_WORD2 58 }; 59 60 static u32 nfsd41_ex_attrmask[] = { 61 NFSD_SUPPATTR_EXCLCREAT_WORD0, 62 NFSD_SUPPATTR_EXCLCREAT_WORD1, 63 NFSD_SUPPATTR_EXCLCREAT_WORD2 64 }; 65 66 static __be32 67 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 68 u32 *bmval, u32 *writable) 69 { 70 struct dentry *dentry = cstate->current_fh.fh_dentry; 71 72 /* 73 * Check about attributes are supported by the NFSv4 server or not. 74 * According to spec, unsupported attributes return ERR_ATTRNOTSUPP. 75 */ 76 if ((bmval[0] & ~nfsd_suppattrs0(cstate->minorversion)) || 77 (bmval[1] & ~nfsd_suppattrs1(cstate->minorversion)) || 78 (bmval[2] & ~nfsd_suppattrs2(cstate->minorversion))) 79 return nfserr_attrnotsupp; 80 81 /* 82 * Check FATTR4_WORD0_ACL can be supported 83 * in current environment or not. 84 */ 85 if (bmval[0] & FATTR4_WORD0_ACL) { 86 if (!IS_POSIXACL(dentry->d_inode)) 87 return nfserr_attrnotsupp; 88 } 89 90 /* 91 * According to spec, read-only attributes return ERR_INVAL. 92 */ 93 if (writable) { 94 if ((bmval[0] & ~writable[0]) || (bmval[1] & ~writable[1]) || 95 (bmval[2] & ~writable[2])) 96 return nfserr_inval; 97 } 98 99 return nfs_ok; 100 } 101 102 static __be32 103 nfsd4_check_open_attributes(struct svc_rqst *rqstp, 104 struct nfsd4_compound_state *cstate, struct nfsd4_open *open) 105 { 106 __be32 status = nfs_ok; 107 108 if (open->op_create == NFS4_OPEN_CREATE) { 109 if (open->op_createmode == NFS4_CREATE_UNCHECKED 110 || open->op_createmode == NFS4_CREATE_GUARDED) 111 status = check_attr_support(rqstp, cstate, 112 open->op_bmval, nfsd_attrmask); 113 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) 114 status = check_attr_support(rqstp, cstate, 115 open->op_bmval, nfsd41_ex_attrmask); 116 } 117 118 return status; 119 } 120 121 static int 122 is_create_with_attrs(struct nfsd4_open *open) 123 { 124 return open->op_create == NFS4_OPEN_CREATE 125 && (open->op_createmode == NFS4_CREATE_UNCHECKED 126 || open->op_createmode == NFS4_CREATE_GUARDED 127 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); 128 } 129 130 /* 131 * if error occurs when setting the acl, just clear the acl bit 132 * in the returned attr bitmap. 133 */ 134 static void 135 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp, 136 struct nfs4_acl *acl, u32 *bmval) 137 { 138 __be32 status; 139 140 status = nfsd4_set_nfs4_acl(rqstp, fhp, acl); 141 if (status) 142 /* 143 * We should probably fail the whole open at this point, 144 * but we've already created the file, so it's too late; 145 * So this seems the least of evils: 146 */ 147 bmval[0] &= ~FATTR4_WORD0_ACL; 148 } 149 150 static inline void 151 fh_dup2(struct svc_fh *dst, struct svc_fh *src) 152 { 153 fh_put(dst); 154 dget(src->fh_dentry); 155 if (src->fh_export) 156 cache_get(&src->fh_export->h); 157 *dst = *src; 158 } 159 160 static __be32 161 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode) 162 { 163 __be32 status; 164 165 if (open->op_truncate && 166 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) 167 return nfserr_inval; 168 169 if (open->op_share_access & NFS4_SHARE_ACCESS_READ) 170 accmode |= NFSD_MAY_READ; 171 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) 172 accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC); 173 if (open->op_share_deny & NFS4_SHARE_DENY_WRITE) 174 accmode |= NFSD_MAY_WRITE; 175 176 status = fh_verify(rqstp, current_fh, S_IFREG, accmode); 177 178 return status; 179 } 180 181 static __be32 182 do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 183 { 184 struct svc_fh resfh; 185 __be32 status; 186 int created = 0; 187 188 fh_init(&resfh, NFS4_FHSIZE); 189 open->op_truncate = 0; 190 191 if (open->op_create) { 192 /* FIXME: check session persistence and pnfs flags. 193 * The nfsv4.1 spec requires the following semantics: 194 * 195 * Persistent | pNFS | Server REQUIRED | Client Allowed 196 * Reply Cache | server | | 197 * -------------+--------+-----------------+-------------------- 198 * no | no | EXCLUSIVE4_1 | EXCLUSIVE4_1 199 * | | | (SHOULD) 200 * | | and EXCLUSIVE4 | or EXCLUSIVE4 201 * | | | (SHOULD NOT) 202 * no | yes | EXCLUSIVE4_1 | EXCLUSIVE4_1 203 * yes | no | GUARDED4 | GUARDED4 204 * yes | yes | GUARDED4 | GUARDED4 205 */ 206 207 /* 208 * Note: create modes (UNCHECKED,GUARDED...) are the same 209 * in NFSv4 as in v3. 210 */ 211 status = nfsd_create_v3(rqstp, current_fh, open->op_fname.data, 212 open->op_fname.len, &open->op_iattr, 213 &resfh, open->op_createmode, 214 (u32 *)open->op_verf.data, 215 &open->op_truncate, &created); 216 217 /* 218 * Following rfc 3530 14.2.16, use the returned bitmask 219 * to indicate which attributes we used to store the 220 * verifier: 221 */ 222 if (open->op_createmode == NFS4_CREATE_EXCLUSIVE && status == 0) 223 open->op_bmval[1] = (FATTR4_WORD1_TIME_ACCESS | 224 FATTR4_WORD1_TIME_MODIFY); 225 } else { 226 status = nfsd_lookup(rqstp, current_fh, 227 open->op_fname.data, open->op_fname.len, &resfh); 228 fh_unlock(current_fh); 229 } 230 if (status) 231 goto out; 232 233 if (is_create_with_attrs(open) && open->op_acl != NULL) 234 do_set_nfs4_acl(rqstp, &resfh, open->op_acl, open->op_bmval); 235 236 set_change_info(&open->op_cinfo, current_fh); 237 fh_dup2(current_fh, &resfh); 238 239 /* set reply cache */ 240 fh_copy_shallow(&open->op_stateowner->so_replay.rp_openfh, 241 &resfh.fh_handle); 242 if (!created) 243 status = do_open_permission(rqstp, current_fh, open, 244 NFSD_MAY_NOP); 245 246 out: 247 fh_put(&resfh); 248 return status; 249 } 250 251 static __be32 252 do_open_fhandle(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open) 253 { 254 __be32 status; 255 256 /* Only reclaims from previously confirmed clients are valid */ 257 if ((status = nfs4_check_open_reclaim(&open->op_clientid))) 258 return status; 259 260 /* We don't know the target directory, and therefore can not 261 * set the change info 262 */ 263 264 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); 265 266 /* set replay cache */ 267 fh_copy_shallow(&open->op_stateowner->so_replay.rp_openfh, 268 ¤t_fh->fh_handle); 269 270 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && 271 (open->op_iattr.ia_size == 0); 272 273 status = do_open_permission(rqstp, current_fh, open, 274 NFSD_MAY_OWNER_OVERRIDE); 275 276 return status; 277 } 278 279 static void 280 copy_clientid(clientid_t *clid, struct nfsd4_session *session) 281 { 282 struct nfsd4_sessionid *sid = 283 (struct nfsd4_sessionid *)session->se_sessionid.data; 284 285 clid->cl_boot = sid->clientid.cl_boot; 286 clid->cl_id = sid->clientid.cl_id; 287 } 288 289 static __be32 290 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 291 struct nfsd4_open *open) 292 { 293 __be32 status; 294 struct nfsd4_compoundres *resp; 295 296 dprintk("NFSD: nfsd4_open filename %.*s op_stateowner %p\n", 297 (int)open->op_fname.len, open->op_fname.data, 298 open->op_stateowner); 299 300 /* This check required by spec. */ 301 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) 302 return nfserr_inval; 303 304 if (nfsd4_has_session(cstate)) 305 copy_clientid(&open->op_clientid, cstate->session); 306 307 nfs4_lock_state(); 308 309 /* check seqid for replay. set nfs4_owner */ 310 resp = rqstp->rq_resp; 311 status = nfsd4_process_open1(&resp->cstate, open); 312 if (status == nfserr_replay_me) { 313 struct nfs4_replay *rp = &open->op_stateowner->so_replay; 314 fh_put(&cstate->current_fh); 315 fh_copy_shallow(&cstate->current_fh.fh_handle, 316 &rp->rp_openfh); 317 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 318 if (status) 319 dprintk("nfsd4_open: replay failed" 320 " restoring previous filehandle\n"); 321 else 322 status = nfserr_replay_me; 323 } 324 if (status) 325 goto out; 326 327 status = nfsd4_check_open_attributes(rqstp, cstate, open); 328 if (status) 329 goto out; 330 331 /* Openowner is now set, so sequence id will get bumped. Now we need 332 * these checks before we do any creates: */ 333 status = nfserr_grace; 334 if (locks_in_grace() && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) 335 goto out; 336 status = nfserr_no_grace; 337 if (!locks_in_grace() && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) 338 goto out; 339 340 switch (open->op_claim_type) { 341 case NFS4_OPEN_CLAIM_DELEGATE_CUR: 342 case NFS4_OPEN_CLAIM_NULL: 343 /* 344 * (1) set CURRENT_FH to the file being opened, 345 * creating it if necessary, (2) set open->op_cinfo, 346 * (3) set open->op_truncate if the file is to be 347 * truncated after opening, (4) do permission checking. 348 */ 349 status = do_open_lookup(rqstp, &cstate->current_fh, 350 open); 351 if (status) 352 goto out; 353 break; 354 case NFS4_OPEN_CLAIM_PREVIOUS: 355 open->op_stateowner->so_confirmed = 1; 356 /* 357 * The CURRENT_FH is already set to the file being 358 * opened. (1) set open->op_cinfo, (2) set 359 * open->op_truncate if the file is to be truncated 360 * after opening, (3) do permission checking. 361 */ 362 status = do_open_fhandle(rqstp, &cstate->current_fh, 363 open); 364 if (status) 365 goto out; 366 break; 367 case NFS4_OPEN_CLAIM_DELEGATE_PREV: 368 open->op_stateowner->so_confirmed = 1; 369 dprintk("NFSD: unsupported OPEN claim type %d\n", 370 open->op_claim_type); 371 status = nfserr_notsupp; 372 goto out; 373 default: 374 dprintk("NFSD: Invalid OPEN claim type %d\n", 375 open->op_claim_type); 376 status = nfserr_inval; 377 goto out; 378 } 379 /* 380 * nfsd4_process_open2() does the actual opening of the file. If 381 * successful, it (1) truncates the file if open->op_truncate was 382 * set, (2) sets open->op_stateid, (3) sets open->op_delegation. 383 */ 384 status = nfsd4_process_open2(rqstp, &cstate->current_fh, open); 385 out: 386 if (open->op_stateowner) { 387 nfs4_get_stateowner(open->op_stateowner); 388 cstate->replay_owner = open->op_stateowner; 389 } 390 nfs4_unlock_state(); 391 return status; 392 } 393 394 /* 395 * filehandle-manipulating ops. 396 */ 397 static __be32 398 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 399 struct svc_fh **getfh) 400 { 401 if (!cstate->current_fh.fh_dentry) 402 return nfserr_nofilehandle; 403 404 *getfh = &cstate->current_fh; 405 return nfs_ok; 406 } 407 408 static __be32 409 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 410 struct nfsd4_putfh *putfh) 411 { 412 fh_put(&cstate->current_fh); 413 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; 414 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, 415 putfh->pf_fhlen); 416 return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 417 } 418 419 static __be32 420 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 421 void *arg) 422 { 423 __be32 status; 424 425 fh_put(&cstate->current_fh); 426 status = exp_pseudoroot(rqstp, &cstate->current_fh); 427 return status; 428 } 429 430 static __be32 431 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 432 void *arg) 433 { 434 if (!cstate->save_fh.fh_dentry) 435 return nfserr_restorefh; 436 437 fh_dup2(&cstate->current_fh, &cstate->save_fh); 438 return nfs_ok; 439 } 440 441 static __be32 442 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 443 void *arg) 444 { 445 if (!cstate->current_fh.fh_dentry) 446 return nfserr_nofilehandle; 447 448 fh_dup2(&cstate->save_fh, &cstate->current_fh); 449 return nfs_ok; 450 } 451 452 /* 453 * misc nfsv4 ops 454 */ 455 static __be32 456 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 457 struct nfsd4_access *access) 458 { 459 if (access->ac_req_access & ~NFS3_ACCESS_FULL) 460 return nfserr_inval; 461 462 access->ac_resp_access = access->ac_req_access; 463 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, 464 &access->ac_supported); 465 } 466 467 static __be32 468 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 469 struct nfsd4_commit *commit) 470 { 471 __be32 status; 472 473 u32 *p = (u32 *)commit->co_verf.data; 474 *p++ = nfssvc_boot.tv_sec; 475 *p++ = nfssvc_boot.tv_usec; 476 477 status = nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, 478 commit->co_count); 479 if (status == nfserr_symlink) 480 status = nfserr_inval; 481 return status; 482 } 483 484 static __be32 485 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 486 struct nfsd4_create *create) 487 { 488 struct svc_fh resfh; 489 __be32 status; 490 dev_t rdev; 491 492 fh_init(&resfh, NFS4_FHSIZE); 493 494 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, 495 NFSD_MAY_CREATE); 496 if (status == nfserr_symlink) 497 status = nfserr_notdir; 498 if (status) 499 return status; 500 501 status = check_attr_support(rqstp, cstate, create->cr_bmval, 502 nfsd_attrmask); 503 if (status) 504 return status; 505 506 switch (create->cr_type) { 507 case NF4LNK: 508 /* ugh! we have to null-terminate the linktext, or 509 * vfs_symlink() will choke. it is always safe to 510 * null-terminate by brute force, since at worst we 511 * will overwrite the first byte of the create namelen 512 * in the XDR buffer, which has already been extracted 513 * during XDR decode. 514 */ 515 create->cr_linkname[create->cr_linklen] = 0; 516 517 status = nfsd_symlink(rqstp, &cstate->current_fh, 518 create->cr_name, create->cr_namelen, 519 create->cr_linkname, create->cr_linklen, 520 &resfh, &create->cr_iattr); 521 break; 522 523 case NF4BLK: 524 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 525 if (MAJOR(rdev) != create->cr_specdata1 || 526 MINOR(rdev) != create->cr_specdata2) 527 return nfserr_inval; 528 status = nfsd_create(rqstp, &cstate->current_fh, 529 create->cr_name, create->cr_namelen, 530 &create->cr_iattr, S_IFBLK, rdev, &resfh); 531 break; 532 533 case NF4CHR: 534 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); 535 if (MAJOR(rdev) != create->cr_specdata1 || 536 MINOR(rdev) != create->cr_specdata2) 537 return nfserr_inval; 538 status = nfsd_create(rqstp, &cstate->current_fh, 539 create->cr_name, create->cr_namelen, 540 &create->cr_iattr,S_IFCHR, rdev, &resfh); 541 break; 542 543 case NF4SOCK: 544 status = nfsd_create(rqstp, &cstate->current_fh, 545 create->cr_name, create->cr_namelen, 546 &create->cr_iattr, S_IFSOCK, 0, &resfh); 547 break; 548 549 case NF4FIFO: 550 status = nfsd_create(rqstp, &cstate->current_fh, 551 create->cr_name, create->cr_namelen, 552 &create->cr_iattr, S_IFIFO, 0, &resfh); 553 break; 554 555 case NF4DIR: 556 create->cr_iattr.ia_valid &= ~ATTR_SIZE; 557 status = nfsd_create(rqstp, &cstate->current_fh, 558 create->cr_name, create->cr_namelen, 559 &create->cr_iattr, S_IFDIR, 0, &resfh); 560 break; 561 562 default: 563 status = nfserr_badtype; 564 } 565 566 if (status) 567 goto out; 568 569 if (create->cr_acl != NULL) 570 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, 571 create->cr_bmval); 572 573 fh_unlock(&cstate->current_fh); 574 set_change_info(&create->cr_cinfo, &cstate->current_fh); 575 fh_dup2(&cstate->current_fh, &resfh); 576 out: 577 fh_put(&resfh); 578 return status; 579 } 580 581 static __be32 582 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 583 struct nfsd4_getattr *getattr) 584 { 585 __be32 status; 586 587 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 588 if (status) 589 return status; 590 591 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 592 return nfserr_inval; 593 594 getattr->ga_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 595 getattr->ga_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 596 getattr->ga_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 597 598 getattr->ga_fhp = &cstate->current_fh; 599 return nfs_ok; 600 } 601 602 static __be32 603 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 604 struct nfsd4_link *link) 605 { 606 __be32 status = nfserr_nofilehandle; 607 608 if (!cstate->save_fh.fh_dentry) 609 return status; 610 status = nfsd_link(rqstp, &cstate->current_fh, 611 link->li_name, link->li_namelen, &cstate->save_fh); 612 if (!status) 613 set_change_info(&link->li_cinfo, &cstate->current_fh); 614 return status; 615 } 616 617 static __be32 618 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 619 void *arg) 620 { 621 struct svc_fh tmp_fh; 622 __be32 ret; 623 624 fh_init(&tmp_fh, NFS4_FHSIZE); 625 ret = exp_pseudoroot(rqstp, &tmp_fh); 626 if (ret) 627 return ret; 628 if (tmp_fh.fh_dentry == cstate->current_fh.fh_dentry) { 629 fh_put(&tmp_fh); 630 return nfserr_noent; 631 } 632 fh_put(&tmp_fh); 633 return nfsd_lookup(rqstp, &cstate->current_fh, 634 "..", 2, &cstate->current_fh); 635 } 636 637 static __be32 638 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 639 struct nfsd4_lookup *lookup) 640 { 641 return nfsd_lookup(rqstp, &cstate->current_fh, 642 lookup->lo_name, lookup->lo_len, 643 &cstate->current_fh); 644 } 645 646 static __be32 647 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 648 struct nfsd4_read *read) 649 { 650 __be32 status; 651 652 /* no need to check permission - this will be done in nfsd_read() */ 653 654 read->rd_filp = NULL; 655 if (read->rd_offset >= OFFSET_MAX) 656 return nfserr_inval; 657 658 nfs4_lock_state(); 659 /* check stateid */ 660 if ((status = nfs4_preprocess_stateid_op(cstate, &read->rd_stateid, 661 RD_STATE, &read->rd_filp))) { 662 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n"); 663 goto out; 664 } 665 if (read->rd_filp) 666 get_file(read->rd_filp); 667 status = nfs_ok; 668 out: 669 nfs4_unlock_state(); 670 read->rd_rqstp = rqstp; 671 read->rd_fhp = &cstate->current_fh; 672 return status; 673 } 674 675 static __be32 676 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 677 struct nfsd4_readdir *readdir) 678 { 679 u64 cookie = readdir->rd_cookie; 680 static const nfs4_verifier zeroverf; 681 682 /* no need to check permission - this will be done in nfsd_readdir() */ 683 684 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) 685 return nfserr_inval; 686 687 readdir->rd_bmval[0] &= nfsd_suppattrs0(cstate->minorversion); 688 readdir->rd_bmval[1] &= nfsd_suppattrs1(cstate->minorversion); 689 readdir->rd_bmval[2] &= nfsd_suppattrs2(cstate->minorversion); 690 691 if ((cookie > ~(u32)0) || (cookie == 1) || (cookie == 2) || 692 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) 693 return nfserr_bad_cookie; 694 695 readdir->rd_rqstp = rqstp; 696 readdir->rd_fhp = &cstate->current_fh; 697 return nfs_ok; 698 } 699 700 static __be32 701 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 702 struct nfsd4_readlink *readlink) 703 { 704 readlink->rl_rqstp = rqstp; 705 readlink->rl_fhp = &cstate->current_fh; 706 return nfs_ok; 707 } 708 709 static __be32 710 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 711 struct nfsd4_remove *remove) 712 { 713 __be32 status; 714 715 if (locks_in_grace()) 716 return nfserr_grace; 717 status = nfsd_unlink(rqstp, &cstate->current_fh, 0, 718 remove->rm_name, remove->rm_namelen); 719 if (status == nfserr_symlink) 720 return nfserr_notdir; 721 if (!status) { 722 fh_unlock(&cstate->current_fh); 723 set_change_info(&remove->rm_cinfo, &cstate->current_fh); 724 } 725 return status; 726 } 727 728 static __be32 729 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 730 struct nfsd4_rename *rename) 731 { 732 __be32 status = nfserr_nofilehandle; 733 734 if (!cstate->save_fh.fh_dentry) 735 return status; 736 if (locks_in_grace() && !(cstate->save_fh.fh_export->ex_flags 737 & NFSEXP_NOSUBTREECHECK)) 738 return nfserr_grace; 739 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, 740 rename->rn_snamelen, &cstate->current_fh, 741 rename->rn_tname, rename->rn_tnamelen); 742 743 /* the underlying filesystem returns different error's than required 744 * by NFSv4. both save_fh and current_fh have been verified.. */ 745 if (status == nfserr_isdir) 746 status = nfserr_exist; 747 else if ((status == nfserr_notdir) && 748 (S_ISDIR(cstate->save_fh.fh_dentry->d_inode->i_mode) && 749 S_ISDIR(cstate->current_fh.fh_dentry->d_inode->i_mode))) 750 status = nfserr_exist; 751 else if (status == nfserr_symlink) 752 status = nfserr_notdir; 753 754 if (!status) { 755 set_change_info(&rename->rn_sinfo, &cstate->current_fh); 756 set_change_info(&rename->rn_tinfo, &cstate->save_fh); 757 } 758 return status; 759 } 760 761 static __be32 762 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 763 struct nfsd4_secinfo *secinfo) 764 { 765 struct svc_fh resfh; 766 struct svc_export *exp; 767 struct dentry *dentry; 768 __be32 err; 769 770 fh_init(&resfh, NFS4_FHSIZE); 771 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, 772 secinfo->si_name, secinfo->si_namelen, 773 &exp, &dentry); 774 if (err) 775 return err; 776 if (dentry->d_inode == NULL) { 777 exp_put(exp); 778 err = nfserr_noent; 779 } else 780 secinfo->si_exp = exp; 781 dput(dentry); 782 return err; 783 } 784 785 static __be32 786 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 787 struct nfsd4_setattr *setattr) 788 { 789 __be32 status = nfs_ok; 790 791 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { 792 nfs4_lock_state(); 793 status = nfs4_preprocess_stateid_op(cstate, 794 &setattr->sa_stateid, WR_STATE, NULL); 795 nfs4_unlock_state(); 796 if (status) { 797 dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n"); 798 return status; 799 } 800 } 801 status = mnt_want_write(cstate->current_fh.fh_export->ex_path.mnt); 802 if (status) 803 return status; 804 status = nfs_ok; 805 806 status = check_attr_support(rqstp, cstate, setattr->sa_bmval, 807 nfsd_attrmask); 808 if (status) 809 goto out; 810 811 if (setattr->sa_acl != NULL) 812 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, 813 setattr->sa_acl); 814 if (status) 815 goto out; 816 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, 817 0, (time_t)0); 818 out: 819 mnt_drop_write(cstate->current_fh.fh_export->ex_path.mnt); 820 return status; 821 } 822 823 static __be32 824 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 825 struct nfsd4_write *write) 826 { 827 stateid_t *stateid = &write->wr_stateid; 828 struct file *filp = NULL; 829 u32 *p; 830 __be32 status = nfs_ok; 831 unsigned long cnt; 832 833 /* no need to check permission - this will be done in nfsd_write() */ 834 835 if (write->wr_offset >= OFFSET_MAX) 836 return nfserr_inval; 837 838 nfs4_lock_state(); 839 status = nfs4_preprocess_stateid_op(cstate, stateid, WR_STATE, &filp); 840 if (filp) 841 get_file(filp); 842 nfs4_unlock_state(); 843 844 if (status) { 845 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n"); 846 return status; 847 } 848 849 cnt = write->wr_buflen; 850 write->wr_how_written = write->wr_stable_how; 851 p = (u32 *)write->wr_verifier.data; 852 *p++ = nfssvc_boot.tv_sec; 853 *p++ = nfssvc_boot.tv_usec; 854 855 status = nfsd_write(rqstp, &cstate->current_fh, filp, 856 write->wr_offset, rqstp->rq_vec, write->wr_vlen, 857 &cnt, &write->wr_how_written); 858 if (filp) 859 fput(filp); 860 861 write->wr_bytes_written = cnt; 862 863 if (status == nfserr_symlink) 864 status = nfserr_inval; 865 return status; 866 } 867 868 /* This routine never returns NFS_OK! If there are no other errors, it 869 * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the 870 * attributes matched. VERIFY is implemented by mapping NFSERR_SAME 871 * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK. 872 */ 873 static __be32 874 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 875 struct nfsd4_verify *verify) 876 { 877 __be32 *buf, *p; 878 int count; 879 __be32 status; 880 881 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); 882 if (status) 883 return status; 884 885 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); 886 if (status) 887 return status; 888 889 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) 890 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) 891 return nfserr_inval; 892 if (verify->ve_attrlen & 3) 893 return nfserr_inval; 894 895 /* count in words: 896 * bitmap_len(1) + bitmap(2) + attr_len(1) = 4 897 */ 898 count = 4 + (verify->ve_attrlen >> 2); 899 buf = kmalloc(count << 2, GFP_KERNEL); 900 if (!buf) 901 return nfserr_resource; 902 903 status = nfsd4_encode_fattr(&cstate->current_fh, 904 cstate->current_fh.fh_export, 905 cstate->current_fh.fh_dentry, buf, 906 &count, verify->ve_bmval, 907 rqstp, 0); 908 909 /* this means that nfsd4_encode_fattr() ran out of space */ 910 if (status == nfserr_resource && count == 0) 911 status = nfserr_not_same; 912 if (status) 913 goto out_kfree; 914 915 /* skip bitmap */ 916 p = buf + 1 + ntohl(buf[0]); 917 status = nfserr_not_same; 918 if (ntohl(*p++) != verify->ve_attrlen) 919 goto out_kfree; 920 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) 921 status = nfserr_same; 922 923 out_kfree: 924 kfree(buf); 925 return status; 926 } 927 928 static __be32 929 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 930 struct nfsd4_verify *verify) 931 { 932 __be32 status; 933 934 status = _nfsd4_verify(rqstp, cstate, verify); 935 return status == nfserr_not_same ? nfs_ok : status; 936 } 937 938 static __be32 939 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 940 struct nfsd4_verify *verify) 941 { 942 __be32 status; 943 944 status = _nfsd4_verify(rqstp, cstate, verify); 945 return status == nfserr_same ? nfs_ok : status; 946 } 947 948 /* 949 * NULL call. 950 */ 951 static __be32 952 nfsd4_proc_null(struct svc_rqst *rqstp, void *argp, void *resp) 953 { 954 return nfs_ok; 955 } 956 957 static inline void nfsd4_increment_op_stats(u32 opnum) 958 { 959 if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP) 960 nfsdstats.nfs4_opcount[opnum]++; 961 } 962 963 typedef __be32(*nfsd4op_func)(struct svc_rqst *, struct nfsd4_compound_state *, 964 void *); 965 enum nfsd4_op_flags { 966 ALLOWED_WITHOUT_FH = 1 << 0, /* No current filehandle required */ 967 ALLOWED_ON_ABSENT_FS = 2 << 0, /* ops processed on absent fs */ 968 ALLOWED_AS_FIRST_OP = 3 << 0, /* ops reqired first in compound */ 969 }; 970 971 struct nfsd4_operation { 972 nfsd4op_func op_func; 973 u32 op_flags; 974 char *op_name; 975 }; 976 977 static struct nfsd4_operation nfsd4_ops[]; 978 979 static const char *nfsd4_op_name(unsigned opnum); 980 981 /* 982 * Enforce NFSv4.1 COMPOUND ordering rules. 983 * 984 * TODO: 985 * - enforce NFS4ERR_NOT_ONLY_OP, 986 * - DESTROY_SESSION MUST be the final operation in the COMPOUND request. 987 */ 988 static bool nfs41_op_ordering_ok(struct nfsd4_compoundargs *args) 989 { 990 if (args->minorversion && args->opcnt > 0) { 991 struct nfsd4_op *op = &args->ops[0]; 992 return (op->status == nfserr_op_illegal) || 993 (nfsd4_ops[op->opnum].op_flags & ALLOWED_AS_FIRST_OP); 994 } 995 return true; 996 } 997 998 /* 999 * COMPOUND call. 1000 */ 1001 static __be32 1002 nfsd4_proc_compound(struct svc_rqst *rqstp, 1003 struct nfsd4_compoundargs *args, 1004 struct nfsd4_compoundres *resp) 1005 { 1006 struct nfsd4_op *op; 1007 struct nfsd4_operation *opdesc; 1008 struct nfsd4_compound_state *cstate = &resp->cstate; 1009 int slack_bytes; 1010 __be32 status; 1011 1012 resp->xbuf = &rqstp->rq_res; 1013 resp->p = rqstp->rq_res.head[0].iov_base + 1014 rqstp->rq_res.head[0].iov_len; 1015 resp->tagp = resp->p; 1016 /* reserve space for: taglen, tag, and opcnt */ 1017 resp->p += 2 + XDR_QUADLEN(args->taglen); 1018 resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE; 1019 resp->taglen = args->taglen; 1020 resp->tag = args->tag; 1021 resp->opcnt = 0; 1022 resp->rqstp = rqstp; 1023 resp->cstate.minorversion = args->minorversion; 1024 resp->cstate.replay_owner = NULL; 1025 fh_init(&resp->cstate.current_fh, NFS4_FHSIZE); 1026 fh_init(&resp->cstate.save_fh, NFS4_FHSIZE); 1027 /* Use the deferral mechanism only for NFSv4.0 compounds */ 1028 rqstp->rq_usedeferral = (args->minorversion == 0); 1029 1030 /* 1031 * According to RFC3010, this takes precedence over all other errors. 1032 */ 1033 status = nfserr_minor_vers_mismatch; 1034 if (args->minorversion > nfsd_supported_minorversion) 1035 goto out; 1036 1037 if (!nfs41_op_ordering_ok(args)) { 1038 op = &args->ops[0]; 1039 op->status = nfserr_sequence_pos; 1040 goto encode_op; 1041 } 1042 1043 status = nfs_ok; 1044 while (!status && resp->opcnt < args->opcnt) { 1045 op = &args->ops[resp->opcnt++]; 1046 1047 dprintk("nfsv4 compound op #%d/%d: %d (%s)\n", 1048 resp->opcnt, args->opcnt, op->opnum, 1049 nfsd4_op_name(op->opnum)); 1050 /* 1051 * The XDR decode routines may have pre-set op->status; 1052 * for example, if there is a miscellaneous XDR error 1053 * it will be set to nfserr_bad_xdr. 1054 */ 1055 if (op->status) 1056 goto encode_op; 1057 1058 /* We must be able to encode a successful response to 1059 * this operation, with enough room left over to encode a 1060 * failed response to the next operation. If we don't 1061 * have enough room, fail with ERR_RESOURCE. 1062 */ 1063 slack_bytes = (char *)resp->end - (char *)resp->p; 1064 if (slack_bytes < COMPOUND_SLACK_SPACE 1065 + COMPOUND_ERR_SLACK_SPACE) { 1066 BUG_ON(slack_bytes < COMPOUND_ERR_SLACK_SPACE); 1067 op->status = nfserr_resource; 1068 goto encode_op; 1069 } 1070 1071 opdesc = &nfsd4_ops[op->opnum]; 1072 1073 if (!cstate->current_fh.fh_dentry) { 1074 if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) { 1075 op->status = nfserr_nofilehandle; 1076 goto encode_op; 1077 } 1078 } else if (cstate->current_fh.fh_export->ex_fslocs.migrated && 1079 !(opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { 1080 op->status = nfserr_moved; 1081 goto encode_op; 1082 } 1083 1084 if (opdesc->op_func) 1085 op->status = opdesc->op_func(rqstp, cstate, &op->u); 1086 else 1087 BUG_ON(op->status == nfs_ok); 1088 1089 encode_op: 1090 /* Only from SEQUENCE */ 1091 if (resp->cstate.status == nfserr_replay_cache) { 1092 dprintk("%s NFS4.1 replay from cache\n", __func__); 1093 status = op->status; 1094 goto out; 1095 } 1096 if (op->status == nfserr_replay_me) { 1097 op->replay = &cstate->replay_owner->so_replay; 1098 nfsd4_encode_replay(resp, op); 1099 status = op->status = op->replay->rp_status; 1100 } else { 1101 nfsd4_encode_operation(resp, op); 1102 status = op->status; 1103 } 1104 1105 dprintk("nfsv4 compound op %p opcnt %d #%d: %d: status %d\n", 1106 args->ops, args->opcnt, resp->opcnt, op->opnum, 1107 be32_to_cpu(status)); 1108 1109 if (cstate->replay_owner) { 1110 nfs4_put_stateowner(cstate->replay_owner); 1111 cstate->replay_owner = NULL; 1112 } 1113 /* XXX Ugh, we need to get rid of this kind of special case: */ 1114 if (op->opnum == OP_READ && op->u.read.rd_filp) 1115 fput(op->u.read.rd_filp); 1116 1117 nfsd4_increment_op_stats(op->opnum); 1118 } 1119 if (!rqstp->rq_usedeferral && status == nfserr_dropit) { 1120 dprintk("%s Dropit - send NFS4ERR_DELAY\n", __func__); 1121 status = nfserr_jukebox; 1122 } 1123 1124 resp->cstate.status = status; 1125 fh_put(&resp->cstate.current_fh); 1126 fh_put(&resp->cstate.save_fh); 1127 BUG_ON(resp->cstate.replay_owner); 1128 out: 1129 nfsd4_release_compoundargs(args); 1130 /* Reset deferral mechanism for RPC deferrals */ 1131 rqstp->rq_usedeferral = 1; 1132 dprintk("nfsv4 compound returned %d\n", ntohl(status)); 1133 return status; 1134 } 1135 1136 static struct nfsd4_operation nfsd4_ops[] = { 1137 [OP_ACCESS] = { 1138 .op_func = (nfsd4op_func)nfsd4_access, 1139 .op_name = "OP_ACCESS", 1140 }, 1141 [OP_CLOSE] = { 1142 .op_func = (nfsd4op_func)nfsd4_close, 1143 .op_name = "OP_CLOSE", 1144 }, 1145 [OP_COMMIT] = { 1146 .op_func = (nfsd4op_func)nfsd4_commit, 1147 .op_name = "OP_COMMIT", 1148 }, 1149 [OP_CREATE] = { 1150 .op_func = (nfsd4op_func)nfsd4_create, 1151 .op_name = "OP_CREATE", 1152 }, 1153 [OP_DELEGRETURN] = { 1154 .op_func = (nfsd4op_func)nfsd4_delegreturn, 1155 .op_name = "OP_DELEGRETURN", 1156 }, 1157 [OP_GETATTR] = { 1158 .op_func = (nfsd4op_func)nfsd4_getattr, 1159 .op_flags = ALLOWED_ON_ABSENT_FS, 1160 .op_name = "OP_GETATTR", 1161 }, 1162 [OP_GETFH] = { 1163 .op_func = (nfsd4op_func)nfsd4_getfh, 1164 .op_name = "OP_GETFH", 1165 }, 1166 [OP_LINK] = { 1167 .op_func = (nfsd4op_func)nfsd4_link, 1168 .op_name = "OP_LINK", 1169 }, 1170 [OP_LOCK] = { 1171 .op_func = (nfsd4op_func)nfsd4_lock, 1172 .op_name = "OP_LOCK", 1173 }, 1174 [OP_LOCKT] = { 1175 .op_func = (nfsd4op_func)nfsd4_lockt, 1176 .op_name = "OP_LOCKT", 1177 }, 1178 [OP_LOCKU] = { 1179 .op_func = (nfsd4op_func)nfsd4_locku, 1180 .op_name = "OP_LOCKU", 1181 }, 1182 [OP_LOOKUP] = { 1183 .op_func = (nfsd4op_func)nfsd4_lookup, 1184 .op_name = "OP_LOOKUP", 1185 }, 1186 [OP_LOOKUPP] = { 1187 .op_func = (nfsd4op_func)nfsd4_lookupp, 1188 .op_name = "OP_LOOKUPP", 1189 }, 1190 [OP_NVERIFY] = { 1191 .op_func = (nfsd4op_func)nfsd4_nverify, 1192 .op_name = "OP_NVERIFY", 1193 }, 1194 [OP_OPEN] = { 1195 .op_func = (nfsd4op_func)nfsd4_open, 1196 .op_name = "OP_OPEN", 1197 }, 1198 [OP_OPEN_CONFIRM] = { 1199 .op_func = (nfsd4op_func)nfsd4_open_confirm, 1200 .op_name = "OP_OPEN_CONFIRM", 1201 }, 1202 [OP_OPEN_DOWNGRADE] = { 1203 .op_func = (nfsd4op_func)nfsd4_open_downgrade, 1204 .op_name = "OP_OPEN_DOWNGRADE", 1205 }, 1206 [OP_PUTFH] = { 1207 .op_func = (nfsd4op_func)nfsd4_putfh, 1208 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1209 .op_name = "OP_PUTFH", 1210 }, 1211 [OP_PUTPUBFH] = { 1212 .op_func = (nfsd4op_func)nfsd4_putrootfh, 1213 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1214 .op_name = "OP_PUTPUBFH", 1215 }, 1216 [OP_PUTROOTFH] = { 1217 .op_func = (nfsd4op_func)nfsd4_putrootfh, 1218 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1219 .op_name = "OP_PUTROOTFH", 1220 }, 1221 [OP_READ] = { 1222 .op_func = (nfsd4op_func)nfsd4_read, 1223 .op_name = "OP_READ", 1224 }, 1225 [OP_READDIR] = { 1226 .op_func = (nfsd4op_func)nfsd4_readdir, 1227 .op_name = "OP_READDIR", 1228 }, 1229 [OP_READLINK] = { 1230 .op_func = (nfsd4op_func)nfsd4_readlink, 1231 .op_name = "OP_READLINK", 1232 }, 1233 [OP_REMOVE] = { 1234 .op_func = (nfsd4op_func)nfsd4_remove, 1235 .op_name = "OP_REMOVE", 1236 }, 1237 [OP_RENAME] = { 1238 .op_name = "OP_RENAME", 1239 .op_func = (nfsd4op_func)nfsd4_rename, 1240 }, 1241 [OP_RENEW] = { 1242 .op_func = (nfsd4op_func)nfsd4_renew, 1243 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1244 .op_name = "OP_RENEW", 1245 }, 1246 [OP_RESTOREFH] = { 1247 .op_func = (nfsd4op_func)nfsd4_restorefh, 1248 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1249 .op_name = "OP_RESTOREFH", 1250 }, 1251 [OP_SAVEFH] = { 1252 .op_func = (nfsd4op_func)nfsd4_savefh, 1253 .op_name = "OP_SAVEFH", 1254 }, 1255 [OP_SECINFO] = { 1256 .op_func = (nfsd4op_func)nfsd4_secinfo, 1257 .op_name = "OP_SECINFO", 1258 }, 1259 [OP_SETATTR] = { 1260 .op_func = (nfsd4op_func)nfsd4_setattr, 1261 .op_name = "OP_SETATTR", 1262 }, 1263 [OP_SETCLIENTID] = { 1264 .op_func = (nfsd4op_func)nfsd4_setclientid, 1265 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1266 .op_name = "OP_SETCLIENTID", 1267 }, 1268 [OP_SETCLIENTID_CONFIRM] = { 1269 .op_func = (nfsd4op_func)nfsd4_setclientid_confirm, 1270 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1271 .op_name = "OP_SETCLIENTID_CONFIRM", 1272 }, 1273 [OP_VERIFY] = { 1274 .op_func = (nfsd4op_func)nfsd4_verify, 1275 .op_name = "OP_VERIFY", 1276 }, 1277 [OP_WRITE] = { 1278 .op_func = (nfsd4op_func)nfsd4_write, 1279 .op_name = "OP_WRITE", 1280 }, 1281 [OP_RELEASE_LOCKOWNER] = { 1282 .op_func = (nfsd4op_func)nfsd4_release_lockowner, 1283 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS, 1284 .op_name = "OP_RELEASE_LOCKOWNER", 1285 }, 1286 1287 /* NFSv4.1 operations */ 1288 [OP_EXCHANGE_ID] = { 1289 .op_func = (nfsd4op_func)nfsd4_exchange_id, 1290 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1291 .op_name = "OP_EXCHANGE_ID", 1292 }, 1293 [OP_CREATE_SESSION] = { 1294 .op_func = (nfsd4op_func)nfsd4_create_session, 1295 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1296 .op_name = "OP_CREATE_SESSION", 1297 }, 1298 [OP_DESTROY_SESSION] = { 1299 .op_func = (nfsd4op_func)nfsd4_destroy_session, 1300 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1301 .op_name = "OP_DESTROY_SESSION", 1302 }, 1303 [OP_SEQUENCE] = { 1304 .op_func = (nfsd4op_func)nfsd4_sequence, 1305 .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP, 1306 .op_name = "OP_SEQUENCE", 1307 }, 1308 }; 1309 1310 static const char *nfsd4_op_name(unsigned opnum) 1311 { 1312 if (opnum < ARRAY_SIZE(nfsd4_ops)) 1313 return nfsd4_ops[opnum].op_name; 1314 return "unknown_operation"; 1315 } 1316 1317 #define nfsd4_voidres nfsd4_voidargs 1318 struct nfsd4_voidargs { int dummy; }; 1319 1320 /* 1321 * TODO: At the present time, the NFSv4 server does not do XID caching 1322 * of requests. Implementing XID caching would not be a serious problem, 1323 * although it would require a mild change in interfaces since one 1324 * doesn't know whether an NFSv4 request is idempotent until after the 1325 * XDR decode. However, XID caching totally confuses pynfs (Peter 1326 * Astrand's regression testsuite for NFSv4 servers), which reuses 1327 * XID's liberally, so I've left it unimplemented until pynfs generates 1328 * better XID's. 1329 */ 1330 static struct svc_procedure nfsd_procedures4[2] = { 1331 [NFSPROC4_NULL] = { 1332 .pc_func = (svc_procfunc) nfsd4_proc_null, 1333 .pc_encode = (kxdrproc_t) nfs4svc_encode_voidres, 1334 .pc_argsize = sizeof(struct nfsd4_voidargs), 1335 .pc_ressize = sizeof(struct nfsd4_voidres), 1336 .pc_cachetype = RC_NOCACHE, 1337 .pc_xdrressize = 1, 1338 }, 1339 [NFSPROC4_COMPOUND] = { 1340 .pc_func = (svc_procfunc) nfsd4_proc_compound, 1341 .pc_decode = (kxdrproc_t) nfs4svc_decode_compoundargs, 1342 .pc_encode = (kxdrproc_t) nfs4svc_encode_compoundres, 1343 .pc_argsize = sizeof(struct nfsd4_compoundargs), 1344 .pc_ressize = sizeof(struct nfsd4_compoundres), 1345 .pc_cachetype = RC_NOCACHE, 1346 .pc_xdrressize = NFSD_BUFSIZE/4, 1347 }, 1348 }; 1349 1350 struct svc_version nfsd_version4 = { 1351 .vs_vers = 4, 1352 .vs_nproc = 2, 1353 .vs_proc = nfsd_procedures4, 1354 .vs_dispatch = nfsd_dispatch, 1355 .vs_xdrsize = NFS4_SVC_XDRSIZE, 1356 }; 1357 1358 /* 1359 * Local variables: 1360 * c-basic-offset: 8 1361 * End: 1362 */ 1363