Lines Matching +full:ssc +full:- +full:range
2 * Server-side procedures for NFSv4.
87 struct dentry *dentry = cstate->current_fh.fh_dentry; in check_attr_support()
88 struct svc_export *exp = cstate->current_fh.fh_export; in check_attr_support()
90 if (!nfsd_attrs_supported(cstate->minorversion, bmval)) in check_attr_support()
95 !(exp->ex_flags & NFSEXP_SECURITY_LABEL)) in check_attr_support()
111 if (open->op_create == NFS4_OPEN_CREATE) { in nfsd4_check_open_attributes()
112 if (open->op_createmode == NFS4_CREATE_UNCHECKED in nfsd4_check_open_attributes()
113 || open->op_createmode == NFS4_CREATE_GUARDED) in nfsd4_check_open_attributes()
115 open->op_bmval, nfsd_attrmask); in nfsd4_check_open_attributes()
116 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) in nfsd4_check_open_attributes()
118 open->op_bmval, nfsd41_ex_attrmask); in nfsd4_check_open_attributes()
127 return open->op_create == NFS4_OPEN_CREATE in is_create_with_attrs()
128 && (open->op_createmode == NFS4_CREATE_UNCHECKED in is_create_with_attrs()
129 || open->op_createmode == NFS4_CREATE_GUARDED in is_create_with_attrs()
130 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); in is_create_with_attrs()
137 dget(src->fh_dentry); in fh_dup2()
138 if (src->fh_export) in fh_dup2()
139 exp_get(src->fh_export); in fh_dup2()
147 if (open->op_truncate && in do_open_permission()
148 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) in do_open_permission()
153 if (open->op_share_access & NFS4_SHARE_ACCESS_READ) in do_open_permission()
155 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) in do_open_permission()
157 if (open->op_share_deny & NFS4_SHARE_DENY_READ) in do_open_permission()
165 umode_t mode = d_inode(fh->fh_dentry)->i_mode; in nfsd_check_obj_isreg()
174 /* RFC 7530 - 16.16.6 */ in nfsd_check_obj_isreg()
186 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, in nfsd4_set_open_owner_reply_cache()
187 &resfh->fh_handle); in nfsd4_set_open_owner_reply_cache()
205 switch (open->op_share_access & NFS4_SHARE_ACCESS_BOTH) { in nfsd4_vfs_create()
216 path.mnt = fhp->fh_export->ex_path.mnt; in nfsd4_vfs_create()
218 filp = dentry_create(&path, oflags, open->op_iattr.ia_mode, in nfsd4_vfs_create()
223 open->op_filp = filp; in nfsd4_vfs_create()
238 struct iattr *iap = &open->op_iattr; in nfsd4_create_file()
241 .na_seclabel = &open->op_label, in nfsd4_create_file()
249 if (isdotent(open->op_fname, open->op_fnamelen)) in nfsd4_create_file()
251 if (!(iap->ia_valid & ATTR_MODE)) in nfsd4_create_file()
252 iap->ia_mode = 0; in nfsd4_create_file()
257 parent = fhp->fh_dentry; in nfsd4_create_file()
265 nfsd4_acl_to_attr(NF4REG, open->op_acl, &attrs); in nfsd4_create_file()
270 &QSTR_LEN(open->op_fname, open->op_fnamelen), in nfsd4_create_file()
283 status = fh_compose(resfhp, fhp->fh_export, child, fhp); in nfsd4_create_file()
289 if (nfsd4_create_is_exclusive(open->op_createmode)) { in nfsd4_create_file()
290 u32 *verifier = (u32 *)open->op_verf.data; in nfsd4_create_file()
312 switch (open->op_createmode) { in nfsd4_create_file()
323 open->op_truncate = (iap->ia_valid & ATTR_SIZE) && in nfsd4_create_file()
324 !iap->ia_size; in nfsd4_create_file()
332 d_inode(child)->i_size == 0) { in nfsd4_create_file()
333 open->op_created = true; in nfsd4_create_file()
341 d_inode(child)->i_size == 0) { in nfsd4_create_file()
342 open->op_created = true; in nfsd4_create_file()
351 iap->ia_mode &= ~current_umask(); in nfsd4_create_file()
359 open->op_created = true; in nfsd4_create_file()
363 if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) in nfsd4_create_file()
364 iap->ia_valid &= ~ATTR_SIZE; in nfsd4_create_file()
365 if (nfsd4_create_is_exclusive(open->op_createmode)) { in nfsd4_create_file()
366 iap->ia_valid = ATTR_MTIME | ATTR_ATIME | in nfsd4_create_file()
368 iap->ia_mtime.tv_sec = v_mtime; in nfsd4_create_file()
369 iap->ia_atime.tv_sec = v_atime; in nfsd4_create_file()
370 iap->ia_mtime.tv_nsec = 0; in nfsd4_create_file()
371 iap->ia_atime.tv_nsec = 0; in nfsd4_create_file()
378 open->op_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in nfsd4_create_file()
380 open->op_bmval[0] &= ~FATTR4_WORD0_ACL; in nfsd4_create_file()
391 * set_change_info - set up the change_info4 for a reply
397 * the event that we didn't get any pre-attrs, just zero out both.
402 cinfo->atomic = (u32)(fhp->fh_pre_saved && fhp->fh_post_saved && !fhp->fh_no_atomic_attr); in set_change_info()
403 cinfo->before_change = fhp->fh_pre_change; in set_change_info()
404 cinfo->after_change = fhp->fh_post_change; in set_change_info()
407 * If fetching the pre-change attributes failed, then we should in set_change_info()
409 * failed to fetch post-change attributes however. in set_change_info()
411 * If we didn't get post-op attrs, just zero-out the after in set_change_info()
416 if (WARN_ON_ONCE(!fhp->fh_pre_saved)) in set_change_info()
417 cinfo->before_change = 0; in set_change_info()
418 if (!fhp->fh_post_saved) in set_change_info()
419 cinfo->after_change = cinfo->before_change + 1; in set_change_info()
425 struct svc_fh *current_fh = &cstate->current_fh; in do_open_lookup()
433 open->op_truncate = false; in do_open_lookup()
435 if (open->op_create) { in do_open_lookup()
441 * -------------+--------+-----------------+-------------------- in do_open_lookup()
451 current->fs->umask = open->op_umask; in do_open_lookup()
453 current->fs->umask = 0; in do_open_lookup()
460 if (nfsd4_create_is_exclusive(open->op_createmode) && status == 0) in do_open_lookup()
461 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | in do_open_lookup()
465 open->op_fname, open->op_fnamelen, *resfh); in do_open_lookup()
474 status = nfsd_check_obj_isreg(*resfh, cstate->minorversion); in do_open_lookup()
480 if (open->op_created || in do_open_lookup()
481 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) in do_open_lookup()
484 set_change_info(&open->op_cinfo, current_fh); in do_open_lookup()
492 struct svc_fh *current_fh = &cstate->current_fh; in do_open_fhandle()
499 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); in do_open_fhandle()
503 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && in do_open_fhandle()
504 (open->op_iattr.ia_size == 0); in do_open_fhandle()
514 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) in do_open_fhandle()
524 (struct nfsd4_sessionid *)session->se_sessionid.data; in copy_clientid()
526 clid->cl_boot = sid->clientid.cl_boot; in copy_clientid()
527 clid->cl_id = sid->clientid.cl_id; in copy_clientid()
534 struct nfsd4_open *open = &u->open; in nfsd4_open()
542 (int)open->op_fnamelen, open->op_fname, in nfsd4_open()
543 open->op_openowner); in nfsd4_open()
545 open->op_filp = NULL; in nfsd4_open()
546 open->op_rqstp = rqstp; in nfsd4_open()
549 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) in nfsd4_open()
552 open->op_created = false; in nfsd4_open()
558 !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &cstate->clp->cl_flags) && in nfsd4_open()
559 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
563 copy_clientid(&open->op_clientid, cstate->session); in nfsd4_open()
568 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; in nfsd4_open()
569 fh_put(&cstate->current_fh); in nfsd4_open()
570 fh_copy_shallow(&cstate->current_fh.fh_handle, in nfsd4_open()
571 &rp->rp_openfh); in nfsd4_open()
572 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_open()
581 if (open->op_xdr_error) { in nfsd4_open()
582 status = open->op_xdr_error; in nfsd4_open()
593 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
596 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
599 switch (open->op_claim_type) { in nfsd4_open()
607 status = nfs4_check_open_reclaim(cstate->clp); in nfsd4_open()
610 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; in nfsd4_open()
618 resfh = &cstate->current_fh; in nfsd4_open()
630 if (status && open->op_created) in nfsd4_open()
631 pr_warn("nfsd4_process_open2 failed to open newly-created file: status=%u\n", in nfsd4_open()
634 nn->somebody_reclaimed = true; in nfsd4_open()
636 if (open->op_filp) { in nfsd4_open()
637 fput(open->op_filp); in nfsd4_open()
638 open->op_filp = NULL; in nfsd4_open()
640 if (resfh && resfh != &cstate->current_fh) { in nfsd4_open()
641 fh_dup2(&cstate->current_fh, resfh); in nfsd4_open()
651 * OPEN is the only seqid-mutating operation whose decoding can fail
652 * with a seqid-mutating error (specifically, decoding of user names in
658 struct nfsd4_open *open = &op->u.open; in nfsd4_open_omfg()
660 if (!seqid_mutating_err(ntohl(op->status))) in nfsd4_open_omfg()
661 return op->status; in nfsd4_open_omfg()
663 return op->status; in nfsd4_open_omfg()
664 open->op_xdr_error = op->status; in nfsd4_open_omfg()
665 return nfsd4_open(rqstp, cstate, &op->u); in nfsd4_open_omfg()
669 * filehandle-manipulating ops.
675 u->getfh = &cstate->current_fh; in nfsd4_getfh()
683 struct nfsd4_putfh *putfh = &u->putfh; in nfsd4_putfh()
686 fh_put(&cstate->current_fh); in nfsd4_putfh()
687 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; in nfsd4_putfh()
688 memcpy(&cstate->current_fh.fh_handle.fh_raw, putfh->pf_fhval, in nfsd4_putfh()
689 putfh->pf_fhlen); in nfsd4_putfh()
690 ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); in nfsd4_putfh()
692 if (ret == nfserr_stale && putfh->no_verify) { in nfsd4_putfh()
693 SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN); in nfsd4_putfh()
704 fh_put(&cstate->current_fh); in nfsd4_putrootfh()
706 return exp_pseudoroot(rqstp, &cstate->current_fh); in nfsd4_putrootfh()
713 if (!cstate->save_fh.fh_dentry) in nfsd4_restorefh()
716 fh_dup2(&cstate->current_fh, &cstate->save_fh); in nfsd4_restorefh()
718 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); in nfsd4_restorefh()
728 fh_dup2(&cstate->save_fh, &cstate->current_fh); in nfsd4_savefh()
730 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); in nfsd4_savefh()
743 struct nfsd4_access *access = &u->access; in nfsd4_access()
747 if (cstate->minorversion >= 2) in nfsd4_access()
751 if (access->ac_req_access & ~access_full) in nfsd4_access()
754 access->ac_resp_access = access->ac_req_access; in nfsd4_access()
755 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, in nfsd4_access()
756 &access->ac_supported); in nfsd4_access()
763 struct nfsd4_commit *commit = &u->commit; in nfsd4_commit()
767 status = nfsd_file_acquire(rqstp, &cstate->current_fh, NFSD_MAY_WRITE | in nfsd4_commit()
772 status = nfsd_commit(rqstp, &cstate->current_fh, nf, commit->co_offset, in nfsd4_commit()
773 commit->co_count, in nfsd4_commit()
774 (__be32 *)commit->co_verf.data); in nfsd4_commit()
783 struct nfsd4_create *create = &u->create; in nfsd4_create()
785 .na_iattr = &create->cr_iattr, in nfsd4_create()
786 .na_seclabel = &create->cr_label, in nfsd4_create()
794 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); in nfsd4_create()
798 status = check_attr_support(rqstp, cstate, create->cr_bmval, in nfsd4_create()
803 status = nfsd4_acl_to_attr(create->cr_type, create->cr_acl, &attrs); in nfsd4_create()
804 current->fs->umask = create->cr_umask; in nfsd4_create()
805 switch (create->cr_type) { in nfsd4_create()
807 status = nfsd_symlink(rqstp, &cstate->current_fh, in nfsd4_create()
808 create->cr_name, create->cr_namelen, in nfsd4_create()
809 create->cr_data, &attrs, &resfh); in nfsd4_create()
814 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
815 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
816 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
818 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
819 create->cr_name, create->cr_namelen, in nfsd4_create()
825 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
826 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
827 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
829 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
830 create->cr_name, create->cr_namelen, in nfsd4_create()
835 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
836 create->cr_name, create->cr_namelen, in nfsd4_create()
841 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
842 create->cr_name, create->cr_namelen, in nfsd4_create()
847 create->cr_iattr.ia_valid &= ~ATTR_SIZE; in nfsd4_create()
848 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
849 create->cr_name, create->cr_namelen, in nfsd4_create()
861 create->cr_bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in nfsd4_create()
863 create->cr_bmval[0] &= ~FATTR4_WORD0_ACL; in nfsd4_create()
864 set_change_info(&create->cr_cinfo, &cstate->current_fh); in nfsd4_create()
865 fh_dup2(&cstate->current_fh, &resfh); in nfsd4_create()
869 current->fs->umask = 0; in nfsd4_create()
878 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_getattr()
881 trace_nfsd_vfs_getattr(rqstp, &cstate->current_fh); in nfsd4_getattr()
883 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_getattr()
887 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_getattr()
890 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_getattr()
891 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_getattr()
892 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_getattr()
894 getattr->ga_fhp = &cstate->current_fh; in nfsd4_getattr()
902 struct nfsd4_link *link = &u->link; in nfsd4_link()
905 status = nfsd_link(rqstp, &cstate->current_fh, in nfsd4_link()
906 link->li_name, link->li_namelen, &cstate->save_fh); in nfsd4_link()
908 set_change_info(&link->li_cinfo, &cstate->current_fh); in nfsd4_link()
921 if (tmp_fh.fh_dentry == fh->fh_dentry) { in nfsd4_do_lookupp()
933 return nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_lookupp()
940 return nfsd_lookup(rqstp, &cstate->current_fh, in nfsd4_lookup()
941 u->lookup.lo_name, u->lookup.lo_len, in nfsd4_lookup()
942 &cstate->current_fh); in nfsd4_lookup()
949 struct nfsd4_read *read = &u->read; in nfsd4_read()
952 read->rd_nf = NULL; in nfsd4_read()
954 trace_nfsd_read_start(rqstp, &cstate->current_fh, in nfsd4_read()
955 read->rd_offset, read->rd_length); in nfsd4_read()
957 read->rd_length = min_t(u32, read->rd_length, svc_max_payload(rqstp)); in nfsd4_read()
958 if (read->rd_offset > (u64)OFFSET_MAX) in nfsd4_read()
959 read->rd_offset = (u64)OFFSET_MAX; in nfsd4_read()
960 if (read->rd_offset + read->rd_length > (u64)OFFSET_MAX) in nfsd4_read()
961 read->rd_length = (u64)OFFSET_MAX - read->rd_offset; in nfsd4_read()
972 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in nfsd4_read()
974 argp->splice_ok = false; in nfsd4_read()
978 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_read()
979 &read->rd_stateid, RD_STATE, in nfsd4_read()
980 &read->rd_nf, NULL); in nfsd4_read()
982 read->rd_rqstp = rqstp; in nfsd4_read()
983 read->rd_fhp = &cstate->current_fh; in nfsd4_read()
991 if (u->read.rd_nf) { in nfsd4_read_release()
992 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp, in nfsd4_read_release()
993 u->read.rd_offset, u->read.rd_length); in nfsd4_read_release()
994 nfsd_file_put(u->read.rd_nf); in nfsd4_read_release()
1002 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_readdir()
1003 u64 cookie = readdir->rd_cookie; in nfsd4_readdir()
1006 trace_nfsd_vfs_readdir(rqstp, &cstate->current_fh, in nfsd4_readdir()
1007 readdir->rd_maxcount, readdir->rd_cookie); in nfsd4_readdir()
1009 /* no need to check permission - this will be done in nfsd_readdir() */ in nfsd4_readdir()
1011 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_readdir()
1014 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_readdir()
1015 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_readdir()
1016 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_readdir()
1019 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) in nfsd4_readdir()
1022 readdir->rd_rqstp = rqstp; in nfsd4_readdir()
1023 readdir->rd_fhp = &cstate->current_fh; in nfsd4_readdir()
1031 u->readlink.rl_rqstp = rqstp; in nfsd4_readlink()
1032 u->readlink.rl_fhp = &cstate->current_fh; in nfsd4_readlink()
1040 struct nfsd4_remove *remove = &u->remove; in nfsd4_remove()
1045 status = nfsd_unlink(rqstp, &cstate->current_fh, 0, in nfsd4_remove()
1046 remove->rm_name, remove->rm_namelen); in nfsd4_remove()
1048 set_change_info(&remove->rm_cinfo, &cstate->current_fh); in nfsd4_remove()
1056 struct nfsd4_rename *rename = &u->rename; in nfsd4_rename()
1061 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, in nfsd4_rename()
1062 rename->rn_snamelen, &cstate->current_fh, in nfsd4_rename()
1063 rename->rn_tname, rename->rn_tnamelen); in nfsd4_rename()
1066 set_change_info(&rename->rn_sinfo, &cstate->save_fh); in nfsd4_rename()
1067 set_change_info(&rename->rn_tinfo, &cstate->current_fh); in nfsd4_rename()
1075 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_secinfo()
1080 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); in nfsd4_secinfo()
1083 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, in nfsd4_secinfo()
1084 secinfo->si_name, secinfo->si_namelen, in nfsd4_secinfo()
1092 secinfo->si_exp = exp; in nfsd4_secinfo()
1094 if (cstate->minorversion) in nfsd4_secinfo()
1096 fh_put(&cstate->current_fh); in nfsd4_secinfo()
1106 switch (u->secinfo_no_name.sin_style) { in nfsd4_secinfo_no_name()
1110 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_secinfo_no_name()
1118 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export); in nfsd4_secinfo_no_name()
1119 fh_put(&cstate->current_fh); in nfsd4_secinfo_no_name()
1126 if (u->secinfo.si_exp) in nfsd4_secinfo_release()
1127 exp_put(u->secinfo.si_exp); in nfsd4_secinfo_release()
1133 if (u->secinfo_no_name.sin_exp) in nfsd4_secinfo_no_name_release()
1134 exp_put(u->secinfo_no_name.sin_exp); in nfsd4_secinfo_no_name_release()
1138 * Validate that the requested timestamps are within the acceptable range. If
1145 struct timespec64 now = current_time(dp->dl_stid.sc_file->fi_inode); in vet_deleg_attrs()
1146 struct iattr *iattr = &setattr->sa_iattr; in vet_deleg_attrs()
1148 if ((setattr->sa_bmval[2] & FATTR4_WORD2_TIME_DELEG_ACCESS) && in vet_deleg_attrs()
1149 !nfsd4_vet_deleg_time(&iattr->ia_atime, &dp->dl_atime, &now)) in vet_deleg_attrs()
1150 iattr->ia_valid &= ~(ATTR_ATIME | ATTR_ATIME_SET); in vet_deleg_attrs()
1152 if (setattr->sa_bmval[2] & FATTR4_WORD2_TIME_DELEG_MODIFY) { in vet_deleg_attrs()
1153 if (nfsd4_vet_deleg_time(&iattr->ia_mtime, &dp->dl_mtime, &now)) { in vet_deleg_attrs()
1154 iattr->ia_ctime = iattr->ia_mtime; in vet_deleg_attrs()
1155 if (nfsd4_vet_deleg_time(&iattr->ia_ctime, &dp->dl_ctime, &now)) in vet_deleg_attrs()
1156 dp->dl_setattr = true; in vet_deleg_attrs()
1158 iattr->ia_valid &= ~(ATTR_CTIME | ATTR_CTIME_SET); in vet_deleg_attrs()
1160 iattr->ia_valid &= ~(ATTR_CTIME | ATTR_CTIME_SET | in vet_deleg_attrs()
1170 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_setattr()
1172 .na_iattr = &setattr->sa_iattr, in nfsd4_setattr()
1173 .na_seclabel = &setattr->sa_label, in nfsd4_setattr()
1181 deleg_attrs = setattr->sa_bmval[2] & (FATTR4_WORD2_TIME_DELEG_ACCESS | in nfsd4_setattr()
1184 if (deleg_attrs || (setattr->sa_iattr.ia_valid & ATTR_SIZE)) { in nfsd4_setattr()
1187 if (setattr->sa_bmval[2] & FATTR4_WORD2_TIME_DELEG_ACCESS) in nfsd4_setattr()
1191 &cstate->current_fh, &setattr->sa_stateid, in nfsd4_setattr()
1199 if (st->sc_type & SC_TYPE_DELEG) { in nfsd4_setattr()
1203 if (deleg_attrs_deleg(dp->dl_type)) { in nfsd4_setattr()
1214 err = fh_want_write(&cstate->current_fh); in nfsd4_setattr()
1219 status = check_attr_support(rqstp, cstate, setattr->sa_bmval, in nfsd4_setattr()
1224 inode = cstate->current_fh.fh_dentry->d_inode; in nfsd4_setattr()
1225 status = nfsd4_acl_to_attr(S_ISDIR(inode->i_mode) ? NF4DIR : NF4REG, in nfsd4_setattr()
1226 setattr->sa_acl, &attrs); in nfsd4_setattr()
1230 save_no_wcc = cstate->current_fh.fh_no_wcc; in nfsd4_setattr()
1231 cstate->current_fh.fh_no_wcc = true; in nfsd4_setattr()
1232 status = nfsd_setattr(rqstp, &cstate->current_fh, &attrs, NULL); in nfsd4_setattr()
1233 cstate->current_fh.fh_no_wcc = save_no_wcc; in nfsd4_setattr()
1240 fh_drop_write(&cstate->current_fh); in nfsd4_setattr()
1246 spin_lock(&fi->fi_lock); in nfsd4_file_mark_deleg_written()
1247 if (!list_empty(&fi->fi_delegations)) { in nfsd4_file_mark_deleg_written()
1248 struct nfs4_delegation *dp = list_first_entry(&fi->fi_delegations, in nfsd4_file_mark_deleg_written()
1251 if (dp->dl_type == OPEN_DELEGATE_WRITE_ATTRS_DELEG) in nfsd4_file_mark_deleg_written()
1252 dp->dl_written = true; in nfsd4_file_mark_deleg_written()
1254 spin_unlock(&fi->fi_lock); in nfsd4_file_mark_deleg_written()
1261 struct nfsd4_write *write = &u->write; in nfsd4_write()
1262 stateid_t *stateid = &write->wr_stateid; in nfsd4_write()
1268 if (write->wr_offset > (u64)OFFSET_MAX || in nfsd4_write()
1269 write->wr_offset + write->wr_buflen > (u64)OFFSET_MAX) in nfsd4_write()
1272 cnt = write->wr_buflen; in nfsd4_write()
1273 trace_nfsd_write_start(rqstp, &cstate->current_fh, in nfsd4_write()
1274 write->wr_offset, cnt); in nfsd4_write()
1275 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_write()
1281 nfsd4_file_mark_deleg_written(stid->sc_file); in nfsd4_write()
1285 write->wr_how_written = write->wr_stable_how; in nfsd4_write()
1286 status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf, in nfsd4_write()
1287 write->wr_offset, &write->wr_payload, in nfsd4_write()
1288 &cnt, write->wr_how_written, in nfsd4_write()
1289 (__be32 *)write->wr_verifier.data); in nfsd4_write()
1292 write->wr_bytes_written = cnt; in nfsd4_write()
1293 trace_nfsd_write_done(rqstp, &cstate->current_fh, in nfsd4_write()
1294 write->wr_offset, cnt); in nfsd4_write()
1305 if (!cstate->save_fh.fh_dentry) in nfsd4_verify_copy()
1308 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh, in nfsd4_verify_copy()
1313 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_verify_copy()
1318 /* fix up for NFS-specific error code */ in nfsd4_verify_copy()
1319 if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) || in nfsd4_verify_copy()
1320 !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) { in nfsd4_verify_copy()
1340 struct nfsd4_clone *clone = &u->clone; in nfsd4_clone()
1344 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src, in nfsd4_clone()
1345 &clone->cl_dst_stateid, &dst); in nfsd4_clone()
1349 status = nfsd4_clone_file_range(rqstp, src, clone->cl_src_pos, in nfsd4_clone()
1350 dst, clone->cl_dst_pos, clone->cl_count, in nfsd4_clone()
1351 EX_ISSYNC(cstate->current_fh.fh_export)); in nfsd4_clone()
1360 * nfsd4_has_active_async_copies - Check for ongoing copy operations
1377 spin_lock(&clp->async_lock); in nfsd4_has_active_async_copies()
1378 list_for_each_entry(copy, &clp->async_copies, copies) { in nfsd4_has_active_async_copies()
1379 if (!test_bit(NFSD4_COPY_F_COMPLETED, ©->cp_flags) && in nfsd4_has_active_async_copies()
1380 !test_bit(NFSD4_COPY_F_STOPPED, ©->cp_flags)) { in nfsd4_has_active_async_copies()
1385 spin_unlock(&clp->async_lock); in nfsd4_has_active_async_copies()
1390 * nfsd4_async_copy_reaper - Purge completed copies
1399 spin_lock(&nn->client_lock); in nfsd4_async_copy_reaper()
1400 list_for_each_entry(clp, &nn->client_lru, cl_lru) { in nfsd4_async_copy_reaper()
1403 spin_lock(&clp->async_lock); in nfsd4_async_copy_reaper()
1404 list_for_each_safe(pos, next, &clp->async_copies) { in nfsd4_async_copy_reaper()
1406 if (test_bit(NFSD4_COPY_F_OFFLOAD_DONE, ©->cp_flags)) { in nfsd4_async_copy_reaper()
1407 if (--copy->cp_ttl) { in nfsd4_async_copy_reaper()
1408 list_del_init(©->copies); in nfsd4_async_copy_reaper()
1409 list_add(©->copies, &reaplist); in nfsd4_async_copy_reaper()
1413 spin_unlock(&clp->async_lock); in nfsd4_async_copy_reaper()
1415 spin_unlock(&nn->client_lock); in nfsd4_async_copy_reaper()
1419 list_del_init(©->copies); in nfsd4_async_copy_reaper()
1426 if (!refcount_dec_and_test(©->refcount)) in nfs4_put_copy()
1428 kfree(copy->cp_src); in nfs4_put_copy()
1435 if (!test_and_set_bit(NFSD4_COPY_F_STOPPED, ©->cp_flags)) { in nfsd4_stop_copy()
1436 kthread_stop(copy->copy_task); in nfsd4_stop_copy()
1437 copy->nfserr = nfs_ok; in nfsd4_stop_copy()
1438 set_bit(NFSD4_COPY_F_COMPLETED, ©->cp_flags); in nfsd4_stop_copy()
1447 spin_lock(&clp->async_lock); in nfsd4_unhash_copy()
1448 if (!list_empty(&clp->async_copies)) { in nfsd4_unhash_copy()
1449 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, in nfsd4_unhash_copy()
1451 refcount_inc(©->refcount); in nfsd4_unhash_copy()
1452 copy->cp_clp = NULL; in nfsd4_unhash_copy()
1453 if (!list_empty(©->copies)) in nfsd4_unhash_copy()
1454 list_del_init(©->copies); in nfsd4_unhash_copy()
1456 spin_unlock(&clp->async_lock); in nfsd4_unhash_copy()
1479 * setup a work entry in the ssc delayed unmount list.
1494 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1495 list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) { in nfsd4_ssc_setup_dul()
1496 if (strncmp(ni->nsui_ipaddr, ipaddr, sizeof(ni->nsui_ipaddr))) in nfsd4_ssc_setup_dul()
1499 if (ni->nsui_busy) { in nfsd4_ssc_setup_dul()
1500 /* wait - and try again */ in nfsd4_ssc_setup_dul()
1501 prepare_to_wait(&nn->nfsd_ssc_waitq, &wait, TASK_IDLE); in nfsd4_ssc_setup_dul()
1502 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1504 /* allow 20secs for mount/unmount for now - revisit */ in nfsd4_ssc_setup_dul()
1507 finish_wait(&nn->nfsd_ssc_waitq, &wait); in nfsd4_ssc_setup_dul()
1511 finish_wait(&nn->nfsd_ssc_waitq, &wait); in nfsd4_ssc_setup_dul()
1515 refcount_inc(&ni->nsui_refcnt); in nfsd4_ssc_setup_dul()
1516 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1519 /* return vfsmount in (*nsui)->nsui_vfsmount */ in nfsd4_ssc_setup_dul()
1523 strscpy(work->nsui_ipaddr, ipaddr, sizeof(work->nsui_ipaddr)); in nfsd4_ssc_setup_dul()
1524 refcount_set(&work->nsui_refcnt, 2); in nfsd4_ssc_setup_dul()
1525 work->nsui_busy = true; in nfsd4_ssc_setup_dul()
1526 list_add_tail(&work->nsui_list, &nn->nfsd_ssc_mount_list); in nfsd4_ssc_setup_dul()
1530 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_setup_dul()
1538 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_update_dul()
1539 nsui->nsui_vfsmount = ss_mnt; in nfsd4_ssc_update_dul()
1540 nsui->nsui_busy = false; in nfsd4_ssc_update_dul()
1541 wake_up_all(&nn->nfsd_ssc_waitq); in nfsd4_ssc_update_dul()
1542 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_update_dul()
1548 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_ssc_cancel_dul()
1549 list_del(&nsui->nsui_list); in nfsd4_ssc_cancel_dul()
1550 wake_up_all(&nn->nfsd_ssc_waitq); in nfsd4_ssc_cancel_dul()
1551 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_ssc_cancel_dul()
1573 naddr = &nss->u.nl4_addr; in nfsd4_interssc_connect()
1574 tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr, in nfsd4_interssc_connect()
1575 naddr->addr_len, in nfsd4_interssc_connect()
1589 if (naddr->netid_len != match_netid_len || in nfsd4_interssc_connect()
1590 strncmp(naddr->netid, match_netid, naddr->netid_len)) in nfsd4_interssc_connect()
1624 if ((*nsui)->nsui_vfsmount) in nfsd4_interssc_connect()
1627 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */ in nfsd4_interssc_connect()
1629 module_put(type->owner); in nfsd4_interssc_connect()
1664 stateid_t *s_stid = ©->cp_src_stateid; in nfsd4_setup_inter_ssc()
1668 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_setup_inter_ssc()
1669 ©->cp_dst_stateid, in nfsd4_setup_inter_ssc()
1670 WR_STATE, ©->nf_dst, NULL); in nfsd4_setup_inter_ssc()
1674 status = nfsd4_interssc_connect(copy->cp_src, rqstp, ©->ss_nsui); in nfsd4_setup_inter_ssc()
1678 s_fh = &cstate->save_fh; in nfsd4_setup_inter_ssc()
1680 copy->c_fh.size = s_fh->fh_handle.fh_size; in nfsd4_setup_inter_ssc()
1681 memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_raw, copy->c_fh.size); in nfsd4_setup_inter_ssc()
1682 copy->stateid.seqid = cpu_to_be32(s_stid->si_generation); in nfsd4_setup_inter_ssc()
1683 memcpy(copy->stateid.other, (void *)&s_stid->si_opaque, in nfsd4_setup_inter_ssc()
1695 struct nfsd_net *nn = net_generic(dst->nf_net, nfsd_net_id); in nfsd4_cleanup_inter_ssc()
1701 spin_lock(&nn->nfsd_ssc_lock); in nfsd4_cleanup_inter_ssc()
1702 list_del(&nsui->nsui_list); in nfsd4_cleanup_inter_ssc()
1708 refcount_dec(&nsui->nsui_refcnt); in nfsd4_cleanup_inter_ssc()
1709 nsui->nsui_expire = jiffies + timeout; in nfsd4_cleanup_inter_ssc()
1710 list_add_tail(&nsui->nsui_list, &nn->nfsd_ssc_mount_list); in nfsd4_cleanup_inter_ssc()
1711 spin_unlock(&nn->nfsd_ssc_lock); in nfsd4_cleanup_inter_ssc()
1743 return nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, in nfsd4_setup_intra_ssc()
1744 ©->nf_src, ©->cp_dst_stateid, in nfsd4_setup_intra_ssc()
1745 ©->nf_dst); in nfsd4_setup_intra_ssc()
1755 set_bit(NFSD4_COPY_F_OFFLOAD_DONE, ©->cp_flags); in nfsd4_cb_offload_release()
1764 trace_nfsd_cb_offload_done(&cbo->co_res.cb_stateid, task); in nfsd4_cb_offload_done()
1765 switch (task->tk_status) { in nfsd4_cb_offload_done()
1766 case -NFS4ERR_DELAY: in nfsd4_cb_offload_done()
1767 if (cbo->co_retries--) { in nfsd4_cb_offload_done()
1784 copy->cp_res.wr_stable_how = in nfsd4_init_copy_res()
1785 test_bit(NFSD4_COPY_F_COMMITTED, ©->cp_flags) ? in nfsd4_init_copy_res()
1796 u64 bytes_total = copy->cp_count; in _nfsd_copy_file_range()
1797 u64 src_pos = copy->cp_src_pos; in _nfsd_copy_file_range()
1798 u64 dst_pos = copy->cp_dst_pos; in _nfsd_copy_file_range()
1813 bytes_total -= bytes_copied; in _nfsd_copy_file_range()
1814 copy->cp_res.wr_bytes_written += bytes_copied; in _nfsd_copy_file_range()
1818 /* for a non-zero asynchronous copy do a commit of data */ in _nfsd_copy_file_range()
1819 if (nfsd4_copy_is_async(copy) && copy->cp_res.wr_bytes_written > 0) { in _nfsd_copy_file_range()
1820 since = READ_ONCE(dst->f_wb_err); in _nfsd_copy_file_range()
1821 end = copy->cp_dst_pos + copy->cp_res.wr_bytes_written - 1; in _nfsd_copy_file_range()
1822 status = vfs_fsync_range(dst, copy->cp_dst_pos, end, 0); in _nfsd_copy_file_range()
1824 status = filemap_check_wb_err(dst->f_mapping, since); in _nfsd_copy_file_range()
1826 set_bit(NFSD4_COPY_F_COMMITTED, ©->cp_flags); in _nfsd_copy_file_range()
1843 if (bytes < 0 && !copy->cp_res.wr_bytes_written) in nfsd4_do_copy()
1854 dst->cp_src_pos = src->cp_src_pos; in dup_copy_fields()
1855 dst->cp_dst_pos = src->cp_dst_pos; in dup_copy_fields()
1856 dst->cp_count = src->cp_count; in dup_copy_fields()
1857 dst->cp_flags = src->cp_flags; in dup_copy_fields()
1858 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res)); in dup_copy_fields()
1859 memcpy(&dst->fh, &src->fh, sizeof(src->fh)); in dup_copy_fields()
1860 dst->cp_clp = src->cp_clp; in dup_copy_fields()
1861 dst->nf_dst = nfsd_file_get(src->nf_dst); in dup_copy_fields()
1864 dst->nf_src = nfsd_file_get(src->nf_src); in dup_copy_fields()
1866 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid)); in dup_copy_fields()
1867 memcpy(dst->cp_src, src->cp_src, sizeof(struct nl4_server)); in dup_copy_fields()
1868 memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid)); in dup_copy_fields()
1869 memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh)); in dup_copy_fields()
1870 dst->ss_nsui = src->ss_nsui; in dup_copy_fields()
1875 if (copy->nf_src) in release_copy_files()
1876 nfsd_file_put(copy->nf_src); in release_copy_files()
1877 if (copy->nf_dst) in release_copy_files()
1878 nfsd_file_put(copy->nf_dst); in release_copy_files()
1885 if (copy->cp_clp) { in cleanup_async_copy()
1886 spin_lock(©->cp_clp->async_lock); in cleanup_async_copy()
1887 if (!list_empty(©->copies)) in cleanup_async_copy()
1888 list_del_init(©->copies); in cleanup_async_copy()
1889 spin_unlock(©->cp_clp->async_lock); in cleanup_async_copy()
1896 struct nfsd4_cb_offload *cbo = ©->cp_cb_offload; in nfsd4_send_cb_offload()
1898 memcpy(&cbo->co_res, ©->cp_res, sizeof(copy->cp_res)); in nfsd4_send_cb_offload()
1899 memcpy(&cbo->co_fh, ©->fh, sizeof(copy->fh)); in nfsd4_send_cb_offload()
1900 cbo->co_nfserr = copy->nfserr; in nfsd4_send_cb_offload()
1901 cbo->co_retries = 5; in nfsd4_send_cb_offload()
1903 nfsd4_init_cb(&cbo->co_cb, copy->cp_clp, &nfsd4_cb_offload_ops, in nfsd4_send_cb_offload()
1905 nfsd41_cb_referring_call(&cbo->co_cb, &cbo->co_referring_sessionid, in nfsd4_send_cb_offload()
1906 cbo->co_referring_slotid, in nfsd4_send_cb_offload()
1907 cbo->co_referring_seqno); in nfsd4_send_cb_offload()
1908 trace_nfsd_cb_offload(copy->cp_clp, &cbo->co_res.cb_stateid, in nfsd4_send_cb_offload()
1909 &cbo->co_fh, copy->cp_count, copy->nfserr); in nfsd4_send_cb_offload()
1910 nfsd4_try_run_cb(&cbo->co_cb); in nfsd4_send_cb_offload()
1914 * nfsd4_do_async_copy - kthread function for background server-side COPY
1928 filp = nfs42_ssc_open(copy->ss_nsui->nsui_vfsmount, in nfsd4_do_async_copy()
1929 ©->c_fh, ©->stateid); in nfsd4_do_async_copy()
1932 case -EBADF: in nfsd4_do_async_copy()
1933 copy->nfserr = nfserr_wrong_type; in nfsd4_do_async_copy()
1936 copy->nfserr = nfserr_offload_denied; in nfsd4_do_async_copy()
1941 copy->nfserr = nfsd4_do_copy(copy, filp, copy->nf_dst->nf_file, in nfsd4_do_async_copy()
1943 nfsd4_cleanup_inter_ssc(copy->ss_nsui, filp, copy->nf_dst); in nfsd4_do_async_copy()
1945 copy->nfserr = nfsd4_do_copy(copy, copy->nf_src->nf_file, in nfsd4_do_async_copy()
1946 copy->nf_dst->nf_file, false); in nfsd4_do_async_copy()
1952 set_bit(NFSD4_COPY_F_STOPPED, ©->cp_flags); in nfsd4_do_async_copy()
1954 set_bit(NFSD4_COPY_F_COMPLETED, ©->cp_flags); in nfsd4_do_async_copy()
1957 atomic_dec(©->cp_nn->pending_async_copies); in nfsd4_do_async_copy()
1967 struct nfsd4_copy *copy = &u->copy; in nfsd4_copy()
1971 result = ©->cp_res; in nfsd4_copy()
1972 nfsd_copy_write_verifier((__be32 *)&result->wr_verifier.data, nn); in nfsd4_copy()
1974 copy->cp_clp = cstate->clp; in nfsd4_copy()
1995 memcpy(©->fh, &cstate->current_fh.fh_handle, in nfsd4_copy()
2001 async_copy->cp_nn = nn; in nfsd4_copy()
2002 INIT_LIST_HEAD(&async_copy->copies); in nfsd4_copy()
2003 refcount_set(&async_copy->refcount, 1); in nfsd4_copy()
2004 async_copy->cp_ttl = NFSD_COPY_INITIAL_TTL; in nfsd4_copy()
2006 if (atomic_inc_return(&nn->pending_async_copies) > in nfsd4_copy()
2007 (int)rqstp->rq_pool->sp_nrthreads) in nfsd4_copy()
2009 async_copy->cp_src = kmalloc(sizeof(*async_copy->cp_src), GFP_KERNEL); in nfsd4_copy()
2010 if (!async_copy->cp_src) in nfsd4_copy()
2014 memcpy(&result->cb_stateid, ©->cp_stateid.cs_stid, in nfsd4_copy()
2015 sizeof(result->cb_stateid)); in nfsd4_copy()
2017 memcpy(async_copy->cp_cb_offload.co_referring_sessionid.data, in nfsd4_copy()
2018 cstate->session->se_sessionid.data, in nfsd4_copy()
2020 async_copy->cp_cb_offload.co_referring_slotid = cstate->slot->sl_index; in nfsd4_copy()
2021 async_copy->cp_cb_offload.co_referring_seqno = cstate->slot->sl_seqid; in nfsd4_copy()
2022 async_copy->copy_task = kthread_create(nfsd4_do_async_copy, in nfsd4_copy()
2024 if (IS_ERR(async_copy->copy_task)) in nfsd4_copy()
2026 spin_lock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
2027 list_add(&async_copy->copies, in nfsd4_copy()
2028 &async_copy->cp_clp->async_copies); in nfsd4_copy()
2029 spin_unlock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
2030 wake_up_process(async_copy->copy_task); in nfsd4_copy()
2033 status = nfsd4_do_copy(copy, copy->nf_src->nf_file, in nfsd4_copy()
2034 copy->nf_dst->nf_file, true); in nfsd4_copy()
2042 atomic_dec(&nn->pending_async_copies); in nfsd4_copy()
2046 * Source's vfsmount of inter-copy will be unmounted in nfsd4_copy()
2048 * since async_copy->ss_nsui might not be set yet. in nfsd4_copy()
2050 refcount_dec(©->ss_nsui->nsui_refcnt); in nfsd4_copy()
2063 lockdep_assert_held(&clp->async_lock); in find_async_copy_locked()
2065 list_for_each_entry(copy, &clp->async_copies, copies) { in find_async_copy_locked()
2066 if (memcmp(©->cp_stateid.cs_stid, stateid, NFS4_STATEID_SIZE)) in find_async_copy_locked()
2078 spin_lock(&clp->async_lock); in find_async_copy()
2081 refcount_inc(©->refcount); in find_async_copy()
2082 spin_unlock(&clp->async_lock); in find_async_copy()
2091 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_cancel()
2093 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_cancel()
2095 copy = find_async_copy(clp, &os->stateid); in nfsd4_offload_cancel()
2099 return manage_cpntf_state(nn, &os->stateid, clp, NULL); in nfsd4_offload_cancel()
2110 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_copy_notify()
2115 struct nfs4_client *clp = cstate->clp; in nfsd4_copy_notify()
2117 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_copy_notify()
2118 &cn->cpn_src_stateid, RD_STATE, NULL, in nfsd4_copy_notify()
2125 cn->cpn_lease_time.tv_sec = nn->nfsd4_lease; in nfsd4_copy_notify()
2126 cn->cpn_lease_time.tv_nsec = 0; in nfsd4_copy_notify()
2128 status = nfserrno(-ENOMEM); in nfsd4_copy_notify()
2132 memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.cs_stid, sizeof(stateid_t)); in nfsd4_copy_notify()
2133 memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t)); in nfsd4_copy_notify()
2134 memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t)); in nfsd4_copy_notify()
2139 cn->cpn_src->nl4_type = NL4_NETADDR; in nfsd4_copy_notify()
2140 status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr, in nfsd4_copy_notify()
2141 &cn->cpn_src->u.nl4_addr); in nfsd4_copy_notify()
2159 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_fallocate()
2160 &fallocate->falloc_stateid, in nfsd4_fallocate()
2165 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file, in nfsd4_fallocate()
2166 fallocate->falloc_offset, in nfsd4_fallocate()
2167 fallocate->falloc_length, in nfsd4_fallocate()
2178 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_status()
2181 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_status()
2183 os->completed = false; in nfsd4_offload_status()
2184 spin_lock(&clp->async_lock); in nfsd4_offload_status()
2185 copy = find_async_copy_locked(clp, &os->stateid); in nfsd4_offload_status()
2187 os->count = copy->cp_res.wr_bytes_written; in nfsd4_offload_status()
2188 if (test_bit(NFSD4_COPY_F_COMPLETED, ©->cp_flags)) { in nfsd4_offload_status()
2189 os->completed = true; in nfsd4_offload_status()
2190 os->status = copy->nfserr; in nfsd4_offload_status()
2194 spin_unlock(&clp->async_lock); in nfsd4_offload_status()
2203 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0); in nfsd4_allocate()
2210 return nfsd4_fallocate(rqstp, cstate, &u->deallocate, in nfsd4_deallocate()
2218 struct nfsd4_seek *seek = &u->seek; in nfsd4_seek()
2223 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_seek()
2224 &seek->seek_stateid, in nfsd4_seek()
2229 switch (seek->seek_whence) { in nfsd4_seek()
2242 * Note: This call does change file->f_pos, but nothing in NFSD in nfsd4_seek()
2243 * should ever file->f_pos. in nfsd4_seek()
2245 seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence); in nfsd4_seek()
2246 if (seek->seek_pos < 0) in nfsd4_seek()
2247 status = nfserrno(seek->seek_pos); in nfsd4_seek()
2248 else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file))) in nfsd4_seek()
2249 seek->seek_eof = true; in nfsd4_seek()
2269 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in _nfsd4_verify()
2273 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); in _nfsd4_verify()
2277 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) in _nfsd4_verify()
2278 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) in _nfsd4_verify()
2280 if (verify->ve_attrlen & 3) in _nfsd4_verify()
2286 count = 4 + (verify->ve_attrlen >> 2); in _nfsd4_verify()
2292 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh, in _nfsd4_verify()
2293 cstate->current_fh.fh_export, in _nfsd4_verify()
2294 cstate->current_fh.fh_dentry, in _nfsd4_verify()
2295 verify->ve_bmval, in _nfsd4_verify()
2309 if (ntohl(*p++) != verify->ve_attrlen) in _nfsd4_verify()
2311 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) in _nfsd4_verify()
2325 status = _nfsd4_verify(rqstp, cstate, &u->verify); in nfsd4_nverify()
2335 status = _nfsd4_verify(rqstp, cstate, &u->nverify); in nfsd4_verify()
2344 struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation; in nfsd4_get_dir_delegation()
2352 * This is sub-optimal, since it means that the server would need to in nfsd4_get_dir_delegation()
2355 * return NFS4_OK with a non-fatal status of GDD4_UNAVAIL in this in nfsd4_get_dir_delegation()
2358 gdd->gddrnf_status = GDD4_UNAVAIL; in nfsd4_get_dir_delegation()
2366 if (!exp->ex_layout_types) { in nfsd4_layout_verify()
2372 !(exp->ex_layout_types & (1 << layout_type))) { in nfsd4_layout_verify()
2385 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo; in nfsd4_getdeviceinfo()
2393 gdp->gd_layout_type, in nfsd4_getdeviceinfo()
2394 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, in nfsd4_getdeviceinfo()
2395 gdp->gd_maxcount); in nfsd4_getdeviceinfo()
2397 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx); in nfsd4_getdeviceinfo()
2404 exp = rqst_exp_find(&rqstp->rq_chandle, SVC_NET(rqstp), in nfsd4_getdeviceinfo()
2405 rqstp->rq_client, rqstp->rq_gssclient, in nfsd4_getdeviceinfo()
2406 map->fsid_type, map->fsid); in nfsd4_getdeviceinfo()
2413 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type); in nfsd4_getdeviceinfo()
2418 if (gdp->gd_maxcount != 0) { in nfsd4_getdeviceinfo()
2419 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, in nfsd4_getdeviceinfo()
2420 rqstp, cstate->clp, gdp); in nfsd4_getdeviceinfo()
2423 gdp->gd_notify_types &= ops->notify_types; in nfsd4_getdeviceinfo()
2432 kfree(u->getdeviceinfo.gd_device); in nfsd4_getdeviceinfo_release()
2439 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_layoutget()
2440 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutget()
2446 switch (lgp->lg_seg.iomode) { in nfsd4_layoutget()
2455 __func__, lgp->lg_seg.iomode); in nfsd4_layoutget()
2465 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type); in nfsd4_layoutget()
2470 * Verify minlength and range as per RFC5661: in nfsd4_layoutget()
2481 if (lgp->lg_seg.length < lgp->lg_minlength || in nfsd4_layoutget()
2482 (lgp->lg_minlength != NFS4_MAX_UINT64 && in nfsd4_layoutget()
2483 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || in nfsd4_layoutget()
2484 (lgp->lg_seg.length != NFS4_MAX_UINT64 && in nfsd4_layoutget()
2485 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) in nfsd4_layoutget()
2487 if (lgp->lg_seg.length == 0) in nfsd4_layoutget()
2490 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid, in nfsd4_layoutget()
2491 true, lgp->lg_layout_type, &ls); in nfsd4_layoutget()
2493 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid); in nfsd4_layoutget()
2498 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) in nfsd4_layoutget()
2501 nfserr = ops->proc_layoutget(rqstp, d_inode(current_fh->fh_dentry), in nfsd4_layoutget()
2509 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutget()
2510 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutget()
2518 kfree(u->layoutget.lg_content); in nfsd4_layoutget_release()
2526 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_layoutcommit()
2527 const struct nfsd4_layout_seg *seg = &lcp->lc_seg; in nfsd4_layoutcommit()
2528 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutcommit()
2540 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); in nfsd4_layoutcommit()
2543 inode = d_inode(current_fh->fh_dentry); in nfsd4_layoutcommit()
2545 lcp->lc_size_chg = false; in nfsd4_layoutcommit()
2546 if (lcp->lc_newoffset) { in nfsd4_layoutcommit()
2547 loff_t new_size = lcp->lc_last_wr + 1; in nfsd4_layoutcommit()
2550 if (new_size <= seg->offset) in nfsd4_layoutcommit()
2552 if (new_size > seg->offset + seg->length) in nfsd4_layoutcommit()
2556 lcp->lc_size_chg = true; in nfsd4_layoutcommit()
2557 lcp->lc_newsize = new_size; in nfsd4_layoutcommit()
2562 if (locks_in_grace(net) && !lcp->lc_reclaim) in nfsd4_layoutcommit()
2565 if (!locks_in_grace(net) && lcp->lc_reclaim) in nfsd4_layoutcommit()
2568 if (!lcp->lc_reclaim) { in nfsd4_layoutcommit()
2570 &lcp->lc_sid, false, lcp->lc_layout_type, &ls); in nfsd4_layoutcommit()
2572 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid); in nfsd4_layoutcommit()
2580 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutcommit()
2583 nfserr = ops->proc_layoutcommit(inode, rqstp, lcp); in nfsd4_layoutcommit()
2585 if (!lcp->lc_reclaim) { in nfsd4_layoutcommit()
2586 nfsd4_file_mark_deleg_written(ls->ls_stid.sc_file); in nfsd4_layoutcommit()
2587 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutcommit()
2597 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_layoutreturn()
2598 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutreturn()
2606 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type)) in nfsd4_layoutreturn()
2609 switch (lrp->lr_seg.iomode) { in nfsd4_layoutreturn()
2616 lrp->lr_seg.iomode); in nfsd4_layoutreturn()
2621 switch (lrp->lr_return_type) { in nfsd4_layoutreturn()
2631 lrp->lr_return_type); in nfsd4_layoutreturn()
2644 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_getxattr()
2646 return nfsd_getxattr(rqstp, &cstate->current_fh, in nfsd4_getxattr()
2647 getxattr->getxa_name, &getxattr->getxa_buf, in nfsd4_getxattr()
2648 &getxattr->getxa_len); in nfsd4_getxattr()
2655 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_setxattr()
2661 ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name, in nfsd4_setxattr()
2662 setxattr->setxa_buf, setxattr->setxa_len, in nfsd4_setxattr()
2663 setxattr->setxa_flags); in nfsd4_setxattr()
2666 set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh); in nfsd4_setxattr()
2679 return nfsd_listxattr(rqstp, &cstate->current_fh, in nfsd4_listxattrs()
2680 &u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len); in nfsd4_listxattrs()
2687 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_removexattr()
2693 ret = nfsd_removexattr(rqstp, &cstate->current_fh, in nfsd4_removexattr()
2694 removexattr->rmxa_name); in nfsd4_removexattr()
2697 set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh); in nfsd4_removexattr()
2714 percpu_counter_inc(&nn->counter[NFSD_STATS_NFS4_OP(opnum)]); in nfsd4_increment_op_stats()
2725 * - SEQUENCE other than as first op results in
2727 * - BIND_CONN_TO_SESSION must be the only op in its compound.
2729 * - DESTROY_SESSION must be the final operation in a compound, if
2735 struct nfsd4_op *first_op = &args->ops[0]; in nfs41_check_op_ordering()
2738 if (args->minorversion == 0) in nfs41_check_op_ordering()
2741 if (args->opcnt == 0) in nfs41_check_op_ordering()
2743 if (first_op->status == nfserr_op_illegal) in nfs41_check_op_ordering()
2745 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) in nfs41_check_op_ordering()
2747 if (first_op->opnum == OP_SEQUENCE) in nfs41_check_op_ordering()
2754 if (args->opcnt != 1) in nfs41_check_op_ordering()
2761 return &nfsd4_ops[op->opnum]; in OPDESC()
2766 if (op->opnum == OP_ILLEGAL) in nfsd4_cache_this_op()
2768 return OPDESC(op)->op_flags & OP_CACHEME; in nfsd4_cache_this_op()
2773 struct nfsd4_compoundres *resp = rqstp->rq_resp; in need_wrongsec_check()
2774 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in need_wrongsec_check()
2775 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; in need_wrongsec_check()
2776 struct nfsd4_op *next = &argp->ops[resp->opcnt]; in need_wrongsec_check()
2781 * Most ops check wronsec on our own; only the putfh-like ops in need_wrongsec_check()
2784 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) in need_wrongsec_check()
2788 * put-filehandle operation if we're not going to use the in need_wrongsec_check()
2791 if (argp->opcnt == resp->opcnt) in need_wrongsec_check()
2793 if (next->opnum == OP_ILLEGAL) in need_wrongsec_check()
2801 return !(nextd->op_flags & OP_HANDLES_WRONGSEC); in need_wrongsec_check()
2816 for (i = 0; i < args->opcnt; i++) { in check_if_stalefh_allowed()
2817 op = &args->ops[i]; in check_if_stalefh_allowed()
2818 if (op->opnum == OP_PUTFH) in check_if_stalefh_allowed()
2820 else if (op->opnum == OP_SAVEFH) in check_if_stalefh_allowed()
2822 else if (op->opnum == OP_RESTOREFH) in check_if_stalefh_allowed()
2824 else if (op->opnum == OP_COPY) { in check_if_stalefh_allowed()
2825 copy = (struct nfsd4_copy *)&op->u; in check_if_stalefh_allowed()
2827 op->status = nfserr_nofilehandle; in check_if_stalefh_allowed()
2830 putfh = (struct nfsd4_putfh *)&saved_op->u; in check_if_stalefh_allowed()
2832 putfh->no_verify = true; in check_if_stalefh_allowed()
2849 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_proc_compound()
2850 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_proc_compound()
2852 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_proc_compound()
2853 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_proc_compound()
2854 struct svc_fh *save_fh = &cstate->save_fh; in nfsd4_proc_compound()
2858 resp->xdr = &rqstp->rq_res_stream; in nfsd4_proc_compound()
2859 resp->statusp = resp->xdr->p; in nfsd4_proc_compound()
2862 xdr_reserve_space(resp->xdr, XDR_UNIT); in nfsd4_proc_compound()
2865 xdr_reserve_space(resp->xdr, XDR_UNIT * 2 + args->taglen); in nfsd4_proc_compound()
2866 resp->taglen = args->taglen; in nfsd4_proc_compound()
2867 resp->tag = args->tag; in nfsd4_proc_compound()
2868 resp->rqstp = rqstp; in nfsd4_proc_compound()
2869 cstate->minorversion = args->minorversion; in nfsd4_proc_compound()
2874 * too hard to avoid non-idempotency problems. in nfsd4_proc_compound()
2876 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
2882 if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0) in nfsd4_proc_compound()
2887 op = &args->ops[0]; in nfsd4_proc_compound()
2888 op->status = status; in nfsd4_proc_compound()
2889 resp->opcnt = 1; in nfsd4_proc_compound()
2894 rqstp->rq_lease_breaker = (void **)&cstate->clp; in nfsd4_proc_compound()
2896 trace_nfsd_compound(rqstp, args->tag, args->taglen, args->client_opcnt); in nfsd4_proc_compound()
2897 while (!status && resp->opcnt < args->opcnt) { in nfsd4_proc_compound()
2898 op = &args->ops[resp->opcnt++]; in nfsd4_proc_compound()
2900 if (unlikely(resp->opcnt == NFSD_MAX_OPS_PER_COMPOUND)) { in nfsd4_proc_compound()
2903 if (cstate->minorversion == 0 && in nfsd4_proc_compound()
2904 args->client_opcnt > resp->opcnt) { in nfsd4_proc_compound()
2905 op->status = nfserr_resource; in nfsd4_proc_compound()
2911 * The XDR decode routines may have pre-set op->status; in nfsd4_proc_compound()
2915 if (op->status) { in nfsd4_proc_compound()
2916 if (op->opnum == OP_OPEN) in nfsd4_proc_compound()
2917 op->status = nfsd4_open_omfg(rqstp, cstate, op); in nfsd4_proc_compound()
2920 if (!current_fh->fh_dentry && in nfsd4_proc_compound()
2922 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) { in nfsd4_proc_compound()
2923 op->status = nfserr_nofilehandle; in nfsd4_proc_compound()
2926 } else if (current_fh->fh_export && in nfsd4_proc_compound()
2927 current_fh->fh_export->ex_fslocs.migrated && in nfsd4_proc_compound()
2928 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { in nfsd4_proc_compound()
2929 op->status = nfserr_moved; in nfsd4_proc_compound()
2935 /* If op is non-idempotent */ in nfsd4_proc_compound()
2936 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) { in nfsd4_proc_compound()
2941 u32 plen = op->opdesc->op_rsize_bop(rqstp, op); in nfsd4_proc_compound()
2946 if (resp->opcnt < args->opcnt) in nfsd4_proc_compound()
2948 op->status = nfsd4_check_resp_size(resp, plen); in nfsd4_proc_compound()
2951 if (op->status) in nfsd4_proc_compound()
2954 if (op->opdesc->op_get_currentstateid) in nfsd4_proc_compound()
2955 op->opdesc->op_get_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2956 op->status = op->opdesc->op_func(rqstp, cstate, &op->u); in nfsd4_proc_compound()
2957 trace_nfsd_compound_op_err(rqstp, op->opnum, op->status); in nfsd4_proc_compound()
2960 if (cstate->status == nfserr_replay_cache) { in nfsd4_proc_compound()
2962 status = op->status; in nfsd4_proc_compound()
2965 if (!op->status) { in nfsd4_proc_compound()
2966 if (op->opdesc->op_set_currentstateid) in nfsd4_proc_compound()
2967 op->opdesc->op_set_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2969 if (op->opdesc->op_flags & OP_CLEAR_STATEID) in nfsd4_proc_compound()
2972 if (current_fh->fh_export && in nfsd4_proc_compound()
2974 op->status = check_nfsd_access(current_fh->fh_export, rqstp, false); in nfsd4_proc_compound()
2977 if (op->status == nfserr_replay_me) { in nfsd4_proc_compound()
2978 op->replay = &cstate->replay_owner->so_replay; in nfsd4_proc_compound()
2979 nfsd4_encode_replay(resp->xdr, op); in nfsd4_proc_compound()
2980 status = op->status = op->replay->rp_status; in nfsd4_proc_compound()
2983 status = op->status; in nfsd4_proc_compound()
2986 trace_nfsd_compound_status(args->client_opcnt, resp->opcnt, in nfsd4_proc_compound()
2987 status, nfsd4_op_name(op->opnum)); in nfsd4_proc_compound()
2990 nfsd4_increment_op_stats(nn, op->opnum); in nfsd4_proc_compound()
2995 BUG_ON(cstate->replay_owner); in nfsd4_proc_compound()
2997 cstate->status = status; in nfsd4_proc_compound()
2999 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
3031 buflen = (rqstp->rq_page_end - rqstp->rq_next_page) * PAGE_SIZE; in nfsd4_max_payload()
3032 buflen -= rqstp->rq_auth_slack; in nfsd4_max_payload()
3033 buflen -= rqstp->rq_res.head[0].iov_len; in nfsd4_max_payload()
3077 const u32 *bmap = op->u.getattr.ga_bmval; in nfsd4_getattr_rsize()
3144 u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp)); in nfsd4_read_rsize()
3152 u32 rlen = min(op->u.read.rd_length, nfsd4_max_payload(rqstp)); in nfsd4_read_plus_rsize()
3166 u32 rlen = min(op->u.readdir.rd_maxcount, nfsd4_max_payload(rqstp)); in nfsd4_readdir_rsize()
3202 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids) in nfsd4_test_stateid_rsize()
3317 u32 rlen = min(op->u.getdeviceinfo.gd_maxcount, nfsd4_max_payload(rqstp)); in nfsd4_getdeviceinfo_rsize()
3381 u32 rlen = min(op->u.listxattrs.lsxa_maxcount, nfsd4_max_payload(rqstp)); in nfsd4_listxattrs_rsize()
3816 * nfsd4_spo_must_allow - Determine if the compound op contains an
3827 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_spo_must_allow()
3828 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in nfsd4_spo_must_allow()
3830 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_spo_must_allow()
3831 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; in nfsd4_spo_must_allow()
3834 if (rqstp->rq_procinfo != &nfsd_version4.vs_proc[NFSPROC4_COMPOUND] || in nfsd4_spo_must_allow()
3835 cstate->minorversion == 0) in nfsd4_spo_must_allow()
3838 if (cstate->spo_must_allowed) in nfsd4_spo_must_allow()
3841 opiter = resp->opcnt; in nfsd4_spo_must_allow()
3842 while (opiter < argp->opcnt) { in nfsd4_spo_must_allow()
3843 this = &argp->ops[opiter++]; in nfsd4_spo_must_allow()
3844 if (test_bit(this->opnum, allow->u.longs) && in nfsd4_spo_must_allow()
3845 cstate->clp->cl_mach_cred && in nfsd4_spo_must_allow()
3846 nfsd4_mach_creds_match(cstate->clp, rqstp)) { in nfsd4_spo_must_allow()
3847 cstate->spo_must_allowed = true; in nfsd4_spo_must_allow()
3851 cstate->spo_must_allowed = false; in nfsd4_spo_must_allow()
3857 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp) in nfsd4_max_reply()
3860 BUG_ON(OPDESC(op)->op_rsize_bop == NULL); in nfsd4_max_reply()
3861 return OPDESC(op)->op_rsize_bop(rqstp, op); in nfsd4_max_reply()
3866 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { in warn_on_nonidempotent_op()
3868 op->opnum, nfsd4_op_name(op->opnum)); in warn_on_nonidempotent_op()