Lines Matching +full:ssc +full:- +full:range
2 * Server-side procedures for NFSv4.
71 struct inode *inode = d_inode(resfh->fh_dentry); in nfsd4_security_inode_setsecctx()
75 status = security_inode_setsecctx(resfh->fh_dentry, in nfsd4_security_inode_setsecctx()
76 label->data, label->len); in nfsd4_security_inode_setsecctx()
113 struct dentry *dentry = cstate->current_fh.fh_dentry; in check_attr_support()
114 struct svc_export *exp = cstate->current_fh.fh_export; in check_attr_support()
116 if (!nfsd_attrs_supported(cstate->minorversion, bmval)) in check_attr_support()
121 !(exp->ex_flags & NFSEXP_SECURITY_LABEL)) in check_attr_support()
137 if (open->op_create == NFS4_OPEN_CREATE) { in nfsd4_check_open_attributes()
138 if (open->op_createmode == NFS4_CREATE_UNCHECKED in nfsd4_check_open_attributes()
139 || open->op_createmode == NFS4_CREATE_GUARDED) in nfsd4_check_open_attributes()
141 open->op_bmval, nfsd_attrmask); in nfsd4_check_open_attributes()
142 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) in nfsd4_check_open_attributes()
144 open->op_bmval, nfsd41_ex_attrmask); in nfsd4_check_open_attributes()
153 return open->op_create == NFS4_OPEN_CREATE in is_create_with_attrs()
154 && (open->op_createmode == NFS4_CREATE_UNCHECKED in is_create_with_attrs()
155 || open->op_createmode == NFS4_CREATE_GUARDED in is_create_with_attrs()
156 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); in is_create_with_attrs()
183 dget(src->fh_dentry); in fh_dup2()
184 if (src->fh_export) in fh_dup2()
185 exp_get(src->fh_export); in fh_dup2()
194 if (open->op_truncate && in do_open_permission()
195 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) in do_open_permission()
200 if (open->op_share_access & NFS4_SHARE_ACCESS_READ) in do_open_permission()
202 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) in do_open_permission()
204 if (open->op_share_deny & NFS4_SHARE_DENY_READ) in do_open_permission()
214 umode_t mode = d_inode(fh->fh_dentry)->i_mode; in nfsd_check_obj_isreg()
221 * Using err_symlink as our catch-all case may look odd; but in nfsd_check_obj_isreg()
234 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, in nfsd4_set_open_owner_reply_cache()
235 &resfh->fh_handle); in nfsd4_set_open_owner_reply_cache()
241 struct svc_fh *current_fh = &cstate->current_fh; in do_open_lookup()
249 open->op_truncate = false; in do_open_lookup()
251 if (open->op_create) { in do_open_lookup()
257 * -------------+--------+-----------------+-------------------- in do_open_lookup()
271 current->fs->umask = open->op_umask; in do_open_lookup()
272 status = do_nfsd_create(rqstp, current_fh, open->op_fname, in do_open_lookup()
273 open->op_fnamelen, &open->op_iattr, in do_open_lookup()
274 *resfh, open->op_createmode, in do_open_lookup()
275 (u32 *)open->op_verf.data, in do_open_lookup()
276 &open->op_truncate, &open->op_created); in do_open_lookup()
277 current->fs->umask = 0; in do_open_lookup()
279 if (!status && open->op_label.len) in do_open_lookup()
280 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval); in do_open_lookup()
287 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0) in do_open_lookup()
288 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | in do_open_lookup()
298 open->op_fname, open->op_fnamelen, *resfh); in do_open_lookup()
305 if (is_create_with_attrs(open) && open->op_acl != NULL) in do_open_lookup()
306 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval); in do_open_lookup()
310 if (open->op_created || in do_open_lookup()
311 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) in do_open_lookup()
314 set_change_info(&open->op_cinfo, current_fh); in do_open_lookup()
322 struct svc_fh *current_fh = &cstate->current_fh; in do_open_fhandle()
330 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); in do_open_fhandle()
334 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && in do_open_fhandle()
335 (open->op_iattr.ia_size == 0); in do_open_fhandle()
345 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) in do_open_fhandle()
357 (struct nfsd4_sessionid *)session->se_sessionid.data; in copy_clientid()
359 clid->cl_boot = sid->clientid.cl_boot; in copy_clientid()
360 clid->cl_id = sid->clientid.cl_id; in copy_clientid()
367 struct nfsd4_open *open = &u->open; in nfsd4_open()
375 (int)open->op_fnamelen, open->op_fname, in nfsd4_open()
376 open->op_openowner); in nfsd4_open()
379 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) in nfsd4_open()
382 open->op_created = false; in nfsd4_open()
388 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags) && in nfsd4_open()
389 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
393 copy_clientid(&open->op_clientid, cstate->session); in nfsd4_open()
398 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; in nfsd4_open()
399 fh_put(&cstate->current_fh); in nfsd4_open()
400 fh_copy_shallow(&cstate->current_fh.fh_handle, in nfsd4_open()
401 &rp->rp_openfh); in nfsd4_open()
402 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_open()
411 if (open->op_xdr_error) { in nfsd4_open()
412 status = open->op_xdr_error; in nfsd4_open()
423 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
426 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
429 switch (open->op_claim_type) { in nfsd4_open()
437 status = nfs4_check_open_reclaim(cstate->clp); in nfsd4_open()
440 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; in nfsd4_open()
448 resfh = &cstate->current_fh; in nfsd4_open()
453 open->op_claim_type); in nfsd4_open()
458 open->op_claim_type); in nfsd4_open()
464 * successful, it (1) truncates the file if open->op_truncate was in nfsd4_open()
465 * set, (2) sets open->op_stateid, (3) sets open->op_delegation. in nfsd4_open()
468 WARN(status && open->op_created, in nfsd4_open()
469 "nfsd4_process_open2 failed to open newly-created file! status=%u\n", in nfsd4_open()
472 nn->somebody_reclaimed = true; in nfsd4_open()
474 if (resfh && resfh != &cstate->current_fh) { in nfsd4_open()
475 fh_dup2(&cstate->current_fh, resfh); in nfsd4_open()
485 * OPEN is the only seqid-mutating operation whose decoding can fail
486 * with a seqid-mutating error (specifically, decoding of user names in
492 struct nfsd4_open *open = &op->u.open; in nfsd4_open_omfg()
494 if (!seqid_mutating_err(ntohl(op->status))) in nfsd4_open_omfg()
495 return op->status; in nfsd4_open_omfg()
497 return op->status; in nfsd4_open_omfg()
498 open->op_xdr_error = op->status; in nfsd4_open_omfg()
499 return nfsd4_open(rqstp, cstate, &op->u); in nfsd4_open_omfg()
503 * filehandle-manipulating ops.
509 u->getfh = &cstate->current_fh; in nfsd4_getfh()
517 struct nfsd4_putfh *putfh = &u->putfh; in nfsd4_putfh()
520 fh_put(&cstate->current_fh); in nfsd4_putfh()
521 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; in nfsd4_putfh()
522 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, in nfsd4_putfh()
523 putfh->pf_fhlen); in nfsd4_putfh()
524 ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); in nfsd4_putfh()
526 if (ret == nfserr_stale && putfh->no_verify) { in nfsd4_putfh()
527 SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN); in nfsd4_putfh()
540 fh_put(&cstate->current_fh); in nfsd4_putrootfh()
541 status = exp_pseudoroot(rqstp, &cstate->current_fh); in nfsd4_putrootfh()
549 if (!cstate->save_fh.fh_dentry) in nfsd4_restorefh()
552 fh_dup2(&cstate->current_fh, &cstate->save_fh); in nfsd4_restorefh()
554 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); in nfsd4_restorefh()
564 fh_dup2(&cstate->save_fh, &cstate->current_fh); in nfsd4_savefh()
566 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); in nfsd4_savefh()
579 struct nfsd4_access *access = &u->access; in nfsd4_access()
583 if (cstate->minorversion >= 2) in nfsd4_access()
587 if (access->ac_req_access & ~access_full) in nfsd4_access()
590 access->ac_resp_access = access->ac_req_access; in nfsd4_access()
591 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, in nfsd4_access()
592 &access->ac_supported); in nfsd4_access()
597 __be32 *verf = (__be32 *)verifier->data; in gen_boot_verifier()
599 BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data)); in gen_boot_verifier()
608 struct nfsd4_commit *commit = &u->commit; in nfsd4_commit()
610 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, in nfsd4_commit()
611 commit->co_count, in nfsd4_commit()
612 (__be32 *)commit->co_verf.data); in nfsd4_commit()
619 struct nfsd4_create *create = &u->create; in nfsd4_create()
626 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); in nfsd4_create()
630 status = check_attr_support(rqstp, cstate, create->cr_bmval, in nfsd4_create()
635 current->fs->umask = create->cr_umask; in nfsd4_create()
636 switch (create->cr_type) { in nfsd4_create()
638 status = nfsd_symlink(rqstp, &cstate->current_fh, in nfsd4_create()
639 create->cr_name, create->cr_namelen, in nfsd4_create()
640 create->cr_data, &resfh); in nfsd4_create()
645 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
646 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
647 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
649 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
650 create->cr_name, create->cr_namelen, in nfsd4_create()
651 &create->cr_iattr, S_IFBLK, rdev, &resfh); in nfsd4_create()
656 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
657 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
658 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
660 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
661 create->cr_name, create->cr_namelen, in nfsd4_create()
662 &create->cr_iattr,S_IFCHR, rdev, &resfh); in nfsd4_create()
666 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
667 create->cr_name, create->cr_namelen, in nfsd4_create()
668 &create->cr_iattr, S_IFSOCK, 0, &resfh); in nfsd4_create()
672 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
673 create->cr_name, create->cr_namelen, in nfsd4_create()
674 &create->cr_iattr, S_IFIFO, 0, &resfh); in nfsd4_create()
678 create->cr_iattr.ia_valid &= ~ATTR_SIZE; in nfsd4_create()
679 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
680 create->cr_name, create->cr_namelen, in nfsd4_create()
681 &create->cr_iattr, S_IFDIR, 0, &resfh); in nfsd4_create()
691 if (create->cr_label.len) in nfsd4_create()
692 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval); in nfsd4_create()
694 if (create->cr_acl != NULL) in nfsd4_create()
695 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, in nfsd4_create()
696 create->cr_bmval); in nfsd4_create()
698 fh_unlock(&cstate->current_fh); in nfsd4_create()
699 set_change_info(&create->cr_cinfo, &cstate->current_fh); in nfsd4_create()
700 fh_dup2(&cstate->current_fh, &resfh); in nfsd4_create()
704 current->fs->umask = 0; in nfsd4_create()
712 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_getattr()
715 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_getattr()
719 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_getattr()
722 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_getattr()
723 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_getattr()
724 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_getattr()
726 getattr->ga_fhp = &cstate->current_fh; in nfsd4_getattr()
734 struct nfsd4_link *link = &u->link; in nfsd4_link()
737 status = nfsd_link(rqstp, &cstate->current_fh, in nfsd4_link()
738 link->li_name, link->li_namelen, &cstate->save_fh); in nfsd4_link()
740 set_change_info(&link->li_cinfo, &cstate->current_fh); in nfsd4_link()
753 if (tmp_fh.fh_dentry == fh->fh_dentry) { in nfsd4_do_lookupp()
765 return nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_lookupp()
772 return nfsd_lookup(rqstp, &cstate->current_fh, in nfsd4_lookup()
773 u->lookup.lo_name, u->lookup.lo_len, in nfsd4_lookup()
774 &cstate->current_fh); in nfsd4_lookup()
781 struct nfsd4_read *read = &u->read; in nfsd4_read()
784 read->rd_nf = NULL; in nfsd4_read()
785 if (read->rd_offset >= OFFSET_MAX) in nfsd4_read()
788 trace_nfsd_read_start(rqstp, &cstate->current_fh, in nfsd4_read()
789 read->rd_offset, read->rd_length); in nfsd4_read()
800 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags); in nfsd4_read()
803 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_read()
804 &read->rd_stateid, RD_STATE, in nfsd4_read()
805 &read->rd_nf, NULL); in nfsd4_read()
812 read->rd_rqstp = rqstp; in nfsd4_read()
813 read->rd_fhp = &cstate->current_fh; in nfsd4_read()
821 if (u->read.rd_nf) in nfsd4_read_release()
822 nfsd_file_put(u->read.rd_nf); in nfsd4_read_release()
823 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp, in nfsd4_read_release()
824 u->read.rd_offset, u->read.rd_length); in nfsd4_read_release()
831 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_readdir()
832 u64 cookie = readdir->rd_cookie; in nfsd4_readdir()
835 /* no need to check permission - this will be done in nfsd_readdir() */ in nfsd4_readdir()
837 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_readdir()
840 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_readdir()
841 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_readdir()
842 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_readdir()
845 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) in nfsd4_readdir()
848 readdir->rd_rqstp = rqstp; in nfsd4_readdir()
849 readdir->rd_fhp = &cstate->current_fh; in nfsd4_readdir()
857 u->readlink.rl_rqstp = rqstp; in nfsd4_readlink()
858 u->readlink.rl_fhp = &cstate->current_fh; in nfsd4_readlink()
866 struct nfsd4_remove *remove = &u->remove; in nfsd4_remove()
871 status = nfsd_unlink(rqstp, &cstate->current_fh, 0, in nfsd4_remove()
872 remove->rm_name, remove->rm_namelen); in nfsd4_remove()
874 fh_unlock(&cstate->current_fh); in nfsd4_remove()
875 set_change_info(&remove->rm_cinfo, &cstate->current_fh); in nfsd4_remove()
884 struct nfsd4_rename *rename = &u->rename; in nfsd4_rename()
889 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, in nfsd4_rename()
890 rename->rn_snamelen, &cstate->current_fh, in nfsd4_rename()
891 rename->rn_tname, rename->rn_tnamelen); in nfsd4_rename()
894 set_change_info(&rename->rn_sinfo, &cstate->current_fh); in nfsd4_rename()
895 set_change_info(&rename->rn_tinfo, &cstate->save_fh); in nfsd4_rename()
903 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_secinfo()
908 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); in nfsd4_secinfo()
911 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, in nfsd4_secinfo()
912 secinfo->si_name, secinfo->si_namelen, in nfsd4_secinfo()
916 fh_unlock(&cstate->current_fh); in nfsd4_secinfo()
921 secinfo->si_exp = exp; in nfsd4_secinfo()
923 if (cstate->minorversion) in nfsd4_secinfo()
925 fh_put(&cstate->current_fh); in nfsd4_secinfo()
935 switch (u->secinfo_no_name.sin_style) { in nfsd4_secinfo_no_name()
939 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_secinfo_no_name()
947 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export); in nfsd4_secinfo_no_name()
948 fh_put(&cstate->current_fh); in nfsd4_secinfo_no_name()
955 if (u->secinfo.si_exp) in nfsd4_secinfo_release()
956 exp_put(u->secinfo.si_exp); in nfsd4_secinfo_release()
962 if (u->secinfo_no_name.sin_exp) in nfsd4_secinfo_no_name_release()
963 exp_put(u->secinfo_no_name.sin_exp); in nfsd4_secinfo_no_name_release()
970 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_setattr()
974 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { in nfsd4_setattr()
976 &cstate->current_fh, &setattr->sa_stateid, in nfsd4_setattr()
983 err = fh_want_write(&cstate->current_fh); in nfsd4_setattr()
988 status = check_attr_support(rqstp, cstate, setattr->sa_bmval, in nfsd4_setattr()
993 if (setattr->sa_acl != NULL) in nfsd4_setattr()
994 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, in nfsd4_setattr()
995 setattr->sa_acl); in nfsd4_setattr()
998 if (setattr->sa_label.len) in nfsd4_setattr()
999 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh, in nfsd4_setattr()
1000 &setattr->sa_label); in nfsd4_setattr()
1003 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, in nfsd4_setattr()
1006 fh_drop_write(&cstate->current_fh); in nfsd4_setattr()
1014 struct nfsd4_write *write = &u->write; in nfsd4_write()
1015 stateid_t *stateid = &write->wr_stateid; in nfsd4_write()
1021 if (write->wr_offset >= OFFSET_MAX) in nfsd4_write()
1024 cnt = write->wr_buflen; in nfsd4_write()
1025 trace_nfsd_write_start(rqstp, &cstate->current_fh, in nfsd4_write()
1026 write->wr_offset, cnt); in nfsd4_write()
1027 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_write()
1034 write->wr_how_written = write->wr_stable_how; in nfsd4_write()
1036 nvecs = svc_fill_write_vector(rqstp, write->wr_payload.pages, in nfsd4_write()
1037 write->wr_payload.head, write->wr_buflen); in nfsd4_write()
1038 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec)); in nfsd4_write()
1040 status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf, in nfsd4_write()
1041 write->wr_offset, rqstp->rq_vec, nvecs, &cnt, in nfsd4_write()
1042 write->wr_how_written, in nfsd4_write()
1043 (__be32 *)write->wr_verifier.data); in nfsd4_write()
1046 write->wr_bytes_written = cnt; in nfsd4_write()
1047 trace_nfsd_write_done(rqstp, &cstate->current_fh, in nfsd4_write()
1048 write->wr_offset, cnt); in nfsd4_write()
1059 if (!cstate->save_fh.fh_dentry) in nfsd4_verify_copy()
1062 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh, in nfsd4_verify_copy()
1069 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_verify_copy()
1076 /* fix up for NFS-specific error code */ in nfsd4_verify_copy()
1077 if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) || in nfsd4_verify_copy()
1078 !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) { in nfsd4_verify_copy()
1096 struct nfsd4_clone *clone = &u->clone; in nfsd4_clone()
1100 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src, in nfsd4_clone()
1101 &clone->cl_dst_stateid, &dst); in nfsd4_clone()
1105 status = nfsd4_clone_file_range(src, clone->cl_src_pos, in nfsd4_clone()
1106 dst, clone->cl_dst_pos, clone->cl_count, in nfsd4_clone()
1107 EX_ISSYNC(cstate->current_fh.fh_export)); in nfsd4_clone()
1117 if (!refcount_dec_and_test(©->refcount)) in nfs4_put_copy()
1127 spin_lock(©->cp_clp->async_lock); in check_and_set_stop_copy()
1128 value = copy->stopped; in check_and_set_stop_copy()
1129 if (!copy->stopped) in check_and_set_stop_copy()
1130 copy->stopped = true; in check_and_set_stop_copy()
1131 spin_unlock(©->cp_clp->async_lock); in check_and_set_stop_copy()
1139 kthread_stop(copy->copy_task); in nfsd4_stop_copy()
1147 spin_lock(&clp->async_lock); in nfsd4_get_copy()
1148 if (!list_empty(&clp->async_copies)) { in nfsd4_get_copy()
1149 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, in nfsd4_get_copy()
1151 refcount_inc(©->refcount); in nfsd4_get_copy()
1153 spin_unlock(&clp->async_lock); in nfsd4_get_copy()
1176 * setup a work entry in the ssc delayed unmount list.
1190 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1191 list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { in nfsd4_ssc_setup_dul()
1192 if (strncmp(ni->nsui_ipaddr, ipaddr, sizeof(ni->nsui_ipaddr))) in nfsd4_ssc_setup_dul()
1195 if (ni->nsui_busy) { in nfsd4_ssc_setup_dul()
1196 /* wait - and try again */ in nfsd4_ssc_setup_dul()
1197 prepare_to_wait(&nn->nfsd_ssc_waitq, &wait, in nfsd4_ssc_setup_dul()
1199 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1201 /* allow 20secs for mount/unmount for now - revisit */ in nfsd4_ssc_setup_dul()
1207 finish_wait(&nn->nfsd_ssc_waitq, &wait); in nfsd4_ssc_setup_dul()
1210 *ss_mnt = ni->nsui_vfsmount; in nfsd4_ssc_setup_dul()
1211 refcount_inc(&ni->nsui_refcnt); in nfsd4_ssc_setup_dul()
1212 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1219 strncpy(work->nsui_ipaddr, ipaddr, sizeof(work->nsui_ipaddr)); in nfsd4_ssc_setup_dul()
1220 refcount_set(&work->nsui_refcnt, 2); in nfsd4_ssc_setup_dul()
1221 work->nsui_busy = true; in nfsd4_ssc_setup_dul()
1222 list_add_tail(&work->nsui_list, &nn->nfsd_ssc_mount_list); in nfsd4_ssc_setup_dul()
1225 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1233 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_update_dul_work()
1234 work->nsui_vfsmount = ss_mnt; in nfsd4_ssc_update_dul_work()
1235 work->nsui_busy = false; in nfsd4_ssc_update_dul_work()
1236 wake_up_all(&nn->nfsd_ssc_waitq); in nfsd4_ssc_update_dul_work()
1237 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_update_dul_work()
1243 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_cancel_dul_work()
1244 list_del(&work->nsui_list); in nfsd4_ssc_cancel_dul_work()
1245 wake_up_all(&nn->nfsd_ssc_waitq); in nfsd4_ssc_cancel_dul_work()
1246 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_cancel_dul_work()
1269 naddr = &nss->u.nl4_addr; in nfsd4_interssc_connect()
1270 tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr, in nfsd4_interssc_connect()
1271 naddr->addr_len, in nfsd4_interssc_connect()
1284 if (naddr->netid_len != match_netid_len || in nfsd4_interssc_connect()
1285 strncmp(naddr->netid, match_netid, naddr->netid_len)) in nfsd4_interssc_connect()
1322 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */ in nfsd4_interssc_connect()
1324 module_put(type->owner); in nfsd4_interssc_connect()
1350 nfs_do_sb_deactive(ss_mnt->mnt_sb); in nfsd4_interssc_disconnect()
1369 stateid_t *s_stid = ©->cp_src_stateid; in nfsd4_setup_inter_ssc()
1373 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_setup_inter_ssc()
1374 ©->cp_dst_stateid, in nfsd4_setup_inter_ssc()
1375 WR_STATE, ©->nf_dst, NULL); in nfsd4_setup_inter_ssc()
1379 status = nfsd4_interssc_connect(©->cp_src, rqstp, mount); in nfsd4_setup_inter_ssc()
1383 s_fh = &cstate->save_fh; in nfsd4_setup_inter_ssc()
1385 copy->c_fh.size = s_fh->fh_handle.fh_size; in nfsd4_setup_inter_ssc()
1386 memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size); in nfsd4_setup_inter_ssc()
1387 copy->stateid.seqid = cpu_to_be32(s_stid->si_generation); in nfsd4_setup_inter_ssc()
1388 memcpy(copy->stateid.other, (void *)&s_stid->si_opaque, in nfsd4_setup_inter_ssc()
1404 struct nfsd_net *nn = net_generic(dst->nf_net, nfsd_net_id); in nfsd4_cleanup_inter_ssc()
1406 nfs42_ssc_close(src->nf_file); in nfsd4_cleanup_inter_ssc()
1408 fput(src->nf_file); in nfsd4_cleanup_inter_ssc()
1414 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_cleanup_inter_ssc()
1416 list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { in nfsd4_cleanup_inter_ssc()
1417 if (ni->nsui_vfsmount->mnt_sb == ss_mnt->mnt_sb) { in nfsd4_cleanup_inter_ssc()
1418 list_del(&ni->nsui_list); in nfsd4_cleanup_inter_ssc()
1424 refcount_dec(&ni->nsui_refcnt); in nfsd4_cleanup_inter_ssc()
1425 ni->nsui_expire = jiffies + timeout; in nfsd4_cleanup_inter_ssc()
1426 list_add_tail(&ni->nsui_list, &nn->nfsd_ssc_mount_list); in nfsd4_cleanup_inter_ssc()
1431 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_cleanup_inter_ssc()
1474 return nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, in nfsd4_setup_intra_ssc()
1475 ©->nf_src, ©->cp_dst_stateid, in nfsd4_setup_intra_ssc()
1476 ©->nf_dst); in nfsd4_setup_intra_ssc()
1506 copy->cp_res.wr_stable_how = in nfsd4_init_copy_res()
1507 copy->committed ? NFS_FILE_SYNC : NFS_UNSTABLE; in nfsd4_init_copy_res()
1508 copy->cp_synchronous = sync; in nfsd4_init_copy_res()
1509 gen_boot_verifier(©->cp_res.wr_verifier, copy->cp_clp->net); in nfsd4_init_copy_res()
1515 u64 bytes_total = copy->cp_count; in _nfsd_copy_file_range()
1516 u64 src_pos = copy->cp_src_pos; in _nfsd_copy_file_range()
1517 u64 dst_pos = copy->cp_dst_pos; in _nfsd_copy_file_range()
1526 bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file, in _nfsd_copy_file_range()
1527 src_pos, copy->nf_dst->nf_file, dst_pos, in _nfsd_copy_file_range()
1531 bytes_total -= bytes_copied; in _nfsd_copy_file_range()
1532 copy->cp_res.wr_bytes_written += bytes_copied; in _nfsd_copy_file_range()
1535 } while (bytes_total > 0 && !copy->cp_synchronous); in _nfsd_copy_file_range()
1536 /* for a non-zero asynchronous copy do a commit of data */ in _nfsd_copy_file_range()
1537 if (!copy->cp_synchronous && copy->cp_res.wr_bytes_written > 0) { in _nfsd_copy_file_range()
1538 down_write(©->nf_dst->nf_rwsem); in _nfsd_copy_file_range()
1539 status = vfs_fsync_range(copy->nf_dst->nf_file, in _nfsd_copy_file_range()
1540 copy->cp_dst_pos, in _nfsd_copy_file_range()
1541 copy->cp_res.wr_bytes_written, 0); in _nfsd_copy_file_range()
1542 up_write(©->nf_dst->nf_rwsem); in _nfsd_copy_file_range()
1544 copy->committed = true; in _nfsd_copy_file_range()
1558 if (bytes < 0 && !copy->cp_res.wr_bytes_written) in nfsd4_do_copy()
1565 if (!copy->cp_intra) /* Inter server SSC */ in nfsd4_do_copy()
1566 nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src, in nfsd4_do_copy()
1567 copy->nf_dst); in nfsd4_do_copy()
1569 nfsd4_cleanup_intra_ssc(copy->nf_src, copy->nf_dst); in nfsd4_do_copy()
1576 dst->cp_src_pos = src->cp_src_pos; in dup_copy_fields()
1577 dst->cp_dst_pos = src->cp_dst_pos; in dup_copy_fields()
1578 dst->cp_count = src->cp_count; in dup_copy_fields()
1579 dst->cp_synchronous = src->cp_synchronous; in dup_copy_fields()
1580 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res)); in dup_copy_fields()
1581 memcpy(&dst->fh, &src->fh, sizeof(src->fh)); in dup_copy_fields()
1582 dst->cp_clp = src->cp_clp; in dup_copy_fields()
1583 dst->nf_dst = nfsd_file_get(src->nf_dst); in dup_copy_fields()
1584 dst->cp_intra = src->cp_intra; in dup_copy_fields()
1585 if (src->cp_intra) /* for inter, file_src doesn't exist yet */ in dup_copy_fields()
1586 dst->nf_src = nfsd_file_get(src->nf_src); in dup_copy_fields()
1588 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid)); in dup_copy_fields()
1589 memcpy(&dst->cp_src, &src->cp_src, sizeof(struct nl4_server)); in dup_copy_fields()
1590 memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid)); in dup_copy_fields()
1591 memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh)); in dup_copy_fields()
1592 dst->ss_mnt = src->ss_mnt; in dup_copy_fields()
1598 nfsd_file_put(copy->nf_dst); in cleanup_async_copy()
1599 if (copy->cp_intra) in cleanup_async_copy()
1600 nfsd_file_put(copy->nf_src); in cleanup_async_copy()
1601 spin_lock(©->cp_clp->async_lock); in cleanup_async_copy()
1602 list_del(©->copies); in cleanup_async_copy()
1603 spin_unlock(©->cp_clp->async_lock); in cleanup_async_copy()
1612 if (!copy->cp_intra) { /* Inter server SSC */ in nfsd4_do_async_copy()
1613 copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL); in nfsd4_do_async_copy()
1614 if (!copy->nf_src) { in nfsd4_do_async_copy()
1615 copy->nfserr = nfserr_serverfault; in nfsd4_do_async_copy()
1616 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_do_async_copy()
1619 copy->nf_src->nf_file = nfs42_ssc_open(copy->ss_mnt, ©->c_fh, in nfsd4_do_async_copy()
1620 ©->stateid); in nfsd4_do_async_copy()
1621 if (IS_ERR(copy->nf_src->nf_file)) { in nfsd4_do_async_copy()
1622 copy->nfserr = nfserr_offload_denied; in nfsd4_do_async_copy()
1623 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_do_async_copy()
1628 copy->nfserr = nfsd4_do_copy(copy, 0); in nfsd4_do_async_copy()
1633 refcount_set(&cb_copy->refcount, 1); in nfsd4_do_async_copy()
1634 memcpy(&cb_copy->cp_res, ©->cp_res, sizeof(copy->cp_res)); in nfsd4_do_async_copy()
1635 cb_copy->cp_clp = copy->cp_clp; in nfsd4_do_async_copy()
1636 cb_copy->nfserr = copy->nfserr; in nfsd4_do_async_copy()
1637 memcpy(&cb_copy->fh, ©->fh, sizeof(copy->fh)); in nfsd4_do_async_copy()
1638 nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp, in nfsd4_do_async_copy()
1640 trace_nfsd_cb_offload(copy->cp_clp, ©->cp_res.cb_stateid, in nfsd4_do_async_copy()
1641 ©->fh, copy->cp_count, copy->nfserr); in nfsd4_do_async_copy()
1642 nfsd4_run_cb(&cb_copy->cp_cb); in nfsd4_do_async_copy()
1644 if (!copy->cp_intra) in nfsd4_do_async_copy()
1645 kfree(copy->nf_src); in nfsd4_do_async_copy()
1654 struct nfsd4_copy *copy = &u->copy; in nfsd4_copy()
1658 if (!copy->cp_intra) { /* Inter server SSC */ in nfsd4_copy()
1659 if (!inter_copy_offload_enable || copy->cp_synchronous) { in nfsd4_copy()
1664 ©->ss_mnt); in nfsd4_copy()
1673 copy->cp_clp = cstate->clp; in nfsd4_copy()
1674 memcpy(©->fh, &cstate->current_fh.fh_handle, in nfsd4_copy()
1676 if (!copy->cp_synchronous) { in nfsd4_copy()
1679 status = nfserrno(-ENOMEM); in nfsd4_copy()
1685 refcount_set(&async_copy->refcount, 1); in nfsd4_copy()
1686 memcpy(©->cp_res.cb_stateid, ©->cp_stateid.stid, in nfsd4_copy()
1687 sizeof(copy->cp_res.cb_stateid)); in nfsd4_copy()
1689 async_copy->copy_task = kthread_create(nfsd4_do_async_copy, in nfsd4_copy()
1691 if (IS_ERR(async_copy->copy_task)) in nfsd4_copy()
1693 spin_lock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
1694 list_add(&async_copy->copies, in nfsd4_copy()
1695 &async_copy->cp_clp->async_copies); in nfsd4_copy()
1696 spin_unlock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
1697 wake_up_process(async_copy->copy_task); in nfsd4_copy()
1707 status = nfserrno(-ENOMEM); in nfsd4_copy()
1708 if (!copy->cp_intra) in nfsd4_copy()
1709 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_copy()
1718 spin_lock(&clp->async_lock); in find_async_copy()
1719 list_for_each_entry(copy, &clp->async_copies, copies) { in find_async_copy()
1720 if (memcmp(©->cp_stateid.stid, stateid, NFS4_STATEID_SIZE)) in find_async_copy()
1722 refcount_inc(©->refcount); in find_async_copy()
1723 spin_unlock(&clp->async_lock); in find_async_copy()
1726 spin_unlock(&clp->async_lock); in find_async_copy()
1735 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_cancel()
1737 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_cancel()
1739 copy = find_async_copy(clp, &os->stateid); in nfsd4_offload_cancel()
1743 return manage_cpntf_state(nn, &os->stateid, clp, NULL); in nfsd4_offload_cancel()
1754 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_copy_notify()
1759 struct nfs4_client *clp = cstate->clp; in nfsd4_copy_notify()
1761 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_copy_notify()
1762 &cn->cpn_src_stateid, RD_STATE, NULL, in nfsd4_copy_notify()
1767 cn->cpn_sec = nn->nfsd4_lease; in nfsd4_copy_notify()
1768 cn->cpn_nsec = 0; in nfsd4_copy_notify()
1770 status = nfserrno(-ENOMEM); in nfsd4_copy_notify()
1774 memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.stid, sizeof(stateid_t)); in nfsd4_copy_notify()
1775 memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t)); in nfsd4_copy_notify()
1776 memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t)); in nfsd4_copy_notify()
1781 cn->cpn_src.nl4_type = NL4_NETADDR; in nfsd4_copy_notify()
1782 status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr, in nfsd4_copy_notify()
1783 &cn->cpn_src.u.nl4_addr); in nfsd4_copy_notify()
1801 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_fallocate()
1802 &fallocate->falloc_stateid, in nfsd4_fallocate()
1809 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file, in nfsd4_fallocate()
1810 fallocate->falloc_offset, in nfsd4_fallocate()
1811 fallocate->falloc_length, in nfsd4_fallocate()
1821 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_status()
1824 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_status()
1826 copy = find_async_copy(clp, &os->stateid); in nfsd4_offload_status()
1828 os->count = copy->cp_res.wr_bytes_written; in nfsd4_offload_status()
1840 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0); in nfsd4_allocate()
1847 return nfsd4_fallocate(rqstp, cstate, &u->deallocate, in nfsd4_deallocate()
1855 struct nfsd4_seek *seek = &u->seek; in nfsd4_seek()
1860 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_seek()
1861 &seek->seek_stateid, in nfsd4_seek()
1868 switch (seek->seek_whence) { in nfsd4_seek()
1881 * Note: This call does change file->f_pos, but nothing in NFSD in nfsd4_seek()
1882 * should ever file->f_pos. in nfsd4_seek()
1884 seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence); in nfsd4_seek()
1885 if (seek->seek_pos < 0) in nfsd4_seek()
1886 status = nfserrno(seek->seek_pos); in nfsd4_seek()
1887 else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file))) in nfsd4_seek()
1888 seek->seek_eof = true; in nfsd4_seek()
1908 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in _nfsd4_verify()
1912 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); in _nfsd4_verify()
1916 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) in _nfsd4_verify()
1917 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) in _nfsd4_verify()
1919 if (verify->ve_attrlen & 3) in _nfsd4_verify()
1925 count = 4 + (verify->ve_attrlen >> 2); in _nfsd4_verify()
1931 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh, in _nfsd4_verify()
1932 cstate->current_fh.fh_export, in _nfsd4_verify()
1933 cstate->current_fh.fh_dentry, in _nfsd4_verify()
1934 verify->ve_bmval, in _nfsd4_verify()
1948 if (ntohl(*p++) != verify->ve_attrlen) in _nfsd4_verify()
1950 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) in _nfsd4_verify()
1964 status = _nfsd4_verify(rqstp, cstate, &u->verify); in nfsd4_nverify()
1974 status = _nfsd4_verify(rqstp, cstate, &u->nverify); in nfsd4_verify()
1982 if (!exp->ex_layout_types) { in nfsd4_layout_verify()
1988 !(exp->ex_layout_types & (1 << layout_type))) { in nfsd4_layout_verify()
2001 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo; in nfsd4_getdeviceinfo()
2009 gdp->gd_layout_type, in nfsd4_getdeviceinfo()
2010 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, in nfsd4_getdeviceinfo()
2011 gdp->gd_maxcount); in nfsd4_getdeviceinfo()
2013 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx); in nfsd4_getdeviceinfo()
2020 exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid); in nfsd4_getdeviceinfo()
2027 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type); in nfsd4_getdeviceinfo()
2032 if (gdp->gd_maxcount != 0) { in nfsd4_getdeviceinfo()
2033 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, in nfsd4_getdeviceinfo()
2034 rqstp, cstate->clp, gdp); in nfsd4_getdeviceinfo()
2037 gdp->gd_notify_types &= ops->notify_types; in nfsd4_getdeviceinfo()
2046 kfree(u->getdeviceinfo.gd_device); in nfsd4_getdeviceinfo_release()
2053 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_layoutget()
2054 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutget()
2060 switch (lgp->lg_seg.iomode) { in nfsd4_layoutget()
2069 __func__, lgp->lg_seg.iomode); in nfsd4_layoutget()
2079 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type); in nfsd4_layoutget()
2084 * Verify minlength and range as per RFC5661: in nfsd4_layoutget()
2095 if (lgp->lg_seg.length < lgp->lg_minlength || in nfsd4_layoutget()
2096 (lgp->lg_minlength != NFS4_MAX_UINT64 && in nfsd4_layoutget()
2097 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || in nfsd4_layoutget()
2098 (lgp->lg_seg.length != NFS4_MAX_UINT64 && in nfsd4_layoutget()
2099 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) in nfsd4_layoutget()
2101 if (lgp->lg_seg.length == 0) in nfsd4_layoutget()
2104 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid, in nfsd4_layoutget()
2105 true, lgp->lg_layout_type, &ls); in nfsd4_layoutget()
2107 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid); in nfsd4_layoutget()
2112 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) in nfsd4_layoutget()
2115 nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry), in nfsd4_layoutget()
2123 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutget()
2124 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutget()
2132 kfree(u->layoutget.lg_content); in nfsd4_layoutget_release()
2139 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_layoutcommit()
2140 const struct nfsd4_layout_seg *seg = &lcp->lc_seg; in nfsd4_layoutcommit()
2141 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutcommit()
2143 loff_t new_size = lcp->lc_last_wr + 1; in nfsd4_layoutcommit()
2153 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); in nfsd4_layoutcommit()
2156 inode = d_inode(current_fh->fh_dentry); in nfsd4_layoutcommit()
2159 if (new_size <= seg->offset) { in nfsd4_layoutcommit()
2163 if (new_size > seg->offset + seg->length) { in nfsd4_layoutcommit()
2167 if (!lcp->lc_newoffset && new_size > i_size_read(inode)) { in nfsd4_layoutcommit()
2172 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid, in nfsd4_layoutcommit()
2173 false, lcp->lc_layout_type, in nfsd4_layoutcommit()
2176 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid); in nfsd4_layoutcommit()
2184 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutcommit()
2187 lcp->lc_size_chg = 1; in nfsd4_layoutcommit()
2188 lcp->lc_newsize = new_size; in nfsd4_layoutcommit()
2190 lcp->lc_size_chg = 0; in nfsd4_layoutcommit()
2193 nfserr = ops->proc_layoutcommit(inode, lcp); in nfsd4_layoutcommit()
2194 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutcommit()
2203 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_layoutreturn()
2204 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutreturn()
2212 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type)) in nfsd4_layoutreturn()
2215 switch (lrp->lr_seg.iomode) { in nfsd4_layoutreturn()
2222 lrp->lr_seg.iomode); in nfsd4_layoutreturn()
2227 switch (lrp->lr_return_type) { in nfsd4_layoutreturn()
2237 lrp->lr_return_type); in nfsd4_layoutreturn()
2250 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_getxattr()
2252 return nfsd_getxattr(rqstp, &cstate->current_fh, in nfsd4_getxattr()
2253 getxattr->getxa_name, &getxattr->getxa_buf, in nfsd4_getxattr()
2254 &getxattr->getxa_len); in nfsd4_getxattr()
2261 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_setxattr()
2267 ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name, in nfsd4_setxattr()
2268 setxattr->setxa_buf, setxattr->setxa_len, in nfsd4_setxattr()
2269 setxattr->setxa_flags); in nfsd4_setxattr()
2272 set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh); in nfsd4_setxattr()
2285 return nfsd_listxattr(rqstp, &cstate->current_fh, in nfsd4_listxattrs()
2286 &u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len); in nfsd4_listxattrs()
2293 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_removexattr()
2299 ret = nfsd_removexattr(rqstp, &cstate->current_fh, in nfsd4_removexattr()
2300 removexattr->rmxa_name); in nfsd4_removexattr()
2303 set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh); in nfsd4_removexattr()
2331 * - SEQUENCE other than as first op results in
2333 * - BIND_CONN_TO_SESSION must be the only op in its compound.
2335 * - DESTROY_SESSION must be the final operation in a compound, if
2341 struct nfsd4_op *first_op = &args->ops[0]; in nfs41_check_op_ordering()
2344 if (args->minorversion == 0) in nfs41_check_op_ordering()
2347 if (args->opcnt == 0) in nfs41_check_op_ordering()
2349 if (first_op->status == nfserr_op_illegal) in nfs41_check_op_ordering()
2351 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) in nfs41_check_op_ordering()
2353 if (first_op->opnum == OP_SEQUENCE) in nfs41_check_op_ordering()
2360 if (args->opcnt != 1) in nfs41_check_op_ordering()
2367 return &nfsd4_ops[op->opnum]; in OPDESC()
2372 if (op->opnum == OP_ILLEGAL) in nfsd4_cache_this_op()
2374 return OPDESC(op)->op_flags & OP_CACHEME; in nfsd4_cache_this_op()
2379 struct nfsd4_compoundres *resp = rqstp->rq_resp; in need_wrongsec_check()
2380 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in need_wrongsec_check()
2381 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; in need_wrongsec_check()
2382 struct nfsd4_op *next = &argp->ops[resp->opcnt]; in need_wrongsec_check()
2387 * Most ops check wronsec on our own; only the putfh-like ops in need_wrongsec_check()
2390 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) in need_wrongsec_check()
2394 * put-filehandle operation if we're not going to use the in need_wrongsec_check()
2397 if (argp->opcnt == resp->opcnt) in need_wrongsec_check()
2399 if (next->opnum == OP_ILLEGAL) in need_wrongsec_check()
2407 return !(nextd->op_flags & OP_HANDLES_WRONGSEC); in need_wrongsec_check()
2422 for (i = 0; i < args->opcnt; i++) { in check_if_stalefh_allowed()
2423 op = &args->ops[i]; in check_if_stalefh_allowed()
2424 if (op->opnum == OP_PUTFH) in check_if_stalefh_allowed()
2426 else if (op->opnum == OP_SAVEFH) in check_if_stalefh_allowed()
2428 else if (op->opnum == OP_RESTOREFH) in check_if_stalefh_allowed()
2430 else if (op->opnum == OP_COPY) { in check_if_stalefh_allowed()
2431 copy = (struct nfsd4_copy *)&op->u; in check_if_stalefh_allowed()
2433 op->status = nfserr_nofilehandle; in check_if_stalefh_allowed()
2436 putfh = (struct nfsd4_putfh *)&saved_op->u; in check_if_stalefh_allowed()
2437 if (!copy->cp_intra) in check_if_stalefh_allowed()
2438 putfh->no_verify = true; in check_if_stalefh_allowed()
2455 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_proc_compound()
2456 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_proc_compound()
2458 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_proc_compound()
2459 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_proc_compound()
2460 struct svc_fh *save_fh = &cstate->save_fh; in nfsd4_proc_compound()
2464 resp->xdr = &rqstp->rq_res_stream; in nfsd4_proc_compound()
2467 xdr_reserve_space(resp->xdr, XDR_UNIT); in nfsd4_proc_compound()
2469 resp->tagp = resp->xdr->p; in nfsd4_proc_compound()
2471 xdr_reserve_space(resp->xdr, XDR_UNIT * 2 + args->taglen); in nfsd4_proc_compound()
2472 resp->taglen = args->taglen; in nfsd4_proc_compound()
2473 resp->tag = args->tag; in nfsd4_proc_compound()
2474 resp->rqstp = rqstp; in nfsd4_proc_compound()
2475 cstate->minorversion = args->minorversion; in nfsd4_proc_compound()
2480 * too hard to avoid non-idempotency problems. in nfsd4_proc_compound()
2482 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
2488 if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0) in nfsd4_proc_compound()
2491 if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND) in nfsd4_proc_compound()
2496 op = &args->ops[0]; in nfsd4_proc_compound()
2497 op->status = status; in nfsd4_proc_compound()
2498 resp->opcnt = 1; in nfsd4_proc_compound()
2503 rqstp->rq_lease_breaker = (void **)&cstate->clp; in nfsd4_proc_compound()
2505 trace_nfsd_compound(rqstp, args->opcnt); in nfsd4_proc_compound()
2506 while (!status && resp->opcnt < args->opcnt) { in nfsd4_proc_compound()
2507 op = &args->ops[resp->opcnt++]; in nfsd4_proc_compound()
2510 * The XDR decode routines may have pre-set op->status; in nfsd4_proc_compound()
2514 if (op->status) { in nfsd4_proc_compound()
2515 if (op->opnum == OP_OPEN) in nfsd4_proc_compound()
2516 op->status = nfsd4_open_omfg(rqstp, cstate, op); in nfsd4_proc_compound()
2519 if (!current_fh->fh_dentry && in nfsd4_proc_compound()
2521 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) { in nfsd4_proc_compound()
2522 op->status = nfserr_nofilehandle; in nfsd4_proc_compound()
2525 } else if (current_fh->fh_export && in nfsd4_proc_compound()
2526 current_fh->fh_export->ex_fslocs.migrated && in nfsd4_proc_compound()
2527 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { in nfsd4_proc_compound()
2528 op->status = nfserr_moved; in nfsd4_proc_compound()
2534 /* If op is non-idempotent */ in nfsd4_proc_compound()
2535 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) { in nfsd4_proc_compound()
2540 u32 plen = op->opdesc->op_rsize_bop(rqstp, op); in nfsd4_proc_compound()
2545 if (resp->opcnt < args->opcnt) in nfsd4_proc_compound()
2547 op->status = nfsd4_check_resp_size(resp, plen); in nfsd4_proc_compound()
2550 if (op->status) in nfsd4_proc_compound()
2553 if (op->opdesc->op_get_currentstateid) in nfsd4_proc_compound()
2554 op->opdesc->op_get_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2555 op->status = op->opdesc->op_func(rqstp, cstate, &op->u); in nfsd4_proc_compound()
2558 if (cstate->status == nfserr_replay_cache) { in nfsd4_proc_compound()
2560 status = op->status; in nfsd4_proc_compound()
2563 if (!op->status) { in nfsd4_proc_compound()
2564 if (op->opdesc->op_set_currentstateid) in nfsd4_proc_compound()
2565 op->opdesc->op_set_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2567 if (op->opdesc->op_flags & OP_CLEAR_STATEID) in nfsd4_proc_compound()
2570 if (current_fh->fh_export && in nfsd4_proc_compound()
2572 op->status = check_nfsd_access(current_fh->fh_export, rqstp); in nfsd4_proc_compound()
2575 if (op->status == nfserr_replay_me) { in nfsd4_proc_compound()
2576 op->replay = &cstate->replay_owner->so_replay; in nfsd4_proc_compound()
2577 nfsd4_encode_replay(resp->xdr, op); in nfsd4_proc_compound()
2578 status = op->status = op->replay->rp_status; in nfsd4_proc_compound()
2581 status = op->status; in nfsd4_proc_compound()
2584 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status, in nfsd4_proc_compound()
2585 nfsd4_op_name(op->opnum)); in nfsd4_proc_compound()
2588 nfsd4_increment_op_stats(op->opnum); in nfsd4_proc_compound()
2593 BUG_ON(cstate->replay_owner); in nfsd4_proc_compound()
2595 cstate->status = status; in nfsd4_proc_compound()
2597 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
2654 u32 *bmap = op->u.getattr.ga_bmval; in nfsd4_getattr_rsize()
2719 rlen = min(op->u.read.rd_length, maxcount); in nfsd4_read_rsize()
2727 u32 rlen = min(op->u.read.rd_length, maxcount); in nfsd4_read_plus_rsize()
2743 rlen = min(op->u.readdir.rd_maxcount, maxcount); in nfsd4_readdir_rsize()
2775 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids) in nfsd4_test_stateid_rsize()
2872 rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount); in nfsd4_getdeviceinfo_rsize()
2938 rlen = min(op->u.listxattrs.lsxa_maxcount, maxcount); in nfsd4_listxattrs_rsize()
3364 * nfsd4_spo_must_allow - Determine if the compound op contains an
3375 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_spo_must_allow()
3376 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in nfsd4_spo_must_allow()
3378 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_spo_must_allow()
3379 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; in nfsd4_spo_must_allow()
3382 if (!cstate->minorversion) in nfsd4_spo_must_allow()
3385 if (cstate->spo_must_allowed) in nfsd4_spo_must_allow()
3388 opiter = resp->opcnt; in nfsd4_spo_must_allow()
3389 while (opiter < argp->opcnt) { in nfsd4_spo_must_allow()
3390 this = &argp->ops[opiter++]; in nfsd4_spo_must_allow()
3391 if (test_bit(this->opnum, allow->u.longs) && in nfsd4_spo_must_allow()
3392 cstate->clp->cl_mach_cred && in nfsd4_spo_must_allow()
3393 nfsd4_mach_creds_match(cstate->clp, rqstp)) { in nfsd4_spo_must_allow()
3394 cstate->spo_must_allowed = true; in nfsd4_spo_must_allow()
3398 cstate->spo_must_allowed = false; in nfsd4_spo_must_allow()
3404 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp) in nfsd4_max_reply()
3407 BUG_ON(OPDESC(op)->op_rsize_bop == NULL); in nfsd4_max_reply()
3408 return OPDESC(op)->op_rsize_bop(rqstp, op); in nfsd4_max_reply()
3413 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { in warn_on_nonidempotent_op()
3415 op->opnum, nfsd4_op_name(op->opnum)); in warn_on_nonidempotent_op()