Lines Matching +full:ssc +full:- +full:range
2 * Server-side procedures for NFSv4.
59 struct inode *inode = d_inode(resfh->fh_dentry); in nfsd4_security_inode_setsecctx()
63 status = security_inode_setsecctx(resfh->fh_dentry, in nfsd4_security_inode_setsecctx()
64 label->data, label->len); in nfsd4_security_inode_setsecctx()
101 struct dentry *dentry = cstate->current_fh.fh_dentry; in check_attr_support()
102 struct svc_export *exp = cstate->current_fh.fh_export; in check_attr_support()
104 if (!nfsd_attrs_supported(cstate->minorversion, bmval)) in check_attr_support()
109 !(exp->ex_flags & NFSEXP_SECURITY_LABEL)) in check_attr_support()
125 if (open->op_create == NFS4_OPEN_CREATE) { in nfsd4_check_open_attributes()
126 if (open->op_createmode == NFS4_CREATE_UNCHECKED in nfsd4_check_open_attributes()
127 || open->op_createmode == NFS4_CREATE_GUARDED) in nfsd4_check_open_attributes()
129 open->op_bmval, nfsd_attrmask); in nfsd4_check_open_attributes()
130 else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1) in nfsd4_check_open_attributes()
132 open->op_bmval, nfsd41_ex_attrmask); in nfsd4_check_open_attributes()
141 return open->op_create == NFS4_OPEN_CREATE in is_create_with_attrs()
142 && (open->op_createmode == NFS4_CREATE_UNCHECKED in is_create_with_attrs()
143 || open->op_createmode == NFS4_CREATE_GUARDED in is_create_with_attrs()
144 || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1); in is_create_with_attrs()
171 dget(src->fh_dentry); in fh_dup2()
172 if (src->fh_export) in fh_dup2()
173 exp_get(src->fh_export); in fh_dup2()
182 if (open->op_truncate && in do_open_permission()
183 !(open->op_share_access & NFS4_SHARE_ACCESS_WRITE)) in do_open_permission()
188 if (open->op_share_access & NFS4_SHARE_ACCESS_READ) in do_open_permission()
190 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) in do_open_permission()
192 if (open->op_share_deny & NFS4_SHARE_DENY_READ) in do_open_permission()
202 umode_t mode = d_inode(fh->fh_dentry)->i_mode; in nfsd_check_obj_isreg()
209 * Using err_symlink as our catch-all case may look odd; but in nfsd_check_obj_isreg()
222 fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh, in nfsd4_set_open_owner_reply_cache()
223 &resfh->fh_handle); in nfsd4_set_open_owner_reply_cache()
229 struct svc_fh *current_fh = &cstate->current_fh; in do_open_lookup()
237 open->op_truncate = false; in do_open_lookup()
239 if (open->op_create) { in do_open_lookup()
245 * -------------+--------+-----------------+-------------------- in do_open_lookup()
259 current->fs->umask = open->op_umask; in do_open_lookup()
260 status = do_nfsd_create(rqstp, current_fh, open->op_fname.data, in do_open_lookup()
261 open->op_fname.len, &open->op_iattr, in do_open_lookup()
262 *resfh, open->op_createmode, in do_open_lookup()
263 (u32 *)open->op_verf.data, in do_open_lookup()
264 &open->op_truncate, &open->op_created); in do_open_lookup()
265 current->fs->umask = 0; in do_open_lookup()
267 if (!status && open->op_label.len) in do_open_lookup()
268 nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval); in do_open_lookup()
275 if (nfsd_create_is_exclusive(open->op_createmode) && status == 0) in do_open_lookup()
276 open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS | in do_open_lookup()
286 open->op_fname.data, open->op_fname.len, *resfh); in do_open_lookup()
293 if (is_create_with_attrs(open) && open->op_acl != NULL) in do_open_lookup()
294 do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval); in do_open_lookup()
298 if (open->op_created || in do_open_lookup()
299 open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR) in do_open_lookup()
302 set_change_info(&open->op_cinfo, current_fh); in do_open_lookup()
310 struct svc_fh *current_fh = &cstate->current_fh; in do_open_fhandle()
318 memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info)); in do_open_fhandle()
322 open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) && in do_open_fhandle()
323 (open->op_iattr.ia_size == 0); in do_open_fhandle()
333 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH) in do_open_fhandle()
345 (struct nfsd4_sessionid *)session->se_sessionid.data; in copy_clientid()
347 clid->cl_boot = sid->clientid.cl_boot; in copy_clientid()
348 clid->cl_id = sid->clientid.cl_id; in copy_clientid()
355 struct nfsd4_open *open = &u->open; in nfsd4_open()
363 (int)open->op_fname.len, open->op_fname.data, in nfsd4_open()
364 open->op_openowner); in nfsd4_open()
367 if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL) in nfsd4_open()
370 open->op_created = false; in nfsd4_open()
377 &cstate->session->se_client->cl_flags) && in nfsd4_open()
378 open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
382 copy_clientid(&open->op_clientid, cstate->session); in nfsd4_open()
387 struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay; in nfsd4_open()
388 fh_put(&cstate->current_fh); in nfsd4_open()
389 fh_copy_shallow(&cstate->current_fh.fh_handle, in nfsd4_open()
390 &rp->rp_openfh); in nfsd4_open()
391 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_open()
400 if (open->op_xdr_error) { in nfsd4_open()
401 status = open->op_xdr_error; in nfsd4_open()
412 if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
415 if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS) in nfsd4_open()
418 switch (open->op_claim_type) { in nfsd4_open()
426 status = nfs4_check_open_reclaim(&open->op_clientid, in nfsd4_open()
430 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED; in nfsd4_open()
438 resfh = &cstate->current_fh; in nfsd4_open()
443 open->op_claim_type); in nfsd4_open()
448 open->op_claim_type); in nfsd4_open()
454 * successful, it (1) truncates the file if open->op_truncate was in nfsd4_open()
455 * set, (2) sets open->op_stateid, (3) sets open->op_delegation. in nfsd4_open()
458 WARN(status && open->op_created, in nfsd4_open()
459 "nfsd4_process_open2 failed to open newly-created file! status=%u\n", in nfsd4_open()
462 nn->somebody_reclaimed = true; in nfsd4_open()
464 if (resfh && resfh != &cstate->current_fh) { in nfsd4_open()
465 fh_dup2(&cstate->current_fh, resfh); in nfsd4_open()
475 * OPEN is the only seqid-mutating operation whose decoding can fail
476 * with a seqid-mutating error (specifically, decoding of user names in
482 struct nfsd4_open *open = &op->u.open; in nfsd4_open_omfg()
484 if (!seqid_mutating_err(ntohl(op->status))) in nfsd4_open_omfg()
485 return op->status; in nfsd4_open_omfg()
487 return op->status; in nfsd4_open_omfg()
488 open->op_xdr_error = op->status; in nfsd4_open_omfg()
489 return nfsd4_open(rqstp, cstate, &op->u); in nfsd4_open_omfg()
493 * filehandle-manipulating ops.
499 u->getfh = &cstate->current_fh; in nfsd4_getfh()
507 struct nfsd4_putfh *putfh = &u->putfh; in nfsd4_putfh()
510 fh_put(&cstate->current_fh); in nfsd4_putfh()
511 cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen; in nfsd4_putfh()
512 memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval, in nfsd4_putfh()
513 putfh->pf_fhlen); in nfsd4_putfh()
514 ret = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS); in nfsd4_putfh()
516 if (ret == nfserr_stale && putfh->no_verify) { in nfsd4_putfh()
517 SET_FH_FLAG(&cstate->current_fh, NFSD4_FH_FOREIGN); in nfsd4_putfh()
530 fh_put(&cstate->current_fh); in nfsd4_putrootfh()
531 status = exp_pseudoroot(rqstp, &cstate->current_fh); in nfsd4_putrootfh()
539 if (!cstate->save_fh.fh_dentry) in nfsd4_restorefh()
542 fh_dup2(&cstate->current_fh, &cstate->save_fh); in nfsd4_restorefh()
544 memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t)); in nfsd4_restorefh()
554 fh_dup2(&cstate->save_fh, &cstate->current_fh); in nfsd4_savefh()
556 memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t)); in nfsd4_savefh()
569 struct nfsd4_access *access = &u->access; in nfsd4_access()
573 if (cstate->minorversion >= 2) in nfsd4_access()
577 if (access->ac_req_access & ~access_full) in nfsd4_access()
580 access->ac_resp_access = access->ac_req_access; in nfsd4_access()
581 return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access, in nfsd4_access()
582 &access->ac_supported); in nfsd4_access()
587 __be32 *verf = (__be32 *)verifier->data; in gen_boot_verifier()
589 BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data)); in gen_boot_verifier()
598 struct nfsd4_commit *commit = &u->commit; in nfsd4_commit()
600 return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset, in nfsd4_commit()
601 commit->co_count, in nfsd4_commit()
602 (__be32 *)commit->co_verf.data); in nfsd4_commit()
609 struct nfsd4_create *create = &u->create; in nfsd4_create()
616 status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP); in nfsd4_create()
620 status = check_attr_support(rqstp, cstate, create->cr_bmval, in nfsd4_create()
625 current->fs->umask = create->cr_umask; in nfsd4_create()
626 switch (create->cr_type) { in nfsd4_create()
628 status = nfsd_symlink(rqstp, &cstate->current_fh, in nfsd4_create()
629 create->cr_name, create->cr_namelen, in nfsd4_create()
630 create->cr_data, &resfh); in nfsd4_create()
635 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
636 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
637 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
639 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
640 create->cr_name, create->cr_namelen, in nfsd4_create()
641 &create->cr_iattr, S_IFBLK, rdev, &resfh); in nfsd4_create()
646 rdev = MKDEV(create->cr_specdata1, create->cr_specdata2); in nfsd4_create()
647 if (MAJOR(rdev) != create->cr_specdata1 || in nfsd4_create()
648 MINOR(rdev) != create->cr_specdata2) in nfsd4_create()
650 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
651 create->cr_name, create->cr_namelen, in nfsd4_create()
652 &create->cr_iattr,S_IFCHR, rdev, &resfh); in nfsd4_create()
656 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
657 create->cr_name, create->cr_namelen, in nfsd4_create()
658 &create->cr_iattr, S_IFSOCK, 0, &resfh); in nfsd4_create()
662 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
663 create->cr_name, create->cr_namelen, in nfsd4_create()
664 &create->cr_iattr, S_IFIFO, 0, &resfh); in nfsd4_create()
668 create->cr_iattr.ia_valid &= ~ATTR_SIZE; in nfsd4_create()
669 status = nfsd_create(rqstp, &cstate->current_fh, in nfsd4_create()
670 create->cr_name, create->cr_namelen, in nfsd4_create()
671 &create->cr_iattr, S_IFDIR, 0, &resfh); in nfsd4_create()
681 if (create->cr_label.len) in nfsd4_create()
682 nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval); in nfsd4_create()
684 if (create->cr_acl != NULL) in nfsd4_create()
685 do_set_nfs4_acl(rqstp, &resfh, create->cr_acl, in nfsd4_create()
686 create->cr_bmval); in nfsd4_create()
688 fh_unlock(&cstate->current_fh); in nfsd4_create()
689 set_change_info(&create->cr_cinfo, &cstate->current_fh); in nfsd4_create()
690 fh_dup2(&cstate->current_fh, &resfh); in nfsd4_create()
694 current->fs->umask = 0; in nfsd4_create()
702 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_getattr()
705 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in nfsd4_getattr()
709 if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_getattr()
712 getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_getattr()
713 getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_getattr()
714 getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_getattr()
716 getattr->ga_fhp = &cstate->current_fh; in nfsd4_getattr()
724 struct nfsd4_link *link = &u->link; in nfsd4_link()
727 status = nfsd_link(rqstp, &cstate->current_fh, in nfsd4_link()
728 link->li_name, link->li_namelen, &cstate->save_fh); in nfsd4_link()
730 set_change_info(&link->li_cinfo, &cstate->current_fh); in nfsd4_link()
743 if (tmp_fh.fh_dentry == fh->fh_dentry) { in nfsd4_do_lookupp()
755 return nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_lookupp()
762 return nfsd_lookup(rqstp, &cstate->current_fh, in nfsd4_lookup()
763 u->lookup.lo_name, u->lookup.lo_len, in nfsd4_lookup()
764 &cstate->current_fh); in nfsd4_lookup()
771 struct nfsd4_read *read = &u->read; in nfsd4_read()
774 read->rd_nf = NULL; in nfsd4_read()
775 if (read->rd_offset >= OFFSET_MAX) in nfsd4_read()
778 trace_nfsd_read_start(rqstp, &cstate->current_fh, in nfsd4_read()
779 read->rd_offset, read->rd_length); in nfsd4_read()
790 clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags); in nfsd4_read()
793 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_read()
794 &read->rd_stateid, RD_STATE, in nfsd4_read()
795 &read->rd_nf, NULL); in nfsd4_read()
802 read->rd_rqstp = rqstp; in nfsd4_read()
803 read->rd_fhp = &cstate->current_fh; in nfsd4_read()
811 if (u->read.rd_nf) in nfsd4_read_release()
812 nfsd_file_put(u->read.rd_nf); in nfsd4_read_release()
813 trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp, in nfsd4_read_release()
814 u->read.rd_offset, u->read.rd_length); in nfsd4_read_release()
821 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_readdir()
822 u64 cookie = readdir->rd_cookie; in nfsd4_readdir()
825 /* no need to check permission - this will be done in nfsd_readdir() */ in nfsd4_readdir()
827 if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1) in nfsd4_readdir()
830 readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0]; in nfsd4_readdir()
831 readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1]; in nfsd4_readdir()
832 readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2]; in nfsd4_readdir()
835 (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE))) in nfsd4_readdir()
838 readdir->rd_rqstp = rqstp; in nfsd4_readdir()
839 readdir->rd_fhp = &cstate->current_fh; in nfsd4_readdir()
847 u->readlink.rl_rqstp = rqstp; in nfsd4_readlink()
848 u->readlink.rl_fhp = &cstate->current_fh; in nfsd4_readlink()
856 struct nfsd4_remove *remove = &u->remove; in nfsd4_remove()
861 status = nfsd_unlink(rqstp, &cstate->current_fh, 0, in nfsd4_remove()
862 remove->rm_name, remove->rm_namelen); in nfsd4_remove()
864 fh_unlock(&cstate->current_fh); in nfsd4_remove()
865 set_change_info(&remove->rm_cinfo, &cstate->current_fh); in nfsd4_remove()
874 struct nfsd4_rename *rename = &u->rename; in nfsd4_rename()
879 status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname, in nfsd4_rename()
880 rename->rn_snamelen, &cstate->current_fh, in nfsd4_rename()
881 rename->rn_tname, rename->rn_tnamelen); in nfsd4_rename()
884 set_change_info(&rename->rn_sinfo, &cstate->current_fh); in nfsd4_rename()
885 set_change_info(&rename->rn_tinfo, &cstate->save_fh); in nfsd4_rename()
893 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_secinfo()
898 err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC); in nfsd4_secinfo()
901 err = nfsd_lookup_dentry(rqstp, &cstate->current_fh, in nfsd4_secinfo()
902 secinfo->si_name, secinfo->si_namelen, in nfsd4_secinfo()
906 fh_unlock(&cstate->current_fh); in nfsd4_secinfo()
911 secinfo->si_exp = exp; in nfsd4_secinfo()
913 if (cstate->minorversion) in nfsd4_secinfo()
915 fh_put(&cstate->current_fh); in nfsd4_secinfo()
925 switch (u->secinfo_no_name.sin_style) { in nfsd4_secinfo_no_name()
929 err = nfsd4_do_lookupp(rqstp, &cstate->current_fh); in nfsd4_secinfo_no_name()
937 u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export); in nfsd4_secinfo_no_name()
938 fh_put(&cstate->current_fh); in nfsd4_secinfo_no_name()
945 if (u->secinfo.si_exp) in nfsd4_secinfo_release()
946 exp_put(u->secinfo.si_exp); in nfsd4_secinfo_release()
952 if (u->secinfo_no_name.sin_exp) in nfsd4_secinfo_no_name_release()
953 exp_put(u->secinfo_no_name.sin_exp); in nfsd4_secinfo_no_name_release()
960 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_setattr()
964 if (setattr->sa_iattr.ia_valid & ATTR_SIZE) { in nfsd4_setattr()
966 &cstate->current_fh, &setattr->sa_stateid, in nfsd4_setattr()
973 err = fh_want_write(&cstate->current_fh); in nfsd4_setattr()
978 status = check_attr_support(rqstp, cstate, setattr->sa_bmval, in nfsd4_setattr()
983 if (setattr->sa_acl != NULL) in nfsd4_setattr()
984 status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh, in nfsd4_setattr()
985 setattr->sa_acl); in nfsd4_setattr()
988 if (setattr->sa_label.len) in nfsd4_setattr()
989 status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh, in nfsd4_setattr()
990 &setattr->sa_label); in nfsd4_setattr()
993 status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr, in nfsd4_setattr()
996 fh_drop_write(&cstate->current_fh); in nfsd4_setattr()
1004 struct nfsd4_write *write = &u->write; in nfsd4_write()
1005 stateid_t *stateid = &write->wr_stateid; in nfsd4_write()
1011 if (write->wr_offset >= OFFSET_MAX) in nfsd4_write()
1014 cnt = write->wr_buflen; in nfsd4_write()
1015 trace_nfsd_write_start(rqstp, &cstate->current_fh, in nfsd4_write()
1016 write->wr_offset, cnt); in nfsd4_write()
1017 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_write()
1024 write->wr_how_written = write->wr_stable_how; in nfsd4_write()
1026 nvecs = svc_fill_write_vector(rqstp, write->wr_pagelist, in nfsd4_write()
1027 &write->wr_head, write->wr_buflen); in nfsd4_write()
1028 WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec)); in nfsd4_write()
1030 status = nfsd_vfs_write(rqstp, &cstate->current_fh, nf, in nfsd4_write()
1031 write->wr_offset, rqstp->rq_vec, nvecs, &cnt, in nfsd4_write()
1032 write->wr_how_written, in nfsd4_write()
1033 (__be32 *)write->wr_verifier.data); in nfsd4_write()
1036 write->wr_bytes_written = cnt; in nfsd4_write()
1037 trace_nfsd_write_done(rqstp, &cstate->current_fh, in nfsd4_write()
1038 write->wr_offset, cnt); in nfsd4_write()
1049 if (!cstate->save_fh.fh_dentry) in nfsd4_verify_copy()
1052 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh, in nfsd4_verify_copy()
1059 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_verify_copy()
1066 /* fix up for NFS-specific error code */ in nfsd4_verify_copy()
1067 if (!S_ISREG(file_inode((*src)->nf_file)->i_mode) || in nfsd4_verify_copy()
1068 !S_ISREG(file_inode((*dst)->nf_file)->i_mode)) { in nfsd4_verify_copy()
1086 struct nfsd4_clone *clone = &u->clone; in nfsd4_clone()
1090 status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src, in nfsd4_clone()
1091 &clone->cl_dst_stateid, &dst); in nfsd4_clone()
1095 status = nfsd4_clone_file_range(src, clone->cl_src_pos, in nfsd4_clone()
1096 dst, clone->cl_dst_pos, clone->cl_count, in nfsd4_clone()
1097 EX_ISSYNC(cstate->current_fh.fh_export)); in nfsd4_clone()
1107 if (!refcount_dec_and_test(©->refcount)) in nfs4_put_copy()
1117 spin_lock(©->cp_clp->async_lock); in check_and_set_stop_copy()
1118 value = copy->stopped; in check_and_set_stop_copy()
1119 if (!copy->stopped) in check_and_set_stop_copy()
1120 copy->stopped = true; in check_and_set_stop_copy()
1121 spin_unlock(©->cp_clp->async_lock); in check_and_set_stop_copy()
1129 kthread_stop(copy->copy_task); in nfsd4_stop_copy()
1137 spin_lock(&clp->async_lock); in nfsd4_get_copy()
1138 if (!list_empty(&clp->async_copies)) { in nfsd4_get_copy()
1139 copy = list_first_entry(&clp->async_copies, struct nfsd4_copy, in nfsd4_get_copy()
1141 refcount_inc(©->refcount); in nfsd4_get_copy()
1143 spin_unlock(&clp->async_lock); in nfsd4_get_copy()
1182 naddr = &nss->u.nl4_addr; in nfsd4_interssc_connect()
1183 tmp_addrlen = rpc_uaddr2sockaddr(SVC_NET(rqstp), naddr->addr, in nfsd4_interssc_connect()
1184 naddr->addr_len, in nfsd4_interssc_connect()
1197 if (naddr->netid_len != match_netid_len || in nfsd4_interssc_connect()
1198 strncmp(naddr->netid, match_netid, naddr->netid_len)) in nfsd4_interssc_connect()
1229 /* Use an 'internal' mount: SB_KERNMOUNT -> MNT_INTERNAL */ in nfsd4_interssc_connect()
1231 module_put(type->owner); in nfsd4_interssc_connect()
1251 nfs_do_sb_deactive(ss_mnt->mnt_sb); in nfsd4_interssc_disconnect()
1270 stateid_t *s_stid = ©->cp_src_stateid; in nfsd4_setup_inter_ssc()
1274 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_setup_inter_ssc()
1275 ©->cp_dst_stateid, in nfsd4_setup_inter_ssc()
1276 WR_STATE, ©->nf_dst, NULL); in nfsd4_setup_inter_ssc()
1280 status = nfsd4_interssc_connect(©->cp_src, rqstp, mount); in nfsd4_setup_inter_ssc()
1284 s_fh = &cstate->save_fh; in nfsd4_setup_inter_ssc()
1286 copy->c_fh.size = s_fh->fh_handle.fh_size; in nfsd4_setup_inter_ssc()
1287 memcpy(copy->c_fh.data, &s_fh->fh_handle.fh_base, copy->c_fh.size); in nfsd4_setup_inter_ssc()
1288 copy->stateid.seqid = cpu_to_be32(s_stid->si_generation); in nfsd4_setup_inter_ssc()
1289 memcpy(copy->stateid.other, (void *)&s_stid->si_opaque, in nfsd4_setup_inter_ssc()
1301 nfs42_ssc_close(src->nf_file); in nfsd4_cleanup_inter_ssc()
1302 fput(src->nf_file); in nfsd4_cleanup_inter_ssc()
1343 return nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, in nfsd4_setup_intra_ssc()
1344 ©->nf_src, ©->cp_dst_stateid, in nfsd4_setup_intra_ssc()
1345 ©->nf_dst); in nfsd4_setup_intra_ssc()
1375 copy->cp_res.wr_stable_how = NFS_UNSTABLE; in nfsd4_init_copy_res()
1376 copy->cp_synchronous = sync; in nfsd4_init_copy_res()
1377 gen_boot_verifier(©->cp_res.wr_verifier, copy->cp_clp->net); in nfsd4_init_copy_res()
1383 size_t bytes_total = copy->cp_count; in _nfsd_copy_file_range()
1384 u64 src_pos = copy->cp_src_pos; in _nfsd_copy_file_range()
1385 u64 dst_pos = copy->cp_dst_pos; in _nfsd_copy_file_range()
1390 bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file, in _nfsd_copy_file_range()
1391 src_pos, copy->nf_dst->nf_file, dst_pos, in _nfsd_copy_file_range()
1395 bytes_total -= bytes_copied; in _nfsd_copy_file_range()
1396 copy->cp_res.wr_bytes_written += bytes_copied; in _nfsd_copy_file_range()
1399 } while (bytes_total > 0 && !copy->cp_synchronous); in _nfsd_copy_file_range()
1412 if (bytes < 0 && !copy->cp_res.wr_bytes_written) in nfsd4_do_copy()
1419 if (!copy->cp_intra) /* Inter server SSC */ in nfsd4_do_copy()
1420 nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src, in nfsd4_do_copy()
1421 copy->nf_dst); in nfsd4_do_copy()
1423 nfsd4_cleanup_intra_ssc(copy->nf_src, copy->nf_dst); in nfsd4_do_copy()
1430 dst->cp_src_pos = src->cp_src_pos; in dup_copy_fields()
1431 dst->cp_dst_pos = src->cp_dst_pos; in dup_copy_fields()
1432 dst->cp_count = src->cp_count; in dup_copy_fields()
1433 dst->cp_synchronous = src->cp_synchronous; in dup_copy_fields()
1434 memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res)); in dup_copy_fields()
1435 memcpy(&dst->fh, &src->fh, sizeof(src->fh)); in dup_copy_fields()
1436 dst->cp_clp = src->cp_clp; in dup_copy_fields()
1437 dst->nf_dst = nfsd_file_get(src->nf_dst); in dup_copy_fields()
1438 dst->cp_intra = src->cp_intra; in dup_copy_fields()
1439 if (src->cp_intra) /* for inter, file_src doesn't exist yet */ in dup_copy_fields()
1440 dst->nf_src = nfsd_file_get(src->nf_src); in dup_copy_fields()
1442 memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid)); in dup_copy_fields()
1443 memcpy(&dst->cp_src, &src->cp_src, sizeof(struct nl4_server)); in dup_copy_fields()
1444 memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid)); in dup_copy_fields()
1445 memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh)); in dup_copy_fields()
1446 dst->ss_mnt = src->ss_mnt; in dup_copy_fields()
1452 nfsd_file_put(copy->nf_dst); in cleanup_async_copy()
1453 if (copy->cp_intra) in cleanup_async_copy()
1454 nfsd_file_put(copy->nf_src); in cleanup_async_copy()
1455 spin_lock(©->cp_clp->async_lock); in cleanup_async_copy()
1456 list_del(©->copies); in cleanup_async_copy()
1457 spin_unlock(©->cp_clp->async_lock); in cleanup_async_copy()
1466 if (!copy->cp_intra) { /* Inter server SSC */ in nfsd4_do_async_copy()
1467 copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL); in nfsd4_do_async_copy()
1468 if (!copy->nf_src) { in nfsd4_do_async_copy()
1469 copy->nfserr = nfserr_serverfault; in nfsd4_do_async_copy()
1470 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_do_async_copy()
1473 copy->nf_src->nf_file = nfs42_ssc_open(copy->ss_mnt, ©->c_fh, in nfsd4_do_async_copy()
1474 ©->stateid); in nfsd4_do_async_copy()
1475 if (IS_ERR(copy->nf_src->nf_file)) { in nfsd4_do_async_copy()
1476 copy->nfserr = nfserr_offload_denied; in nfsd4_do_async_copy()
1477 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_do_async_copy()
1482 copy->nfserr = nfsd4_do_copy(copy, 0); in nfsd4_do_async_copy()
1487 refcount_set(&cb_copy->refcount, 1); in nfsd4_do_async_copy()
1488 memcpy(&cb_copy->cp_res, ©->cp_res, sizeof(copy->cp_res)); in nfsd4_do_async_copy()
1489 cb_copy->cp_clp = copy->cp_clp; in nfsd4_do_async_copy()
1490 cb_copy->nfserr = copy->nfserr; in nfsd4_do_async_copy()
1491 memcpy(&cb_copy->fh, ©->fh, sizeof(copy->fh)); in nfsd4_do_async_copy()
1492 nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp, in nfsd4_do_async_copy()
1494 nfsd4_run_cb(&cb_copy->cp_cb); in nfsd4_do_async_copy()
1496 if (!copy->cp_intra) in nfsd4_do_async_copy()
1497 kfree(copy->nf_src); in nfsd4_do_async_copy()
1506 struct nfsd4_copy *copy = &u->copy; in nfsd4_copy()
1510 if (!copy->cp_intra) { /* Inter server SSC */ in nfsd4_copy()
1511 if (!inter_copy_offload_enable || copy->cp_synchronous) { in nfsd4_copy()
1516 ©->ss_mnt); in nfsd4_copy()
1525 copy->cp_clp = cstate->clp; in nfsd4_copy()
1526 memcpy(©->fh, &cstate->current_fh.fh_handle, in nfsd4_copy()
1528 if (!copy->cp_synchronous) { in nfsd4_copy()
1531 status = nfserrno(-ENOMEM); in nfsd4_copy()
1537 refcount_set(&async_copy->refcount, 1); in nfsd4_copy()
1538 memcpy(©->cp_res.cb_stateid, ©->cp_stateid.stid, in nfsd4_copy()
1539 sizeof(copy->cp_res.cb_stateid)); in nfsd4_copy()
1541 async_copy->copy_task = kthread_create(nfsd4_do_async_copy, in nfsd4_copy()
1543 if (IS_ERR(async_copy->copy_task)) in nfsd4_copy()
1545 spin_lock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
1546 list_add(&async_copy->copies, in nfsd4_copy()
1547 &async_copy->cp_clp->async_copies); in nfsd4_copy()
1548 spin_unlock(&async_copy->cp_clp->async_lock); in nfsd4_copy()
1549 wake_up_process(async_copy->copy_task); in nfsd4_copy()
1559 status = nfserrno(-ENOMEM); in nfsd4_copy()
1560 if (!copy->cp_intra) in nfsd4_copy()
1561 nfsd4_interssc_disconnect(copy->ss_mnt); in nfsd4_copy()
1570 spin_lock(&clp->async_lock); in find_async_copy()
1571 list_for_each_entry(copy, &clp->async_copies, copies) { in find_async_copy()
1572 if (memcmp(©->cp_stateid.stid, stateid, NFS4_STATEID_SIZE)) in find_async_copy()
1574 refcount_inc(©->refcount); in find_async_copy()
1575 spin_unlock(&clp->async_lock); in find_async_copy()
1578 spin_unlock(&clp->async_lock); in find_async_copy()
1587 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_cancel()
1589 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_cancel()
1591 copy = find_async_copy(clp, &os->stateid); in nfsd4_offload_cancel()
1595 return manage_cpntf_state(nn, &os->stateid, clp, NULL); in nfsd4_offload_cancel()
1606 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_copy_notify()
1611 struct nfs4_client *clp = cstate->clp; in nfsd4_copy_notify()
1613 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_copy_notify()
1614 &cn->cpn_src_stateid, RD_STATE, NULL, in nfsd4_copy_notify()
1619 cn->cpn_sec = nn->nfsd4_lease; in nfsd4_copy_notify()
1620 cn->cpn_nsec = 0; in nfsd4_copy_notify()
1622 status = nfserrno(-ENOMEM); in nfsd4_copy_notify()
1626 memcpy(&cn->cpn_cnr_stateid, &cps->cp_stateid.stid, sizeof(stateid_t)); in nfsd4_copy_notify()
1627 memcpy(&cps->cp_p_stateid, &stid->sc_stateid, sizeof(stateid_t)); in nfsd4_copy_notify()
1628 memcpy(&cps->cp_p_clid, &clp->cl_clientid, sizeof(clientid_t)); in nfsd4_copy_notify()
1633 cn->cpn_src.nl4_type = NL4_NETADDR; in nfsd4_copy_notify()
1634 status = nfsd4_set_netaddr((struct sockaddr *)&rqstp->rq_daddr, in nfsd4_copy_notify()
1635 &cn->cpn_src.u.nl4_addr); in nfsd4_copy_notify()
1653 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_fallocate()
1654 &fallocate->falloc_stateid, in nfsd4_fallocate()
1661 status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, nf->nf_file, in nfsd4_fallocate()
1662 fallocate->falloc_offset, in nfsd4_fallocate()
1663 fallocate->falloc_length, in nfsd4_fallocate()
1673 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_offload_status()
1676 struct nfs4_client *clp = cstate->clp; in nfsd4_offload_status()
1678 copy = find_async_copy(clp, &os->stateid); in nfsd4_offload_status()
1680 os->count = copy->cp_res.wr_bytes_written; in nfsd4_offload_status()
1692 return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0); in nfsd4_allocate()
1699 return nfsd4_fallocate(rqstp, cstate, &u->deallocate, in nfsd4_deallocate()
1707 struct nfsd4_seek *seek = &u->seek; in nfsd4_seek()
1712 status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh, in nfsd4_seek()
1713 &seek->seek_stateid, in nfsd4_seek()
1720 switch (seek->seek_whence) { in nfsd4_seek()
1733 * Note: This call does change file->f_pos, but nothing in NFSD in nfsd4_seek()
1734 * should ever file->f_pos. in nfsd4_seek()
1736 seek->seek_pos = vfs_llseek(nf->nf_file, seek->seek_offset, whence); in nfsd4_seek()
1737 if (seek->seek_pos < 0) in nfsd4_seek()
1738 status = nfserrno(seek->seek_pos); in nfsd4_seek()
1739 else if (seek->seek_pos >= i_size_read(file_inode(nf->nf_file))) in nfsd4_seek()
1740 seek->seek_eof = true; in nfsd4_seek()
1760 status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP); in _nfsd4_verify()
1764 status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL); in _nfsd4_verify()
1768 if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR) in _nfsd4_verify()
1769 || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)) in _nfsd4_verify()
1771 if (verify->ve_attrlen & 3) in _nfsd4_verify()
1777 count = 4 + (verify->ve_attrlen >> 2); in _nfsd4_verify()
1783 status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh, in _nfsd4_verify()
1784 cstate->current_fh.fh_export, in _nfsd4_verify()
1785 cstate->current_fh.fh_dentry, in _nfsd4_verify()
1786 verify->ve_bmval, in _nfsd4_verify()
1800 if (ntohl(*p++) != verify->ve_attrlen) in _nfsd4_verify()
1802 if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen)) in _nfsd4_verify()
1816 status = _nfsd4_verify(rqstp, cstate, &u->verify); in nfsd4_nverify()
1826 status = _nfsd4_verify(rqstp, cstate, &u->nverify); in nfsd4_verify()
1834 if (!exp->ex_layout_types) { in nfsd4_layout_verify()
1840 !(exp->ex_layout_types & (1 << layout_type))) { in nfsd4_layout_verify()
1853 struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo; in nfsd4_getdeviceinfo()
1861 gdp->gd_layout_type, in nfsd4_getdeviceinfo()
1862 gdp->gd_devid.fsid_idx, gdp->gd_devid.generation, in nfsd4_getdeviceinfo()
1863 gdp->gd_maxcount); in nfsd4_getdeviceinfo()
1865 map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx); in nfsd4_getdeviceinfo()
1872 exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid); in nfsd4_getdeviceinfo()
1879 ops = nfsd4_layout_verify(exp, gdp->gd_layout_type); in nfsd4_getdeviceinfo()
1884 if (gdp->gd_maxcount != 0) { in nfsd4_getdeviceinfo()
1885 nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb, in nfsd4_getdeviceinfo()
1886 rqstp, cstate->session->se_client, gdp); in nfsd4_getdeviceinfo()
1889 gdp->gd_notify_types &= ops->notify_types; in nfsd4_getdeviceinfo()
1898 kfree(u->getdeviceinfo.gd_device); in nfsd4_getdeviceinfo_release()
1905 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_layoutget()
1906 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutget()
1912 switch (lgp->lg_seg.iomode) { in nfsd4_layoutget()
1921 __func__, lgp->lg_seg.iomode); in nfsd4_layoutget()
1931 ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type); in nfsd4_layoutget()
1936 * Verify minlength and range as per RFC5661: in nfsd4_layoutget()
1947 if (lgp->lg_seg.length < lgp->lg_minlength || in nfsd4_layoutget()
1948 (lgp->lg_minlength != NFS4_MAX_UINT64 && in nfsd4_layoutget()
1949 lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) || in nfsd4_layoutget()
1950 (lgp->lg_seg.length != NFS4_MAX_UINT64 && in nfsd4_layoutget()
1951 lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset)) in nfsd4_layoutget()
1953 if (lgp->lg_seg.length == 0) in nfsd4_layoutget()
1956 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid, in nfsd4_layoutget()
1957 true, lgp->lg_layout_type, &ls); in nfsd4_layoutget()
1959 trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid); in nfsd4_layoutget()
1964 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) in nfsd4_layoutget()
1967 nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry), in nfsd4_layoutget()
1975 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutget()
1976 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutget()
1984 kfree(u->layoutget.lg_content); in nfsd4_layoutget_release()
1991 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_layoutcommit()
1992 const struct nfsd4_layout_seg *seg = &lcp->lc_seg; in nfsd4_layoutcommit()
1993 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutcommit()
1995 loff_t new_size = lcp->lc_last_wr + 1; in nfsd4_layoutcommit()
2005 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); in nfsd4_layoutcommit()
2008 inode = d_inode(current_fh->fh_dentry); in nfsd4_layoutcommit()
2011 if (new_size <= seg->offset) { in nfsd4_layoutcommit()
2015 if (new_size > seg->offset + seg->length) { in nfsd4_layoutcommit()
2019 if (!lcp->lc_newoffset && new_size > i_size_read(inode)) { in nfsd4_layoutcommit()
2024 nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid, in nfsd4_layoutcommit()
2025 false, lcp->lc_layout_type, in nfsd4_layoutcommit()
2028 trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid); in nfsd4_layoutcommit()
2036 mutex_unlock(&ls->ls_mutex); in nfsd4_layoutcommit()
2039 lcp->lc_size_chg = 1; in nfsd4_layoutcommit()
2040 lcp->lc_newsize = new_size; in nfsd4_layoutcommit()
2042 lcp->lc_size_chg = 0; in nfsd4_layoutcommit()
2045 nfserr = ops->proc_layoutcommit(inode, lcp); in nfsd4_layoutcommit()
2046 nfs4_put_stid(&ls->ls_stid); in nfsd4_layoutcommit()
2055 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_layoutreturn()
2056 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_layoutreturn()
2064 if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type)) in nfsd4_layoutreturn()
2067 switch (lrp->lr_seg.iomode) { in nfsd4_layoutreturn()
2074 lrp->lr_seg.iomode); in nfsd4_layoutreturn()
2079 switch (lrp->lr_return_type) { in nfsd4_layoutreturn()
2089 lrp->lr_return_type); in nfsd4_layoutreturn()
2102 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_getxattr()
2104 return nfsd_getxattr(rqstp, &cstate->current_fh, in nfsd4_getxattr()
2105 getxattr->getxa_name, &getxattr->getxa_buf, in nfsd4_getxattr()
2106 &getxattr->getxa_len); in nfsd4_getxattr()
2113 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_setxattr()
2119 ret = nfsd_setxattr(rqstp, &cstate->current_fh, setxattr->setxa_name, in nfsd4_setxattr()
2120 setxattr->setxa_buf, setxattr->setxa_len, in nfsd4_setxattr()
2121 setxattr->setxa_flags); in nfsd4_setxattr()
2124 set_change_info(&setxattr->setxa_cinfo, &cstate->current_fh); in nfsd4_setxattr()
2137 return nfsd_listxattr(rqstp, &cstate->current_fh, in nfsd4_listxattrs()
2138 &u->listxattrs.lsxa_buf, &u->listxattrs.lsxa_len); in nfsd4_listxattrs()
2145 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_removexattr()
2151 ret = nfsd_removexattr(rqstp, &cstate->current_fh, in nfsd4_removexattr()
2152 removexattr->rmxa_name); in nfsd4_removexattr()
2155 set_change_info(&removexattr->rmxa_cinfo, &cstate->current_fh); in nfsd4_removexattr()
2183 * - SEQUENCE other than as first op results in
2185 * - BIND_CONN_TO_SESSION must be the only op in its compound.
2187 * - DESTROY_SESSION must be the final operation in a compound, if
2193 struct nfsd4_op *first_op = &args->ops[0]; in nfs41_check_op_ordering()
2196 if (args->minorversion == 0) in nfs41_check_op_ordering()
2199 if (args->opcnt == 0) in nfs41_check_op_ordering()
2201 if (first_op->status == nfserr_op_illegal) in nfs41_check_op_ordering()
2203 if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP)) in nfs41_check_op_ordering()
2205 if (first_op->opnum == OP_SEQUENCE) in nfs41_check_op_ordering()
2212 if (args->opcnt != 1) in nfs41_check_op_ordering()
2219 return &nfsd4_ops[op->opnum]; in OPDESC()
2224 if (op->opnum == OP_ILLEGAL) in nfsd4_cache_this_op()
2226 return OPDESC(op)->op_flags & OP_CACHEME; in nfsd4_cache_this_op()
2231 struct nfsd4_compoundres *resp = rqstp->rq_resp; in need_wrongsec_check()
2232 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in need_wrongsec_check()
2233 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; in need_wrongsec_check()
2234 struct nfsd4_op *next = &argp->ops[resp->opcnt]; in need_wrongsec_check()
2239 * Most ops check wronsec on our own; only the putfh-like ops in need_wrongsec_check()
2242 if (!(thisd->op_flags & OP_IS_PUTFH_LIKE)) in need_wrongsec_check()
2246 * put-filehandle operation if we're not going to use the in need_wrongsec_check()
2249 if (argp->opcnt == resp->opcnt) in need_wrongsec_check()
2251 if (next->opnum == OP_ILLEGAL) in need_wrongsec_check()
2259 return !(nextd->op_flags & OP_HANDLES_WRONGSEC); in need_wrongsec_check()
2265 struct xdr_stream *xdr = &resp->xdr; in svcxdr_init_encode()
2266 struct xdr_buf *buf = &rqstp->rq_res; in svcxdr_init_encode()
2267 struct kvec *head = buf->head; in svcxdr_init_encode()
2269 xdr->buf = buf; in svcxdr_init_encode()
2270 xdr->iov = head; in svcxdr_init_encode()
2271 xdr->p = head->iov_base + head->iov_len; in svcxdr_init_encode()
2272 xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack; in svcxdr_init_encode()
2274 buf->len = buf->head[0].iov_len; in svcxdr_init_encode()
2275 xdr->scratch.iov_len = 0; in svcxdr_init_encode()
2276 xdr->page_ptr = buf->pages - 1; in svcxdr_init_encode()
2277 buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages) in svcxdr_init_encode()
2278 - rqstp->rq_auth_slack; in svcxdr_init_encode()
2293 for (i = 0; i < args->opcnt; i++) { in check_if_stalefh_allowed()
2294 op = &args->ops[i]; in check_if_stalefh_allowed()
2295 if (op->opnum == OP_PUTFH) in check_if_stalefh_allowed()
2297 else if (op->opnum == OP_SAVEFH) in check_if_stalefh_allowed()
2299 else if (op->opnum == OP_RESTOREFH) in check_if_stalefh_allowed()
2301 else if (op->opnum == OP_COPY) { in check_if_stalefh_allowed()
2302 copy = (struct nfsd4_copy *)&op->u; in check_if_stalefh_allowed()
2304 op->status = nfserr_nofilehandle; in check_if_stalefh_allowed()
2307 putfh = (struct nfsd4_putfh *)&saved_op->u; in check_if_stalefh_allowed()
2308 if (!copy->cp_intra) in check_if_stalefh_allowed()
2309 putfh->no_verify = true; in check_if_stalefh_allowed()
2326 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_proc_compound()
2327 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_proc_compound()
2329 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_proc_compound()
2330 struct svc_fh *current_fh = &cstate->current_fh; in nfsd4_proc_compound()
2331 struct svc_fh *save_fh = &cstate->save_fh; in nfsd4_proc_compound()
2336 resp->tagp = resp->xdr.p; in nfsd4_proc_compound()
2338 xdr_reserve_space(&resp->xdr, 8 + args->taglen); in nfsd4_proc_compound()
2339 resp->taglen = args->taglen; in nfsd4_proc_compound()
2340 resp->tag = args->tag; in nfsd4_proc_compound()
2341 resp->rqstp = rqstp; in nfsd4_proc_compound()
2342 cstate->minorversion = args->minorversion; in nfsd4_proc_compound()
2347 * too hard to avoid non-idempotency problems. in nfsd4_proc_compound()
2349 clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
2355 if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0) in nfsd4_proc_compound()
2358 if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND) in nfsd4_proc_compound()
2363 op = &args->ops[0]; in nfsd4_proc_compound()
2364 op->status = status; in nfsd4_proc_compound()
2365 resp->opcnt = 1; in nfsd4_proc_compound()
2370 rqstp->rq_lease_breaker = (void **)&cstate->clp; in nfsd4_proc_compound()
2372 trace_nfsd_compound(rqstp, args->opcnt); in nfsd4_proc_compound()
2373 while (!status && resp->opcnt < args->opcnt) { in nfsd4_proc_compound()
2374 op = &args->ops[resp->opcnt++]; in nfsd4_proc_compound()
2377 * The XDR decode routines may have pre-set op->status; in nfsd4_proc_compound()
2381 if (op->status) { in nfsd4_proc_compound()
2382 if (op->opnum == OP_OPEN) in nfsd4_proc_compound()
2383 op->status = nfsd4_open_omfg(rqstp, cstate, op); in nfsd4_proc_compound()
2386 if (!current_fh->fh_dentry && in nfsd4_proc_compound()
2388 if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) { in nfsd4_proc_compound()
2389 op->status = nfserr_nofilehandle; in nfsd4_proc_compound()
2392 } else if (current_fh->fh_export && in nfsd4_proc_compound()
2393 current_fh->fh_export->ex_fslocs.migrated && in nfsd4_proc_compound()
2394 !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) { in nfsd4_proc_compound()
2395 op->status = nfserr_moved; in nfsd4_proc_compound()
2401 /* If op is non-idempotent */ in nfsd4_proc_compound()
2402 if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) { in nfsd4_proc_compound()
2407 u32 plen = op->opdesc->op_rsize_bop(rqstp, op); in nfsd4_proc_compound()
2412 if (resp->opcnt < args->opcnt) in nfsd4_proc_compound()
2414 op->status = nfsd4_check_resp_size(resp, plen); in nfsd4_proc_compound()
2417 if (op->status) in nfsd4_proc_compound()
2420 if (op->opdesc->op_get_currentstateid) in nfsd4_proc_compound()
2421 op->opdesc->op_get_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2422 op->status = op->opdesc->op_func(rqstp, cstate, &op->u); in nfsd4_proc_compound()
2425 if (cstate->status == nfserr_replay_cache) { in nfsd4_proc_compound()
2427 status = op->status; in nfsd4_proc_compound()
2430 if (!op->status) { in nfsd4_proc_compound()
2431 if (op->opdesc->op_set_currentstateid) in nfsd4_proc_compound()
2432 op->opdesc->op_set_currentstateid(cstate, &op->u); in nfsd4_proc_compound()
2434 if (op->opdesc->op_flags & OP_CLEAR_STATEID) in nfsd4_proc_compound()
2437 if (current_fh->fh_export && in nfsd4_proc_compound()
2439 op->status = check_nfsd_access(current_fh->fh_export, rqstp); in nfsd4_proc_compound()
2442 if (op->status == nfserr_replay_me) { in nfsd4_proc_compound()
2443 op->replay = &cstate->replay_owner->so_replay; in nfsd4_proc_compound()
2444 nfsd4_encode_replay(&resp->xdr, op); in nfsd4_proc_compound()
2445 status = op->status = op->replay->rp_status; in nfsd4_proc_compound()
2448 status = op->status; in nfsd4_proc_compound()
2451 trace_nfsd_compound_status(args->opcnt, resp->opcnt, status, in nfsd4_proc_compound()
2452 nfsd4_op_name(op->opnum)); in nfsd4_proc_compound()
2455 nfsd4_increment_op_stats(op->opnum); in nfsd4_proc_compound()
2460 BUG_ON(cstate->replay_owner); in nfsd4_proc_compound()
2462 cstate->status = status; in nfsd4_proc_compound()
2464 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags); in nfsd4_proc_compound()
2521 u32 *bmap = op->u.getattr.ga_bmval; in nfsd4_getattr_rsize()
2586 rlen = min(op->u.read.rd_length, maxcount); in nfsd4_read_rsize()
2594 u32 rlen = min(op->u.read.rd_length, maxcount); in nfsd4_read_plus_rsize()
2610 rlen = min(op->u.readdir.rd_maxcount, maxcount); in nfsd4_readdir_rsize()
2642 return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids) in nfsd4_test_stateid_rsize()
2739 rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount); in nfsd4_getdeviceinfo_rsize()
2805 rlen = min(op->u.listxattrs.lsxa_maxcount, maxcount); in nfsd4_listxattrs_rsize()
3231 * nfsd4_spo_must_allow - Determine if the compound op contains an
3242 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_spo_must_allow()
3243 struct nfsd4_compoundargs *argp = rqstp->rq_argp; in nfsd4_spo_must_allow()
3244 struct nfsd4_op *this = &argp->ops[resp->opcnt - 1]; in nfsd4_spo_must_allow()
3245 struct nfsd4_compound_state *cstate = &resp->cstate; in nfsd4_spo_must_allow()
3246 struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow; in nfsd4_spo_must_allow()
3249 if (!cstate->minorversion) in nfsd4_spo_must_allow()
3252 if (cstate->spo_must_allowed) in nfsd4_spo_must_allow()
3255 opiter = resp->opcnt; in nfsd4_spo_must_allow()
3256 while (opiter < argp->opcnt) { in nfsd4_spo_must_allow()
3257 this = &argp->ops[opiter++]; in nfsd4_spo_must_allow()
3258 if (test_bit(this->opnum, allow->u.longs) && in nfsd4_spo_must_allow()
3259 cstate->clp->cl_mach_cred && in nfsd4_spo_must_allow()
3260 nfsd4_mach_creds_match(cstate->clp, rqstp)) { in nfsd4_spo_must_allow()
3261 cstate->spo_must_allowed = true; in nfsd4_spo_must_allow()
3265 cstate->spo_must_allowed = false; in nfsd4_spo_must_allow()
3271 if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp) in nfsd4_max_reply()
3274 BUG_ON(OPDESC(op)->op_rsize_bop == NULL); in nfsd4_max_reply()
3275 return OPDESC(op)->op_rsize_bop(rqstp, op); in nfsd4_max_reply()
3280 if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) { in warn_on_nonidempotent_op()
3282 op->opnum, nfsd4_op_name(op->opnum)); in warn_on_nonidempotent_op()
3333 * c-basic-offset: 8